New release: 1.1.6 → 1.1.7

The setuptools dependency is not needed in this file because setuptools
will be installed from the pyproject.toml file. Since the project does
not use anything from the setuptools package, remove it as a dependency.

This fixes the following bug in Debian:
https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=1083736

.bumpversion.cfg

@@ -0,0 +1,12 @@
+[bumpversion]
+current_version = 1.1.7
+commit = True
+tag = True
+tag_name = {new_version}
+message = New release: {current_version} → {new_version}
+
+[bumpversion:file:.bumpversion.cfg]
+
+[bumpversion:file:qmk_cli/__init__.py]
+
+[bumpversion:file:setup.cfg]

.github/dependabot.yml

@@ -0,0 +1,17 @@
+# Please see the documentation for all configuration options:
+# https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: "github-actions" # See documentation for possible values
+    directory: "/"
+    schedule:
+      interval: "daily"
+    reviewers:
+      - "qmk/collaborators"
+  - package-ecosystem: "pip" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "daily"
+    reviewers:
+      - "qmk/collaborators"

.github/workflows/cli_setup.yml

@@ -7,65 +7,74 @@ on:
   pull_request:
 
 jobs:
+  test_cli_base_container:
+    runs-on: ubuntu-latest
+    container: ghcr.io/qmk/qmk_base_container
+
+    env:
+      QMK_HOME: ~/qmk_firmware
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Install dependencies
+      run: apt-get update && apt-get install -y python3-venv
+
+    - name: Run ci_tests
+      run: ./ci_tests -a
+
   test_cli_linux_macos:
+    needs: test_cli_base_container
+
     runs-on: ${{ matrix.os }}
     env:
       QMK_HOME: ~/qmk_firmware
     strategy:
       matrix:
         os: [macos-latest, ubuntu-latest]
-        python-version: [3.7, 3.8, 3.9]
+        python-version: ['3.9', '3.10', '3.11', '3.12']
+        include:
+          - os: macos-13
+            python-version: '3.9'
 
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v4
 
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v1
+      uses: actions/setup-python@v5
       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
+    - name: Run ci_tests
+      run: ./ci_tests -a
 
   test_cli_win:
+    needs: test_cli_base_container
+
     runs-on: windows-latest
     env:
       QMK_HOME: $HOME/qmk_firmware
 
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v4
 
     - 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
+        install: git mingw-w64-x86_64-toolchain mingw-w64-x86_64-python-pip mingw-w64-x86_64-python-build mingw-w64-x86_64-python-pillow mingw-w64-x86_64-rust
 
+    # Upgrade pip due to msys packaging + pypa/build/pull/736 issues
     - name: (MSYS2) Install Python dependencies
       shell: msys2 {0}
       run: |
-        python3 -m pip install wheel
+        python3 -m pip install --break-system-packages --force-reinstall --upgrade pip
 
     - 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
-
+        python3 -m build
+        python3 -m pip install --break-system-packages dist/qmk-*.tar.gz
     - name: (MSYS2) Run qmk setup -y
       shell: msys2 {0}
       run: qmk setup -y

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,71 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ master ]
+  schedule:
+    - cron: '22 18 * * 0'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'python' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
+        # Learn more:
+        # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v3
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v3
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v3

.github/workflows/docker-republish.yml

@@ -0,0 +1,56 @@
+name: Rebuild Docker Image
+
+on:
+  workflow_dispatch:
+
+jobs:
+  redeploy:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.9'
+
+    - name: Set up QEMU
+      uses: docker/setup-qemu-action@v3
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+
+    - name: 'Get Previous tag'
+      id: previoustag
+      uses: "WyriHaximus/github-action-get-previous-tag@v1"
+
+    - name: Download previous artifact
+      run: |
+        pip download -d "${GITHUB_WORKSPACE}/dist" qmk=="${{ steps.previoustag.outputs.tag }}"
+
+    - name: Login to GitHub Container Registry
+      uses: docker/login-action@v3
+      with:
+        registry: ghcr.io
+        username: ${{ github.repository_owner }}
+        password: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Log in to Docker Hub
+      uses: docker/login-action@v3
+      with:
+        username: ${{ secrets.DOCKER_HUB_USERNAME }}
+        password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
+
+    - name: Build and Push to Docker Hub
+      uses: docker/build-push-action@v6.15.0
+      with:
+        context: .
+        push: true
+        platforms: linux/amd64,linux/arm64
+        tags: |
+          ghcr.io/qmk/qmk_cli:latest
+          qmkfm/qmk_cli:latest

.github/workflows/python-publish.yml

@@ -17,31 +17,73 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v2
     - name: Set up Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v5
       with:
-        python-version: '3.7'
+        python-version: '3.9'
+
+    - name: Set up QEMU
+      uses: docker/setup-qemu-action@v3
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+
+    - uses: actions/checkout@v4
+
+    - name: Run ci_tests
+      run: ./ci_tests
+
     - name: Install dependencies
       run: |
-        python -m pip install --upgrade pip
-        pip install setuptools wheel 
+        python3 -m pip install --upgrade pip
+        pip install setuptools wheel
         pip install -r requirements-dev.txt
+
     - name: Bump version
       run: |
         git config --local user.email "hello@qmk.fm"
         git config --local user.name "QMK Bot"
         bumpversion ${{ github.event.inputs.version_part }}
+
     - name: Push changes
       uses: ad-m/github-push-action@master
       with:
         github_token: ${{ secrets.GITHUB_TOKEN }}
         branch: master
         tags: true
+
     - name: Build and publish
       env:
-        TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
-        TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
+        TWINE_USERNAME: __token__
+        TWINE_PASSWORD: ${{ secrets.PYPI_APITOKEN }}
       run: |
