[CLI] Add a subcommand for getting information about a keyboard (#8666)
You can now use `qmk info` to get information about keyboards and keymaps. Co-authored-by: Erovia <Erovia@users.noreply.github.com>pre-develop-merge-nov20 0.8.188
Zach White
5 years ago
committed by
GitHub
parent
5d3bf8a050
commit
751316c344
@ -0,0 +1,161 @@ |
||||
"""Functions for working with config.h files. |
||||
""" |
||||
from pathlib import Path |
||||
|
||||
from milc import cli |
||||
|
||||
from qmk.comment_remover import comment_remover |
||||
|
||||
default_key_entry = {'x': -1, 'y': 0, 'w': 1} |
||||
|
||||
|
||||
def c_source_files(dir_names): |
||||
"""Returns a list of all *.c, *.h, and *.cpp files for a given list of directories |
||||
|
||||
Args: |
||||
|
||||
dir_names |
||||
List of directories relative to `qmk_firmware`. |
||||
""" |
||||
files = [] |
||||
for dir in dir_names: |
||||
files.extend(file for file in Path(dir).glob('**/*') if file.suffix in ['.c', '.h', '.cpp']) |
||||
return files |
||||
|
||||
|
||||
def find_layouts(file): |
||||
"""Returns list of parsed LAYOUT preprocessor macros found in the supplied include file. |
||||
""" |
||||
file = Path(file) |
||||
aliases = {} # Populated with all `#define`s that aren't functions |
||||
parsed_layouts = {} |
||||
|
||||
# Search the file for LAYOUT macros and aliases |
||||
file_contents = file.read_text() |
||||
file_contents = comment_remover(file_contents) |
||||
file_contents = file_contents.replace('\\\n', '') |
||||
|
||||
for line in file_contents.split('\n'): |
||||
if line.startswith('#define') and '(' in line and 'LAYOUT' in line: |
||||
# We've found a LAYOUT macro |
||||
macro_name, layout, matrix = _parse_layout_macro(line.strip()) |
||||
|
||||
# Reject bad macro names |
||||
if macro_name.startswith('LAYOUT_kc') or not macro_name.startswith('LAYOUT'): |
||||
continue |
||||
|
||||
# Parse the matrix data |
||||
matrix_locations = _parse_matrix_locations(matrix, file, macro_name) |
||||
|
||||
# Parse the layout entries into a basic structure |
||||
default_key_entry['x'] = -1 # Set to -1 so _default_key(key) will increment it to 0 |
||||
layout = layout.strip() |
||||
parsed_layout = [_default_key(key) for key in layout.split(',')] |
||||
|
||||
for key in parsed_layout: |
||||
key['matrix'] = matrix_locations.get(key['label']) |
||||
|
||||
parsed_layouts[macro_name] = { |
||||
'key_count': len(parsed_layout), |
||||
'layout': parsed_layout, |
||||
'filename': str(file), |
||||
} |
||||
|
||||
elif '#define' in line: |
||||
# Attempt to extract a new layout alias |
||||
try: |
||||
_, pp_macro_name, pp_macro_text = line.strip().split(' ', 2) |
||||
aliases[pp_macro_name] = pp_macro_text |
||||
except ValueError: |
||||
continue |
||||
|
||||
# Populate our aliases |
||||
for alias, text in aliases.items(): |
||||
if text in parsed_layouts and 'KEYMAP' not in alias: |
||||
parsed_layouts[alias] = parsed_layouts[text] |
||||
|
||||
return parsed_layouts |
||||
|
||||
|
||||
def parse_config_h_file(config_h_file, config_h=None): |
||||
"""Extract defines from a config.h file. |
||||
""" |
||||
if not config_h: |
||||
config_h = {} |
||||
|
||||
config_h_file = Path(config_h_file) |
||||
|
||||
if config_h_file.exists(): |
||||
config_h_text = config_h_file.read_text() |
||||
config_h_text = config_h_text.replace('\\\n', '') |
||||
|
||||
for linenum, line in enumerate(config_h_text.split('\n')): |
||||
line = line.strip() |
||||
|
||||
if '//' in line: |
||||
line = line[:line.index('//')].strip() |
||||
|
||||
if not line: |
||||
continue |
||||
|
||||
line = line.split() |
||||
|
||||
if line[0] == '#define': |
||||
if len(line) == 1: |
||||
cli.log.error('%s: Incomplete #define! On or around line %s' % (config_h_file, linenum)) |
||||
elif len(line) == 2: |
||||
config_h[line[1]] = True |
||||
else: |
||||
config_h[line[1]] = ' '.join(line[2:]) |
||||
|
||||
elif line[0] == '#undef': |
||||
if len(line) == 2: |
||||
if line[1] in config_h: |
||||
if config_h[line[1]] is True: |
||||
del config_h[line[1]] |
||||
else: |
||||
config_h[line[1]] = False |
||||
else: |
||||
cli.log.error('%s: Incomplete #undef! On or around line %s' % (config_h_file, linenum)) |
||||
|
||||
return config_h |
||||
|
||||
|
||||
def _default_key(label=None): |
||||
"""Increment x and return a copy of the default_key_entry. |
||||
""" |
||||
default_key_entry['x'] += 1 |
||||
new_key = default_key_entry.copy() |
||||
|
||||
if label: |
||||
new_key['label'] = label |
||||
|
||||
return new_key |
||||
|
||||
|
||||
def _parse_layout_macro(layout_macro): |
||||
"""Split the LAYOUT macro into its constituent parts |
||||
""" |
||||
layout_macro = layout_macro.replace('\\', '').replace(' ', '').replace('\t', '').replace('#define', '') |
||||
macro_name, layout = layout_macro.split('(', 1) |
||||
layout, matrix = layout.split(')', 1) |
||||
|
||||
return macro_name, layout, matrix |
||||
|
||||
|
||||
def _parse_matrix_locations(matrix, file, macro_name): |
||||
"""Parse raw matrix data into a dictionary keyed by the LAYOUT identifier. |
||||
""" |
||||
matrix_locations = {} |
||||
|
||||
for row_num, row in enumerate(matrix.split('},{')): |
||||
if row.startswith('LAYOUT'): |
||||
cli.log.error('%s: %s: Nested layout macro detected. Matrix data not available!', file, macro_name) |
||||
break |
||||
|
||||
row = row.replace('{', '').replace('}', '') |
||||
for col_num, identifier in enumerate(row.split(',')): |
||||
if identifier != 'KC_NO': |
||||
matrix_locations[identifier] = (row_num, col_num) |
||||
|
||||
return matrix_locations |
||||
@ -0,0 +1,141 @@ |
||||
"""Keyboard information script. |
||||
|
||||
Compile an info.json for a particular keyboard and pretty-print it. |
||||
""" |
||||
import json |
||||
|
||||
from milc import cli |
||||
|
||||
from qmk.decorators import automagic_keyboard, automagic_keymap |
||||
from qmk.keyboard import render_layouts, render_layout |
||||
from qmk.keymap import locate_keymap |
||||
from qmk.info import info_json |
||||
from qmk.path import is_keyboard |
||||
|
||||
ROW_LETTERS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnop' |
||||
COL_LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijilmnopqrstuvwxyz' |
||||
|
||||
|
||||
def show_keymap(info_json, title_caps=True): |
||||
"""Render the keymap in ascii art. |
||||
""" |
||||
keymap_path = locate_keymap(cli.config.info.keyboard, cli.config.info.keymap) |
||||
|
||||
if keymap_path and keymap_path.suffix == '.json': |
||||
if title_caps: |
||||
cli.echo('{fg_blue}Keymap "%s"{fg_reset}:', cli.config.info.keymap) |
||||
else: |
||||
cli.echo('{fg_blue}keymap_%s{fg_reset}:', cli.config.info.keymap) |
||||
|
||||
keymap_data = json.load(keymap_path.open()) |
||||
layout_name = keymap_data['layout'] |
||||
|
||||
for layer_num, layer in enumerate(keymap_data['layers']): |
||||
if title_caps: |
||||
cli.echo('{fg_cyan}Layer %s{fg_reset}:', layer_num) |
||||
else: |
||||
cli.echo('{fg_cyan}layer_%s{fg_reset}:', layer_num) |
||||
|
||||
print(render_layout(info_json['layouts'][layout_name]['layout'], layer)) |
||||
|
||||
|
||||
def show_layouts(kb_info_json, title_caps=True): |
||||
"""Render the layouts with info.json labels. |
||||
""" |
||||
for layout_name, layout_art in render_layouts(kb_info_json).items(): |
||||
title = layout_name.title() if title_caps else layout_name |
||||
cli.echo('{fg_cyan}%s{fg_reset}:', title) |
||||
print(layout_art) # Avoid passing dirty data to cli.echo() |
||||
|
||||
|
||||
def show_matrix(info_json, title_caps=True): |
||||
"""Render the layout with matrix labels in ascii art. |
||||
""" |
||||
for layout_name, layout in info_json['layouts'].items(): |
||||
# Build our label list |
||||
labels = [] |
||||
for key in layout['layout']: |
||||
if key['matrix']: |
||||
row = ROW_LETTERS[key['matrix'][0]] |
||||
col = COL_LETTERS[key['matrix'][1]] |
||||
|
||||
labels.append(row + col) |
||||
else: |
||||
labels.append('') |
||||
|
||||
# Print the header |
||||
if title_caps: |
||||
cli.echo('{fg_blue}Matrix for "%s"{fg_reset}:', layout_name) |
||||
else: |
||||
cli.echo('{fg_blue}matrix_%s{fg_reset}:', layout_name) |
||||
|
||||
print(render_layout(info_json['layouts'][layout_name]['layout'], labels)) |
||||
|
||||
|
||||
@cli.argument('-kb', '--keyboard', help='Keyboard to show info for.') |
||||
@cli.argument('-km', '--keymap', help='Show the layers for a JSON keymap too.') |
||||
@cli.argument('-l', '--layouts', action='store_true', help='Render the layouts.') |
||||
@cli.argument('-m', '--matrix', action='store_true', help='Render the layouts with matrix information.') |
||||
@cli.argument('-f', '--format', default='friendly', arg_only=True, help='Format to display the data in (friendly, text, json) (Default: friendly).') |
||||
@cli.subcommand('Keyboard information.') |
||||
@automagic_keyboard |
||||
@automagic_keymap |
||||
def info(cli): |
||||
"""Compile an info.json for a particular keyboard and pretty-print it. |
||||
""" |
||||
# Determine our keyboard(s) |
||||
if not is_keyboard(cli.config.info.keyboard): |
||||
cli.log.error('Invalid keyboard: %s!', cli.config.info.keyboard) |
||||
exit(1) |
||||
|
||||
# Build the info.json file |
||||
kb_info_json = info_json(cli.config.info.keyboard) |
||||
|
||||
# Output in the requested format |
||||
if cli.args.format == 'json': |
||||
print(json.dumps(kb_info_json)) |
||||
exit() |
||||
|
||||
if cli.args.format == 'text': |
||||
for key in sorted(kb_info_json): |
||||
if key == 'layouts': |
||||
cli.echo('{fg_blue}layouts{fg_reset}: %s', ', '.join(sorted(kb_info_json['layouts'].keys()))) |
||||
else: |
||||
cli.echo('{fg_blue}%s{fg_reset}: %s', key, kb_info_json[key]) |
||||
|
||||
if cli.config.info.layouts: |
||||
show_layouts(kb_info_json, False) |
||||
|
||||
if cli.config.info.matrix: |
||||
show_matrix(kb_info_json, False) |
||||
|
||||
if cli.config_source.info.keymap and cli.config_source.info.keymap != 'config_file': |
||||
show_keymap(kb_info_json, False) |
||||
|
||||
elif cli.args.format == 'friendly': |
||||
cli.echo('{fg_blue}Keyboard Name{fg_reset}: %s', kb_info_json.get('keyboard_name', 'Unknown')) |
||||
cli.echo('{fg_blue}Manufacturer{fg_reset}: %s', kb_info_json.get('manufacturer', 'Unknown')) |
||||
if 'url' in kb_info_json: |
||||
cli.echo('{fg_blue}Website{fg_reset}: %s', kb_info_json['url']) |
||||
if kb_info_json.get('maintainer') == 'qmk': |
||||
cli.echo('{fg_blue}Maintainer{fg_reset}: QMK Community') |
||||
else: |
||||
cli.echo('{fg_blue}Maintainer{fg_reset}: %s', kb_info_json.get('maintainer', 'qmk')) |
||||
cli.echo('{fg_blue}Keyboard Folder{fg_reset}: %s', kb_info_json.get('keyboard_folder', 'Unknown')) |
||||
cli.echo('{fg_blue}Layouts{fg_reset}: %s', ', '.join(sorted(kb_info_json['layouts'].keys()))) |
||||
if 'width' in kb_info_json and 'height' in kb_info_json: |
||||
cli.echo('{fg_blue}Size{fg_reset}: %s x %s' % (kb_info_json['width'], kb_info_json['height'])) |
||||
cli.echo('{fg_blue}Processor{fg_reset}: %s', kb_info_json.get('processor', 'Unknown')) |
||||
cli.echo('{fg_blue}Bootloader{fg_reset}: %s', kb_info_json.get('bootloader', 'Unknown')) |
||||
|
||||
if cli.config.info.layouts: |
||||
show_layouts(kb_info_json, True) |
||||
|
||||
if cli.config.info.matrix: |
||||
show_matrix(kb_info_json, True) |
||||
|
||||
if cli.config_source.info.keymap and cli.config_source.info.keymap != 'config_file': |
||||
show_keymap(kb_info_json, True) |
||||
|
||||
else: |
||||
cli.log.error('Unknown format: %s', cli.args.format) |
||||
@ -0,0 +1,20 @@ |
||||
"""Removes C/C++ style comments from text. |
||||
|
||||
Gratefully adapted from https://stackoverflow.com/a/241506 |
||||
""" |
||||
import re |
||||
|
||||
comment_pattern = re.compile(r'//.*?$|/\*.*?\*/|\'(?:\\.|[^\\\'])*\'|"(?:\\.|[^\\"])*"', re.DOTALL | re.MULTILINE) |
||||
|
||||
|
||||
def _comment_stripper(match): |
||||
"""Removes C/C++ style comments from a regex match. |
||||
""" |
||||
s = match.group(0) |
||||
return ' ' if s.startswith('/') else s |
||||
|
||||
|
||||
def comment_remover(text): |
||||
"""Remove C/C++ style comments from text. |
||||
""" |
||||
return re.sub(comment_pattern, _comment_stripper, text) |
||||
@ -0,0 +1,249 @@ |
||||
"""Functions that help us generate and use info.json files. |
||||
""" |
||||
import json |
||||
from glob import glob |
||||
from pathlib import Path |
||||
|
||||
from milc import cli |
||||
|
||||
from qmk.constants import ARM_PROCESSORS, AVR_PROCESSORS, VUSB_PROCESSORS |
||||
from qmk.c_parse import find_layouts |
||||
from qmk.keyboard import config_h, rules_mk |
||||
from qmk.math import compute |
||||
|
||||
|
||||
def info_json(keyboard): |
||||
"""Generate the info.json data for a specific keyboard. |
||||
""" |
||||
info_data = { |
||||
'keyboard_name': str(keyboard), |
||||
'keyboard_folder': str(keyboard), |
||||
'layouts': {}, |
||||
'maintainer': 'qmk', |
||||
} |
||||
|
||||
for layout_name, layout_json in _find_all_layouts(keyboard).items(): |
||||
if not layout_name.startswith('LAYOUT_kc'): |
||||
info_data['layouts'][layout_name] = layout_json |
||||
|
||||
info_data = merge_info_jsons(keyboard, info_data) |
||||
info_data = _extract_config_h(info_data) |
||||
info_data = _extract_rules_mk(info_data) |
||||
|
||||
return info_data |
||||
|
||||
|
||||
def _extract_config_h(info_data): |
||||
"""Pull some keyboard information from existing rules.mk files |
||||
""" |
||||
config_c = config_h(info_data['keyboard_folder']) |
||||
row_pins = config_c.get('MATRIX_ROW_PINS', '').replace('{', '').replace('}', '').strip() |
||||
col_pins = config_c.get('MATRIX_COL_PINS', '').replace('{', '').replace('}', '').strip() |
||||
direct_pins = config_c.get('DIRECT_PINS', '').replace(' ', '')[1:-1] |
||||
|
||||
info_data['diode_direction'] = config_c.get('DIODE_DIRECTION') |
||||
info_data['matrix_size'] = { |
||||
'rows': compute(config_c.get('MATRIX_ROWS', '0')), |
||||
'cols': compute(config_c.get('MATRIX_COLS', '0')), |
||||
} |
||||
info_data['matrix_pins'] = {} |
||||
|
||||
if row_pins: |
||||
info_data['matrix_pins']['rows'] = row_pins.split(',') |
||||
if col_pins: |
||||
info_data['matrix_pins']['cols'] = col_pins.split(',') |
||||
|
||||
if direct_pins: |
||||
direct_pin_array = [] |
||||
for row in direct_pins.split('},{'): |
||||
if row.startswith('{'): |
||||
row = row[1:] |
||||
if row.endswith('}'): |
||||
row = row[:-1] |
||||
|
||||
direct_pin_array.append([]) |
||||
|
||||
for pin in row.split(','): |
||||
if pin == 'NO_PIN': |
||||
pin = None |
||||
|
||||
direct_pin_array[-1].append(pin) |
||||
|
||||
info_data['matrix_pins']['direct'] = direct_pin_array |
||||
|
||||
info_data['usb'] = { |
||||
'vid': config_c.get('VENDOR_ID'), |
||||
'pid': config_c.get('PRODUCT_ID'), |
||||
'device_ver': config_c.get('DEVICE_VER'), |
||||
'manufacturer': config_c.get('MANUFACTURER'), |
||||
'product': config_c.get('PRODUCT'), |
||||
'description': config_c.get('DESCRIPTION'), |
||||
} |
||||
|
||||
return info_data |
||||
|
||||
|
||||
def _extract_rules_mk(info_data): |
||||
"""Pull some keyboard information from existing rules.mk files |
||||
""" |
||||
rules = rules_mk(info_data['keyboard_folder']) |
||||
mcu = rules.get('MCU') |
||||
|
||||
if mcu in ARM_PROCESSORS: |
||||
arm_processor_rules(info_data, rules) |
||||
elif mcu in AVR_PROCESSORS: |
||||
avr_processor_rules(info_data, rules) |
||||
else: |
||||
cli.log.warning("%s: Unknown MCU: %s" % (info_data['keyboard_folder'], mcu)) |
||||
unknown_processor_rules(info_data, rules) |
||||
|
||||
return info_data |
||||
|
||||
|
||||
def _find_all_layouts(keyboard): |
||||
"""Looks for layout macros associated with this keyboard. |
||||
""" |
||||
layouts = {} |
||||
rules = rules_mk(keyboard) |
||||
keyboard_path = Path(rules.get('DEFAULT_FOLDER', keyboard)) |
||||
|
||||
# Pull in all layouts defined in the standard files |
||||
current_path = Path('keyboards/') |
||||
for directory in keyboard_path.parts: |
||||
current_path = current_path / directory |
||||
keyboard_h = '%s.h' % (directory,) |
||||
keyboard_h_path = current_path / keyboard_h |
||||
if keyboard_h_path.exists(): |
||||
layouts.update(find_layouts(keyboard_h_path)) |
||||
|
||||
if not layouts: |
||||
# If we didn't find any layouts above we widen our search. This is error |
||||
# prone which is why we want to encourage people to follow the standard above. |
||||
cli.log.warning('%s: Falling back to searching for KEYMAP/LAYOUT macros.' % (keyboard)) |
||||
for file in glob('keyboards/%s/*.h' % keyboard): |
||||
if file.endswith('.h'): |
||||
these_layouts = find_layouts(file) |
||||
if these_layouts: |
||||
layouts.update(these_layouts) |
||||
|
||||
if 'LAYOUTS' in rules: |
||||
# Match these up against the supplied layouts |
||||
supported_layouts = rules['LAYOUTS'].strip().split() |
||||
for layout_name in sorted(layouts): |
||||
if not layout_name.startswith('LAYOUT_'): |
||||
continue |
||||
layout_name = layout_name[7:] |
||||
if layout_name in supported_layouts: |
||||
supported_layouts.remove(layout_name) |
||||
|
||||
if supported_layouts: |
||||
cli.log.error('%s: Missing LAYOUT() macro for %s' % (keyboard, ', '.join(supported_layouts))) |
||||
|
||||
return layouts |
||||
|
||||
|
||||
def arm_processor_rules(info_data, rules): |
||||
"""Setup the default info for an ARM board. |
||||
""" |
||||
info_data['processor_type'] = 'arm' |
||||
info_data['bootloader'] = rules['BOOTLOADER'] if 'BOOTLOADER' in rules else 'unknown' |
||||
info_data['processor'] = rules['MCU'] if 'MCU' in rules else 'unknown' |
||||
info_data['protocol'] = 'ChibiOS' |
||||
|
||||
if info_data['bootloader'] == 'unknown': |
||||
if 'STM32' in info_data['processor']: |
||||
info_data['bootloader'] = 'stm32-dfu' |
||||
elif info_data.get('manufacturer') == 'Input Club': |
||||
info_data['bootloader'] = 'kiibohd-dfu' |
||||
|
||||
if 'STM32' in info_data['processor']: |
||||
info_data['platform'] = 'STM32' |
||||
elif 'MCU_SERIES' in rules: |
||||
info_data['platform'] = rules['MCU_SERIES'] |
||||
elif 'ARM_ATSAM' in rules: |
||||
info_data['platform'] = 'ARM_ATSAM' |
||||
|
||||
return info_data |
||||
|
||||
|
||||
def avr_processor_rules(info_data, rules): |
||||
"""Setup the default info for an AVR board. |
||||
""" |
||||
info_data['processor_type'] = 'avr' |
||||
info_data['bootloader'] = rules['BOOTLOADER'] if 'BOOTLOADER' in rules else 'atmel-dfu' |
||||
info_data['platform'] = rules['ARCH'] if 'ARCH' in rules else 'unknown' |
||||
info_data['processor'] = rules['MCU'] if 'MCU' in rules else 'unknown' |
||||
info_data['protocol'] = 'V-USB' if rules.get('MCU') in VUSB_PROCESSORS else 'LUFA' |
||||
|
||||
# FIXME(fauxpark/anyone): Eventually we should detect the protocol by looking at PROTOCOL inherited from mcu_selection.mk: |
||||
# info_data['protocol'] = 'V-USB' if rules.get('PROTOCOL') == 'VUSB' else 'LUFA' |
||||
|
||||
return info_data |
||||
|
||||
|
||||
def unknown_processor_rules(info_data, rules): |
||||
"""Setup the default keyboard info for unknown boards. |
||||
""" |
||||
info_data['bootloader'] = 'unknown' |
||||
info_data['platform'] = 'unknown' |
||||
info_data['processor'] = 'unknown' |
||||
info_data['processor_type'] = 'unknown' |
||||
info_data['protocol'] = 'unknown' |
||||
|
||||
return info_data |
||||
|
||||
|
||||
def merge_info_jsons(keyboard, info_data): |
||||
"""Return a merged copy of all the info.json files for a keyboard. |
||||
""" |
||||
for info_file in find_info_json(keyboard): |
||||
# Load and validate the JSON data |
||||
with info_file.open('r') as info_fd: |
||||
new_info_data = json.load(info_fd) |
||||
|
||||
if not isinstance(new_info_data, dict): |
||||
cli.log.error("Invalid file %s, root object should be a dictionary.", str(info_file)) |
||||
continue |
||||
|
||||
# Copy whitelisted keys into `info_data` |
||||
for key in ('keyboard_name', 'manufacturer', 'identifier', 'url', 'maintainer', 'processor', 'bootloader', 'width', 'height'): |
||||
if key in new_info_data: |
||||
info_data[key] = new_info_data[key] |
||||
|
||||
# Merge the layouts in |
||||
if 'layouts' in new_info_data: |
||||
for layout_name, json_layout in new_info_data['layouts'].items(): |
||||
# Only pull in layouts we have a macro for |
||||
if layout_name in info_data['layouts']: |
||||
if info_data['layouts'][layout_name]['key_count'] != len(json_layout['layout']): |
||||
cli.log.error('%s: %s: Number of elements in info.json does not match! info.json:%s != %s:%s', info_data['keyboard_folder'], layout_name, len(json_layout['layout']), layout_name, len(info_data['layouts'][layout_name]['layout'])) |
||||
else: |
||||
for i, key in enumerate(info_data['layouts'][layout_name]['layout']): |
||||
key.update(json_layout['layout'][i]) |
||||
|
||||
return info_data |
||||
|
||||
|
||||
def find_info_json(keyboard): |
||||
"""Finds all the info.json files associated with a keyboard. |
||||
""" |
||||
# Find the most specific first |
||||
base_path = Path('keyboards') |
||||
keyboard_path = base_path / keyboard |
||||
keyboard_parent = keyboard_path.parent |
||||
info_jsons = [keyboard_path / 'info.json'] |
||||
|
||||
# Add DEFAULT_FOLDER before parents, if present |
||||
rules = rules_mk(keyboard) |
||||
if 'DEFAULT_FOLDER' in rules: |
||||
info_jsons.append(Path(rules['DEFAULT_FOLDER']) / 'info.json') |
||||
|
||||
# Add in parent folders for least specific |
||||
for _ in range(5): |
||||
info_jsons.append(keyboard_parent / 'info.json') |
||||
if keyboard_parent.parent == base_path: |
||||
break |
||||
keyboard_parent = keyboard_parent.parent |
||||
|
||||
# Return a list of the info.json files that actually exist |
||||
return [info_json for info_json in info_jsons if info_json.exists()] |
||||
@ -0,0 +1,111 @@ |
||||
"""Functions that help us work with keyboards. |
||||
""" |
||||
from array import array |
||||
from math import ceil |
||||
from pathlib import Path |
||||
|
||||
from qmk.c_parse import parse_config_h_file |
||||
from qmk.makefile import parse_rules_mk_file |
||||
|
||||
|
||||
def config_h(keyboard): |
||||
"""Parses all the config.h files for a keyboard. |
||||
|
||||
Args: |
||||
keyboard: name of the keyboard |
||||
|
||||
Returns: |
||||
a dictionary representing the content of the entire config.h tree for a keyboard |
||||
""" |
||||
config = {} |
||||
cur_dir = Path('keyboards') |
||||
rules = rules_mk(keyboard) |
||||
keyboard = Path(rules['DEFAULT_FOLDER'] if 'DEFAULT_FOLDER' in rules else keyboard) |
||||
|
||||
for dir in keyboard.parts: |
||||
cur_dir = cur_dir / dir |
||||
config = {**config, **parse_config_h_file(cur_dir / 'config.h')} |
||||
|
||||
return config |
||||
|
||||
|
||||
def rules_mk(keyboard): |
||||
"""Get a rules.mk for a keyboard |
||||
|
||||
Args: |
||||
keyboard: name of the keyboard |
||||
|
||||
Returns: |
||||
a dictionary representing the content of the entire rules.mk tree for a keyboard |
||||
""" |
||||
keyboard = Path(keyboard) |
||||
cur_dir = Path('keyboards') |
||||
rules = parse_rules_mk_file(cur_dir / keyboard / 'rules.mk') |
||||
|
||||
if 'DEFAULT_FOLDER' in rules: |
||||
keyboard = Path(rules['DEFAULT_FOLDER']) |
||||
|
||||
for i, dir in enumerate(keyboard.parts): |
||||
cur_dir = cur_dir / dir |
||||
rules = parse_rules_mk_file(cur_dir / 'rules.mk', rules) |
||||
|
||||
return rules |
||||
|
||||
|
||||
def render_layout(layout_data, key_labels=None): |
||||
"""Renders a single layout. |
||||
""" |
||||
textpad = [array('u', ' ' * 200) for x in range(50)] |
||||
|
||||
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) |
||||
|
||||
if key_labels: |
||||
label = key_labels.pop(0) |
||||
if label.startswith('KC_'): |
||||
label = label[3:] |
||||
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 = '─' * label_len |
||||
label_middle = label + ' '*label_leftover # noqa: yapf insists there be no whitespace around * |
||||
|
||||
top_line = array('u', '┌' + label_border + '┐') |
||||
lab_line = array('u', '│' + label_middle + '│') |
||||
mid_line = array('u', '│' + label_blank + '│') |
||||
bot_line = array('u', '└' + label_border + "┘") |
||||
|
||||
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 |
||||
|
||||
lines = [] |
||||
for line in textpad: |
||||
if line.tounicode().strip(): |
||||
lines.append(line.tounicode().rstrip()) |
||||
|
||||
return '\n'.join(lines) |
||||
|
||||
|
||||
def render_layouts(info_json): |
||||
"""Renders all the layouts from an `info_json` structure. |
||||
""" |
||||
layouts = {} |
||||
|
||||
for layout in info_json['layouts']: |
||||
layout_data = info_json['layouts'][layout]['layout'] |
||||
layouts[layout] = render_layout(layout_data) |
||||
|
||||
return layouts |
||||
@ -0,0 +1,33 @@ |
||||
"""Parse arbitrary math equations in a safe way. |
||||
|
||||
Gratefully copied from https://stackoverflow.com/a/9558001 |
||||
""" |
||||
import ast |
||||
import operator as op |
||||
|
||||
# supported operators |
||||
operators = {ast.Add: op.add, ast.Sub: op.sub, ast.Mult: op.mul, ast.Div: op.truediv, ast.Pow: op.pow, ast.BitXor: op.xor, ast.USub: op.neg} |
||||
|
||||
|
||||
def compute(expr): |
||||
"""Parse a mathematical expression and return the answer. |
||||
|
||||
>>> compute('2^6') |
||||
4 |
||||
>>> compute('2**6') |
||||
64 |
||||
>>> compute('1 + 2*3**(4^5) / (6 + -7)') |
||||
-5.0 |
||||
""" |
||||
return _eval(ast.parse(expr, mode='eval').body) |
||||
|
||||
|
||||
def _eval(node): |
||||
if isinstance(node, ast.Num): # <number> |
||||
return node.n |
||||
elif isinstance(node, ast.BinOp): # <left> <operator> <right> |
||||
return operators[type(node.op)](_eval(node.left), _eval(node.right)) |
||||
elif isinstance(node, ast.UnaryOp): # <operator> <operand> e.g., -1 |
||||
return operators[type(node.op)](_eval(node.operand)) |
||||
else: |
||||
raise TypeError(node) |
||||
Loading…
Reference in new issue