Add milc as a dependency and remove the installed milc (#10563)
* Add milc as a dependency and remove the installed milc * update doctor.py too * pyformat * remove rather than shim questions
This commit is contained in:
Zach White
James Young
parent
53f2b5b944
commit
fa6bd5cbe5
4 changed files with 2 additions and 1011 deletions
|
|
@ -1,826 +0,0 @@
|
|||
#!/usr/bin/env python3
|
||||
# coding=utf-8
|
||||
"""MILC - A CLI Framework
|
||||
|
||||
PYTHON_ARGCOMPLETE_OK
|
||||
|
||||
MILC is an opinionated framework for writing CLI apps. It optimizes for the
|
||||
most common unix tool pattern- small tools that are run from the command
|
||||
line but generally do not feature any user interaction while they run.
|
||||
|
||||
For more details see the MILC documentation:
|
||||
|
||||
<https://github.com/clueboard/milc/tree/master/docs>
|
||||
"""
|
||||
from __future__ import division, print_function, unicode_literals
|
||||
import argparse
|
||||
import logging
|
||||
import os
|
||||
import re
|
||||
import shlex
|
||||
import subprocess
|
||||
import sys
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
from platform import platform
|
||||
from tempfile import NamedTemporaryFile
|
||||
from time import sleep
|
||||
|
||||
try:
|
||||
from ConfigParser import RawConfigParser
|
||||
except ImportError:
|
||||
from configparser import RawConfigParser
|
||||
|
||||
try:
|
||||
import thread
|
||||
import threading
|
||||
except ImportError:
|
||||
thread = None
|
||||
|
||||
import argcomplete
|
||||
import colorama
|
||||
from appdirs import user_config_dir
|
||||
|
||||
# Disable logging until we can configure it how the user wants
|
||||
logging.basicConfig(stream=os.devnull)
|
||||
|
||||
# Log Level Representations
|
||||
EMOJI_LOGLEVELS = {
|
||||
'CRITICAL': '{bg_red}{fg_white}¬_¬{style_reset_all}',
|
||||
'ERROR': '{fg_red}☒{style_reset_all}',
|
||||
'WARNING': '{fg_yellow}⚠{style_reset_all}',
|
||||
'INFO': '{fg_blue}ℹ{style_reset_all}',
|
||||
'DEBUG': '{fg_cyan}☐{style_reset_all}',
|
||||
'NOTSET': '{style_reset_all}¯\\_(o_o)_/¯'
|
||||
}
|
||||
EMOJI_LOGLEVELS['FATAL'] = EMOJI_LOGLEVELS['CRITICAL']
|
||||
EMOJI_LOGLEVELS['WARN'] = EMOJI_LOGLEVELS['WARNING']
|
||||
UNICODE_SUPPORT = sys.stdout.encoding.lower().startswith('utf')
|
||||
|
||||
# ANSI Color setup
|
||||
# Regex was gratefully borrowed from kfir on stackoverflow:
|
||||
# https://stackoverflow.com/a/45448194
|
||||
ansi_regex = r'\x1b(' \
|
||||
r'(\[\??\d+[hl])|' \
|
||||
r'([=<>a-kzNM78])|' \
|
||||
r'([\(\)][a-b0-2])|' \
|
||||
r'(\[\d{0,2}[ma-dgkjqi])|' \
|
||||
r'(\[\d+;\d+[hfy]?)|' \
|
||||
r'(\[;?[hf])|' \
|
||||
r'(#[3-68])|' \
|
||||
r'([01356]n)|' \
|
||||
r'(O[mlnp-z]?)|' \
|
||||
r'(/Z)|' \
|
||||
r'(\d+)|' \
|
||||
r'(\[\?\d;\d0c)|' \
|
||||
r'(\d;\dR))'
|
||||
ansi_escape = re.compile(ansi_regex, flags=re.IGNORECASE)
|
||||
ansi_styles = (
|
||||
('fg', colorama.ansi.AnsiFore()),
|
||||
('bg', colorama.ansi.AnsiBack()),
|
||||
('style', colorama.ansi.AnsiStyle()),
|
||||
)
|
||||
ansi_colors = {}
|
||||
|
||||
for prefix, obj in ansi_styles:
|
||||
for color in [x for x in obj.__dict__ if not x.startswith('_')]:
|
||||
ansi_colors[prefix + '_' + color.lower()] = getattr(obj, color)
|
||||
|
||||
|
||||
def format_ansi(text):
|
||||
"""Return a copy of text with certain strings replaced with ansi.
|
||||
"""
|
||||
# Avoid .format() so we don't have to worry about the log content
|
||||
for color in ansi_colors:
|
||||
text = text.replace('{%s}' % color, ansi_colors[color])
|
||||
return text + ansi_colors['style_reset_all']
|
||||
|
||||
|
||||
class ANSIFormatterMixin(object):
|
||||
"""A log formatter mixin that inserts ANSI color.
|
||||
"""
|
||||
def format(self, record):
|
||||
msg = super(ANSIFormatterMixin, self).format(record)
|
||||
return format_ansi(msg)
|
||||
|
||||
|
||||
class ANSIStrippingMixin(object):
|
||||
"""A log formatter mixin that strips ANSI.
|
||||
"""
|
||||
def format(self, record):
|
||||
msg = super(ANSIStrippingMixin, self).format(record)
|
||||
record.levelname = ansi_escape.sub('', record.levelname)
|
||||
return ansi_escape.sub('', msg)
|
||||
|
||||
|
||||
class EmojiLoglevelMixin(object):
|
||||
"""A log formatter mixin that makes the loglevel an emoji on UTF capable terminals.
|
||||
"""
|
||||
def format(self, record):
|
||||
if UNICODE_SUPPORT:
|
||||
record.levelname = EMOJI_LOGLEVELS[record.levelname].format(**ansi_colors)
|
||||
return super(EmojiLoglevelMixin, self).format(record)
|
||||
|
||||
|
||||
class ANSIFormatter(ANSIFormatterMixin, logging.Formatter):
|
||||
"""A log formatter that colorizes output.
|
||||
"""
|
||||
pass
|
||||
|
||||
|
||||
class ANSIStrippingFormatter(ANSIStrippingMixin, ANSIFormatterMixin, logging.Formatter):
|
||||
"""A log formatter that strips ANSI
|
||||
"""
|
||||
pass
|
||||
|
||||
|
||||
class ANSIEmojiLoglevelFormatter(EmojiLoglevelMixin, ANSIFormatterMixin, logging.Formatter):
|
||||
"""A log formatter that adds Emoji and ANSI
|
||||
"""
|
||||
pass
|
||||
|
||||
|
||||
class ANSIStrippingEmojiLoglevelFormatter(ANSIStrippingMixin, EmojiLoglevelMixin, ANSIFormatterMixin, logging.Formatter):
|
||||
"""A log formatter that adds Emoji and strips ANSI
|
||||
"""
|
||||
pass
|
||||
|
||||
|
||||
class Configuration(object):
|
||||
"""Represents the running configuration.
|
||||
|
||||
This class never raises IndexError, instead it will return None if a
|
||||
section or option does not yet exist.
|
||||
"""
|
||||
def __contains__(self, key):
|
||||
return self._config.__contains__(key)
|
||||
|
||||
def __iter__(self):
|
||||
return self._config.__iter__()
|
||||
|
||||
def __len__(self):
|
||||
return self._config.__len__()
|
||||
|
||||
def __repr__(self):
|
||||
return self._config.__repr__()
|
||||
|
||||
def keys(self):
|
||||
return self._config.keys()
|
||||
|
||||
def items(self):
|
||||
return self._config.items()
|
||||
|
||||
def values(self):
|
||||
return self._config.values()
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
self._config = {}
|
||||
|
||||
def __getattr__(self, key):
|
||||
return self.__getitem__(key)
|
||||
|
||||
def __getitem__(self, key):
|
||||
"""Returns a config section, creating it if it doesn't exist yet.
|
||||
"""
|
||||
if key not in self._config:
|
||||
self.__dict__[key] = self._config[key] = ConfigurationSection(self)
|
||||
|
||||
return self._config[key]
|
||||
|
||||
def __setitem__(self, key, value):
|
||||
self.__dict__[key] = value
|
||||
self._config[key] = value
|
||||
|
||||
def __delitem__(self, key):
|
||||
if key in self.__dict__ and key[0] != '_':
|
||||
del self.__dict__[key]
|
||||
if key in self._config:
|
||||
del self._config[key]
|
||||
|
||||
|
||||
class ConfigurationSection(Configuration):
|
||||
def __init__(self, parent, *args, **kwargs):
|
||||
super(ConfigurationSection, self).__init__(*args, **kwargs)
|
||||
self.parent = parent
|
||||
|
||||
def __getitem__(self, key):
|
||||
"""Returns a config value, pulling from the `user` section as a fallback.
|
||||
This is called when the attribute is accessed either via the get method or through [ ] index.
|
||||
"""
|
||||
if key in self._config and self._config.get(key) is not None:
|
||||
return self._config[key]
|
||||
|
||||
elif key in self.parent.user:
|
||||
return self.parent.user[key]
|
||||
|
||||
return None
|
||||
|
||||
def __getattr__(self, key):
|
||||
"""Returns the config value from the `user` section.
|
||||
This is called when the attribute is accessed via dot notation but does not exists.
|
||||
"""
|
||||
if key in self.parent.user:
|
||||
return self.parent.user[key]
|
||||
|
||||
return None
|
||||
|
||||
|
||||
def handle_store_boolean(self, *args, **kwargs):
|
||||
"""Does the add_argument for action='store_boolean'.
|
||||
"""
|
||||
disabled_args = None
|
||||
disabled_kwargs = kwargs.copy()
|
||||
disabled_kwargs['action'] = 'store_false'
|
||||
disabled_kwargs['dest'] = self.get_argument_name(*args, **kwargs)
|
||||
disabled_kwargs['help'] = 'Disable ' + kwargs['help']
|
||||
kwargs['action'] = 'store_true'
|
||||
kwargs['help'] = 'Enable ' + kwargs['help']
|
||||
|
||||
for flag in args:
|
||||
if flag[:2] == '--':
|
||||
disabled_args = ('--no-' + flag[2:],)
|
||||
break
|
||||
|
||||
self.add_argument(*args, **kwargs)
|
||||
self.add_argument(*disabled_args, **disabled_kwargs)
|
||||
|
||||
return (args, kwargs, disabled_args, disabled_kwargs)
|
||||
|
||||
|
||||
class SubparserWrapper(object):
|
||||
"""Wrap subparsers so we can track what options the user passed.
|
||||
"""
|
||||
def __init__(self, cli, submodule, subparser):
|
||||
self.cli = cli
|
||||
self.submodule = submodule
|
||||
self.subparser = subparser
|
||||
|
||||
for attr in dir(subparser):
|
||||
if not hasattr(self, attr):
|
||||
setattr(self, attr, getattr(subparser, attr))
|
||||
|
||||
def completer(self, completer):
|
||||
"""Add an arpcomplete completer to this subcommand.
|
||||
"""
|
||||
self.subparser.completer = completer
|
||||
|
||||
def add_argument(self, *args, **kwargs):
|
||||
"""Add an argument for this subcommand.
|
||||
|
||||
This also stores the default for the argument in `self.cli.default_arguments`.
|
||||
"""
|
||||
if kwargs.get('action') == 'store_boolean':
|
||||
# Store boolean will call us again with the enable/disable flag arguments
|
||||
return handle_store_boolean(self, *args, **kwargs)
|
||||
|
||||
self.cli.acquire_lock()
|
||||
argument_name = self.cli.get_argument_name(*args, **kwargs)
|
||||
|
||||
self.subparser.add_argument(*args, **kwargs)
|
||||
|
||||
if kwargs.get('action') == 'store_false':
|
||||
self.cli._config_store_false.append(argument_name)
|
||||
|
||||
if kwargs.get('action') == 'store_true':
|
||||
self.cli._config_store_true.append(argument_name)
|
||||
|
||||
if self.submodule not in self.cli.default_arguments:
|
||||
self.cli.default_arguments[self.submodule] = {}
|
||||
self.cli.default_arguments[self.submodule][argument_name] = kwargs.get('default')
|
||||
self.cli.release_lock()
|
||||
|
||||
|
||||
class MILC(object):
|
||||
"""MILC - An Opinionated Batteries Included Framework
|
||||
"""
|
||||
def __init__(self):
|
||||
"""Initialize the MILC object.
|
||||
|
||||
version
|
||||
The version string to associate with your CLI program
|
||||
"""
|
||||
# Setup a lock for thread safety
|
||||
self._lock = threading.RLock() if thread else None
|
||||
|
||||
# Define some basic info
|
||||
self.acquire_lock()
|
||||
self._config_store_true = []
|
||||
self._config_store_false = []
|
||||
self._description = None
|
||||
self._entrypoint = None
|
||||
self._inside_context_manager = False
|
||||
self.ansi = ansi_colors
|
||||
self.arg_only = {}
|
||||
self.config = self.config_source = None
|
||||
self.config_file = None
|
||||
self.default_arguments = {}
|
||||
self.version = 'unknown'
|
||||
self.platform = platform()
|
||||
|
||||
# Figure out our program name
|
||||
self.prog_name = sys.argv[0][:-3] if sys.argv[0].endswith('.py') else sys.argv[0]
|
||||
self.prog_name = self.prog_name.split('/')[-1]
|
||||
self.release_lock()
|
||||
|
||||
# Initialize all the things
|
||||
self.read_config_file()
|
||||
self.initialize_argparse()
|
||||
self.initialize_logging()
|
||||
|
||||
@property
|
||||
def description(self):
|
||||
return self._description
|
||||
|
||||
@description.setter
|
||||
def description(self, value):
|
||||
self._description = self._arg_parser.description = value
|
||||
|
||||
def echo(self, text, *args, **kwargs):
|
||||
"""Print colorized text to stdout.
|
||||
|
||||
ANSI color strings (such as {fg-blue}) will be converted into ANSI
|
||||
escape sequences, and the ANSI reset sequence will be added to all
|
||||
strings.
|
||||
|
||||
If *args or **kwargs are passed they will be used to %-format the strings.
|
||||
|
||||
If `self.config.general.color` is False any ANSI escape sequences in the text will be stripped.
|
||||
"""
|
||||
if args and kwargs:
|
||||
raise RuntimeError('You can only specify *args or **kwargs, not both!')
|
||||
|
||||
args = args or kwargs
|
||||
text = format_ansi(text)
|
||||
|
||||
if not self.config.general.color:
|
||||
text = ansi_escape.sub('', text)
|
||||
|
||||
print(text % args)
|
||||
|
||||
def run(self, command, *args, **kwargs):
|
||||
"""Run a command with subprocess.run
|
||||
The *args and **kwargs arguments get passed directly to `subprocess.run`.
|
||||
"""
|
||||
if isinstance(command, str):
|
||||
raise TypeError('`command` must be a non-text sequence such as list or tuple.')
|
||||
|
||||
if 'windows' in self.platform.lower():
|
||||
safecmd = map(shlex.quote, command)
|
||||
safecmd = ' '.join(safecmd)
|
||||
command = [os.environ['SHELL'], '-c', safecmd]
|
||||
|
||||
self.log.debug('Running command: %s', command)
|
||||
|
||||
return subprocess.run(command, *args, **kwargs)
|
||||
|
||||
def initialize_argparse(self):
|
||||
"""Prepare to process arguments from sys.argv.
|
||||
"""
|
||||
kwargs = {
|
||||
'fromfile_prefix_chars': '@',
|
||||
'conflict_handler': 'resolve',
|
||||
}
|
||||
|
||||
self.acquire_lock()
|
||||
self.subcommands = {}
|
||||
self._subparsers = None
|
||||
self.argwarn = argcomplete.warn
|
||||
self.args = None
|
||||
self._arg_parser = argparse.ArgumentParser(**kwargs)
|
||||
self.set_defaults = self._arg_parser.set_defaults
|
||||
self.print_usage = self._arg_parser.print_usage
|
||||
self.print_help = self._arg_parser.print_help
|
||||
self.release_lock()
|
||||
|
||||
def completer(self, completer):
|
||||
"""Add an argcomplete completer to this subcommand.
|
||||
"""
|
||||
self._arg_parser.completer = completer
|
||||
|
||||
def add_argument(self, *args, **kwargs):
|
||||
"""Wrapper to add arguments and track whether they were passed on the command line.
|
||||
"""
|
||||
if 'action' in kwargs and kwargs['action'] == 'store_boolean':
|
||||
return handle_store_boolean(self, *args, **kwargs)
|
||||
|
||||
self.acquire_lock()
|
||||
|
||||
self._arg_parser.add_argument(*args, **kwargs)
|
||||
if 'general' not in self.default_arguments:
|
||||
self.default_arguments['general'] = {}
|
||||
self.default_arguments['general'][self.get_argument_name(*args, **kwargs)] = kwargs.get('default')
|
||||
|
||||
self.release_lock()
|
||||
|
||||
def initialize_logging(self):
|
||||
"""Prepare the defaults for the logging infrastructure.
|
||||
"""
|
||||
self.acquire_lock()
|
||||
self.log_file = None
|
||||
self.log_file_mode = 'a'
|
||||
self.log_file_handler = None
|
||||
self.log_print = True
|
||||
self.log_print_to = sys.stderr
|
||||
self.log_print_level = logging.INFO
|
||||
self.log_file_level = logging.DEBUG
|
||||
self.log_level = logging.INFO
|
||||
self.log = logging.getLogger(self.__class__.__name__)
|
||||
self.log.setLevel(logging.DEBUG)
|
||||
logging.root.setLevel(logging.DEBUG)
|
||||
self.release_lock()
|
||||
|
||||
self.add_argument('-V', '--version', version=self.version, action='version', help='Display the version and exit')
|
||||
self.add_argument('-v', '--verbose', action='store_true', help='Make the logging more verbose')
|
||||
self.add_argument('--datetime-fmt', default='%Y-%m-%d %H:%M:%S', help='Format string for datetimes')
|
||||
self.add_argument('--log-fmt', default='%(levelname)s %(message)s', help='Format string for printed log output')
|
||||
self.add_argument('--log-file-fmt', default='[%(levelname)s] [%(asctime)s] [file:%(pathname)s] [line:%(lineno)d] %(message)s', help='Format string for log file.')
|
||||
self.add_argument('--log-file', help='File to write log messages to')
|
||||
self.add_argument('--color', action='store_boolean', default=True, help='color in output')
|
||||
self.add_argument('--config-file', help='The location for the configuration file')
|
||||
self.arg_only['config_file'] = ['general']
|
||||
|
||||
def add_subparsers(self, title='Sub-commands', **kwargs):
|
||||
if self._inside_context_manager:
|
||||
raise RuntimeError('You must run this before the with statement!')
|
||||
|
||||
self.acquire_lock()
|
||||
self._subparsers = self._arg_parser.add_subparsers(title=title, dest='subparsers', **kwargs)
|
||||
self.release_lock()
|
||||
|
||||
def acquire_lock(self):
|
||||
"""Acquire the MILC lock for exclusive access to properties.
|
||||
"""
|
||||
if self._lock:
|
||||
self._lock.acquire()
|
||||
|
||||
def release_lock(self):
|
||||
"""Release the MILC lock.
|
||||
"""
|
||||
if self._lock:
|
||||
self._lock.release()
|
||||
|
||||
def find_config_file(self):
|
||||
"""Locate the config file.
|
||||
"""
|
||||
if self.config_file:
|
||||
return self.config_file
|
||||
|
||||
if '--config-file' in sys.argv:
|
||||
return Path(sys.argv[sys.argv.index('--config-file') + 1]).expanduser().resolve()
|
||||
|
||||
filedir = user_config_dir(appname='qmk', appauthor='QMK')
|
||||
filename = '%s.ini' % self.prog_name
|
||||
return Path(filedir) / filename
|
||||
|
||||
def get_argument_name(self, *args, **kwargs):
|
||||
"""Takes argparse arguments and returns the dest name.
|
||||
"""
|
||||
try:
|
||||
return self._arg_parser._get_optional_kwargs(*args, **kwargs)['dest']
|
||||
except ValueError:
|
||||
return self._arg_parser._get_positional_kwargs(*args, **kwargs)['dest']
|
||||
|
||||
def argument(self, *args, **kwargs):
|
||||
"""Decorator to call self.add_argument or self.<subcommand>.add_argument.
|
||||
"""
|
||||
if self._inside_context_manager:
|
||||
raise RuntimeError('You must run this before the with statement!')
|
||||
|
||||
def argument_function(handler):
|
||||
subcommand_name = handler.__name__.replace("_", "-")
|
||||
|
||||
if kwargs.get('arg_only'):
|
||||
arg_name = self.get_argument_name(*args, **kwargs)
|
||||
if arg_name not in self.arg_only:
|
||||
self.arg_only[arg_name] = []
|
||||
self.arg_only[arg_name].append(subcommand_name)
|
||||
del kwargs['arg_only']
|
||||
|
||||
if handler is self._entrypoint:
|
||||
self.add_argument(*args, **kwargs)
|
||||
|
||||
elif subcommand_name in self.subcommands:
|
||||
self.subcommands[subcommand_name].add_argument(*args, **kwargs)
|
||||
|
||||
else:
|
||||
raise RuntimeError('Decorated function is not entrypoint or subcommand!')
|
||||
|
||||
return handler
|
||||
|
||||
return argument_function
|
||||
|
||||
def arg_passed(self, arg):
|
||||
"""Returns True if arg was passed on the command line.
|
||||
"""
|
||||
return self.default_arguments.get(arg) != self.args[arg]
|
||||
|
||||
def parse_args(self):
|
||||
"""Parse the CLI args.
|
||||
"""
|
||||
if self.args:
|
||||
self.log.debug('Warning: Arguments have already been parsed, ignoring duplicate attempt!')
|
||||
return
|
||||
|
||||
argcomplete.autocomplete(self._arg_parser)
|
||||
|
||||
self.acquire_lock()
|
||||
self.args = self._arg_parser.parse_args()
|
||||
|
||||
if 'entrypoint' in self.args:
|
||||
self._entrypoint = self.args.entrypoint
|
||||
|
||||
self.release_lock()
|
||||
|
||||
def read_config_file(self):
|
||||
"""Read in the configuration file and store it in self.config.
|
||||
"""
|
||||
self.acquire_lock()
|
||||
self.config = Configuration()
|
||||
self.config_source = Configuration()
|
||||
self.config_file = self.find_config_file()
|
||||
|
||||
if self.config_file and self.config_file.exists():
|
||||
config = RawConfigParser(self.config)
|
||||
config.read(str(self.config_file))
|
||||
|
||||
# Iterate over the config file options and write them into self.config
|
||||
for section in config.sections():
|
||||
for option in config.options(section):
|
||||
value = config.get(section, option)
|
||||
|
||||
# Coerce values into useful datatypes
|
||||
if value.lower() in ['1', 'yes', 'true', 'on']:
|
||||
value = True
|
||||
elif value.lower() in ['0', 'no', 'false', 'off']:
|
||||
value = False
|
||||
elif value.lower() in ['none']:
|
||||
continue
|
||||
elif value.replace('.', '').isdigit():
|
||||
if '.' in value:
|
||||
value = Decimal(value)
|
||||
else:
|
||||
value = int(value)
|
||||
|
||||
self.config[section][option] = value
|
||||
self.config_source[section][option] = 'config_file'
|
||||
|
||||
self.release_lock()
|
||||
|
||||
def merge_args_into_config(self):
|
||||
"""Merge CLI arguments into self.config to create the runtime configuration.
|
||||
"""
|
||||
self.acquire_lock()
|
||||
for argument in vars(self.args):
|
||||
if argument in ('subparsers', 'entrypoint'):
|
||||
continue
|
||||
|
||||
# Find the argument's section
|
||||
# Underscores in command's names are converted to dashes during initialization.
|
||||
# TODO(Erovia) Find a better solution
|
||||
entrypoint_name = self._entrypoint.__name__.replace("_", "-")
|
||||
if entrypoint_name in self.default_arguments and argument in self.default_arguments[entrypoint_name]:
|
||||
argument_found = True
|
||||
section = self._entrypoint.__name__
|
||||
if argument in self.default_arguments['general']:
|
||||
argument_found = True
|
||||
section = 'general'
|
||||
|
||||
if not argument_found:
|
||||
raise RuntimeError('Could not find argument in `self.default_arguments`. This should be impossible!')
|
||||
exit(1)
|
||||
|
||||
if argument not in self.arg_only or section not in self.arg_only[argument]:
|
||||
# Determine the arg value and source
|
||||
arg_value = getattr(self.args, argument)
|
||||
if argument in self._config_store_true and arg_value:
|
||||
passed_on_cmdline = True
|
||||
elif argument in self._config_store_false and not arg_value:
|
||||
passed_on_cmdline = True
|
||||
elif arg_value is not None:
|
||||
passed_on_cmdline = True
|
||||
else:
|
||||
passed_on_cmdline = False
|
||||
|
||||
# Merge this argument into self.config
|
||||
if passed_on_cmdline and (argument in self.default_arguments['general'] or argument in self.default_arguments[entrypoint_name] or argument not in self.config[entrypoint_name]):
|
||||
self.config[section][argument] = arg_value
|
||||
self.config_source[section][argument] = 'argument'
|
||||
|
||||
self.release_lock()
|
||||
|
||||
def save_config(self):
|
||||
"""Save the current configuration to the config file.
|
||||
"""
|
||||
self.log.debug("Saving config file to '%s'", str(self.config_file))
|
||||
|
||||
if not self.config_file:
|
||||
self.log.warning('%s.config_file file not set, not saving config!', self.__class__.__name__)
|
||||
return
|
||||
|
||||
self.acquire_lock()
|
||||
|
||||
# Generate a sanitized version of our running configuration
|
||||
config = RawConfigParser()
|
||||
for section_name, section in self.config._config.items():
|
||||
config.add_section(section_name)
|
||||
for option_name, value in section.items():
|
||||
if section_name == 'general':
|
||||
if option_name in ['config_file']:
|
||||
continue
|
||||
if value is not None:
|
||||
config.set(section_name, option_name, str(value))
|
||||
|
||||
# Write out the config file
|
||||
config_dir = self.config_file.parent
|
||||
if not config_dir.exists():
|
||||
config_dir.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
with NamedTemporaryFile(mode='w', dir=str(config_dir), delete=False) as tmpfile:
|
||||
config.write(tmpfile)
|
||||
|
||||
# Move the new config file into place atomically
|
||||
if os.path.getsize(tmpfile.name) > 0:
|
||||
os.replace(tmpfile.name, str(self.config_file))
|
||||
else:
|
||||
self.log.warning('Config file saving failed, not replacing %s with %s.', str(self.config_file), tmpfile.name)
|
||||
|
||||
# Housekeeping
|
||||
self.release_lock()
|
||||
cli.log.info('Wrote configuration to %s', shlex.quote(str(self.config_file)))
|
||||
|
||||
def __call__(self):
|
||||
"""Execute the entrypoint function.
|
||||
"""
|
||||
if not self._inside_context_manager:
|
||||
# If they didn't use the context manager use it ourselves
|
||||
with self:
|
||||
return self.__call__()
|
||||
|
||||
if not self._entrypoint:
|
||||
raise RuntimeError('No entrypoint provided!')
|
||||
|
||||
return self._entrypoint(self)
|
||||
|
||||
def entrypoint(self, description):
|
||||
"""Set the entrypoint for when no subcommand is provided.
|
||||
"""
|
||||
if self._inside_context_manager:
|
||||
raise RuntimeError('You must run this before cli()!')
|
||||
|
||||
self.acquire_lock()
|
||||
self.description = description
|
||||
self.release_lock()
|
||||
|
||||
def entrypoint_func(handler):
|
||||
self.acquire_lock()
|
||||
self._entrypoint = handler
|
||||
self.release_lock()
|
||||
|
||||
return handler
|
||||
|
||||
return entrypoint_func
|
||||
|
||||
def add_subcommand(self, handler, description, name=None, hidden=False, **kwargs):
|
||||
"""Register a subcommand.
|
||||
|
||||
If name is not provided we use `handler.__name__`.
|
||||
"""
|
||||
|
||||
if self._inside_context_manager:
|
||||
raise RuntimeError('You must run this before the with statement!')
|
||||
|
||||
if self._subparsers is None:
|
||||
self.add_subparsers(metavar="")
|
||||
|
||||
if not name:
|
||||
name = handler.__name__.replace("_", "-")
|
||||
|
||||
self.acquire_lock()
|
||||
if not hidden:
|
||||
self._subparsers.metavar = "{%s,%s}" % (self._subparsers.metavar[1:-1], name) if self._subparsers.metavar else "{%s%s}" % (self._subparsers.metavar[1:-1], name)
|
||||
kwargs['help'] = description
|
||||
self.subcommands[name] = SubparserWrapper(self, name, self._subparsers.add_parser(name, **kwargs))
|
||||
self.subcommands[name].set_defaults(entrypoint=handler)
|
||||
|
||||
self.release_lock()
|
||||
|
||||
return handler
|
||||
|
||||
def subcommand(self, description, hidden=False, **kwargs):
|
||||
"""Decorator to register a subcommand.
|
||||
"""
|
||||
def subcommand_function(handler):
|
||||
return self.add_subcommand(handler, description, hidden=hidden, **kwargs)
|
||||
|
||||
return subcommand_function
|
||||
|
||||
def setup_logging(self):
|
||||
"""Called by __enter__() to setup the logging configuration.
|
||||
"""
|
||||
if len(logging.root.handlers) != 0:
|
||||
# MILC is the only thing that should have root log handlers
|
||||
logging.root.handlers = []
|
||||
|
||||
self.acquire_lock()
|
||||
|
||||
if self.config['general']['verbose']:
|
||||
self.log_print_level = logging.DEBUG
|
||||
|
||||
self.log_file = self.config['general']['log_file'] or self.log_file
|
||||
self.log_file_format = ANSIStrippingFormatter(self.config['general']['log_file_fmt'], self.config['general']['datetime_fmt'])
|
||||
self.log_format = self.config['general']['log_fmt']
|
||||
|
||||
if self.config.general.color:
|
||||
self.log_format = ANSIEmojiLoglevelFormatter(self.config.general.log_fmt, self.config.general.datetime_fmt)
|
||||
else:
|
||||
self.log_format = ANSIStrippingEmojiLoglevelFormatter(self.config.general.log_fmt, self.config.general.datetime_fmt)
|
||||
|
||||
if self.log_file:
|
||||
self.log_file_handler = logging.FileHandler(self.log_file, self.log_file_mode)
|
||||
self.log_file_handler.setLevel(self.log_file_level)
|
||||
self.log_file_handler.setFormatter(self.log_file_format)
|
||||
logging.root.addHandler(self.log_file_handler)
|
||||
|
||||
if self.log_print:
|
||||
self.log_print_handler = logging.StreamHandler(self.log_print_to)
|
||||
self.log_print_handler.setLevel(self.log_print_level)
|
||||
self.log_print_handler.setFormatter(self.log_format)
|
||||
logging.root.addHandler(self.log_print_handler)
|
||||
|
||||
self.release_lock()
|
||||
|
||||
def __enter__(self):
|
||||
if self._inside_context_manager:
|
||||
self.log.debug('Warning: context manager was entered again. This usually means that self.__call__() was called before the with statement. You probably do not want to do that.')
|
||||
return
|
||||
|
||||
self.acquire_lock()
|
||||
self._inside_context_manager = True
|
||||
self.release_lock()
|
||||
|
||||
colorama.init()
|
||||
self.parse_args()
|
||||
self.merge_args_into_config()
|
||||
self.setup_logging()
|
||||
|
||||
return self
|
||||
|
||||
def __exit__(self, exc_type, exc_val, exc_tb):
|
||||
self.acquire_lock()
|
||||
self._inside_context_manager = False
|
||||
self.release_lock()
|
||||
|
||||
if exc_type is not None and not isinstance(SystemExit(), exc_type):
|
||||
print(exc_type)
|
||||
logging.exception(exc_val)
|
||||
exit(255)
|
||||
|
||||
|
||||
cli = MILC()
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
@cli.argument('-c', '--comma', help='comma in output', default=True, action='store_boolean')
|
||||
@cli.entrypoint('My useful CLI tool with subcommands.')
|
||||
def main(cli):
|
||||
comma = ',' if cli.config.general.comma else ''
|
||||
cli.log.info('{bg_green}{fg_red}Hello%s World!', comma)
|
||||
|
||||
@cli.argument('-n', '--name', help='Name to greet', default='World')
|
||||
@cli.subcommand('Description of hello subcommand here.')
|
||||
def hello(cli):
|
||||
comma = ',' if cli.config.general.comma else ''
|
||||
cli.log.info('{fg_blue}Hello%s %s!', comma, cli.config.hello.name)
|
||||
|
||||
def goodbye(cli):
|
||||
comma = ',' if cli.config.general.comma else ''
|
||||
cli.log.info('{bg_red}Goodbye%s %s!', comma, cli.config.goodbye.name)
|
||||
|
||||
@cli.argument('-n', '--name', help='Name to greet', default='World')
|
||||
@cli.subcommand('Think a bit before greeting the user.')
|
||||
def thinking(cli):
|
||||
comma = ',' if cli.config.general.comma else ''
|
||||
spinner = cli.spinner(text='Just a moment...', spinner='earth')
|
||||
spinner.start()
|
||||
sleep(2)
|
||||
spinner.stop()
|
||||
|
||||
with cli.spinner(text='Almost there!', spinner='moon'):
|
||||
sleep(2)
|
||||
|
||||
cli.log.info('{fg_cyan}Hello%s %s!', comma, cli.config.thinking.name)
|
||||
|
||||
@cli.subcommand('Show off our ANSI colors.')
|
||||
def pride(cli):
|
||||
cli.echo('{bg_red} ')
|
||||
cli.echo('{bg_lightred_ex} ')
|
||||
cli.echo('{bg_lightyellow_ex} ')
|
||||
cli.echo('{bg_green} ')
|
||||
cli.echo('{bg_blue} ')
|
||||
cli.echo('{bg_magenta} ')
|
||||
|
||||
# You can register subcommands using decorators as seen above, or using functions like like this:
|
||||
cli.add_subcommand(goodbye, 'This will show up in --help output.')
|
||||
cli.goodbye.add_argument('-n', '--name', help='Name to bid farewell to', default='World')
|
||||
|
||||
cli() # Automatically picks between main(), hello() and goodbye()
|
||||
|
|
@ -9,9 +9,9 @@ import subprocess
|
|||
from pathlib import Path
|
||||
|
||||
from milc import cli
|
||||
from milc.questions import yesno
|
||||
from qmk import submodules
|
||||
from qmk.constants import QMK_FIRMWARE
|
||||
from qmk.questions import yesno
|
||||
from qmk.commands import run
|
||||
|
||||
ESSENTIAL_BINARIES = {
|
||||
|
|
|
|||
|
|
@ -1,183 +0,0 @@
|
|||
"""Functions to collect user input.
|
||||
"""
|
||||
|
||||
from milc import cli
|
||||
|
||||
try:
|
||||
from milc import format_ansi
|
||||
except ImportError:
|
||||
from milc.ansi import format_ansi
|
||||
|
||||
|
||||
def yesno(prompt, *args, default=None, **kwargs):
|
||||
"""Displays prompt to the user and gets a yes or no response.
|
||||
|
||||
Returns True for a yes and False for a no.
|
||||
|
||||
If you add `--yes` and `--no` arguments to your program the user can answer questions by passing command line flags.
|
||||
|
||||
@add_argument('-y', '--yes', action='store_true', arg_only=True, help='Answer yes to all questions.')
|
||||
@add_argument('-n', '--no', action='store_true', arg_only=True, help='Answer no to all questions.')
|
||||
|
||||
Arguments:
|
||||
prompt
|
||||
The prompt to present to the user. Can include ANSI and format strings like milc's `cli.echo()`.
|
||||
|
||||
default
|
||||
Whether to default to a Yes or No when the user presses enter.
|
||||
|
||||
None- force the user to enter Y or N
|
||||
|
||||
True- Default to yes
|
||||
|
||||
False- Default to no
|
||||
"""
|
||||
if not args and kwargs:
|
||||
args = kwargs
|
||||
|
||||
if 'no' in cli.args and cli.args.no:
|
||||
return False
|
||||
|
||||
if 'yes' in cli.args and cli.args.yes:
|
||||
return True
|
||||
|
||||
if default is not None:
|
||||
if default:
|
||||
prompt = prompt + ' [Y/n] '
|
||||
else:
|
||||
prompt = prompt + ' [y/N] '
|
||||
|
||||
while True:
|
||||
cli.echo('')
|
||||
answer = input(format_ansi(prompt % args))
|
||||
cli.echo('')
|
||||
|
||||
if not answer and prompt is not None:
|
||||
return default
|
||||
|
||||
elif answer.lower() in ['y', 'yes']:
|
||||
return True
|
||||
|
||||
elif answer.lower() in ['n', 'no']:
|
||||
return False
|
||||
|
||||
|
||||
def question(prompt, *args, default=None, confirm=False, answer_type=str, validate=None, **kwargs):
|
||||
"""Prompt the user to answer a question with a free-form input.
|
||||
|
||||
Arguments:
|
||||
prompt
|
||||
The prompt to present to the user. Can include ANSI and format strings like milc's `cli.echo()`.
|
||||
|
||||
default
|
||||
The value to return when the user doesn't enter any value. Use None to prompt until they enter a value.
|
||||
|
||||
confirm
|
||||
Present the user with a confirmation dialog before accepting their answer.
|
||||
|
||||
answer_type
|
||||
Specify a type function for the answer. Will re-prompt the user if the function raises any errors. Common choices here include int, float, and decimal.Decimal.
|
||||
|
||||
validate
|
||||
This is an optional function that can be used to validate the answer. It should return True or False and have the following signature:
|
||||
|
||||
def function_name(answer, *args, **kwargs):
|
||||
"""
|
||||
if not args and kwargs:
|
||||
args = kwargs
|
||||
|
||||
if default is not None:
|
||||
prompt = '%s [%s] ' % (prompt, default)
|
||||
|
||||
while True:
|
||||
cli.echo('')
|
||||
answer = input(format_ansi(prompt % args))
|
||||
cli.echo('')
|
||||
|
||||
if answer:
|
||||
if validate is not None and not validate(answer, *args, **kwargs):
|
||||
continue
|
||||
|
||||
elif confirm:
|
||||
if yesno('Is the answer "%s" correct?', answer, default=True):
|
||||
try:
|
||||
return answer_type(answer)
|
||||
except Exception as e:
|
||||
cli.log.error('Could not convert answer (%s) to type %s: %s', answer, answer_type.__name__, str(e))
|
||||
|
||||
else:
|
||||
try:
|
||||
return answer_type(answer)
|
||||
except Exception as e:
|
||||
cli.log.error('Could not convert answer (%s) to type %s: %s', answer, answer_type.__name__, str(e))
|
||||
|
||||
elif default is not None:
|
||||
return default
|
||||
|
||||
|
||||
def choice(heading, options, *args, default=None, confirm=False, prompt='Please enter your choice: ', **kwargs):
|
||||
"""Present the user with a list of options and let them pick one.
|
||||
|
||||
Users can enter either the number or the text of their choice.
|
||||
|
||||
This will return the value of the item they choose, not the numerical index.
|
||||
|
||||
Arguments:
|
||||
heading
|
||||
The text to place above the list of options.
|
||||
|
||||
options
|
||||
A sequence of items to choose from.
|
||||
|
||||
default
|
||||
The index of the item to return when the user doesn't enter any value. Use None to prompt until they enter a value.
|
||||
|
||||
confirm
|
||||
Present the user with a confirmation dialog before accepting their answer.
|
||||
|
||||
prompt
|
||||
The prompt to present to the user. Can include ANSI and format strings like milc's `cli.echo()`.
|
||||
"""
|
||||
if not args and kwargs:
|
||||
args = kwargs
|
||||
|
||||
if prompt and default:
|
||||
prompt = prompt + ' [%s] ' % (default + 1,)
|
||||
|
||||
while True:
|
||||
# Prompt for an answer.
|
||||
cli.echo('')
|
||||
cli.echo(heading % args)
|
||||
cli.echo('')
|
||||
for i, option in enumerate(options, 1):
|
||||
cli.echo('\t{fg_cyan}%d.{fg_reset} %s', i, option)
|
||||
|
||||
cli.echo('')
|
||||
answer = input(format_ansi(prompt))
|
||||
cli.echo('')
|
||||
|
||||
# If the user types in one of the options exactly use that
|
||||
if answer in options:
|
||||
return answer
|
||||
|
||||
# Massage the answer into a valid integer
|
||||
if answer == '' and default:
|
||||
answer = default
|
||||
else:
|
||||
try:
|
||||
answer = int(answer) - 1
|
||||
except Exception:
|
||||
# Normally we would log the exception here, but in the interest of clean UI we do not.
|
||||
cli.log.error('Invalid choice: %s', answer + 1)
|
||||
continue
|
||||
|
||||
# Validate the answer
|
||||
if answer >= len(options) or answer < 0:
|
||||
cli.log.error('Invalid choice: %s', answer + 1)
|
||||
continue
|
||||
|
||||
if confirm and not yesno('Is the answer "%s" correct?', answer + 1, default=True):
|
||||
continue
|
||||
|
||||
# Return the answer they chose.
|
||||
return options[answer]
|
||||
|
|
@ -1,7 +1,7 @@
|
|||
# Python requirements
|
||||
# milc FIXME(skullydazed): Included in the repo for now.
|
||||
appdirs
|
||||
argcomplete
|
||||
colorama
|
||||
hjson
|
||||
milc
|
||||
pygments
|
||||
|
|
|
|||
Loading…
Reference in a new issue