-        python setup.py sdist bdist_wheel
+        python3 -m build
         twine upload dist/*
+
+    - name: Login to GitHub Container Registry
+      uses: docker/login-action@v3
+      with:
+        registry: ghcr.io
+        username: ${{ github.repository_owner }}
+        password: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Log in to Docker Hub
+      uses: docker/login-action@v3
+      with:
+        username: ${{ secrets.DOCKER_HUB_USERNAME }}
+        password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
+
+    - name: Build and Push to Docker Hub
+      uses: docker/build-push-action@v6.15.0
+      with:
+        context: .
+        push: true
+        platforms: linux/amd64,linux/arm64
+        tags: |
+          ghcr.io/qmk/qmk_cli:latest
+          qmkfm/qmk_cli:latest
+
+    - name: Trigger OS package builds
+      run: ./trigger_packages
+      env:
+        QMK_BOT_TOKEN: ${{ secrets.QMK_BOT_TOKEN }}

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "python.formatting.provider": "yapf"
+}

Dockerfile

@@ -0,0 +1,13 @@
+FROM ghcr.io/qmk/qmk_base_container:latest
+
+# Copy package in
+ADD dist /tmp/dist
+
+# Install python packages
+RUN python3 -m pip uninstall -y qmk || true
+RUN python3 -m pip install --upgrade pip setuptools wheel nose2 && \
+    python3 -m pip install /tmp/dist/qmk-*.whl && \
+    rm -rf /tmp/dist
+
+# Set the default location for qmk_firmware
+ENV QMK_HOME /qmk_firmware

README.md

@@ -1,5 +1,6 @@
 # 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)  
+[![CLI Setup](https://github.com/qmk/qmk_cli/actions/workflows/cli_setup.yml/badge.svg)](https://github.com/qmk/qmk_cli/actions/workflows/cli_setup.yml)
+
 A program to help users work with [QMK Firmware](https://qmk.fm/).
 
 # Features
@@ -7,16 +8,52 @@ A program to help users work with [QMK Firmware](https://qmk.fm/).
 * Interact with your qmk_firmware tree from any location
 * Use `qmk clone` to pull down anyone's `qmk_firmware` fork
 * Setup your build environment with `qmk setup`
+* Use `qmk console` to get debugging information from your keyboard(s)
 * Check that your environment is correctly setup with `qmk doctor`
-* Dispatches to `qmk_firmware/bin/qmk` for additional functionality:
-    * `qmk compile-json`
-    * More to come
+* Integrates with qmk_firmware for additional functionality:
+    * `qmk compile`
+    * `qmk info`
+    * `qmk flash`
+    * `qmk lint`
+    * ...and many more!
+
+# Packages
+
+We provide "install and go" packages for many Operating Systems.
+
+## Linux
+
+Packages for several distributions available here: https://github.com/qmk/qmk_fpm
+
+## macOS
+
+Using [Homebrew](https://brew.sh):
+
+    brew install qmk/qmk/qmk
+
+## Windows
+
+Download our custom MSYS2 installer here: https://msys.qmk.fm/
 
 # Quickstart
 
-Full documentation: <https://docs.qmk.fm/#/tutorial>
-
-Basic steps:
-
 * `python3 -m pip install qmk`
 * `qmk setup`
+
+# Building
+
+We follow PEP517, you can install using [build](https://pypi.org/project/build/):
+
+Setup:
+
+    python3 -m pip install build
+
+Build:
+
+    python3 -m build
+
+You can read more about working with PEP517 packages in the [Python Packaging User Guide](https://packaging.python.org/guides/distributing-packages-using-setuptools/#packaging-your-project).
+
+# Documentation
+
+Full documentation: <https://docs.qmk.fm/#/tutorial>

SECURITY.md

@@ -0,0 +1,14 @@
+# Security Policy
+
+## Supported Versions
+
+Use this section to tell people about which versions of your project are
+currently being supported with security updates.
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 0.0.x   | :white_check_mark: |
+
+## Reporting a Vulnerability
+
+* [Open an Issue](https://github.com/qmk/qmk_cli/issues/new?assignees=&labels=bug&template=bug_report.md&title=%5BBug%5D+)

ci_tests

@@ -0,0 +1,59 @@
+#!/usr/bin/env bash
+
+set -e
+#set -x
+
+ADVANCED=false
+TMPDIR=$(mktemp -d)
+QMK_HOME="$TMPDIR/qmk_firmware"
+export QMK_HOME
+
+for arg in $@; do
+    if [ "$arg" = "-a" ]; then
+        ADVANCED=true
+    fi
+done
+
+if [ $ADVANCED = true ]; then
+    echo "*** Running in advanced mode with tmp files in $TMPDIR"
+else
+    echo "*** Running in basic mode with tmp files in $TMPDIR"
+fi
+
+# Setup our virtualenv
+if [ -e .ci_venv ]; then
+    rm -rf .ci_venv
+fi
+
+python3 -m venv .ci_venv
+source .ci_venv/bin/activate
+
+# Install dependencies
+python3 -m pip install -U pip wheel
+python3 -m pip install .
+python3 -m pip install -r requirements-dev.txt
+
+# Ensure that qmk works
+echo "*** Testing 'qmk clone -h'"
+qmk clone -h
+#echo "*** Testing 'qmk config -a'" # Test disabled as `milc` at least 1.6.8+ returns False and thus non-zero exit code
+#qmk config -a
+echo "*** Testing 'qmk setup -n'"
+qmk setup -n
+
+echo
+echo "*** Basic tests completed successfully!"
+
+# Run advanced test if requested
+if [ $ADVANCED = true ]; then
+    echo
+    echo "*** Testing 'qmk setup -y'"
+    qmk setup -y
+
+    echo
+    echo "*** Advanced tests completed successfully!"
+fi
+
+# Cleanup
+deactivate
+rm -rf .ci_venv $TMPDIR

pyproject.toml

@@ -0,0 +1,6 @@
+[build-system]
+requires = [
+    "setuptools>=42",
+    "wheel"
+]
+build-backend = "setuptools.build_meta"

qmk_cli/__init__.py

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

qmk_cli/helpers.py

@@ -1,8 +1,8 @@
 """Useful helper functions.
 """
 import os
+import json
 from functools import lru_cache
-from importlib.util import find_spec
 from pathlib import Path
 
 from milc import cli
@@ -16,7 +16,7 @@ def is_qmk_firmware(qmk_firmware):
         qmk_firmware / 'quantum',
         qmk_firmware / 'requirements.txt',
         qmk_firmware / 'requirements-dev.txt',
-        qmk_firmware / 'lib/python/qmk/cli/doctor.py'
+        qmk_firmware / 'lib/python/qmk/cli/__init__.py'
     ]
 
     for path in paths:
@@ -26,61 +26,7 @@ def is_qmk_firmware(qmk_firmware):
     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)
+@lru_cache(maxsize=1)
 def find_qmk_firmware():
     """Look for qmk_firmware in the usual places.
 
@@ -101,6 +47,7 @@ def find_qmk_firmware():
     return Path.home() / 'qmk_firmware'
 
 
+@lru_cache(maxsize=1)
 def in_qmk_firmware():
     """Returns the path to the qmk_firmware we are currently in, or None if we are not inside qmk_firmware.
     """
@@ -112,3 +59,49 @@ def in_qmk_firmware():
         # Move up a directory before the next iteration
         cur_dir = cur_dir / '..'
         cur_dir = cur_dir.resolve()
+
+
+def is_qmk_userspace(qmk_userspace):
+    """Returns True if the given Path() is a qmk_userspace clone.
+    """
+    path = qmk_userspace / 'qmk.json'
+    if not path.exists():
+        return False
+
+    try:
+        return 'userspace_version' in json.loads(path.read_text(encoding="UTF-8"))
+    except json.decoder.JSONDecodeError as e:
+        return False
+
+
+@lru_cache(maxsize=1)
+def find_qmk_userspace():
+    """Look for qmk_userspace in the usual places.
+    """
+    if in_qmk_userspace():
+        return in_qmk_userspace()
+
+    if cli.config.user.overlay_dir:
+        return Path(cli.config.user.overlay_dir).expanduser().resolve()
+
+    if 'QMK_USERSPACE' in os.environ:
+        path = Path(os.environ['QMK_USERSPACE']).expanduser()
+        if path.exists():
+            return path.resolve()
+        return path
+
+    return Path.home() / 'qmk_userspace'
+
+
+@lru_cache(maxsize=1)
+def in_qmk_userspace():
+    """Returns the path to the qmk_userspace we are currently in, or None if we are not inside qmk_userspace.
+    """
+    cur_dir = Path.cwd()
+    while len(cur_dir.parents) > 0:
+        if is_qmk_userspace(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

@@ -11,13 +11,16 @@ 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
+from . import __version__
+from .helpers import find_qmk_firmware, is_qmk_firmware, find_qmk_userspace
 
+milc.cli.milc_options(version=__version__)
 milc.EMOJI_LOGLEVELS['INFO'] = '{fg_blue}Ψ{style_reset_all}'
 
+# These must happen after the milc.milc_options() call
+import milc.subcommand.config  # noqa, must come after milc.milc_options()
+
 
 @milc.cli.entrypoint('CLI wrapper for running QMK commands.')
 def qmk_main(cli):
@@ -42,23 +45,35 @@ def main():
     """Setup the environment before dispatching to the entrypoint.
     """
     # Warn if they use an outdated python version
-    if sys.version_info < (3, 7):
+    if sys.version_info < (3, 9):
         print('Warning: Your Python version is out of date! Some subcommands may not work!')
-        print('Please upgrade to Python 3.7 or later.')
+        print('Please upgrade to Python 3.9 or later.')
 
     if 'windows' in platform().lower():
         msystem = os.environ.get('MSYSTEM', '')
 
-        if 'mingw64' not in sys.executable or 'MINGW64' not in msystem:
+        # Assume the environment isn't workable by default
+        env_ok = False
+
+        # Check if we're using the mingw64/msys2 environment
+        if 'mingw64' in sys.executable and 'MINGW64' in msystem:
+            env_ok = True
+
+        # Check if we're using a `uv`-based environment
+        if '\\uv\\' in sys.executable or '/uv/' in sys.executable:
+            env_ok = True
+
+        # If none of the options above were true, then we're in an unsupported environment. Bomb out.
+        if not env_ok:
             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__
+    qmk_userspace = find_qmk_userspace()
     qmk_firmware = find_qmk_firmware()
+    os.environ['QMK_USERSPACE'] = str(qmk_userspace)
     os.environ['QMK_HOME'] = str(qmk_firmware)
     os.environ['ORIG_CWD'] = os.getcwd()
 
@@ -68,31 +83,6 @@ def main():
     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))
-
-        # 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:

qmk_cli/subcommands/__init__.py

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

qmk_cli/subcommands/clone.py

@@ -11,20 +11,21 @@ default_fork = 'qmk/' + default_repo
 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('--baseurl', arg_only=True, default='https://github.com', help='The URL all git operations start from (Default: https://github.com)')
+@cli.argument('-b', '--branch', arg_only=True, default=default_branch, help='The branch to clone. Default: %s' % default_branch)
+@cli.argument('destination', arg_only=True, default=None, nargs='?', help='The directory to clone to. Default: (current directory)')
+@cli.argument('fork', arg_only=True, 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:
         cli.args.destination = os.path.join(os.environ['ORIG_CWD'], default_fork.split('/')[-1])
 
     qmk_firmware = Path(cli.args.destination)
-    git_url = '/'.join((cli.config.clone.baseurl, cli.args.fork))
+    git_url = '/'.join((cli.args.baseurl, cli.args.fork))
 
-    if qmk_firmware.exists():
+    # Exists (but not an empty dir)
+    if qmk_firmware.exists() and any(qmk_firmware.iterdir()):
         cli.log.error('Destination already exists: %s', cli.args.destination)
         exit(1)
 
-    return git_clone(git_url, cli.args.destination, cli.config.clone.branch)
+    return git_clone(git_url, cli.args.destination, cli.args.branch)

qmk_cli/subcommands/console.py

@@ -0,0 +1,360 @@
+"""Acquire debugging information from usb hid devices
+
+cli implementation of https://www.pjrc.com/teensy/hid_listen.html
+"""
+from functools import lru_cache
+from pathlib import Path
+from platform import platform
+from threading import Thread
+from time import sleep, strftime
+
+from milc import cli
+from milc.questions import yesno
+
+LOG_COLOR = {
+    'next': 0,
+    'colors': [
+        '{fg_blue}',
+        '{fg_cyan}',
+        '{fg_green}',
+        '{fg_magenta}',
+        '{fg_red}',
+        '{fg_yellow}',
+    ],
+}
+
+KNOWN_BOOTLOADERS = {
+    # VID  ,  PID
+    ('03EB', '2045'): 'lufa-ms: LUFA Mass Storage Bootloader',
+    ('03EB', '2067'): 'qmk-hid: HID Bootloader',
+    ('03EB', '2FEF'): 'atmel-dfu: ATmega16U2',
+    ('03EB', '2FF0'): 'atmel-dfu: ATmega32U2',
+    ('03EB', '2FF3'): 'atmel-dfu: ATmega16U4',
+    ('03EB', '2FF4'): 'atmel-dfu: ATmega32U4',
+    ('03EB', '2FF9'): 'atmel-dfu: AT90USB64',
+    ('03EB', '2FFA'): 'atmel-dfu: AT90USB162',
+    ('03EB', '2FFB'): 'atmel-dfu: AT90USB128',
+    ('03EB', '6124'): 'Microchip SAM-BA',
+    ('0483', 'DF11'): 'stm32-dfu: STM32 BOOTLOADER',
+    ('16C0', '05DC'): 'usbasploader: USBaspLoader',
+    ('16C0', '05DF'): 'bootloadhid: HIDBoot',
+    ('16C0', '0478'): 'halfkay: Teensy Halfkay',
+    ('1B4F', '9203'): 'caterina: Pro Micro 3.3V',
+    ('1B4F', '9205'): 'caterina: Pro Micro 5V',
+    ('1B4F', '9207'): 'caterina: LilyPadUSB',
+    ('1C11', 'B007'): 'kiibohd: Kiibohd DFU Bootloader',
+    ('1EAF', '0003'): 'stm32duino: Maple 003',
+    ('1FFB', '0101'): 'caterina: Pololu A-Star 32U4 Bootloader',
+    ('2341', '0036'): 'caterina: Arduino Leonardo',
+    ('2341', '0037'): 'caterina: Arduino Micro',
+    ('239A', '000C'): 'caterina: Adafruit Feather 32U4',
+    ('239A', '000D'): 'caterina: Adafruit ItsyBitsy 32U4 3v',
+    ('239A', '000E'): 'caterina: Adafruit ItsyBitsy 32U4 5v',
+    ('2A03', '0036'): 'caterina: Arduino Leonardo',
+    ('2A03', '0037'): 'caterina: Arduino Micro',
+    ('314B', '0106'): 'apm32-dfu: APM32 DFU ISP Mode',
+    ('342D', 'DFA0'): 'wb32-dfu: WB32 Device in DFU Mode'
+}
+
+
+def install_deps():
+    """Install the necessary dependencies for qmk console.
+    """
+    this_platform = platform().lower()
+
+    if 'darwin' in this_platform or 'macos' in this_platform:
+        command = ['brew', 'install', 'hidapi']
+    elif 'linux' in this_platform:
+        command = ['sudo', 'apt', 'install', '-y', 'libhidapi-hidraw0', 'libusb-dev']
+    elif 'windows' in this_platform:
+        command = ['pacboy', 'sync', '--needed', '--noconfirm', '--disable-download-timeout', 'hidapi:x']
+    else:
+        cli.log.error('Unsupported platform: %s', this_platform)
+
+    if yesno("Would you like to run `%s` to install the necessary package?", ' '.join(command)):
+        cli.run(command, capture_output=False)
+        return True
+
+
+@lru_cache(maxsize=0)
+def import_usb_core():
+    """Attempts to import the usb.core module.
+    """
+    try:
+        import usb.core
+        return usb.core
+
+    except ImportError as e:
+        cli.log.error('Could not import usb.core: %s', e)
+
+        if install_deps():
+            return import_usb_core()
+
+        raise
+
+
+def import_hid():
+    """Attempts to import the hid module.
+    """
+    try:
+        import hid
+        return hid
+
+    except ImportError as e:
+        cli.log.error('Could not import hid: %s', e)
+
+        if install_deps():
+            return import_hid()
+
+        raise
+
+
+class MonitorDevice(object):
+    def __init__(self, hid_device, numeric):
+        self.hid = import_hid()
+        self.hid_device = hid_device
+        self.numeric = numeric
+        self.device = self.hid.Device(path=hid_device['path'])
+        self.current_line = ''
+
+        cli.log.info('Console Connected: %(color)s%(manufacturer_string)s %(product_string)s{style_reset_all} (%(color)s%(vendor_id)04X:%(product_id)04X:%(index)d{style_reset_all})', hid_device)
+
+    def read(self, size, encoding='ascii', timeout=1):
+        """Read size bytes from the device.
+        """
+        return self.device.read(size, timeout).decode(encoding)
+
+    def read_line(self):
+        """Read from the device's console until we get a \n.
+        """
+        while '\n' not in self.current_line:
+            self.current_line += self.read(32).replace('\x00', '')
+
+        lines = self.current_line.split('\n', 1)
+        self.current_line = lines[1]
+
+        return lines[0]
+
+    def run_forever(self):
+        while True:
+            try:
+                message = {**self.hid_device, 'text': self.read_line()}
+                identifier = (int2hex(message['vendor_id']), int2hex(message['product_id'])) if self.numeric else (message['manufacturer_string'], message['product_string'])
+                message['identifier'] = ':'.join(identifier)
+                message['ts'] = '{style_dim}{fg_green}%s{style_reset_all} ' % (strftime(cli.config.general.datetime_fmt),) if cli.args.timestamp else ''
+
+                cli.echo('%s', '%(ts)s%(color)s%(identifier)s:%(index)d{style_reset_all}: %(text)s' % message)
+
+            except self.hid.HIDException:
+                break
+
+
+class FindDevices(object):
+    def __init__(self, vid, pid, index, numeric):
+        self.hid = import_hid()
+        self.vid = vid
+        self.pid = pid
+        self.index = index
+        self.numeric = numeric
+
+    def run_forever(self):
+        """Process messages from our queue in a loop.
+        """
+        live_devices = {}
+        live_bootloaders = {}
+
+        while True:
+            try:
+                for device in list(live_devices):
+                    if not live_devices[device]['thread'].is_alive():
+                        cli.log.info('Console Disconnected: %(color)s%(manufacturer_string)s %(product_string)s{style_reset_all} (%(color)s%(vendor_id)04X:%(product_id)04X:%(index)d{style_reset_all})', live_devices[device])
+                        del live_devices[device]
+
+                for device in self.find_devices():
+                    if device['path'] not in live_devices:
+                        device['color'] = LOG_COLOR['colors'][LOG_COLOR['next']]
+                        LOG_COLOR['next'] = (LOG_COLOR['next'] + 1) % len(LOG_COLOR['colors'])
+                        live_devices[device['path']] = device
+
+                        try:
+                            monitor = MonitorDevice(device, self.numeric)
+                            device['thread'] = Thread(target=monitor.run_forever, daemon=True)
+
+                            device['thread'].start()
+                        except Exception as e:
+                            device['e'] = e
+                            device['e_name'] = e.__class__.__name__
+                            cli.log.error("Could not connect to %(color)s%(manufacturer_string)s %(product_string)s{style_reset_all} (%(color)s%(vendor_id)04X:%(product_id)04X:%(index)d{style_reset_all}): %(e_name)s: %(e)s", device)
+                            if cli.config.general.verbose:
+                                cli.log.exception(e)
+                            del live_devices[device['path']]
+
+                if cli.args.bootloaders:
+                    for device in self.find_bootloaders():
+                        if device.address in live_bootloaders:
+                            live_bootloaders[device.address]._qmk_found = True
+                        else:
+                            name = KNOWN_BOOTLOADERS[(int2hex(device.idVendor), int2hex(device.idProduct))]
+                            cli.log.info('Bootloader Connected: {style_bright}{fg_magenta}%s', name)
+                            device._qmk_found = True
+                            live_bootloaders[device.address] = device
+
+                    for device in list(live_bootloaders):
+                        if live_bootloaders[device]._qmk_found:
+                            live_bootloaders[device]._qmk_found = False
+                        else:
+                            name = KNOWN_BOOTLOADERS[(int2hex(live_bootloaders[device].idVendor), int2hex(live_bootloaders[device].idProduct))]
+                            cli.log.info('Bootloader Disconnected: {style_bright}{fg_magenta}%s', name)
+                            del live_bootloaders[device]
+
+                sleep(.1)
+
+            except KeyboardInterrupt:
+                break
+
+    def is_bootloader(self, hid_device):
+        """Returns true if the device in question matches a known bootloader vid/pid.
+        """
+        return (int2hex(hid_device.idVendor), int2hex(hid_device.idProduct)) in KNOWN_BOOTLOADERS
+
+    def is_console_hid(self, hid_device):
+        """Returns true when the usage page indicates it's a teensy-style console.
+        """
+        return hid_device['usage_page'] == 0xFF31 and hid_device['usage'] == 0x0074
+
+    def is_filtered_device(self, hid_device):
+        """Returns True if the device should be included in the list of available consoles.
+        """
+        return int2hex(hid_device['vendor_id']) == self.vid and int2hex(hid_device['product_id']) == self.pid
+
+    def find_devices_by_report(self, hid_devices):
+        """Returns a list of available teensy-style consoles by doing a brute-force search.
+
+        Some versions of linux don't report usage and usage_page. In that case we fallback to reading the report (possibly inaccurately) ourselves.
+        """
+        devices = []
+
+        for device in hid_devices:
+            path = device['path'].decode('utf-8')
+
+            if path.startswith('/dev/hidraw'):
+                number = path[11:]
+                report = Path(f'/sys/class/hidraw/hidraw{number}/device/report_descriptor')
+
+                if report.exists():
+                    rp = report.read_bytes()
+
+                    if rp[1] == 0x31 and rp[3] == 0x09:
+                        devices.append(device)
+
+        return devices
+
+    def find_bootloaders(self):
+        """Returns a list of available bootloader devices.
+        """
+        import usb.core
+
+        return list(filter(self.is_bootloader, usb.core.find(find_all=True)))
+
+    def find_devices(self):
+        """Returns a list of available teensy-style consoles.
+        """
+        hid_devices = self.hid.enumerate()
+        devices = list(filter(self.is_console_hid, hid_devices))
+
+        if not devices:
+            devices = self.find_devices_by_report(hid_devices)
+
+        if self.vid and self.pid:
+            devices = list(filter(self.is_filtered_device, devices))
+
+        # Add index numbers
+        device_index = {}
+        for device in devices:
+            id = ':'.join((int2hex(device['vendor_id']), int2hex(device['product_id'])))
+
+            if id not in device_index:
+                device_index[id] = 0
+
+            device_index[id] += 1
+            device['index'] = device_index[id]
+
+        return devices
+
+
+def int2hex(number):
+    """Returns a string representation of the number as hex.
+    """
+    return "%04X" % number
+
+
+def list_devices(device_finder):
+    """Show the user a nicely formatted list of devices.
+    """
+    devices = device_finder.find_devices()
+
+    if devices:
+        cli.log.info('Available devices:')
+        for dev in devices:
+            color = LOG_COLOR['colors'][LOG_COLOR['next']]
+            LOG_COLOR['next'] = (LOG_COLOR['next'] + 1) % len(LOG_COLOR['colors'])
+            cli.log.info("\t%s%s:%s:%d{style_reset_all}\t%s %s", color, int2hex(dev['vendor_id']), int2hex(dev['product_id']), dev['index'], dev['manufacturer_string'], dev['product_string'])
+
+    if cli.args.bootloaders:
+        bootloaders = device_finder.find_bootloaders()
+
+        if bootloaders:
+            cli.log.info('Available Bootloaders:')
+
+            for dev in bootloaders:
+                cli.log.info("\t%s:%s\t%s", int2hex(dev.idVendor), int2hex(dev.idProduct), KNOWN_BOOTLOADERS[(int2hex(dev.idVendor), int2hex(dev.idProduct))])
+
+
+@cli.argument('--bootloaders', arg_only=True, default=True, action='store_boolean', help='displaying bootloaders.')
+@cli.argument('-d', '--device', help='Device to select - uses format <pid>:<vid>[:<index>].')
+@cli.argument('-l', '--list', arg_only=True, action='store_true', help='List available hid_listen devices.')
+@cli.argument('-n', '--numeric', arg_only=True, action='store_true', help='Show VID/PID instead of names.')
+@cli.argument('-t', '--timestamp', arg_only=True, action='store_true', help='Print the timestamp for received messages as well.')
+@cli.argument('-w', '--wait', type=int, default=1, help="How many seconds to wait between checks (Default: 1)")
+@cli.subcommand('Acquire debugging information from usb hid devices.')
+def console(cli):
+    """Acquire debugging information from usb hid devices
+    """
+    vid = None
+    pid = None
+    index = 1
+
+    if cli.config.console.device:
+        device = cli.config.console.device.split(':')
+
+        if len(device) == 2:
+            vid, pid = device
+
+        elif len(device) == 3:
+            vid, pid, index = device
+
+            if not index.isdigit():
+                cli.log.error('Device index must be a number! Got "%s" instead.', index)
+                exit(1)
+
+            index = int(index)
+
+            if index < 1:
+                cli.log.error('Device index must be greater than 0! Got %s', index)
+                exit(1)
+
+        else:
+            cli.log.error('Invalid format for device, expected "<pid>:<vid>[:<index>]" but got "%s".', cli.config.console.device)
+            cli.print_help()
+            exit(1)
+
+        vid = vid.upper()
+        pid = pid.upper()
+
+    device_finder = FindDevices(vid, pid, index, cli.args.numeric)
+
+    if cli.args.list:
+        return list_devices(device_finder)
+
+    print('Looking for devices...', flush=True)
+    device_finder.run_forever()

qmk_cli/subcommands/env.py

@@ -0,0 +1,32 @@
+"""Prints environment information.
+"""
+import os
+from pathlib import Path
+
+from milc import cli
+from qmk_cli.helpers import is_qmk_firmware, is_qmk_userspace
+
+
+@cli.argument('var', arg_only=True, default=None, nargs='?', help='Optional variable to query')
+@cli.subcommand('Prints environment information.')
+def env(cli):
+    home = os.environ.get('QMK_HOME', "")
+    userspace = os.environ.get('QMK_USERSPACE', "")
+    data = {
+        'QMK_HOME': home,
+        'QMK_FIRMWARE': home if is_qmk_firmware(Path(home)) else "",
+        'QMK_USERSPACE': userspace if is_qmk_userspace(Path(userspace)) else ""
+    }
+
+    # Now munge the current cli config
+    for key, val in cli.config.general.items():
+        converted_key = 'QMK_' + key.upper()
+        data[converted_key] = val
+
+    if cli.args.var:
+        # dump out requested arg
+        print(data[cli.args.var])
+    else:
+        # dump out everything
+        for key, val in data.items():
+            print(f'{key}="{val}"')

qmk_cli/subcommands/setup.py

@@ -5,9 +5,10 @@ import shlex
 import subprocess
 import sys
 from pathlib import Path
+from shutil import rmtree
 
 from milc import cli
-from milc.questions import yesno
+from milc.questions import choice, question, yesno
 from qmk_cli.git import git_clone
 from qmk_cli.helpers import is_qmk_firmware
 
@@ -20,7 +21,7 @@ default_branch = 'master'
 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_url = '/'.join((cli.args.baseurl, default_fork))
     git_cmd = [
         'git',
         '-C',
@@ -43,12 +44,23 @@ def git_upstream(destination):
         return False
 
 
+def git_clone_fork(fork, branch, force=False):
+    if force:
+        rmtree(cli.args.home)
+
+    git_url = '/'.join((cli.args.baseurl, fork))
+    if git_clone(git_url, cli.args.home, branch):
+        git_upstream(cli.args.home)
+    else:
+        exit(1)
+
+
 @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.argument('--baseurl', arg_only=True, default=default_base, help='The URL all git operations start from. Default: %s' % default_base)
+@cli.argument('-b', '--branch', arg_only=True, default=default_branch, help='The branch to clone. Default: %s' % default_branch)
+@cli.argument('-H', '--home', arg_only=True, default=Path(os.environ['QMK_HOME']), type=Path, help='The location for QMK Firmware. Default: %s' % os.environ['QMK_HOME'])
+@cli.argument('fork', arg_only=True, 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):
     """Guide the user through setting up their QMK environment.
@@ -61,11 +73,37 @@ def setup(cli):
         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.
+    # Check on qmk_firmware
+    # If it exists, ask the user what to do with it
+    # If it doesn't exist, offer to check it out
     if is_qmk_firmware(cli.args.home):
         cli.log.info('Found qmk_firmware at %s.', str(cli.args.home))
+        found_prompt = "What do you want to do?"
+        found_options = [
+            f"Delete and reclone {cli.args.fork}",
+            "Delete and clone a different fork",
+            "Keep it and continue"
+        ]
+        delete_confirm = "WARNING: This will delete your current qmk_firmware directory. Proceed?"
 
-    elif cli.args.home.exists():
+        found_action = choice(found_prompt, options=found_options, default=2)
+        if found_action == f"Delete and reclone {cli.args.fork}":
+            if not yesno(delete_confirm, default=False):
+                exit(1)
+
+            git_clone_fork(cli.args.fork, cli.args.branch, force=True)
+
+        elif found_action == "Delete and clone a different fork":
+            fork_name = question("Enter the name of the fork:", default=cli.args.fork)
+            branch_name = question("Enter the branch name to clone:", default=cli.args.branch)
+
+            if not yesno(delete_confirm, default=False):
+                exit(1)
+
+            git_clone_fork(fork_name, branch_name, force=True)
+
+    # Exists (but not an empty dir)
+    elif cli.args.home.exists() and any(cli.args.home.iterdir()):
         path_str = str(cli.args.home)
 
         if cli.args.home.name != 'qmk_firmware':
@@ -77,25 +115,26 @@ def setup(cli):
     else:
         cli.log.error('Could not find qmk_firmware!')
         if yesno(clone_prompt):
-            git_url = '/'.join((cli.config.setup.baseurl, cli.args.fork))
-
-            if git_clone(git_url, cli.args.home, cli.config.setup.branch):
-                git_upstream(cli.args.home)
-            else:
-                exit(1)
+            git_clone_fork(cli.args.fork, cli.args.branch)
+        else:
+            cli.log.warning('Not cloning qmk_firmware due to user input or --no flag.')
 
     # 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.config_source['user']['qmk_home'] = 'config_file'
         cli.write_config_option('user', 'qmk_home')
 
     # Run `qmk doctor` to check the rest of the environment out
-    doctor_command = [sys.argv[0], 'doctor']
+    if cli.args.home.exists():
+        color = '--color' if cli.config.general.color else '--no-color'
+        unicode = '--unicode' if cli.config.general.unicode else '--no-unicode'
+        doctor_command = [Path(sys.argv[0]).as_posix(), color, unicode, 'doctor']
 
-    if cli.args.no:
-        doctor_command.append('--no')
+        if cli.args.no:
+            doctor_command.append('-n')
 
-    if cli.args.yes:
-        doctor_command.append('--yes')
+        if cli.args.yes:
+            doctor_command.append('-y')
 
-    cli.run(doctor_command, capture_output=False)
+        cli.run(doctor_command, stdin=None, capture_output=False, cwd=cli.args.home)

release

@@ -3,30 +3,5 @@
 #
 # Required packages: pip3 install bumpversion twine
 
-set -e
-set -x
-
-PYPI_USERNAME=${PYPI_USERNAME:=skully}
-FLIT_USERNAME=$PYPI_USERNAME
-TWINE_USERNAME=$PYPI_USERNAME
-
-export FLIT_USERNAME TWINE_USERNAME
-
-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
-
-# Build and upload
-python3 setup.py sdist bdist_wheel
-twine upload dist/qmk-*
+echo "Use the github action instead!"
+exit 1

requirements-dev.txt

@@ -1,2 +1,4 @@
+build
 bumpversion
+requests
 twine

setup.cfg

@@ -1,13 +1,5 @@
-[bumpversion]
-current_version = 0.0.43
-commit = True
-tag = True
-tag_name = {new_version}
-message = New release: {current_version} → {new_version}
-
-[bumpversion:file:qmk_cli/__init__.py]
-
-[bumpversion:file:setup.cfg]
+#[bumpversion]
+# Bumpversion config has been moved to .bumpversion.cfg
 
 [bdist_wheel]
 universal = 1
@@ -16,17 +8,50 @@ universal = 1
 ignore = E501,E226
 
 [metadata]
+name = qmk
+version = 1.1.7
 author = skullydazed
-author-email = skullydazed@gmail.com
-description-file = README.md
-dist-name = qmk
-license_file = LICENSE
-module = qmk_cli
-home-page = https://github.com/qmk/qmk_cli
-requires-python = >=3.7
+author_email = skullydazed@gmail.com
+description = A program to help users work with QMK Firmware.
+long_description = file: README.md
+long_description_content_type = text/markdown
+license = MIT License
+project_urls =
+	Bug Tracker = https://github.com/qmk/qmk_cli/issues
+	Documentation = https://docs.qmk.fm/#/cli
+	Homepage = https://qmk.fm/
+	Source = https://github.com/qmk/qmk_cli/
+classifiers =
+	Development Status :: 3 - Alpha
+	Environment :: Console
+	Intended Audience :: Developers
+	Intended Audience :: System Administrators
+	Intended Audience :: End Users/Desktop
+	License :: OSI Approved :: MIT License
+	Natural Language :: English
+	Programming Language :: Python :: 3 :: Only
+	Topic :: Scientific/Engineering
+	Topic :: Software Development
+	Topic :: Utilities
 
-[entry_points]
-qmk = qmk_cli.script_qmk:main
+[options]
+install_requires =
+	hid
+	milc>=1.9.0
+	pyusb
+	# qmk_firmware packages
+	dotty-dict
+	hjson
+	jsonschema>=4
+	pillow
+	pygments
+	pyserial
+packages = find:
+python_requires = >=3.9
+
+[options.entry_points]
+console_scripts =
+	qmk = qmk_cli.script_qmk:main
 
 [yapf]
 align_closing_bracket_with_visual_indent = True
@@ -46,13 +71,13 @@ continuation_indent_width = 4
 dedent_closing_brackets = True
 disable_ending_comma_heuristic = False
 each_dict_entry_on_separate_line = True
-i18n_comment = 
-i18n_function_call = 
+i18n_comment =
+i18n_function_call =
 indent_blank_lines = False
 indent_dictionary_value = True
 indent_width = 4
 join_multiple_lines = False
-no_spaces_around_selected_binary_operators = 
+no_spaces_around_selected_binary_operators =
 spaces_around_default_or_named_assign = False
 spaces_around_power_operator = False
 spaces_before_comment = 2

setup.py

@@ -1,55 +0,0 @@
-from configparser import ConfigParser
-from setuptools import setup, find_packages
-
-setup_cfg = ConfigParser()
-setup_cfg.read('setup.cfg')
-metadata = setup_cfg['metadata']
-
-if __name__ == "__main__":
-    with open('README.md', encoding='utf-8') as readme_file:
-        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' % i for i in setup_cfg['entry_points'].items()],
-        },
-        license='MIT License',
-        url=metadata['home-page'],
-        version=setup_cfg['bumpversion']['current_version'],
-        author=metadata['author'],
-        author_email=metadata['author-email'],
-        maintainer=metadata['author'],
-        maintainer_email=metadata['author-email'],
-        long_description=long_description,
-        long_description_content_type="text/markdown",
-        packages=find_packages(),
-        py_modules=['milc'],
-        classifiers=[
-            'Development Status :: 3 - Alpha',
-            'Environment :: Console',
-            'Intended Audience :: Developers',
-            'Intended Audience :: System Administrators',
-            'Intended Audience :: End Users/Desktop',
-            'License :: OSI Approved :: MIT License',
-            'Natural Language :: English',
-            'Programming Language :: Python :: 3 :: Only',
-            'Topic :: Scientific/Engineering',
-            'Topic :: Software Development',
-            'Topic :: Utilities',
-        ],
-        python_requires=metadata['requires-python'],
-        install_requires=[
-            "appdirs",
-            "argcomplete",
-            "colorama",
-            "dotty-dict",
-            "flake8",
-            "hjson",
-            "jsonschema>=3",
-            "milc>=1.0.8",
-            "nose2",
-            "pygments",
-            "yapf"
-        ],
-    )

trigger_packages

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+"""Trigger workflows that build QMK packages.
+"""
+from os import environ
+from pathlib import Path
+
+import requests
+
+# Pull in environment vars
+gh_user = environ.get('GH_USERNAME', 'qmk-bot')
+gh_pat = environ.get('QMK_BOT_TOKEN', '')
+gh_repo_owner = environ.get('REPO_OWNER', 'qmk')
+gh_repo_name = environ.get('REPO_NAME', 'qmk_fpm')
+gh_ref = environ.get('BRANCH_NAME', 'main')
+gh_workflow_ids = environ.get('WORKFLOW_IDS', 'all-trigger.yml').split(',')
+gh_api_url = environ.get('GITHUB_API_URL', 'https://api.github.com')
+gh_workflow_args = {'ref': gh_ref}
+gh_workflow_headers = {'Accept': 'application/vnd.github.v3+json'}
+
+for gh_workflow_id in gh_workflow_ids:
+    gh_workflow_endpoint = f'{gh_api_url}/repos/{gh_repo_owner}/{gh_repo_name}/actions/workflows/{gh_workflow_id}/dispatches'
+    print(f'Triggering {gh_workflow_id} workflow at: {gh_workflow_endpoint}')
+    workflow_dispatch = requests.post(gh_workflow_endpoint, headers=gh_workflow_headers, json=gh_workflow_args, auth=(gh_user, gh_pat))
+    if workflow_dispatch.status_code != 204:
+        print(f'Error from GitHub API, status_code {workflow_dispatch.status_code}!')
+        print(workflow_dispatch.text)
+        exit(1)
+
+exit(0)