diff options
Diffstat (limited to 'lib/python')
| -rw-r--r-- | lib/python/milc.py | 826 | ||||
| -rw-r--r-- | lib/python/qmk/cli/__init__.py | 1 | ||||
| -rw-r--r-- | lib/python/qmk/cli/chibios/__init__.py | 1 | ||||
| -rw-r--r-- | lib/python/qmk/cli/chibios/confmigrate.py | 161 | ||||
| -rwxr-xr-x | lib/python/qmk/cli/doctor.py | 2 | ||||
| -rw-r--r-- | lib/python/qmk/questions.py | 183 |
6 files changed, 164 insertions, 1010 deletions
diff --git a/lib/python/milc.py b/lib/python/milc.py deleted file mode 100644 index 0cdd43dc89..0000000000 --- a/lib/python/milc.py +++ /dev/null @@ -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() diff --git a/lib/python/qmk/cli/__init__.py b/lib/python/qmk/cli/__init__.py index 77724a2448..10536bb230 100644 --- a/lib/python/qmk/cli/__init__.py +++ b/lib/python/qmk/cli/__init__.py @@ -8,6 +8,7 @@ from milc import cli from . import c2json from . import cformat +from . import chibios from . import clean from . import compile from . import config diff --git a/lib/python/qmk/cli/chibios/__init__.py b/lib/python/qmk/cli/chibios/__init__.py new file mode 100644 index 0000000000..4301837def --- /dev/null +++ b/lib/python/qmk/cli/chibios/__init__.py @@ -0,0 +1 @@ +from . import confmigrate diff --git a/lib/python/qmk/cli/chibios/confmigrate.py b/lib/python/qmk/cli/chibios/confmigrate.py new file mode 100644 index 0000000000..eae294a0c6 --- /dev/null +++ b/lib/python/qmk/cli/chibios/confmigrate.py @@ -0,0 +1,161 @@ +"""This script automates the copying of the default keymap into your own keymap. +""" +import re +import sys +import os + +from qmk.constants import QMK_FIRMWARE +from qmk.path import normpath +from milc import cli + + +def eprint(*args, **kwargs): + print(*args, file=sys.stderr, **kwargs) + + +fileHeader = """\ +/* Copyright 2020 QMK + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +/* + * This file was auto-generated by: + * `qmk chibios-confupdate -i {0} -r {1}` + */ + +#pragma once +""" + + +def collect_defines(filepath): + with open(filepath, 'r') as f: + content = f.read() + define_search = re.compile(r'(?m)^#\s*define\s+(?:.*\\\r?\n)*.*$', re.MULTILINE) + value_search = re.compile(r'^#\s*define\s+(?P<name>[a-zA-Z0-9_]+(\([^\)]*\))?)\s*(?P<value>.*)', re.DOTALL) + define_matches = define_search.findall(content) + + defines = {"keys": [], "dict": {}} + for define_match in define_matches: + value_match = value_search.search(define_match) + defines["keys"].append(value_match.group("name")) + defines["dict"][value_match.group("name")] = value_match.group("value") + return defines + + +def check_diffs(input_defs, reference_defs): + not_present_in_input = [] + not_present_in_reference = [] + to_override = [] + + for key in reference_defs["keys"]: + if key not in input_defs["dict"]: + not_present_in_input.append(key) + continue + + for key in input_defs["keys"]: + if key not in input_defs["dict"]: + not_present_in_input.append(key) + continue + + for key in input_defs["keys"]: + if key in reference_defs["keys"] and input_defs["dict"][key] != reference_defs["dict"][key]: + to_override.append((key, input_defs["dict"][key])) + + return (to_override, not_present_in_input, not_present_in_reference) + + +def migrate_chconf_h(to_override, outfile): + print(fileHeader.format(cli.args.input.relative_to(QMK_FIRMWARE), cli.args.reference.relative_to(QMK_FIRMWARE)), file=outfile) + + for override in to_override: + print("#define %s %s" % (override[0], override[1]), file=outfile) + print("", file=outfile) + + print("#include_next <chconf.h>\n", file=outfile) + + +def migrate_halconf_h(to_override, outfile): + print(fileHeader.format(cli.args.input.relative_to(QMK_FIRMWARE), cli.args.reference.relative_to(QMK_FIRMWARE)), file=outfile) + + for override in to_override: + print("#define %s %s" % (override[0], override[1]), file=outfile) + print("", file=outfile) + + print("#include_next <halconf.h>\n", file=outfile) + + +def migrate_mcuconf_h(to_override, outfile): + print(fileHeader.format(cli.args.input.relative_to(QMK_FIRMWARE), cli.args.reference.relative_to(QMK_FIRMWARE)), file=outfile) + + print("#include_next <mcuconf.h>\n", file=outfile) + + for override in to_override: + print("#undef %s" % (override[0]), file=outfile) + print("#define %s %s" % (override[0], override[1]), file=outfile) + print("", file=outfile) + + +@cli.argument('-i', '--input', type=normpath, arg_only=True, help='Specify input config file.') +@cli.argument('-r', '--reference', type=normpath, arg_only=True, help='Specify the reference file to compare against') +@cli.argument('-o', '--overwrite', arg_only=True, action='store_true', help='Overwrites the input file during migration.') +@cli.argument('-d', '--delete', arg_only=True, action='store_true', help='If the file has no overrides, migration will delete the input file.') +@cli.subcommand('Generates a migrated ChibiOS configuration file, as a result of comparing the input against a reference') +def chibios_confmigrate(cli): + """Generates a usable ChibiOS replacement configuration file, based on a fully-defined conf and a reference config. + """ + + input_defs = collect_defines(cli.args.input) + reference_defs = collect_defines(cli.args.reference) + + (to_override, not_present_in_input, not_present_in_reference) = check_diffs(input_defs, reference_defs) + + if len(not_present_in_input) > 0: + eprint("Keys not in input, but present inside reference (potential manual migration required):") + for key in not_present_in_input: + eprint(" %s" % (key)) + + if len(not_present_in_reference) > 0: + eprint("Keys not in reference, but present inside input (potential manual migration required):") + for key in not_present_in_reference: + eprint(" %s" % (key)) + + if len(to_override) == 0: + eprint('No overrides found! If there were no missing keys above, it should be safe to delete the input file.') + if cli.args.delete: + os.remove(cli.args.input) + else: + eprint('Overrides found:') + for override in to_override: + eprint("%40s: %s -> %s" % (override[0], reference_defs["dict"][override[0]].encode('unicode_escape').decode("utf-8"), override[1].encode('unicode_escape').decode("utf-8"))) + + eprint('--------------------------------------') + + if "CHCONF_H" in input_defs["dict"] or "_CHCONF_H_" in input_defs["dict"]: + migrate_chconf_h(to_override, outfile=sys.stdout) + if cli.args.overwrite: + with open(cli.args.input, "w") as out_file: + migrate_chconf_h(to_override, outfile=out_file) + + elif "HALCONF_H" in input_defs["dict"] or "_HALCONF_H_" in input_defs["dict"]: + migrate_halconf_h(to_override, outfile=sys.stdout) + if cli.args.overwrite: + with open(cli.args.input, "w") as out_file: + migrate_halconf_h(to_override, outfile=out_file) + + elif "MCUCONF_H" in input_defs["dict"] or "_MCUCONF_H_" in input_defs["dict"]: + migrate_mcuconf_h(to_override, outfile=sys.stdout) + if cli.args.overwrite: + with open(cli.args.input, "w") as out_file: + migrate_mcuconf_h(to_override, outfile=out_file) diff --git a/lib/python/qmk/cli/doctor.py b/lib/python/qmk/cli/doctor.py index a5eda555f0..4fe318b636 100755 --- a/lib/python/qmk/cli/doctor.py +++ b/lib/python/qmk/cli/doctor.py @@ -10,9 +10,9 @@ from pathlib import Path from enum import Enum 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 diff --git a/lib/python/qmk/questions.py b/lib/python/qmk/questions.py deleted file mode 100644 index 865c6bbdc5..0000000000 --- a/lib/python/qmk/questions.py +++ /dev/null @@ -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] |