New release: 0.0.41 → 0.0.42

* refactor to make the code clearer in some places
* don't call bin/qmk anymore
* ask the user if they want to install python modules when they're missing

.github/workflows/cli_setup.yml

@@ -0,0 +1,71 @@
+name: CLI Setup
+
+on:
+  push:
+    branches:
+    - master
+  pull_request:
+
+jobs:
+  test_cli_linux_macos:
+    runs-on: ${{ matrix.os }}
+    env:
+      QMK_HOME: ~/qmk_firmware
+    strategy:
+      matrix:
+        os: [macos-latest, ubuntu-latest]
+        python-version: [3.7, 3.8, 3.9]
+
+    steps:
+    - uses: actions/checkout@v1
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v1
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install Python dependencies
+      run: |
+        python3 -m pip install wheel
+        echo "$HOME/.local/bin" >> $GITHUB_PATH
+
+    - name: Install QMK CLI from source
+      run: |
+        python3 -m pip install -r requirements.txt
+        python3 setup.py sdist bdist_wheel
+        cd ..
+        python3 -m pip install --force-reinstall --no-index --no-deps --prefix=~/.local --find-links qmk_cli/dist qmk
+
+    - name: Run qmk setup -y
+      run: qmk setup -y
+
+  test_cli_win:
+    runs-on: windows-latest
+    env:
+      QMK_HOME: $HOME/qmk_firmware
+
+    steps:
+    - uses: actions/checkout@v1
+
+    - name: (MSYS2) Setup and install dependencies
+      uses: msys2/setup-msys2@v2
+      with:
+        update: true
+        install: git mingw-w64-x86_64-toolchain mingw-w64-x86_64-python-pip
+
+    - name: (MSYS2) Install Python dependencies
+      shell: msys2 {0}
+      run: |
+        python3 -m pip install wheel
+
+    - name: (MSYS2) Install QMK CLI from source
+      shell: msys2 {0}
+      run: |
+        python3 -m pip install -r requirements.txt
+        python3 setup.py sdist bdist_wheel
+        cd ..
+        python3 -m pip install --force-reinstall --no-index --no-deps --find-links qmk_cli/dist qmk
+
+    - name: (MSYS2) Run qmk setup -y
+      shell: msys2 {0}
+      run: qmk setup -y

CODE_OF_CONDUCT.md

@@ -1,15 +0,0 @@
-# Code Of Conduct
-
-QMK strives to be an inclusive, tolerant, and welcoming community. We encourage participation from anyone regardless of age, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, political belief, race, religion, or sexual identity and orientation.
-
-> “A gentle word turns away wrath, but a harsh word stirs up anger."
-
-Our users, contributors, and collaborators are expected to treat each other with kindness and respect, to assume good intentions, and to gently correct, where possible, rather than react with escalation. While our goal is to be as accurate as possible, kindness and understanding are more valuable than correctness. Some examples of behavior we will not tolerate include, but is not limited to:
-
-* The use of sexualized language or imagery
-* Unwelcome advances, sexual or otherwise
-* Insults or derogatory comments, or personal or political attacks
-* Publishing others’ private information without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a professional setting
-
-If someone is violating this Code of Conduct you may email hello@qmk.fm to bring your concern to the Members. All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. 

README.md

@@ -1,5 +1,5 @@
 # QMK CLI
