diff options
Diffstat (limited to 'lib/python')
26 files changed, 889 insertions, 399 deletions
diff --git a/lib/python/qmk/cli/__init__.py b/lib/python/qmk/cli/__init__.py index c51eece955..5f65e677e5 100644 --- a/lib/python/qmk/cli/__init__.py +++ b/lib/python/qmk/cli/__init__.py @@ -69,6 +69,7 @@ subcommands = [ 'qmk.cli.new.keymap', 'qmk.cli.pyformat', 'qmk.cli.pytest', + 'qmk.cli.via2json', ] diff --git a/lib/python/qmk/cli/cd.py b/lib/python/qmk/cli/cd.py index c62c3f56c6..ef03011f1f 100755 --- a/lib/python/qmk/cli/cd.py +++ b/lib/python/qmk/cli/cd.py @@ -2,6 +2,7 @@ """ import sys import os +import subprocess from milc import cli @@ -41,6 +42,6 @@ def cd(cli): # Set the prompt for the new shell qmk_env['MSYS2_PS1'] = qmk_env['PS1'] # Start the new subshell - cli.run([os.environ.get('SHELL', '/usr/bin/bash')], env=qmk_env) + subprocess.run([os.environ.get('SHELL', '/usr/bin/bash')], env=qmk_env) else: cli.log.info("Already within qmk_firmware directory.") diff --git a/lib/python/qmk/cli/doctor/check.py b/lib/python/qmk/cli/doctor/check.py index 2d691b64b0..8a0422ba72 100644 --- a/lib/python/qmk/cli/doctor/check.py +++ b/lib/python/qmk/cli/doctor/check.py @@ -7,7 +7,6 @@ from subprocess import DEVNULL from milc import cli from qmk import submodules -from qmk.constants import QMK_FIRMWARE class CheckStatus(Enum): @@ -150,14 +149,3 @@ def is_executable(command): cli.log.error("{fg_red}Can't run `%s %s`", command, version_arg) return False - - -def check_git_repo(): - """Checks that the .git directory exists inside QMK_HOME. - - This is a decent enough indicator that the qmk_firmware directory is a - proper Git repository, rather than a .zip download from GitHub. - """ - dot_git = QMK_FIRMWARE / '.git' - - return CheckStatus.OK if dot_git.exists() else CheckStatus.WARNING diff --git a/lib/python/qmk/cli/doctor/main.py b/lib/python/qmk/cli/doctor/main.py index ed20f46d3f..2898a9894c 100755 --- a/lib/python/qmk/cli/doctor/main.py +++ b/lib/python/qmk/cli/doctor/main.py @@ -11,7 +11,8 @@ from milc.questions import yesno from qmk import submodules from qmk.constants import QMK_FIRMWARE, QMK_FIRMWARE_UPSTREAM from .check import CheckStatus, check_binaries, check_binary_versions, check_submodules -from qmk.commands import git_check_repo, git_get_branch, git_is_dirty, git_get_remotes, git_check_deviation, in_virtualenv +from qmk.git import git_check_repo, git_get_branch, git_get_tag, git_is_dirty, git_get_remotes, git_check_deviation +from qmk.commands import in_virtualenv def os_tests(): @@ -47,6 +48,11 @@ def git_tests(): git_branch = git_get_branch() if git_branch: cli.log.info('Git branch: %s', git_branch) + + repo_version = git_get_tag() + if repo_version: + cli.log.info('Repo version: %s', repo_version) + git_dirty = git_is_dirty() if git_dirty: cli.log.warning('{fg_yellow}Git has unstashed/uncommitted changes.') diff --git a/lib/python/qmk/cli/generate/config_h.py b/lib/python/qmk/cli/generate/config_h.py index f16dca1de8..fdc76b23d4 100755 --- a/lib/python/qmk/cli/generate/config_h.py +++ b/lib/python/qmk/cli/generate/config_h.py @@ -9,7 +9,9 @@ from qmk.info import info_json from qmk.json_schema import json_load, validate from qmk.keyboard import keyboard_completer, keyboard_folder from qmk.keymap import locate_keymap +from qmk.commands import dump_lines from qmk.path import normpath +from qmk.constants import GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE def direct_pins(direct_pins, postfix): @@ -21,18 +23,7 @@ def direct_pins(direct_pins, postfix): cols = ','.join(map(str, [col or 'NO_PIN' for col in row])) rows.append('{' + cols + '}') - col_count = len(direct_pins[0]) - row_count = len(direct_pins) - return f""" -#ifndef MATRIX_COLS{postfix} -# define MATRIX_COLS{postfix} {col_count} -#endif // MATRIX_COLS{postfix} - -#ifndef MATRIX_ROWS{postfix} -# define MATRIX_ROWS{postfix} {row_count} -#endif // MATRIX_ROWS{postfix} - #ifndef DIRECT_PINS{postfix} # define DIRECT_PINS{postfix} {{ {", ".join(rows)} }} #endif // DIRECT_PINS{postfix} @@ -42,14 +33,9 @@ def direct_pins(direct_pins, postfix): def pin_array(define, pins, postfix): """Return the config.h lines that set a pin array. """ - pin_num = len(pins) pin_array = ', '.join(map(str, [pin or 'NO_PIN' for pin in pins])) return f""" -#ifndef {define}S{postfix} -# define {define}S{postfix} {pin_num} -#endif // {define}S{postfix} - #ifndef {define}_PINS{postfix} # define {define}_PINS{postfix} {{ {pin_array} }} #endif // {define}_PINS{postfix} @@ -73,6 +59,24 @@ def matrix_pins(matrix_pins, postfix=''): return '\n'.join(pins) +def generate_matrix_size(kb_info_json, config_h_lines): + """Add the matrix size to the config.h. + """ + if 'matrix_pins' in kb_info_json: + col_count = kb_info_json['matrix_size']['cols'] + row_count = kb_info_json['matrix_size']['rows'] + + config_h_lines.append(f""" +#ifndef MATRIX_COLS +# define MATRIX_COLS {col_count} +#endif // MATRIX_COLS + +#ifndef MATRIX_ROWS +# define MATRIX_ROWS {row_count} +#endif // MATRIX_ROWS +""") + + def generate_config_items(kb_info_json, config_h_lines): """Iterate through the info_config map to generate basic config values. """ @@ -108,6 +112,12 @@ def generate_config_items(kb_info_json, config_h_lines): config_h_lines.append(f'#ifndef {key}') config_h_lines.append(f'# define {key} {value}') config_h_lines.append(f'#endif // {key}') + elif key_type == 'bcd_version': + (major, minor, revision) = config_value.split('.') + config_h_lines.append('') + config_h_lines.append(f'#ifndef {config_key}') + config_h_lines.append(f'# define {config_key} 0x{major.zfill(2)}{minor}{revision}') + config_h_lines.append(f'#endif // {config_key}') else: config_h_lines.append('') config_h_lines.append(f'#ifndef {config_key}') @@ -173,10 +183,12 @@ def generate_config_h(cli): kb_info_json = dotty(info_json(cli.args.keyboard)) # Build the info_config.h file. - config_h_lines = ['/* This file was generated by `qmk generate-config-h`. Do not edit or copy.', ' */', '', '#pragma once'] + config_h_lines = [GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE, '#pragma once'] generate_config_items(kb_info_json, config_h_lines) + generate_matrix_size(kb_info_json, config_h_lines) + if 'matrix_pins' in kb_info_json: config_h_lines.append(matrix_pins(kb_info_json['matrix_pins'])) @@ -184,16 +196,4 @@ def generate_config_h(cli): generate_split_config(kb_info_json, config_h_lines) # Show the results - config_h = '\n'.join(config_h_lines) - - if cli.args.output: - cli.args.output.parent.mkdir(parents=True, exist_ok=True) - if cli.args.output.exists(): - cli.args.output.replace(cli.args.output.parent / (cli.args.output.name + '.bak')) - cli.args.output.write_text(config_h) - - if not cli.args.quiet: - cli.log.info('Wrote info_config.h to %s.', cli.args.output) - - else: - print(config_h) + dump_lines(cli.args.output, config_h_lines, cli.args.quiet) diff --git a/lib/python/qmk/cli/generate/develop_pr_list.py b/lib/python/qmk/cli/generate/develop_pr_list.py index 07e46752a6..549db5b185 100755 --- a/lib/python/qmk/cli/generate/develop_pr_list.py +++ b/lib/python/qmk/cli/generate/develop_pr_list.py @@ -12,6 +12,15 @@ fix_expr = re.compile(r'fix', flags=re.IGNORECASE) clean1_expr = re.compile(r'\[(develop|keyboard|keymap|core|cli|bug|docs|feature)\]', flags=re.IGNORECASE) clean2_expr = re.compile(r'^(develop|keyboard|keymap|core|cli|bug|docs|feature):', flags=re.IGNORECASE) +ignored_titles = ["Format code according to conventions"] + + +def _is_ignored(title): + for ignore in ignored_titles: + if ignore in title: + return True + return False + def _get_pr_info(cache, gh, pr_num): pull = cache.get(f'pull:{pr_num}') @@ -81,7 +90,9 @@ def generate_develop_pr_list(cli): else: normal_collection.append(info) - if "dependencies" in commit_info['pr_labels']: + if _is_ignored(commit_info['title']): + return + elif "dependencies" in commit_info['pr_labels']: fix_or_normal(commit_info, pr_list_bugs, pr_list_dependencies) elif "core" in commit_info['pr_labels']: fix_or_normal(commit_info, pr_list_bugs, pr_list_core) @@ -97,7 +108,7 @@ def generate_develop_pr_list(cli): match = git_expr.search(line) if match: pr_info = _get_pr_info(cache, gh, match.group("pr")) - commit_info = {'hash': match.group("hash"), 'title': match.group("title"), 'pr_num': int(match.group("pr")), 'pr_labels': [label.name for label in pr_info.labels.items]} + commit_info = {'hash': match.group("hash"), 'title': pr_info['title'], 'pr_num': int(match.group("pr")), 'pr_labels': [label.name for label in pr_info.labels.items]} _categorise_commit(commit_info) def _dump_commit_list(name, collection): diff --git a/lib/python/qmk/cli/generate/dfu_header.py b/lib/python/qmk/cli/generate/dfu_header.py index 7fb585fc7d..e873117387 100644 --- a/lib/python/qmk/cli/generate/dfu_header.py +++ b/lib/python/qmk/cli/generate/dfu_header.py @@ -7,6 +7,8 @@ from qmk.decorators import automagic_keyboard from qmk.info import info_json from qmk.path import is_keyboard, normpath from qmk.keyboard import keyboard_completer +from qmk.commands import dump_lines +from qmk.constants import GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE @cli.argument('-o', '--output', arg_only=True, type=normpath, help='File to write to') @@ -30,7 +32,7 @@ def generate_dfu_header(cli): # Build the Keyboard.h file. kb_info_json = dotty(info_json(cli.config.generate_dfu_header.keyboard)) - keyboard_h_lines = ['/* This file was generated by `qmk generate-dfu-header`. Do not edit or copy.', ' */', '', '#pragma once'] + keyboard_h_lines = [GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE, '#pragma once'] keyboard_h_lines.append(f'#define MANUFACTURER {kb_info_json["manufacturer"]}') keyboard_h_lines.append(f'#define PRODUCT {kb_info_json["keyboard_name"]} Bootloader') @@ -45,16 +47,4 @@ def generate_dfu_header(cli): keyboard_h_lines.append(f'#define QMK_SPEAKER {kb_info_json["qmk_lufa_bootloader.speaker"]}') # Show the results - keyboard_h = '\n'.join(keyboard_h_lines) - - if cli.args.output: - cli.args.output.parent.mkdir(parents=True, exist_ok=True) - if cli.args.output.exists(): - cli.args.output.replace(cli.args.output.parent / (cli.args.output.name + '.bak')) - cli.args.output.write_text(keyboard_h) - - if not cli.args.quiet: - cli.log.info('Wrote Keyboard.h to %s.', cli.args.output) - - else: - print(keyboard_h) + dump_lines(cli.args.output, keyboard_h_lines, cli.args.quiet) diff --git a/lib/python/qmk/cli/generate/docs.py b/lib/python/qmk/cli/generate/docs.py index 749336fea5..74112d834d 100644 --- a/lib/python/qmk/cli/generate/docs.py +++ b/lib/python/qmk/cli/generate/docs.py @@ -7,7 +7,9 @@ from subprocess import DEVNULL from milc import cli DOCS_PATH = Path('docs/') -BUILD_PATH = Path('.build/docs/') +BUILD_PATH = Path('.build/') +BUILD_DOCS_PATH = BUILD_PATH / 'docs' +DOXYGEN_PATH = BUILD_PATH / 'doxygen' @cli.subcommand('Build QMK documentation.', hidden=False if cli.config.user.developer else True) @@ -18,10 +20,12 @@ def generate_docs(cli): * [ ] Add a real build step... something static docs """ - if BUILD_PATH.exists(): - shutil.rmtree(BUILD_PATH) + if BUILD_DOCS_PATH.exists(): + shutil.rmtree(BUILD_DOCS_PATH) + if DOXYGEN_PATH.exists(): + shutil.rmtree(DOXYGEN_PATH) - shutil.copytree(DOCS_PATH, BUILD_PATH) + shutil.copytree(DOCS_PATH, BUILD_DOCS_PATH) # When not verbose we want to hide all output args = { @@ -34,6 +38,6 @@ def generate_docs(cli): # Generate internal docs cli.run(['doxygen', 'Doxyfile'], **args) - cli.run(['moxygen', '-q', '-a', '-g', '-o', BUILD_PATH / 'internals_%s.md', 'doxygen/xml'], **args) + cli.run(['moxygen', '-q', '-g', '-o', BUILD_DOCS_PATH / 'internals_%s.md', DOXYGEN_PATH / 'xml'], **args) - cli.log.info('Successfully generated internal docs to %s.', BUILD_PATH) + cli.log.info('Successfully generated internal docs to %s.', BUILD_DOCS_PATH) diff --git a/lib/python/qmk/cli/generate/keyboard_h.py b/lib/python/qmk/cli/generate/keyboard_h.py index f05178cede..2058865cbf 100755 --- a/lib/python/qmk/cli/generate/keyboard_h.py +++ b/lib/python/qmk/cli/generate/keyboard_h.py @@ -3,8 +3,10 @@ from milc import cli from qmk.info import info_json +from qmk.commands import dump_lines from qmk.keyboard import keyboard_completer, keyboard_folder from qmk.path import normpath +from qmk.constants import GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE def would_populate_layout_h(keyboard): @@ -36,22 +38,10 @@ def generate_keyboard_h(cli): has_layout_h = would_populate_layout_h(cli.args.keyboard) # Build the layouts.h file. - keyboard_h_lines = ['/* This file was generated by `qmk generate-keyboard-h`. Do not edit or copy.', ' */', '', '#pragma once', '#include "quantum.h"'] + keyboard_h_lines = [GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE, '#pragma once', '#include "quantum.h"'] if not has_layout_h: keyboard_h_lines.append('#pragma error("<keyboard>.h is only optional for data driven keyboards - kb.h == bad times")') # Show the results - keyboard_h = '\n'.join(keyboard_h_lines) + '\n' - - if cli.args.output: - cli.args.output.parent.mkdir(parents=True, exist_ok=True) - if cli.args.output.exists(): - cli.args.output.replace(cli.args.output.parent / (cli.args.output.name + '.bak')) - cli.args.output.write_text(keyboard_h) - - if not cli.args.quiet: - cli.log.info('Wrote keyboard_h to %s.', cli.args.output) - - else: - print(keyboard_h) + dump_lines(cli.args.output, keyboard_h_lines, cli.args.quiet) diff --git a/lib/python/qmk/cli/generate/layouts.py b/lib/python/qmk/cli/generate/layouts.py index e44266e1c8..193633baf6 100755 --- a/lib/python/qmk/cli/generate/layouts.py +++ b/lib/python/qmk/cli/generate/layouts.py @@ -2,11 +2,12 @@ """ from milc import cli -from qmk.constants import COL_LETTERS, ROW_LETTERS +from qmk.constants import COL_LETTERS, ROW_LETTERS, GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE from qmk.decorators import automagic_keyboard, automagic_keymap from qmk.info import info_json from qmk.keyboard import keyboard_completer, keyboard_folder from qmk.path import is_keyboard, normpath +from qmk.commands import dump_lines usb_properties = { 'vid': 'VENDOR_ID', @@ -38,18 +39,14 @@ def generate_layouts(cli): kb_info_json = info_json(cli.config.generate_layouts.keyboard) # Build the layouts.h file. - layouts_h_lines = ['/* This file was generated by `qmk generate-layouts`. Do not edit or copy.', ' */', '', '#pragma once'] - - if 'matrix_pins' in kb_info_json: - if 'direct' in kb_info_json['matrix_pins']: - col_num = len(kb_info_json['matrix_pins']['direct'][0]) - row_num = len(kb_info_json['matrix_pins']['direct']) - elif 'cols' in kb_info_json['matrix_pins'] and 'rows' in kb_info_json['matrix_pins']: - col_num = len(kb_info_json['matrix_pins']['cols']) - row_num = len(kb_info_json['matrix_pins']['rows']) - else: - cli.log.error('%s: Invalid matrix config.', cli.config.generate_layouts.keyboard) - return False + layouts_h_lines = [GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE, '#pragma once'] + + if 'matrix_size' not in kb_info_json: + cli.log.error('%s: Invalid matrix config.', cli.config.generate_layouts.keyboard) + return False + + col_num = kb_info_json['matrix_size']['cols'] + row_num = kb_info_json['matrix_size']['rows'] for layout_name in kb_info_json['layouts']: if kb_info_json['layouts'][layout_name]['c_macro']: @@ -90,16 +87,4 @@ def generate_layouts(cli): layouts_h_lines.append('#endif') # Show the results - layouts_h = '\n'.join(layouts_h_lines) + '\n' - - if cli.args.output: - cli.args.output.parent.mkdir(parents=True, exist_ok=True) - if cli.args.output.exists(): - cli.args.output.replace(cli.args.output.parent / (cli.args.output.name + '.bak')) - cli.args.output.write_text(layouts_h) - - if not cli.args.quiet: - cli.log.info('Wrote info_config.h to %s.', cli.args.output) - - else: - print(layouts_h) + dump_lines(cli.args.output, layouts_h_lines, cli.args.quiet) diff --git a/lib/python/qmk/cli/generate/rules_mk.py b/lib/python/qmk/cli/generate/rules_mk.py index 5d8d7cc8a7..29a1130f99 100755 --- a/lib/python/qmk/cli/generate/rules_mk.py +++ b/lib/python/qmk/cli/generate/rules_mk.py @@ -9,7 +9,9 @@ from qmk.info import info_json from qmk.json_schema import json_load, validate from qmk.keyboard import keyboard_completer, keyboard_folder from qmk.keymap import locate_keymap +from qmk.commands import dump_lines from qmk.path import normpath +from qmk.constants import GPL2_HEADER_SH_LIKE, GENERATED_HEADER_SH_LIKE def process_mapping_rule(kb_info_json, rules_key, info_dict): @@ -29,7 +31,7 @@ def process_mapping_rule(kb_info_json, rules_key, info_dict): if key_type in ['array', 'list']: return f'{rules_key} ?= {" ".join(rules_value)}' elif key_type == 'bool': - return f'{rules_key} ?= {"on" if rules_value else "off"}' + return f'{rules_key} ?= {"yes" if rules_value else "no"}' elif key_type == 'mapping': return '\n'.join([f'{key} ?= {value}' for key, value in rules_value.items()]) @@ -55,7 +57,7 @@ def generate_rules_mk(cli): kb_info_json = dotty(info_json(cli.args.keyboard)) info_rules_map = json_load(Path('data/mappings/info_rules.json')) - rules_mk_lines = ['# This file was generated by `qmk generate-rules-mk`. Do not edit or copy.', ''] + rules_mk_lines = [GPL2_HEADER_SH_LIKE, GENERATED_HEADER_SH_LIKE] # Iterate through the info_rules map to generate basic rules for rules_key, info_dict in info_rules_map.items(): @@ -83,14 +85,9 @@ def generate_rules_mk(cli): rules_mk_lines.append('CUSTOM_MATRIX ?= yes') # Show the results - rules_mk = '\n'.join(rules_mk_lines) + '\n' + dump_lines(cli.args.output, rules_mk_lines) if cli.args.output: - cli.args.output.parent.mkdir(parents=True, exist_ok=True) - if cli.args.output.exists(): - cli.args.output.replace(cli.args.output.parent / (cli.args.output.name + '.bak')) - cli.args.output.write_text(rules_mk) - if cli.args.quiet: if cli.args.escape: print(cli.args.output.as_posix().replace(' ', '\\ ')) @@ -98,6 +95,3 @@ def generate_rules_mk(cli): print(cli.args.output) else: cli.log.info('Wrote rules.mk to %s.', cli.args.output) - - else: - print(rules_mk) diff --git a/lib/python/qmk/cli/generate/version_h.py b/lib/python/qmk/cli/generate/version_h.py index b8e52588c4..a75702c529 100644 --- a/lib/python/qmk/cli/generate/version_h.py +++ b/lib/python/qmk/cli/generate/version_h.py @@ -1,9 +1,15 @@ """Used by the make system to generate version.h for use in code. """ +from time import strftime + from milc import cli -from qmk.commands import create_version_h from qmk.path import normpath +from qmk.commands import dump_lines +from qmk.git import git_get_version +from qmk.constants import GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE + +TIME_FMT = '%Y-%m-%d-%H:%M:%S' @cli.argument('-o', '--output', arg_only=True, type=normpath, help='File to write to') @@ -17,12 +23,29 @@ def generate_version_h(cli): if cli.args.skip_all: cli.args.skip_git = True - version_h = create_version_h(cli.args.skip_git, cli.args.skip_all) - - if cli.args.output: - cli.args.output.write_text(version_h) + if cli.args.skip_all: + current_time = "1970-01-01-00:00:00" + else: + current_time = strftime(TIME_FMT) - if not cli.args.quiet: - cli.log.info('Wrote version.h to %s.', cli.args.output) + if cli.args.skip_git: + git_version = "NA" + chibios_version = "NA" + chibios_contrib_version = "NA" else: - print(version_h) + git_version = git_get_version() or current_time + chibios_version = git_get_version("chibios", "os") or current_time + chibios_contrib_version = git_get_version("chibios-contrib", "os") or current_time + + # Build the version.h file. + version_h_lines = [GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE, '#pragma once'] + + version_h_lines.append(f""" +#define QMK_VERSION "{git_version}" +#define QMK_BUILDDATE "{current_time}" +#define CHIBIOS_VERSION "{chibios_version}" +#define CHIBIOS_CONTRIB_VERSION "{chibios_contrib_version}" +""") + + # Show the results + dump_lines(cli.args.output, version_h_lines, cli.args.quiet) diff --git a/lib/python/qmk/cli/json2c.py b/lib/python/qmk/cli/json2c.py index ae8248e6b7..2873a9bfd3 100755 --- a/lib/python/qmk/cli/json2c.py +++ b/lib/python/qmk/cli/json2c.py @@ -1,12 +1,11 @@ """Generate a keymap.c from a configurator export. """ -import json - from argcomplete.completers import FilesCompleter from milc import cli import qmk.keymap import qmk.path +from qmk.commands import parse_configurator_json @cli.argument('-o', '--output', arg_only=True, type=qmk.path.normpath, help='File to write to') @@ -19,14 +18,8 @@ def json2c(cli): This command uses the `qmk.keymap` module to generate a keymap.c from a configurator export. The generated keymap is written to stdout, or to a file if -o is provided. """ - try: - # Parse the configurator from json file (or stdin) - user_keymap = json.load(cli.args.filename) - - except json.decoder.JSONDecodeError as ex: - cli.log.error('The JSON input does not appear to be valid.') - cli.log.error(ex) - return False + # Parse the configurator from json file (or stdin) + user_keymap = parse_configurator_json(cli.args.filename) # Environment processing if cli.args.output and cli.args.output.name == '-': diff --git a/lib/python/qmk/cli/multibuild.py b/lib/python/qmk/cli/multibuild.py index 85ed0fa1e9..dff8c88422 100755 --- a/lib/python/qmk/cli/multibuild.py +++ b/lib/python/qmk/cli/multibuild.py @@ -32,6 +32,7 @@ def _is_split(keyboard_name): @cli.argument('-c', '--clean', arg_only=True, action='store_true', help="Remove object files before compiling.") @cli.argument('-f', '--filter', arg_only=True, action='append', default=[], help="Filter the list of keyboards based on the supplied value in rules.mk. Supported format is 'SPLIT_KEYBOARD=yes'. May be passed multiple times.") @cli.argument('-km', '--keymap', type=str, default='default', help="The keymap name to build. Default is 'default'.") +@cli.argument('-e', '--env', arg_only=True, action='append', default=[], help="Set a variable to be passed to make. May be passed multiple times.") @cli.subcommand('Compile QMK Firmware for all keyboards.', hidden=False if cli.config.user.developer else True) def multibuild(cli): """Compile QMK Firmware against all keyboards. @@ -68,7 +69,7 @@ def multibuild(cli): all: {keyboard_safe}_binary {keyboard_safe}_binary: @rm -f "{QMK_FIRMWARE}/.build/failed.log.{keyboard_safe}" || true - +@$(MAKE) -C "{QMK_FIRMWARE}" -f "{QMK_FIRMWARE}/build_keyboard.mk" KEYBOARD="{keyboard_name}" KEYMAP="{cli.args.keymap}" REQUIRE_PLATFORM_KEY= COLOR=true SILENT=false \\ + +@$(MAKE) -C "{QMK_FIRMWARE}" -f "{QMK_FIRMWARE}/builddefs/build_keyboard.mk" KEYBOARD="{keyboard_name}" KEYMAP="{cli.args.keymap}" REQUIRE_PLATFORM_KEY= COLOR=true SILENT=false {' '.join(cli.args.env)} \\ >>"{QMK_FIRMWARE}/.build/build.log.{os.getpid()}.{keyboard_safe}" 2>&1 \\ || cp "{QMK_FIRMWARE}/.build/build.log.{os.getpid()}.{keyboard_safe}" "{QMK_FIRMWARE}/.build/failed.log.{os.getpid()}.{keyboard_safe}" @{{ grep '\[ERRORS\]' "{QMK_FIRMWARE}/.build/build.log.{os.getpid()}.{keyboard_safe}" >/dev/null 2>&1 && printf "Build %-64s \e[1;31m[ERRORS]\e[0m\\n" "{keyboard_name}:{cli.args.keymap}" ; }} \\ diff --git a/lib/python/qmk/cli/new/keyboard.py b/lib/python/qmk/cli/new/keyboard.py index 4093b8c90d..1cdfe53206 100644 --- a/lib/python/qmk/cli/new/keyboard.py +++ b/lib/python/qmk/cli/new/keyboard.py @@ -1,15 +1,45 @@ """This script automates the creation of new keyboard directories using a starter template. """ +import re +import json +import shutil from datetime import date from pathlib import Path -import re +from dotty_dict import dotty -from qmk.commands import git_get_username -import qmk.path from milc import cli from milc.questions import choice, question -KEYBOARD_TYPES = ['avr', 'ps2avrgb'] +from qmk.git import git_get_username +from qmk.json_schema import load_jsonschema +from qmk.path import keyboard +from qmk.json_encoders import InfoJSONEncoder +from qmk.json_schema import deep_update +from qmk.constants import MCU2BOOTLOADER + +COMMUNITY = Path('layouts/default/') +TEMPLATE = Path('data/templates/keyboard/') + +# defaults +schema = dotty(load_jsonschema('keyboard')) +mcu_types = sorted(schema["properties.processor.enum"], key=str.casefold) +available_layouts = sorted([x.name for x in COMMUNITY.iterdir() if x.is_dir()]) + + +def mcu_type(mcu): + """Callable for argparse validation. + """ + if mcu not in mcu_types: + raise ValueError + return mcu + + +def layout_type(layout): + """Callable for argparse validation. + """ + if layout not in available_layouts: + raise ValueError + return layout def keyboard_name(name): @@ -27,113 +57,193 @@ def validate_keyboard_name(name): return bool(regex.match(name)) -@cli.argument('-kb', '--keyboard', help='Specify the name for the new keyboard directory', arg_only=True, type=keyboard_name) -@cli.argument('-t', '--type', help='Specify the keyboard type', arg_only=True, choices=KEYBOARD_TYPES) -@cli.argument('-u', '--username', help='Specify your username (default from Git config)', arg_only=True) -@cli.argument('-n', '--realname', help='Specify your real name if you want to use that. Defaults to username', arg_only=True) -@cli.subcommand('Creates a new keyboard directory') -def new_keyboard(cli): - """Creates a new keyboard. +def select_default_bootloader(mcu): + """Provide sane defaults for bootloader """ - cli.log.info('{style_bright}Generating a new QMK keyboard directory{style_normal}') - cli.echo('') + return MCU2BOOTLOADER.get(mcu, "custom") + - # Get keyboard name - new_keyboard_name = None - while not new_keyboard_name: - new_keyboard_name = cli.args.keyboard if cli.args.keyboard else question('Keyboard Name:') - if not validate_keyboard_name(new_keyboard_name): - cli.log.error('Keyboard names must contain only {fg_cyan}lowercase a-z{fg_reset}, {fg_cyan}0-9{fg_reset}, and {fg_cyan}_{fg_reset}! Please choose a different name.') +def replace_placeholders(src, dest, tokens): + """Replaces the given placeholders in each template file. + """ + content = src.read_text() + for key, value in tokens.items(): + content = content.replace(f'%{key}%', value) - # Exit if passed by arg - if cli.args.keyboard: - return False + dest.write_text(content) - new_keyboard_name = None - continue - keyboard_path = qmk.path.keyboard(new_keyboard_name) - if keyboard_path.exists(): - cli.log.error(f'Keyboard {{fg_cyan}}{new_keyboard_name}{{fg_reset}} already exists! Please choose a different name.') +def augment_community_info(src, dest): + """Splice in any additional data into info.json + """ + info = json.loads(src.read_text()) + template = json.loads(dest.read_text()) - # Exit if passed by arg - if cli.args.keyboard: - return False + # merge community with template + deep_update(info, template) - new_keyboard_name = None + # avoid assumptions on macro name by using the first available + first_layout = next(iter(info["layouts"].values()))["layout"] - # Get keyboard type - keyboard_type = cli.args.type if cli.args.type else choice('Keyboard Type:', KEYBOARD_TYPES, default=0) + # guess at width and height now its optional + width, height = (0, 0) + for item in first_layout: + width = max(width, int(item["x"]) + 1) + height = max(height, int(item["y"]) + 1) - # Get username - user_name = None - while not user_name: - user_name = question('Your GitHub User Name:', default=find_user_name()) + info["matrix_pins"] = { + "cols": ["C2"] * width, + "rows": ["D1"] * height, + } - if not user_name: - cli.log.error('You didn\'t provide a username, and we couldn\'t find one set in your QMK or Git configs. Please try again.') + # assume a 1:1 mapping on matrix to electrical + for item in first_layout: + item["matrix"] = [int(item["y"]), int(item["x"])] - # Exit if passed by arg - if cli.args.username: - return False + # finally write out the updated info.json + dest.write_text(json.dumps(info, cls=InfoJSONEncoder)) - real_name = None - while not real_name: - real_name = question('Your real name:', default=user_name) - keyboard_basename = keyboard_path.name - replacements = { - "YEAR": str(date.today().year), - "KEYBOARD": keyboard_basename, - "USER_NAME": user_name, - "YOUR_NAME": real_name, - } +def _question(*args, **kwargs): + """Ugly workaround until 'milc' learns to display a repromt msg + """ + # TODO: Remove this once milc.questions.question handles reprompt messages - template_dir = Path('data/templates') - template_tree(template_dir / 'base', keyboard_path, replacements) - template_tree(template_dir / keyboard_type, keyboard_path, replacements) + reprompt = kwargs["reprompt"] + del kwargs["reprompt"] + validate = kwargs["validate"] + del kwargs["validate"] - cli.echo('') - cli.log.info(f'{{fg_green}}Created a new keyboard called {{fg_cyan}}{new_keyboard_name}{{fg_green}}.{{fg_reset}}') - cli.log.info(f'To start working on things, `cd` into {{fg_cyan}}{keyboard_path}{{fg_reset}},') - cli.log.info('or open the directory in your preferred text editor.') + prompt = args[0] + ret = None + while not ret: + ret = question(prompt, **kwargs) + if not validate(ret): + ret = None + prompt = reprompt + return ret -def find_user_name(): - if cli.args.username: - return cli.args.username - elif cli.config.user.name: - return cli.config.user.name - else: - return git_get_username() +def prompt_keyboard(): + prompt = """{fg_yellow}Name Your Keyboard Project{style_reset_all} +For more infomation, see: +https://docs.qmk.fm/#/hardware_keyboard_guidelines?id=naming-your-keyboardproject -def template_tree(src: Path, dst: Path, replacements: dict): - """Recursively copy template and replace placeholders +Keyboard Name? """ - Args: - src (Path) - The source folder to copy from - dst (Path) - The destination folder to copy to - replacements (dict) - a dictionary with "key":"value" pairs to replace. + errmsg = 'Keyboard already exists! Please choose a different name:' - Raises: - FileExistsError - When trying to overwrite existing files + return _question(prompt, reprompt=errmsg, validate=lambda x: not keyboard(x).exists()) + + +def prompt_user(): + prompt = """ +{fg_yellow}Attribution{style_reset_all} +Used for maintainer, copyright, etc + +Your GitHub Username? """ + return question(prompt, default=git_get_username()) + + +def prompt_name(def_name): + prompt = """ +{fg_yellow}More Attribution{style_reset_all} +Used for maintainer, copyright, etc + +Your Real Name? """ + return question(prompt, default=def_name) + + +def prompt_layout(): + prompt = """ +{fg_yellow}Pick Base Layout{style_reset_all} +As a starting point, one of the common layouts can be used to bootstrap the process + +Default Layout? """ + # avoid overwhelming user - remove some? + filtered_layouts = [x for x in available_layouts if not any(xs in x for xs in ['_split', '_blocker', '_tsangan', '_f13'])] + filtered_layouts.append("none of the above") + + return choice(prompt, filtered_layouts, default=len(filtered_layouts) - 1) + + +def prompt_mcu(): + prompt = """ +{fg_yellow}What Powers Your Project{style_reset_all} +For more infomation, see: +https://docs.qmk.fm/#/compatible_microcontrollers + +MCU? """ + # remove any options strictly used for compatibility + filtered_mcu = [x for x in mcu_types if not any(xs in x for xs in ['cortex', 'unknown'])] + + return choice(prompt, filtered_mcu, default=filtered_mcu.index("atmega32u4")) + + +@cli.argument('-kb', '--keyboard', help='Specify the name for the new keyboard directory', arg_only=True, type=keyboard_name) +@cli.argument('-l', '--layout', help='Community layout to bootstrap with', arg_only=True, type=layout_type) +@cli.argument('-t', '--type', help='Specify the keyboard MCU type', arg_only=True, type=mcu_type) +@cli.argument('-u', '--username', help='Specify your username (default from Git config)', dest='name') +@cli.argument('-n', '--realname', help='Specify your real name if you want to use that. Defaults to username', arg_only=True) +@cli.subcommand('Creates a new keyboard directory') +def new_keyboard(cli): + """Creates a new keyboard. """ + cli.log.info('{style_bright}Generating a new QMK keyboard directory{style_normal}') + cli.echo('') + + kb_name = cli.args.keyboard if cli.args.keyboard else prompt_keyboard() + user_name = cli.config.new_keyboard.name if cli.config.new_keyboard.name else prompt_user() + real_name = cli.args.realname or cli.config.new_keyboard.name if cli.args.realname or cli.config.new_keyboard.name else prompt_name(user_name) + default_layout = cli.args.layout if cli.args.layout else prompt_layout() + mcu = cli.args.type if cli.args.type else prompt_mcu() + bootloader = select_default_bootloader(mcu) + + if not validate_keyboard_name(kb_name): + cli.log.error('Keyboard names must contain only {fg_cyan}lowercase a-z{fg_reset}, {fg_cyan}0-9{fg_reset}, and {fg_cyan}_{fg_reset}! Please choose a different name.') + return 1 + + if keyboard(kb_name).exists(): + cli.log.error(f'Keyboard {{fg_cyan}}{kb_name}{{fg_reset}} already exists! Please choose a different name.') + return 1 + + tokens = { # Comment here is to force multiline formatting + 'YEAR': str(date.today().year), + 'KEYBOARD': kb_name, + 'USER_NAME': user_name, + 'REAL_NAME': real_name, + 'LAYOUT': default_layout, + 'MCU': mcu, + 'BOOTLOADER': bootloader + } + + if cli.config.general.verbose: + cli.log.info("Creating keyboard with:") + for key, value in tokens.items(): + cli.echo(f" {key.ljust(10)}: {value}") - dst.mkdir(parents=True, exist_ok=True) + # TODO: detach community layout and rename to just "LAYOUT" + if default_layout == 'none of the above': + default_layout = "ortho_4x4" - for child in src.iterdir(): - if child.is_dir(): - template_tree(child, dst / child.name, replacements=replacements) + # begin with making the deepest folder in the tree + keymaps_path = keyboard(kb_name) / 'keymaps/' + keymaps_path.mkdir(parents=True) - if child.is_file(): - file_name = dst / (child.name % replacements) + # copy in keymap.c or keymap.json + community_keymap = Path(COMMUNITY / f'{default_layout}/default_{default_layout}/') + shutil.copytree(community_keymap, keymaps_path / 'default') - with file_name.open(mode='x') as dst_f: - with child.open() as src_f: - template = src_f.read() - dst_f.write(template % replacements) + # process template files + for file in list(TEMPLATE.iterdir()): + replace_placeholders(file, keyboard(kb_name) / file.name, tokens) + + # merge in infos + community_info = Path(COMMUNITY / f'{default_layout}/info.json') + augment_community_info(community_info, keyboard(kb_name) / community_info.name) + + cli.log.info(f'{{fg_green}}Created a new keyboard called {{fg_cyan}}{kb_name}{{fg_green}}.{{fg_reset}}') + cli.log.info(f'To start working on things, `cd` into {{fg_cyan}}keyboards/{kb_name}{{fg_reset}},') + cli.log.info('or open the directory in your preferred text editor.') + cli.log.info(f"And build with {{fg_yellow}}qmk compile -kb {kb_name} -km default{{fg_reset}}.") diff --git a/lib/python/qmk/cli/via2json.py b/lib/python/qmk/cli/via2json.py new file mode 100755 index 0000000000..6edc9dfbe5 --- /dev/null +++ b/lib/python/qmk/cli/via2json.py @@ -0,0 +1,145 @@ +"""Generate a keymap.c from a configurator export. +""" +import json +import re + +from milc import cli + +import qmk.keyboard +import qmk.path +from qmk.info import info_json +from qmk.json_encoders import KeymapJSONEncoder +from qmk.commands import parse_configurator_json, dump_lines +from qmk.keymap import generate_json, list_keymaps, locate_keymap, parse_keymap_c + + +def _find_via_layout_macro(keyboard): + keymap_layout = None + if 'via' in list_keymaps(keyboard): + keymap_path = locate_keymap(keyboard, 'via') + if keymap_path.suffix == '.json': + keymap_layout = parse_configurator_json(keymap_path)['layout'] + else: + keymap_layout = parse_keymap_c(keymap_path)['layers'][0]['layout'] + return keymap_layout + + +def _convert_macros(via_macros): + via_macros = list(filter(lambda f: bool(f), via_macros)) + if len(via_macros) == 0: + return list() + split_regex = re.compile(r'(}\,)|(\,{)') + macros = list() + for via_macro in via_macros: + # Split VIA macro to its elements + macro = split_regex.split(via_macro) + # Remove junk elements (None, '},' and ',{') + macro = list(filter(lambda f: False if f in (None, '},', ',{') else True, macro)) + macro_data = list() + for m in macro: + if '{' in m or '}' in m: + # Found keycode(s) + keycodes = m.split(',') + # Remove whitespaces and curly braces from around keycodes + keycodes = list(map(lambda s: s.strip(' {}'), keycodes)) + # Remove the KC prefix + keycodes = list(map(lambda s: s.replace('KC_', ''), keycodes)) + macro_data.append({"action": "tap", "keycodes": keycodes}) + else: + # Found text + macro_data.append(m) + macros.append(macro_data) + + return macros + + +def _fix_macro_keys(keymap_data): + macro_no = re.compile(r'MACRO0?([0-9]{1,2})') + for i in range(0, len(keymap_data)): + for j in range(0, len(keymap_data[i])): + kc = keymap_data[i][j] + m = macro_no.match(kc) + if m: + keymap_data[i][j] = f'MACRO_{m.group(1)}' + return keymap_data + + +def _via_to_keymap(via_backup, keyboard_data, keymap_layout): + # Check if passed LAYOUT is correct + layout_data = keyboard_data['layouts'].get(keymap_layout) + if not layout_data: + cli.log.error(f'LAYOUT macro {keymap_layout} is not a valid one for keyboard {cli.args.keyboard}!') + exit(1) + + layout_data = layout_data['layout'] + sorting_hat = list() + for index, data in enumerate(layout_data): + sorting_hat.append([index, data['matrix']]) + + sorting_hat.sort(key=lambda k: (k[1][0], k[1][1])) + + pos = 0 + for row_num in range(0, keyboard_data['matrix_size']['rows']): + for col_num in range(0, keyboard_data['matrix_size']['cols']): + if pos >= len(sorting_hat) or sorting_hat[pos][1][0] != row_num or sorting_hat[pos][1][1] != col_num: + sorting_hat.insert(pos, [None, [row_num, col_num]]) + else: + sorting_hat.append([None, [row_num, col_num]]) + pos += 1 + + keymap_data = list() + for layer in via_backup['layers']: + pos = 0 + layer_data = list() + for key in layer: + if sorting_hat[pos][0] is not None: + layer_data.append([sorting_hat[pos][0], key]) + pos += 1 + layer_data.sort() + layer_data = [kc[1] for kc in layer_data] + keymap_data.append(layer_data) + + return keymap_data + + +@cli.argument('-o', '--output', arg_only=True, type=qmk.path.normpath, help='File to write to') +@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages") +@cli.argument('filename', type=qmk.path.FileType('r'), arg_only=True, help='VIA Backup JSON file') +@cli.argument('-kb', '--keyboard', type=qmk.keyboard.keyboard_folder, completer=qmk.keyboard.keyboard_completer, arg_only=True, required=True, help='The keyboard\'s name') +@cli.argument('-km', '--keymap', arg_only=True, default='via2json', help='The keymap\'s name') +@cli.argument('-l', '--layout', arg_only=True, help='The keymap\'s layout') +@cli.subcommand('Convert a VIA backup json to keymap.json format.') +def via2json(cli): + """Convert a VIA backup json to keymap.json format. + + This command uses the `qmk.keymap` module to generate a keymap.json from a VIA backup json. The generated keymap is written to stdout, or to a file if -o is provided. + """ + # Find appropriate layout macro + keymap_layout = cli.args.layout if cli.args.layout else _find_via_layout_macro(cli.args.keyboard) + if not keymap_layout: + cli.log.error(f"Couldn't find LAYOUT macro for keyboard {cli.args.keyboard}. Please specify it with the '-l' argument.") + exit(1) + + # Load the VIA backup json + with cli.args.filename.open('r') as fd: + via_backup = json.load(fd) + + # Generate keyboard metadata + keyboard_data = info_json(cli.args.keyboard) + + # Get keycode array + keymap_data = _via_to_keymap(via_backup, keyboard_data, keymap_layout) + + # Convert macros + macro_data = list() + if via_backup.get('macros'): + macro_data = _convert_macros(via_backup['macros']) + + # Replace VIA macro keys with JSON keymap ones + keymap_data = _fix_macro_keys(keymap_data) + + # Generate the keymap.json + keymap_json = generate_json(cli.args.keymap, cli.args.keyboard, keymap_layout, keymap_data, macro_data) + + keymap_lines = [json.dumps(keymap_json, cls=KeymapJSONEncoder)] + dump_lines(cli.args.output, keymap_lines, cli.args.quiet) diff --git a/lib/python/qmk/commands.py b/lib/python/qmk/commands.py index 5a01943773..d0bd00beb7 100644 --- a/lib/python/qmk/commands.py +++ b/lib/python/qmk/commands.py @@ -1,20 +1,16 @@ """Helper functions for commands. """ -import json import os import sys import shutil from pathlib import Path -from subprocess import DEVNULL -from time import strftime from milc import cli +import jsonschema import qmk.keymap -from qmk.constants import QMK_FIRMWARE, KEYBOARD_OUTPUT_PREFIX -from qmk.json_schema import json_load - -time_fmt = '%Y-%m-%d-%H:%M:%S' +from qmk.constants import KEYBOARD_OUTPUT_PREFIX +from qmk.json_schema import json_load, validate def _find_make(): @@ -93,31 +89,6 @@ def create_make_command(keyboard, keymap, target=None, dry_run=False, parallel=1 return create_make_target(':'.join(make_args), dry_run=dry_run, parallel=parallel, **env_vars) -def get_git_version(current_time, repo_dir='.', check_dir='.'): - """Returns the current git version for a repo, or the current time. - """ - git_describe_cmd = ['git', 'describe', '--abbrev=6', '--dirty', '--always', '--tags'] - - if repo_dir != '.': - repo_dir = Path('lib') / repo_dir - - if check_dir != '.': - check_dir = repo_dir / check_dir - - if Path(check_dir).exists(): - git_describe = cli.run(git_describe_cmd, stdin=DEVNULL, cwd=repo_dir) - - if git_describe.returncode == 0: - return git_describe.stdout.strip() - - else: - cli.log.warn(f'"{" ".join(git_describe_cmd)}" returned error code {git_describe.returncode}') - print(git_describe.stderr) - return current_time - - return current_time - - def get_make_parallel_args(parallel=1): """Returns the arguments for running the specified number of parallel jobs. """ @@ -136,37 +107,6 @@ def get_make_parallel_args(parallel=1): return parallel_args -def create_version_h(skip_git=False, skip_all=False): - """Generate version.h contents - """ - if skip_all: - current_time = "1970-01-01-00:00:00" - else: - current_time = strftime(time_fmt) - - if skip_git: - git_version = "NA" - chibios_version = "NA" - chibios_contrib_version = "NA" - else: - git_version = get_git_version(current_time) - chibios_version = get_git_version(current_time, "chibios", "os") - chibios_contrib_version = get_git_version(current_time, "chibios-contrib", "os") - - version_h_lines = f"""/* This file was automatically generated. Do not edit or copy. - */ - -#pragma once - -#define QMK_VERSION "{git_version}" -#define QMK_BUILDDATE "{current_time}" -#define CHIBIOS_VERSION "{chibios_version}" -#define CHIBIOS_CONTRIB_VERSION "{chibios_contrib_version}" -""" - - return version_h_lines - - def compile_configurator_json(user_keymap, bootloader=None, parallel=1, **env_vars): """Convert a configurator export JSON file into a C file and then compile it. @@ -185,6 +125,10 @@ def compile_configurator_json(user_keymap, bootloader=None, parallel=1, **env_va A command to run to compile and flash the C file. """ + # In case the user passes a keymap.json from a keymap directory directly to the CLI. + # e.g.: qmk compile - < keyboards/clueboard/california/keymaps/default/keymap.json + user_keymap["keymap"] = user_keymap.get("keymap", "default_json") + # Write the keymap.c file keyboard_filesafe = user_keymap['keyboard'].replace('/', '_') target = f'{keyboard_filesafe}_{user_keymap["keymap"]}' @@ -197,9 +141,6 @@ def compile_configurator_json(user_keymap, bootloader=None, parallel=1, **env_va keymap_dir.mkdir(exist_ok=True, parents=True) keymap_c.write_text(c_text) - version_h = Path('quantum/version.h') - version_h.write_text(create_version_h()) - # Return a command that can be run to make the keymap and flash if given verbose = 'true' if cli.config.general.verbose else 'false' color = 'true' if cli.config.general.color else 'false' @@ -213,7 +154,7 @@ def compile_configurator_json(user_keymap, bootloader=None, parallel=1, **env_va '-r', '-R', '-f', - 'build_keyboard.mk', + 'builddefs/build_keyboard.mk', ]) if bootloader: @@ -248,8 +189,15 @@ def compile_configurator_json(user_keymap, bootloader=None, parallel=1, **env_va def parse_configurator_json(configurator_file): """Open and parse a configurator json export """ - # FIXME(skullydazed/anyone): Add validation here - user_keymap = json.load(configurator_file) + user_keymap = json_load(configurator_file) + # Validate against the jsonschema + try: + validate(user_keymap, 'qmk.keymap.v1') + + except jsonschema.ValidationError as e: + cli.log.error(f'Invalid JSON keymap: {configurator_file} : {e.message}') + exit(1) + orig_keyboard = user_keymap['keyboard'] aliases = json_load(Path('data/mappings/keyboard_aliases.json')) @@ -263,78 +211,26 @@ def parse_configurator_json(configurator_file): return user_keymap -def git_get_username(): - """Retrieves user's username from Git config, if set. - """ - git_username = cli.run(['git', 'config', '--get', 'user.name']) - - if git_username.returncode == 0 and git_username.stdout: - return git_username.stdout.strip() - - -def git_check_repo(): - """Checks that the .git directory exists inside QMK_HOME. - - This is a decent enough indicator that the qmk_firmware directory is a - proper Git repository, rather than a .zip download from GitHub. - """ - dot_git_dir = QMK_FIRMWARE / '.git' - - return dot_git_dir.is_dir() - - -def git_get_branch(): - """Returns the current branch for a repo, or None. - """ - git_branch = cli.run(['git', 'branch', '--show-current']) - if not git_branch.returncode != 0 or not git_branch.stdout: - # Workaround for Git pre-2.22 - git_branch = cli.run(['git', 'rev-parse', '--abbrev-ref', 'HEAD']) - - if git_branch.returncode == 0: - return git_branch.stdout.strip() - - -def git_is_dirty(): - """Returns 1 if repo is dirty, or 0 if clean - """ - git_diff_staged_cmd = ['git', 'diff', '--quiet'] - git_diff_unstaged_cmd = [*git_diff_staged_cmd, '--cached'] - - unstaged = cli.run(git_diff_staged_cmd) - staged = cli.run(git_diff_unstaged_cmd) - - return unstaged.returncode != 0 or staged.returncode != 0 - - -def git_get_remotes(): - """Returns the current remotes for a repo. - """ - remotes = {} - - git_remote_show_cmd = ['git', 'remote', 'show'] - git_remote_get_cmd = ['git', 'remote', 'get-url'] - - git_remote_show = cli.run(git_remote_show_cmd) - if git_remote_show.returncode == 0: - for name in git_remote_show.stdout.splitlines(): - git_remote_name = cli.run([*git_remote_get_cmd, name]) - remotes[name.strip()] = {"url": git_remote_name.stdout.strip()} - - return remotes - - -def git_check_deviation(active_branch): - """Return True if branch has custom commits - """ - cli.run(['git', 'fetch', 'upstream', active_branch]) - deviations = cli.run(['git', '--no-pager', 'log', f'upstream/{active_branch}...{active_branch}']) - return bool(deviations.returncode) - - def in_virtualenv(): """Check if running inside a virtualenv. Based on https://stackoverflow.com/a/1883251 """ active_prefix = getattr(sys, "base_prefix", None) or getattr(sys, "real_prefix", None) or sys.prefix return active_prefix != sys.prefix + + +def dump_lines(output_file, lines, quiet=True): + """Handle dumping to stdout or file + Creates parent folders if required + """ + generated = '\n'.join(lines) + '\n' + if output_file and output_file.name != '-': + output_file.parent.mkdir(parents=True, exist_ok=True) + if output_file.exists(): + output_file.replace(output_file.parent / (output_file.name + '.bak')) + output_file.write_text(generated) + + if not quiet: + cli.log.info(f'Wrote {output_file.name} to {output_file}.') + else: + print(generated) diff --git a/lib/python/qmk/constants.py b/lib/python/qmk/constants.py index 433b110523..895fcc7d01 100644 --- a/lib/python/qmk/constants.py +++ b/lib/python/qmk/constants.py @@ -1,6 +1,7 @@ """Information that should be available to the python library. """ from os import environ +from datetime import date from pathlib import Path # The root of the qmk_firmware tree. @@ -13,10 +14,53 @@ QMK_FIRMWARE_UPSTREAM = 'qmk/qmk_firmware' MAX_KEYBOARD_SUBFOLDERS = 5 # Supported processor types +<<<<<<< HEAD CHIBIOS_PROCESSORS = 'cortex-m0', 'cortex-m0plus', 'cortex-m3', 'cortex-m4', 'MKL26Z64', 'MK20DX128', 'MK20DX256', 'MK66FX1M0', 'STM32F042', 'STM32F072', 'STM32F103', 'STM32F303', 'STM32F401', 'STM32F405', 'STM32F407', 'STM32F411', 'STM32F446', 'STM32G431', 'STM32G474', 'STM32L412', 'STM32L422', 'STM32L433', 'STM32L443', 'GD32VF103', 'WB32F3G71' +======= +CHIBIOS_PROCESSORS = 'cortex-m0', 'cortex-m0plus', 'cortex-m3', 'cortex-m4', 'MKL26Z64', 'MK20DX128', 'MK20DX256', 'MK66FX1M0', 'STM32F042', 'STM32F072', 'STM32F103', 'STM32F303', 'STM32F401', 'STM32F405', 'STM32F407', 'STM32F411', 'STM32F446', 'STM32G431', 'STM32G474', 'STM32L412', 'STM32L422', 'STM32L432', 'STM32L433', 'STM32L442', 'STM32L443', 'GD32VF103', 'WB32F3G71' +>>>>>>> qmk/master LUFA_PROCESSORS = 'at90usb162', 'atmega16u2', 'atmega32u2', 'atmega16u4', 'atmega32u4', 'at90usb646', 'at90usb647', 'at90usb1286', 'at90usb1287', None VUSB_PROCESSORS = 'atmega32a', 'atmega328p', 'atmega328', 'attiny85' +# Bootloaders of the supported processors +MCU2BOOTLOADER = { + "MKL26Z64": "halfkay", + "MK20DX128": "halfkay", + "MK20DX256": "halfkay", + "MK66FX1M0": "halfkay", + "STM32F042": "stm32-dfu", + "STM32F072": "stm32-dfu", + "STM32F103": "stm32duino", + "STM32F303": "stm32-dfu", + "STM32F401": "stm32-dfu", + "STM32F405": "stm32-dfu", + "STM32F407": "stm32-dfu", + "STM32F411": "stm32-dfu", + "STM32F446": "stm32-dfu", + "STM32G431": "stm32-dfu", + "STM32G474": "stm32-dfu", + "STM32L412": "stm32-dfu", + "STM32L422": "stm32-dfu", + "STM32L432": "stm32-dfu", + "STM32L433": "stm32-dfu", + "STM32L442": "stm32-dfu", + "STM32L443": "stm32-dfu", + "GD32VF103": "gd32v-dfu", + "WB32F3G71": "wb32-dfu", + "atmega16u2": "atmel-dfu", + "atmega32u2": "atmel-dfu", + "atmega16u4": "atmel-dfu", + "atmega32u4": "atmel-dfu", + "at90usb162": "atmel-dfu", + "at90usb646": "atmel-dfu", + "at90usb647": "atmel-dfu", + "at90usb1286": "atmel-dfu", + "at90usb1287": "atmel-dfu", + "atmega32a": "bootloadhid", + "atmega328p": "usbasploader", + "atmega328": "usbasploader", +} + # Common format strings DATE_FORMAT = '%Y-%m-%d' DATETIME_FORMAT = '%Y-%m-%d %H:%M:%S %Z' @@ -36,3 +80,65 @@ LED_INDICATORS = { # Constants that should match their counterparts in make BUILD_DIR = environ.get('BUILD_DIR', '.build') KEYBOARD_OUTPUT_PREFIX = f'{BUILD_DIR}/obj_' + +# Headers for generated files +GPL2_HEADER_C_LIKE = f'''\ +// Copyright {date.today().year} QMK +// SPDX-License-Identifier: GPL-2.0-or-later +''' + +GPL2_HEADER_SH_LIKE = f'''\ +# Copyright {date.today().year} QMK +# SPDX-License-Identifier: GPL-2.0-or-later +''' + +GENERATED_HEADER_C_LIKE = '''\ +/******************************************************************************* + 88888888888 888 d8b .d888 d8b 888 d8b + 888 888 Y8P d88P" Y8P 888 Y8P + 888 888 888 888 + 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b + 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K + 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. + 888 888 888 888 X88 888 888 888 Y8b. 888 X88 + 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' + 888 888 + 888 888 + 888 888 + .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 + d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 + 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 + Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 + "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 + 888 + Y8b d88P + "Y88P" +*******************************************************************************/ +''' + +GENERATED_HEADER_SH_LIKE = '''\ +################################################################################ +# +# 88888888888 888 d8b .d888 d8b 888 d8b +# 888 888 Y8P d88P" Y8P 888 Y8P +# 888 888 888 888 +# 888 88888b. 888 .d8888b 888888 888 888 .d88b. 888 .d8888b +# 888 888 "88b 888 88K 888 888 888 d8P Y8b 888 88K +# 888 888 888 888 "Y8888b. 888 888 888 88888888 888 "Y8888b. +# 888 888 888 888 X88 888 888 888 Y8b. 888 X88 +# 888 888 888 888 88888P' 888 888 888 "Y8888 888 88888P' +# +# 888 888 +# 888 888 +# 888 888 +# .d88b. .d88b. 88888b. .d88b. 888d888 8888b. 888888 .d88b. .d88888 +# d88P"88b d8P Y8b 888 "88b d8P Y8b 888P" "88b 888 d8P Y8b d88" 888 +# 888 888 88888888 888 888 88888888 888 .d888888 888 88888888 888 888 +# Y88b 888 Y8b. 888 888 Y8b. 888 888 888 Y88b. Y8b. Y88b 888 +# "Y88888 "Y8888 888 888 "Y8888 888 "Y888888 "Y888 "Y8888 "Y88888 +# 888 +# Y8b d88P +# "Y88P" +# +################################################################################ +''' diff --git a/lib/python/qmk/git.py b/lib/python/qmk/git.py new file mode 100644 index 0000000000..beeb689144 --- /dev/null +++ b/lib/python/qmk/git.py @@ -0,0 +1,110 @@ +"""Functions for working with the QMK repo. +""" +from subprocess import DEVNULL +from pathlib import Path + +from milc import cli + +from qmk.constants import QMK_FIRMWARE + + +def git_get_version(repo_dir='.', check_dir='.'): + """Returns the current git version for a repo, or None. + """ + git_describe_cmd = ['git', 'describe', '--abbrev=6', '--dirty', '--always', '--tags'] + + if repo_dir != '.': + repo_dir = Path('lib') / repo_dir + + if check_dir != '.': + check_dir = repo_dir / check_dir + + if Path(check_dir).exists(): + git_describe = cli.run(git_describe_cmd, stdin=DEVNULL, cwd=repo_dir) + + if git_describe.returncode == 0: + return git_describe.stdout.strip() + + else: + cli.log.warn(f'"{" ".join(git_describe_cmd)}" returned error code {git_describe.returncode}') + print(git_describe.stderr) + return None + + return None + + +def git_get_username(): + """Retrieves user's username from Git config, if set. + """ + git_username = cli.run(['git', 'config', '--get', 'user.name']) + + if git_username.returncode == 0 and git_username.stdout: + return git_username.stdout.strip() + + +def git_get_branch(): + """Returns the current branch for a repo, or None. + """ + git_branch = cli.run(['git', 'branch', '--show-current']) + if not git_branch.returncode != 0 or not git_branch.stdout: + # Workaround for Git pre-2.22 + git_branch = cli.run(['git', 'rev-parse', '--abbrev-ref', 'HEAD']) + + if git_branch.returncode == 0: + return git_branch.stdout.strip() + + +def git_get_tag(): + """Returns the current tag for a repo, or None. + """ + git_tag = cli.run(['git', 'describe', '--abbrev=0', '--tags']) + if git_tag.returncode == 0: + return git_tag.stdout.strip() + + +def git_get_remotes(): + """Returns the current remotes for a repo. + """ + remotes = {} + + git_remote_show_cmd = ['git', 'remote', 'show'] + git_remote_get_cmd = ['git', 'remote', 'get-url'] + + git_remote_show = cli.run(git_remote_show_cmd) + if git_remote_show.returncode == 0: + for name in git_remote_show.stdout.splitlines(): + git_remote_name = cli.run([*git_remote_get_cmd, name]) + remotes[name.strip()] = {"url": git_remote_name.stdout.strip()} + + return remotes + + +def git_is_dirty(): + """Returns 1 if repo is dirty, or 0 if clean + """ + git_diff_staged_cmd = ['git', 'diff', '--quiet'] + git_diff_unstaged_cmd = [*git_diff_staged_cmd, '--cached'] + + unstaged = cli.run(git_diff_staged_cmd) + staged = cli.run(git_diff_unstaged_cmd) + + return unstaged.returncode != 0 or staged.returncode != 0 + + +def git_check_repo(): + """Checks that the .git directory exists inside QMK_HOME. + + This is a decent enough indicator that the qmk_firmware directory is a + proper Git repository, rather than a .zip download from GitHub. + """ + dot_git_dir = QMK_FIRMWARE / '.git' + + return dot_git_dir.is_dir() + + +def git_check_deviation(active_branch): + """Return True if branch has custom commits + """ + cli.run(['git', 'fetch', 'upstream', active_branch]) + deviations = cli.run(['git', '--no-pager', 'log', f'upstream/{active_branch}...{active_branch}']) + return bool(deviations.returncode) diff --git a/lib/python/qmk/info.py b/lib/python/qmk/info.py index 9a07fc842f..b86eaa059f 100644 --- a/lib/python/qmk/info.py +++ b/lib/python/qmk/info.py @@ -387,6 +387,19 @@ def _extract_matrix_info(info_data, config_c): return info_data +# TODO: kill off usb.device_ver in favor of usb.device_version +def _extract_device_version(info_data): + if info_data.get('usb'): + if info_data['usb'].get('device_version') and not info_data['usb'].get('device_ver'): + (major, minor, revision) = info_data['usb']['device_version'].split('.', 3) + info_data['usb']['device_ver'] = f'0x{major.zfill(2)}{minor}{revision}' + if not info_data['usb'].get('device_version') and info_data['usb'].get('device_ver'): + major = int(info_data['usb']['device_ver'][2:4]) + minor = int(info_data['usb']['device_ver'][4]) + revision = int(info_data['usb']['device_ver'][5]) + info_data['usb']['device_version'] = f'{major}.{minor}.{revision}' + + def _extract_config_h(info_data): """Pull some keyboard information from existing config.h files """ @@ -430,6 +443,13 @@ def _extract_config_h(info_data): elif key_type == 'int': dotty_info[info_key] = int(config_c[config_key]) + elif key_type == 'bcd_version': + major = int(config_c[config_key][2:4]) + minor = int(config_c[config_key][4]) + revision = int(config_c[config_key][5]) + + dotty_info[info_key] = f'{major}.{minor}.{revision}' + else: dotty_info[info_key] = config_c[config_key] @@ -444,6 +464,7 @@ def _extract_config_h(info_data): _extract_split_main(info_data, config_c) _extract_split_transport(info_data, config_c) _extract_split_right_pins(info_data, config_c) + _extract_device_version(info_data) return info_data @@ -529,6 +550,11 @@ def _matrix_size(info_data): info_data['matrix_size']['cols'] = len(info_data['matrix_pins']['cols']) info_data['matrix_size']['rows'] = len(info_data['matrix_pins']['rows']) + # Assumption of split common + if 'split' in info_data: + if info_data['split'].get('enabled', False): + info_data['matrix_size']['rows'] *= 2 + return info_data @@ -622,12 +648,7 @@ def arm_processor_rules(info_data, rules): info_data['protocol'] = 'ChibiOS' if 'bootloader' not in info_data: - if 'STM32' in info_data['processor']: - info_data['bootloader'] = 'stm32-dfu' - elif 'WB32' in info_data['processor']: - info_data['bootloader'] = 'wb32-dfu' - else: - info_data['bootloader'] = 'unknown' + info_data['bootloader'] = 'unknown' if 'STM32' in info_data['processor']: info_data['platform'] = 'STM32' diff --git a/lib/python/qmk/json_encoders.py b/lib/python/qmk/json_encoders.py index 72e91973a3..40a5c1dea8 100755 --- a/lib/python/qmk/json_encoders.py +++ b/lib/python/qmk/json_encoders.py @@ -146,7 +146,13 @@ class KeymapJSONEncoder(QMKJSONEncoder): if key == 'JSON_NEWLINE': layer.append([]) else: - layer[-1].append(f'"{key}"') + if isinstance(key, dict): + # We have a macro + + # TODO: Add proper support for nicely formatting keymap.json macros + layer[-1].append(f'{self.encode(key)}') + else: + layer[-1].append(f'"{key}"') layer = [f"{self.indent_str*indent_level}{', '.join(row)}" for row in layer] diff --git a/lib/python/qmk/json_schema.py b/lib/python/qmk/json_schema.py index ffc7c6bcd1..2b48782fbb 100644 --- a/lib/python/qmk/json_schema.py +++ b/lib/python/qmk/json_schema.py @@ -16,7 +16,11 @@ def json_load(json_file): Note: file must be a Path object. """ try: - return hjson.load(json_file.open(encoding='utf-8')) + # Get the IO Stream for Path objects + # Not necessary if the data is provided via stdin + if isinstance(json_file, Path): + json_file = json_file.open(encoding='utf-8') + return hjson.load(json_file) except (json.decoder.JSONDecodeError, hjson.HjsonDecodeError) as e: cli.log.error('Invalid JSON encountered attempting to load {fg_cyan}%s{fg_reset}:\n\t{fg_red}%s', json_file, e) @@ -62,7 +66,7 @@ def create_validator(schema): """Creates a validator for the given schema id. """ schema_store = compile_schema_store() - resolver = jsonschema.RefResolver.from_schema(schema_store['qmk.keyboard.v1'], store=schema_store) + resolver = jsonschema.RefResolver.from_schema(schema_store[schema], store=schema_store) return jsonschema.Draft7Validator(schema_store[schema], resolver=resolver).validate diff --git a/lib/python/qmk/keyboard.py b/lib/python/qmk/keyboard.py index c87ea9050b..7cd0a1d5a7 100644 --- a/lib/python/qmk/keyboard.py +++ b/lib/python/qmk/keyboard.py @@ -162,13 +162,12 @@ def render_layout(layout_data, render_ascii, key_labels=None): """ textpad = [array('u', ' ' * 200) for x in range(100)] style = 'ascii' if render_ascii else 'unicode' - box_chars = BOX_DRAWING_CHARACTERS[style] for key in layout_data: - x = ceil(key.get('x', 0) * 4) - y = ceil(key.get('y', 0) * 3) - w = ceil(key.get('w', 1) * 4) - h = ceil(key.get('h', 1) * 3) + x = key.get('x', 0) + y = key.get('y', 0) + w = key.get('w', 1) + h = key.get('h', 1) if key_labels: label = key_labels.pop(0) @@ -177,26 +176,12 @@ def render_layout(layout_data, render_ascii, key_labels=None): else: label = key.get('label', '') - label_len = w - 2 - label_leftover = label_len - len(label) - - if len(label) > label_len: - label = label[:label_len] - - label_blank = ' ' * label_len - label_border = box_chars['h'] * label_len - label_middle = label + ' '*label_leftover # noqa: yapf insists there be no whitespace around * - - top_line = array('u', box_chars['tl'] + label_border + box_chars['tr']) - lab_line = array('u', box_chars['v'] + label_middle + box_chars['v']) - mid_line = array('u', box_chars['v'] + label_blank + box_chars['v']) - bot_line = array('u', box_chars['bl'] + label_border + box_chars['br']) - - textpad[y][x:x + w] = top_line - textpad[y + 1][x:x + w] = lab_line - for i in range(h - 3): - textpad[y + i + 2][x:x + w] = mid_line - textpad[y + h - 1][x:x + w] = bot_line + if x >= 0.25 and w == 1.25 and h == 2: + render_key_isoenter(textpad, x, y, w, h, label, style) + elif w == 2.25 and h == 2: + render_key_baenter(textpad, x, y, w, h, label, style) + else: + render_key_rect(textpad, x, y, w, h, label, style) lines = [] for line in textpad: @@ -216,3 +201,96 @@ def render_layouts(info_json, render_ascii): layouts[layout] = render_layout(layout_data, render_ascii) return layouts + + +def render_key_rect(textpad, x, y, w, h, label, style): + box_chars = BOX_DRAWING_CHARACTERS[style] + x = ceil(x * 4) + y = ceil(y * 3) + w = ceil(w * 4) + h = ceil(h * 3) + + label_len = w - 2 + label_leftover = label_len - len(label) + + if len(label) > label_len: + label = label[:label_len] + + label_blank = ' ' * label_len + label_border = box_chars['h'] * label_len + label_middle = label + ' '*label_leftover # noqa: yapf insists there be no whitespace around * + + top_line = array('u', box_chars['tl'] + label_border + box_chars['tr']) + lab_line = array('u', box_chars['v'] + label_middle + box_chars['v']) + mid_line = array('u', box_chars['v'] + label_blank + box_chars['v']) + bot_line = array('u', box_chars['bl'] + label_border + box_chars['br']) + + textpad[y][x:x + w] = top_line + textpad[y + 1][x:x + w] = lab_line + for i in range(h - 3): + textpad[y + i + 2][x:x + w] = mid_line + textpad[y + h - 1][x:x + w] = bot_line + + +def render_key_isoenter(textpad, x, y, w, h, label, style): + box_chars = BOX_DRAWING_CHARACTERS[style] + x = ceil(x * 4) + y = ceil(y * 3) + w = ceil(w * 4) + h = ceil(h * 3) + + label_len = w - 1 + label_leftover = label_len - len(label) + + if len(label) > label_len: + label = label[:label_len] + + label_blank = ' ' * (label_len-1) # noqa: yapf insists there be no whitespace around - and * + label_border_top = box_chars['h'] * label_len + label_border_bottom = box_chars['h'] * (label_len-1) # noqa + label_middle = label + ' '*label_leftover # noqa + + top_line = array('u', box_chars['tl'] + label_border_top + box_chars['tr']) + lab_line = array('u', box_chars['v'] + label_middle + box_chars['v']) + crn_line = array('u', box_chars['bl'] + box_chars['tr'] + label_blank + box_chars['v']) + mid_line = array('u', box_chars['v'] + label_blank + box_chars['v']) + bot_line = array('u', box_chars['bl'] + label_border_bottom + box_chars['br']) + + textpad[y][x - 1:x + w] = top_line + textpad[y + 1][x - 1:x + w] = lab_line + textpad[y + 2][x - 1:x + w] = crn_line + textpad[y + 3][x:x + w] = mid_line + textpad[y + 4][x:x + w] = mid_line + textpad[y + 5][x:x + w] = bot_line + + +def render_key_baenter(textpad, x, y, w, h, label, style): + box_chars = BOX_DRAWING_CHARACTERS[style] + x = ceil(x * 4) + y = ceil(y * 3) + w = ceil(w * 4) + h = ceil(h * 3) + + label_len = w - 2 + label_leftover = label_len - len(label) + + if len(label) > label_len: + label = label[:label_len] + + label_blank = ' ' * (label_len-3) # noqa: yapf insists there be no whitespace around - and * + label_border_top = box_chars['h'] * (label_len-3) # noqa + label_border_bottom = box_chars['h'] * label_len + label_middle = label + ' '*label_leftover # noqa + + top_line = array('u', box_chars['tl'] + label_border_top + box_chars['tr']) + mid_line = array('u', box_chars['v'] + label_blank + box_chars['v']) + crn_line = array('u', box_chars['tl'] + box_chars['h'] + box_chars['h'] + box_chars['br'] + label_blank + box_chars['v']) + lab_line = array('u', box_chars['v'] + label_middle + box_chars['v']) + bot_line = array('u', box_chars['bl'] + label_border_bottom + box_chars['br']) + + textpad[y][x + 3:x + w] = top_line + textpad[y + 1][x + 3:x + w] = mid_line + textpad[y + 2][x + 3:x + w] = mid_line + textpad[y + 3][x:x + w] = crn_line + textpad[y + 4][x:x + w] = lab_line + textpad[y + 5][x:x + w] = bot_line diff --git a/lib/python/qmk/keymap.py b/lib/python/qmk/keymap.py index 00b5a78a5a..ca5be0959b 100644 --- a/lib/python/qmk/keymap.py +++ b/lib/python/qmk/keymap.py @@ -158,7 +158,7 @@ def is_keymap_dir(keymap, c=True, json=True, additional_files=None): return True -def generate_json(keymap, keyboard, layout, layers): +def generate_json(keymap, keyboard, layout, layers, macros=None): """Returns a `keymap.json` for the specified keyboard, layout, and layers. Args: @@ -173,11 +173,16 @@ def generate_json(keymap, keyboard, layout, layers): layers An array of arrays describing the keymap. Each item in the inner array should be a string that is a valid QMK keycode. + + macros + A sequence of strings containing macros to implement for this keyboard. """ new_keymap = template_json(keyboard) new_keymap['keymap'] = keymap new_keymap['layout'] = layout new_keymap['layers'] = layers + if macros: + new_keymap['macros'] = macros return new_keymap diff --git a/lib/python/qmk/path.py b/lib/python/qmk/path.py index 72bae59273..556d0eefc8 100644 --- a/lib/python/qmk/path.py +++ b/lib/python/qmk/path.py @@ -46,7 +46,7 @@ def keymap(keyboard_name): """ keyboard_folder = keyboard(keyboard_name) - for i in range(MAX_KEYBOARD_SUBFOLDERS): + for _ in range(MAX_KEYBOARD_SUBFOLDERS): if (keyboard_folder / 'keymaps').exists(): return (keyboard_folder / 'keymaps').resolve() @@ -70,9 +70,15 @@ def normpath(path): class FileType(argparse.FileType): + def __init__(self, *args, **kwargs): + # Use UTF8 by default for stdin + if 'encoding' not in kwargs: + kwargs['encoding'] = 'UTF-8' + return super().__init__(*args, **kwargs) + def __call__(self, string): """normalize and check exists otherwise magic strings like '-' for stdin resolve to bad paths """ norm = normpath(string) - return super().__call__(norm if norm.exists() else string) + return norm if norm.exists() else super().__call__(string) diff --git a/lib/python/qmk/tests/test_cli_commands.py b/lib/python/qmk/tests/test_cli_commands.py index 92ec879312..01db8aa6ec 100644 --- a/lib/python/qmk/tests/test_cli_commands.py +++ b/lib/python/qmk/tests/test_cli_commands.py @@ -113,7 +113,11 @@ def test_list_keymaps_community(): def test_list_keymaps_kb_only(): +<<<<<<< HEAD result = check_subcommand('list-keymaps', '-kb', 'moonlander') +======= + result = check_subcommand('list-keymaps', '-kb', 'contra') +>>>>>>> qmk/master check_returncode(result) assert 'default' and 'oyrx' and 'webusb' in result.stdout @@ -156,6 +160,18 @@ def test_json2c_stdin(): assert result.stdout == '#include QMK_KEYBOARD_H\nconst uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {\t[0] = LAYOUT_ortho_1x1(KC_A)};\n\n' +def test_json2c_wrong_json(): + result = check_subcommand('json2c', 'keyboards/handwired/pytest/info.json') + check_returncode(result, [1]) + assert 'Invalid JSON keymap' in result.stdout + + +def test_json2c_no_json(): + result = check_subcommand('json2c', 'keyboards/handwired/pytest/pytest.h') + check_returncode(result, [1]) + assert 'Invalid JSON encountered' in result.stdout + + def test_info(): result = check_subcommand('info', '-kb', 'handwired/pytest/basic') check_returncode(result) |