-
+[![CLI Setup](https://github.com/qmk/qmk_cli/workflows/CLI%20Setup/badge.svg)](https://github.com/qmk/qmk_cli/actions?query=workflow%3A%22CLI+Setup%22)  
 A program to help users work with [QMK Firmware](https://qmk.fm/).
 
 # Features
@@ -14,4 +14,9 @@ A program to help users work with [QMK Firmware](https://qmk.fm/).
 
 # Quickstart
 
-To be written.
+Full documentation: <https://docs.qmk.fm/#/tutorial>
+
+Basic steps:
+
+* `python3 -m pip install qmk`
+* `qmk setup`

milc.py

@@ -1,740 +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 sys
-from decimal import Decimal
-from pathlib import Path
-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 ANSIFormatter(logging.Formatter):
-    """A log formatter that inserts ANSI color.
-    """
-    def format(self, record):
-        msg = super(ANSIFormatter, self).format(record)
-        return format_ansi(msg)
-
-
-class ANSIEmojiLoglevelFormatter(ANSIFormatter):
-    """A log formatter 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(ANSIEmojiLoglevelFormatter, self).format(record)
-
-
-class ANSIStrippingFormatter(ANSIFormatter):
-    """A log formatter that strips ANSI.
-    """
-    def format(self, record):
-        msg = super(ANSIStrippingFormatter, self).format(record)
-        return ansi_escape.sub('', msg)
-
-
-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.
-        """
-        if key in self._config:
-            return self._config[key]
-
-        elif 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 'action' in kwargs and kwargs['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()
-        self.subparser.add_argument(*args, **kwargs)
-        if self.submodule not in self.cli.default_arguments:
-            self.cli.default_arguments[self.submodule] = {}
-        self.cli.default_arguments[self.submodule][self.cli.get_argument_name(*args, **kwargs)] = 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._description = None
-        self._entrypoint = None
-        self._inside_context_manager = False
-        self.ansi = ansi_colors
-        self.arg_only = []
-        self.config = None
-        self.config_file = None
-        self.default_arguments = {}
-        self.version = 'unknown'
-        self.release_lock()
-
-        # 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]
-
-        # 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 args and kwargs:
-            raise RuntimeError('You can only specify *args or **kwargs, not both!')
-
-        args = args or kwargs
-        text = format_ansi(text)
-
-        print(text % args)
-
-    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()
-
-    def initialize_arguments(self):
-        """Setup the global parser arguments
-        """
-        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')
-
-    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):
-            if 'arg_only' in kwargs and kwargs['arg_only']:
-                arg_name = self.get_argument_name(*args, **kwargs)
-                self.arg_only.append(arg_name)
-                del kwargs['arg_only']
-
-            name = handler.__name__.replace("_", "-")
-            if handler is self._entrypoint:
-                self.add_argument(*args, **kwargs)
-
-            elif name in self.subcommands:
-                self.subcommands[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_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', 'none', 'off']:
-                        value = False
-                    elif value.replace('.', '').isdigit():
-                        if '.' in value:
-                            value = Decimal(value)
-                        else:
-                            value = int(value)
-
-                    self.config[section][option] = value
-
-        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
-
-            if argument not in self.arg_only:
-                # Find the argument's section
-                argument_found = True
-                for group in self.default_arguments:
-                    if argument in self.default_arguments[group]:
-                        argument_found = True
-                        section = group
-                        break
-
-                if not argument_found:
-                    raise RuntimeError('Could not find argument in `self.default_arguments`. This should be impossible!')
-                    exit(1)
-
-                # Merge this argument into self.config
-                if argument in self.default_arguments:
-                    arg_value = getattr(self.args, argument)
-                    if arg_value:
-                        self.config[section][argument] = arg_value
-                else:
-                    if argument not in self.config[section]:
-                        self.config[section][argument] = getattr(self.args, 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
-                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.rename(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, **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()
-
-        if not name:
-            name = handler.__name__.replace("_", "-")
-
-        self.acquire_lock()
-
-        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, **kwargs):
-        """Decorator to register a subcommand.
-        """
-        def subcommand_function(handler):
-            return self.add_subcommand(handler, description, **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 = self.config['general']['log_file_fmt']
-        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.args.log_fmt, self.config.general.datetime_fmt)
-        else:
-            self.log_format = ANSIStrippingFormatter(self.args.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.initialize_arguments()
-        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()

qmk_cli/__init__.py

@@ -1,3 +1,3 @@
 """A program to help you work with qmk_firmware."""
 
-__version__ = '0.0.21'
+__version__ = '0.0.42'

qmk_cli/git.py

@@ -9,24 +9,32 @@ default_fork = 'qmk/' + default_repo
 default_branch = 'master'
 
 
-def clone(url, destination, branch):
+def git_clone(url, destination, branch):
     git_clone = [
         'git',
         'clone',
         '--recurse-submodules',
         '--branch=' + branch,
         url,
-        destination,
+        str(destination),
     ]
     cli.log.debug('Git clone command: %s', git_clone)
 
-    with subprocess.Popen(git_clone, stderr=subprocess.STDOUT, stdout=subprocess.PIPE, bufsize=1, universal_newlines=True) as p:
-        for line in p.stdout:
-            print(line, end='')
+    try:
+        with subprocess.Popen(git_clone, stderr=subprocess.STDOUT, stdout=subprocess.PIPE, bufsize=1, universal_newlines=True, encoding='utf-8') as p:
+            for line in p.stdout:
+                print(line, end='')
 
-    if p.returncode != 0:
+    except Exception as e:
+        git_cmd = ' '.join([s.replace(' ', r'\ ') for s in git_clone])
+
+        cli.log.error("Could not run '%s': %s: %s", git_cmd, e.__class__.__name__, e)
+        return False
+
+    if p.returncode == 0:
+        cli.log.info('Successfully cloned %s to %s!', url, destination)
+        return True
+
+    else:
         cli.log.error('git clone exited %d', p.returncode)
         return False
-    else:
-        cli.log.info('Successfully cloned %s to %s!', cli.args.fork, cli.args.destination)
-        return True

qmk_cli/helpers.py

@@ -1,35 +1,114 @@
 """Useful helper functions.
 """
+import os
+from functools import lru_cache
+from importlib.util import find_spec
+from pathlib import Path
+
 from milc import cli
 
 
-def question(question, boolean=True, default=''):
-    """Asks the user to answer a question.
-
-    This keeps re-asking until it gets acceptible input.
+def is_qmk_firmware(qmk_firmware):
+    """Returns True if the given Path() is a qmk_firmware clone.
     """
-    if cli.args.yes:
-        return True
+    paths = [
+        qmk_firmware,
+        qmk_firmware / 'quantum',
+        qmk_firmware / 'requirements.txt',
+        qmk_firmware / 'requirements-dev.txt',
+        qmk_firmware / 'lib/python/qmk/cli/doctor.py'
+    ]
 
-    if default and default.lower() == 'y':
-        answer_key = 'Y/n'
-    elif default and default.lower() == 'n':
-        answer_key = 'y/N'
-    else:
-        answer_key = 'y/n'
-
-    prompt = '*** %s [%s] ' % (question, answer_key)
-
-    while True:
-        answer = input(prompt)
-        if answer == '' and default.lower() == 'y':
-            answer = 'y'
-        elif answer == '' and default.lower() == 'n':
-            answer = 'n'
-
-        if answer.lower() in ['y', 'yes']:
-            return True
-        elif answer.lower() in ['n', 'no']:
+    for path in paths:
+        if not path.exists():
             return False
-        else:
-            cli.args.echo('Invalid answer!')
+
+    return True
+
+
+def broken_module_imports():
+    """Make sure we can import all the python modules.
+    """
+    broken_modules = find_broken_requirements('requirements.txt')
+    broken_dev_modules = find_broken_requirements('requirements-dev.txt') if cli.config.user.developer else []
+    to_return = [False, False]
+
+    if broken_modules:
+        to_return[0] = True
+
+    if broken_dev_modules:
+        to_return[1] = True
+
+    for module in broken_modules + broken_dev_modules:
+        print('Could not find module %s!' % module)
+
+    return to_return
+
+
+def find_broken_requirements(requirements):
+    """ Check if the modules in the given requirements.txt are available.
+
+    Args:
+
+        requirements
+            The path to a requirements.txt file
+
+    Returns a list of modules that couldn't be imported
+    """
+    with Path(requirements).open() as fd:
+        broken_modules = []
+
+        for line in fd.readlines():
+            line = line.strip().replace('<', '=').replace('>', '=')
+
+            if len(line) == 0 or line[0] == '#' or line.startswith('-r'):
+                continue
+
+            if '#' in line:
+                line = line.split('#')[0]
+
+            module_name = line.split('=')[0] if '=' in line else line
+            module_import_name = module_name.replace('-', '_')
+
+            # Not every module is importable by its own name.
+            if module_name == "pep8-naming":
+                module_import_name = "pep8ext_naming"
+
+            if not find_spec(module_import_name):
+                broken_modules.append(module_name)
+
+        return broken_modules
+
+
+@lru_cache(maxsize=2)
+def find_qmk_firmware():
+    """Look for qmk_firmware in the usual places.
+
+    This function returns the path to qmk_firmware, or the default location if one does not exist.
+    """
+    if in_qmk_firmware():
+        return in_qmk_firmware()
+
+    if cli.config.user.qmk_home:
+        return Path(cli.config.user.qmk_home).expanduser().resolve()
+
+    if 'QMK_HOME' in os.environ:
+        path = Path(os.environ['QMK_HOME']).expanduser()
+        if path.exists():
+            return path.resolve()
+        return path
+
+    return Path.home() / 'qmk_firmware'
+
+
+def in_qmk_firmware():
+    """Returns the path to the qmk_firmware we are currently in, or None if we are not inside qmk_firmware.
+    """
+    cur_dir = Path.cwd()
+    while len(cur_dir.parents) > 0:
+        if is_qmk_firmware(cur_dir):
+            return cur_dir
+
+        # Move up a directory before the next iteration
+        cur_dir = cur_dir / '..'
+        cur_dir = cur_dir.resolve()

qmk_cli/script_qmk.py

@@ -2,18 +2,19 @@
 """CLI wrapper for running QMK commands.
 
 This program can be run from anywhere, with or without a qmk_firmware repository. If a qmk_firmware repository can be located we will use that to augment our available subcommands.
-
-FIXME(skullydazed/anyone): --help shows underscores where we want dashes in subcommands (EG json_keymap instead of json-keymap)
-TODO(skullydazed/anyone): Need a way to filter some subcommands from --help (EG `qmk hello`)
 """
-import argparse
 import os
+import shlex
 import subprocess
 import sys
-from functools import lru_cache
-from pathlib import Path
+from platform import platform
+from traceback import print_exc
 
 import milc
+import milc.subcommand.config  # noqa
+from milc.questions import yesno
+
+from .helpers import broken_module_imports, find_qmk_firmware, is_qmk_firmware
 
 milc.EMOJI_LOGLEVELS['INFO'] = '{fg_blue}Ψ{style_reset_all}'
 
@@ -25,48 +26,35 @@ def qmk_main(cli):
     cli.print_help()
 
 
-@lru_cache(maxsize=2)
-def in_qmk_firmware():
-    """Returns the path to the qmk_firmware we are currently in, or None if we are not inside qmk_firmware.
+def run_cmd(*command):
+    """Run a command in a subshell.
     """
-    cur_dir = Path.cwd()
-    while len(cur_dir.parents) > 0:
-        found_bin = cur_dir / 'bin' / 'qmk'
-        if found_bin.is_file():
-            command = [found_bin.as_posix(), '--version']
-            result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    if 'windows' in milc.cli.platform.lower():
+        safecmd = map(shlex.quote, command)
+        safecmd = ' '.join(safecmd)
+        command = [os.environ['SHELL'], '-c', safecmd]
 
-            if result.returncode == 0:
-                return cur_dir
-
-        # Move up a directory before the next iteration
-        cur_dir = cur_dir / '..'
-        cur_dir = cur_dir.resolve()
-
-
-def find_qmk_firmware():
-    """Look for qmk_firmware in the usual places.
-
-    This function returns the path to qmk_firmware, or the default location if one does not exist.
-    """
-    if in_qmk_firmware():
-        return in_qmk_firmware()
-
-    if milc.cli.config.user.qmk_home:
-        return Path(milc.cli.config.user.qmk_home).expanduser().resolve()
-
-    if 'QMK_HOME' in os.environ:
-        path = Path(os.environ['QMK_HOME']).expanduser()
-        if path.exists():
-            return path.resolve()
-        return path
-
-    return Path.home() / 'qmk_firmware'
+    return subprocess.run(command)
 
 
+# Python setuptools entrypoint
 def main():
     """Setup the environment before dispatching to the entrypoint.
     """
+    # Warn if they use an outdated python version
+    if sys.version_info < (3, 7):
+        print('Warning: Your Python version is out of date! Some subcommands may not work!')
+        print('Please upgrade to Python 3.7 or later.')
+
+    if 'windows' in platform().lower():
+        msystem = os.environ.get('MSYSTEM', '')
+
+        if 'mingw64' not in sys.executable or 'MINGW64' not in msystem:
+            print('ERROR: It seems you are not using the MINGW64 terminal.')
+            print('Please close this terminal and open a new MSYS2 MinGW 64-bit terminal.')
+            print('Python: %s, MSYSTEM: %s' % (sys.executable, msystem))
+            exit(1)
+
     # Environment setup
     import qmk_cli
     milc.cli.version = qmk_cli.__version__
@@ -74,13 +62,61 @@ def main():
     os.environ['QMK_HOME'] = str(qmk_firmware)
     os.environ['ORIG_CWD'] = os.getcwd()
 
-    # Import the subcommand modules
     import qmk_cli.subcommands
 
-    if qmk_firmware.exists():
+    # Check out and initialize the qmk_firmware environment
+    if is_qmk_firmware(qmk_firmware):
+        # All subcommands are run relative to the qmk_firmware root to make it easier to use the right copy of qmk_firmware.
         os.chdir(str(qmk_firmware))
-        sys.path.append(str(qmk_firmware / 'lib' / 'python'))
-        import qmk.cli
+
+        # Check to make sure we have all the requirements
+        broken_modules, broken_dev_modules = broken_module_imports()
+        msg_install = 'Please run `python3 -m pip install -r %s` to install required python dependencies.'
+
+        if broken_modules:
+            if yesno('Would you like to install the required Python modules?'):
+                run_cmd(sys.executable, '-m', 'pip', 'install', '-r', 'requirements.txt')
+            else:
+                print()
+                print(msg_install % (os.environ['QMK_HOME'] + '/requirements.txt',))
+                print()
+                exit(1)
+
+        if broken_dev_modules:
+            if yesno('Would you like to install the required developer Python modules?'):
+                run_cmd(sys.executable, '-m', 'pip', 'install', '-r', 'requirements.txt')
+            else:
+                print()
+                print(msg_install % (os.environ['QMK_HOME'] + '/requirements-dev.txt',))
+                print('You can also turn off developer mode: qmk config user.developer=None')
+                print()
+                exit(1)
+
+        # Environment looks good, include the qmk_firmware subcommands
+        sys.path.append(str(qmk_firmware / 'lib/python'))
+
+        try:
+            import qmk.cli  # noqa
+
+        except ImportError as e:
+            if qmk_firmware.name != 'qmk_firmware':
+                print('Warning: %s does not end in "qmk_firmware". Do you need to set QMK_HOME to "%s/qmk_firmware"?' % (qmk_firmware, qmk_firmware))
+
+            print('Error: %s: %s', (e.__class__.__name__, e))
+            print_exc()
+            sys.exit(1)
 
     # Call the entrypoint
-    milc.cli()
+    return_code = milc.cli()
+
+    if return_code is False:
+        exit(1)
+
+    elif return_code is not True and isinstance(return_code, int):
+        if return_code < 0 or return_code > 255:
+            milc.cli.log.error('Invalid return_code: %d', return_code)
+            exit(255)
+
+        exit(return_code)
+
+    exit(0)

qmk_cli/subcommands/__init__.py

@@ -2,5 +2,5 @@
 
 We list each subcommand here explicitly because all the reliable ways of searching for modules are slow and delay startup.
 """
-from . import clone
-from . import setup
+from . import clone  # noqa
+from . import setup  # noqa

qmk_cli/subcommands/clone.py

@@ -4,7 +4,7 @@ import os
 from pathlib import Path
 
 from milc import cli
-from qmk_cli.git import clone as git_clone
+from qmk_cli.git import git_clone
 
 default_repo = 'qmk_firmware'
 default_fork = 'qmk/' + default_repo
@@ -12,9 +12,9 @@ default_branch = 'master'
 
 
 @cli.argument('--baseurl', default='https://github.com', help='The URL all git operations start from (Default: https://github.com)')
-@cli.argument('-b', '--branch', default=default_branch, help='The branch to clone (Default: %s)' % default_branch)
-@cli.argument('destination', default=None, nargs='?', help='The directory to clone to (Default: Current Directory)')
-@cli.argument('fork', default=default_fork, nargs='?', help='The qmk_firmware fork to clone (Default: %s)' % default_fork)
+@cli.argument('-b', '--branch', default=default_branch, help='The branch to clone. Default: %s' % default_branch)
+@cli.argument('destination', default=None, nargs='?', help='The directory to clone to. Default: (current directory)')
+@cli.argument('fork', default=default_fork, nargs='?', help='The qmk_firmware fork to clone. Default: %s' % default_fork)
 @cli.subcommand('Clone a qmk_firmware fork.')
 def clone(cli):
     if not cli.args.destination:
@@ -27,5 +27,4 @@ def clone(cli):
         cli.log.error('Destination already exists: %s', cli.args.destination)
         exit(1)
 
-    success = git_clone(git_url, cli.args.destination, cli.config.clone.branch)
-    exit(0 if success else 1)
+    return git_clone(git_url, cli.args.destination, cli.config.clone.branch)

qmk_cli/subcommands/setup.py

@@ -1,48 +1,101 @@
 """Setup qmk_firmware on your computer.
 """
 import os
+import shlex
 import subprocess
 import sys
 from pathlib import Path
 
 from milc import cli
-from qmk_cli.git import clone
-from qmk_cli.helpers import question
+from milc.questions import yesno
+from qmk_cli.git import git_clone
+from qmk_cli.helpers import is_qmk_firmware
 
+default_base = 'https://github.com'
 default_repo = 'qmk_firmware'
 default_fork = 'qmk/' + default_repo
 default_branch = 'master'
 
 
-@cli.argument('-y', '--yes', action='store_true', help='Answer yes to all questions')
-@cli.argument('--baseurl', default='https://github.com', help='The URL all git operations start from')
-@cli.argument('-b', '--branch', default=default_branch, help='The branch to clone')
-@cli.argument('destination', default=os.environ['QMK_HOME'], nargs='?', help='The directory to clone to')
-@cli.argument('fork', default=default_fork, nargs='?', help='The qmk_firmware fork to clone')
+def git_upstream(destination):
+    """Add the qmk/qmk_firmware upstream to a qmk_firmware clone.
+    """
+    git_url = '/'.join((cli.config.setup.baseurl, default_fork))
+    git_cmd = [
+        'git',
+        '-C',
+        destination,
+        'remote',
+        'add',
+        'upstream',
+        git_url,
+    ]
+
+    with subprocess.Popen(git_cmd, stderr=subprocess.STDOUT, stdout=subprocess.PIPE, bufsize=1, universal_newlines=True, encoding='utf-8') as p:
+        for line in p.stdout:
+            print(line, end='')
+
+    if p.returncode == 0:
+        cli.log.info('Added %s as remote upstream.', git_url)
+        return True
+    else:
+        cli.log.error('%s exited %d', ' '.join(git_cmd), p.returncode)
+        return False
+
+
+@cli.argument('-n', '--no', arg_only=True, action='store_true', help='Answer no to all questions')
+@cli.argument('-y', '--yes', arg_only=True, action='store_true', help='Answer yes to all questions')
+@cli.argument('--baseurl', default=default_base, help='The URL all git operations start from. Default: %s' % default_base)
+@cli.argument('-b', '--branch', default=default_branch, help='The branch to clone. Default: %s' % default_branch)
+@cli.argument('-H', '--home', default=Path(os.environ['QMK_HOME']), type=Path, help='The location for QMK Firmware. Default: %s' % os.environ['QMK_HOME'])
+@cli.argument('fork', default=default_fork, nargs='?', help='The qmk_firmware fork to clone. Default: %s' % default_fork)
 @cli.subcommand('Setup your computer for qmk_firmware.')
 def setup(cli):
-    qmk_firmware = Path(cli.args.destination)
+    """Guide the user through setting up their QMK environment.
+    """
+    clone_prompt = 'Would you like to clone {fg_cyan}%s{fg_reset} to {fg_cyan}%s{fg_reset}?' % (cli.args.fork, shlex.quote(str(cli.args.home)))
+    home_prompt = 'Would you like to set {fg_cyan}%s{fg_reset} as your QMK home?' % (shlex.quote(str(cli.args.home)),)
+
+    # Sanity checks
+    if cli.args.yes and cli.args.no:
+        cli.log.error("Can't use both --yes and --no at the same time.")
+        exit(1)
 
     # Check on qmk_firmware, and if it doesn't exist offer to check it out.
-    if qmk_firmware.exists():
-        cli.log.info('Found qmk_firmware at %s.', str(qmk_firmware))
+    if is_qmk_firmware(cli.args.home):
+        cli.log.info('Found qmk_firmware at %s.', str(cli.args.home))
+
+    elif cli.args.home.exists():
+        path_str = str(cli.args.home)
+
+        if cli.args.home.name != 'qmk_firmware':
+            cli.log.warning('Warning: %s does not end in "qmk_firmware". Did you mean to use "--home %s/qmk_firmware"?' % (path_str, path_str))
+
+        cli.log.error("Path '%s' exists but is not a qmk_firmware clone!", path_str)
+        exit(1)
+
     else:
-        cli.log.error('qmk_firmware not found!')
-        if question('Would you like to clone %s?' % cli.args.fork):
+        cli.log.error('Could not find qmk_firmware!')
+        if yesno(clone_prompt):
             git_url = '/'.join((cli.config.setup.baseurl, cli.args.fork))
-            clone(git_url, cli.args.destination, cli.config.setup.branch)
 
-    # Run `qmk_firmware/bin/qmk doctor` to check the rest of the environment out
-    if qmk_firmware.exists():
-        qmk_bin = qmk_firmware / 'bin' / 'qmk'
-        doctor = subprocess.run([sys.executable, qmk_bin, 'doctor'])
-        if doctor.returncode != 0:
-            cli.log.error('Your build environment is not setup completely.')
+            if git_clone(git_url, cli.args.home, cli.config.setup.branch):
+                git_upstream(cli.args.home)
+            else:
+                exit(1)
 
-            if question('Would you like to run util/qmk_install?'):
-                curdir = os.getcwd()
-                os.chdir(str(qmk_firmware))
-                process = subprocess.run(['util/qmk_install.sh'])
-                os.chdir(curdir)
-                if process.returncode == 0:
-                    cli.log.info('QMK setup complete!')
+    # Offer to set `user.qmk_home` for them.
+    if str(cli.args.home) != os.environ['QMK_HOME'] and yesno(home_prompt):
+        cli.config['user']['qmk_home'] = str(cli.args.home.absolute())
+        cli.write_config_option('user', 'qmk_home')
+
+    # Run `qmk doctor` to check the rest of the environment out
+    doctor_command = [sys.executable, sys.argv[0], 'doctor']
+
+    if cli.args.no:
+        doctor_command.append('--no')
+
+    if cli.args.yes:
+        doctor_command.append('--yes')
+
+    cli.run(doctor_command, capture_output=False)

release

@@ -1,4 +1,4 @@
-#!/bin/sh
+#!/bin/bash
 # Increment the verison number and release a new version of qmk_cli.
 #
 # Required packages: pip3 install bumpversion twine
@@ -12,13 +12,21 @@ TWINE_USERNAME=$PYPI_USERNAME
 
 export FLIT_USERNAME TWINE_USERNAME
 
-rm dist/*
+if ! bumpversion -h &> /dev/null; then
+	echo "Missing bumpversion! Please run: pip3 install -U -r requirements-dev.txt"
+	exit 1
+fi
+
+if ! twine -h &> /dev/null; then
+	echo "Missing twine! Please run: pip3 install -U -r requirements-dev.txt"
+	exit 1
+fi
+
+# Bump the version, tag, and push
+rm -f dist/*
 bumpversion patch
 git push origin master --tags
 
-# For now we don't use flit
-#flit publish
-
-# Use setuptools until flit works with homebrew
+# Build and upload
 python3 setup.py sdist bdist_wheel
 twine upload dist/qmk-*

requirements-dev.txt

@@ -0,0 +1,2 @@
+bumpversion
+twine

setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.0.21
+current_version = 0.0.42
 commit = True
 tag = True
 tag_name = {new_version}
@@ -23,7 +23,7 @@ dist-name = qmk
 license_file = LICENSE
 module = qmk_cli
 home-page = https://github.com/qmk/qmk_cli
-requires-python = >=3.5
+requires-python = >=3.7
 
 [entry_points]
 qmk = qmk_cli.script_qmk:main
@@ -80,4 +80,3 @@ split_penalty_for_added_line_split = 30
 split_penalty_import_names = 0
 split_penalty_logical_operator = 300
 use_tabs = False
-

setup.py

@@ -7,12 +7,12 @@ metadata = setup_cfg['metadata']
 
 if __name__ == "__main__":
     with open('README.md', encoding='utf-8') as readme_file:
-        long_description=readme_file.read()
+        long_description = readme_file.read()
     setup(
         name=metadata['dist-name'],
         description='A program to help users work with QMK Firmware.',
         entry_points={
-            'console_scripts': ['%s = %s' % l for l in setup_cfg['entry_points'].items()],
+            'console_scripts': ['%s = %s' % i for i in setup_cfg['entry_points'].items()],
         },
         license='MIT License',
         url=metadata['home-page'],
@@ -24,7 +24,7 @@ if __name__ == "__main__":
         long_description=long_description,
         long_description_content_type="text/markdown",
         packages=find_packages(),
-        py_modules = ['milc'],
+        py_modules=['milc'],
         classifiers=[
             'Development Status :: 3 - Alpha',
             'Environment :: Console',
@@ -38,13 +38,18 @@ if __name__ == "__main__":
             'Topic :: Software Development',
             'Topic :: Utilities',
         ],
-        requires_python=metadata['requires-python'],
+        python_requires=metadata['requires-python'],
         install_requires=[
-            #"milc", #FIXME(skullydazed): Included in the repo for now.
             "appdirs",
             "argcomplete",
             "colorama",
+            "dotty-dict",
+            "flake8",
             "hjson",
+            "jsonschema>=3",
+            "milc>=1.0.8",
+            "nose2",
+            "pygments",
             "yapf"
         ],
     )