qmk-dactyl-manuform-a/lib/python/qmk/commands.py

209 lines
5.9 KiB
Python

"""Helper functions for commands.
"""
import json
import os
import platform
import subprocess
import shlex
import shutil
from pathlib import Path
from time import strftime
from milc import cli
import qmk.keymap
from qmk.constants import KEYBOARD_OUTPUT_PREFIX
time_fmt = '%Y-%m-%d-%H:%M:%S'
def _find_make():
"""Returns the correct make command for this environment.
"""
make_cmd = os.environ.get('MAKE')
if not make_cmd:
make_cmd = 'gmake' if shutil.which('gmake') else 'make'
return make_cmd
def create_make_command(keyboard, keymap, target=None, parallel=1, **env_vars):
"""Create a make compile command
Args:
keyboard
The path of the keyboard, for example 'plank'
keymap
The name of the keymap, for example 'algernon'
target
Usually a bootloader.
parallel
The number of make jobs to run in parallel
**env_vars
Environment variables to be passed to make.
Returns:
A command that can be run to make the specified keyboard and keymap
"""
env = []
make_args = [keyboard, keymap]
make_cmd = _find_make()
if target:
make_args.append(target)
for key, value in env_vars.items():
env.append(f'{key}={value}')
return [make_cmd, '-j', str(parallel), *env, ':'.join(make_args)]
def get_git_version(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 Path(check_dir).exists():
git_describe = cli.run(git_describe_cmd, cwd=repo_dir)
if git_describe.returncode == 0:
return git_describe.stdout.strip()
else:
cli.args.warn(f'"{" ".join(git_describe_cmd)}" returned error code {git_describe.returncode}')
print(git_describe.stderr)
return strftime(time_fmt)
return strftime(time_fmt)
def write_version_h(git_version, build_date, chibios_version, chibios_contrib_version):
"""Generate and write quantum/version.h
"""
version_h = [
f'#define QMK_VERSION "{git_version}"',
f'#define QMK_BUILD_DATE "{build_date}"',
f'#define CHIBIOS_VERSION "{chibios_version}"',
f'#define CHIBIOS_CONTRIB_VERSION "{chibios_contrib_version}"',
]
version_h_file = Path('quantum/version.h')
version_h_file.write_text('\n'.join(version_h))
def compile_configurator_json(user_keymap, parallel=1, **env_vars):
"""Convert a configurator export JSON file into a C file and then compile it.
Args:
user_keymap
A deserialized keymap export
bootloader
A bootloader to flash
parallel
The number of make jobs to run in parallel
Returns:
A command to run to compile and flash the C file.
"""
# Write the keymap.c file
keyboard_filesafe = user_keymap['keyboard'].replace('/', '_')
target = f'{keyboard_filesafe}_{user_keymap["keymap"]}'
keyboard_output = Path(f'{KEYBOARD_OUTPUT_PREFIX}{keyboard_filesafe}')
keymap_output = Path(f'{keyboard_output}_{user_keymap["keymap"]}')
c_text = qmk.keymap.generate_c(user_keymap['keyboard'], user_keymap['layout'], user_keymap['layers'])
keymap_dir = keymap_output / 'src'
keymap_c = keymap_dir / 'keymap.c'
keymap_dir.mkdir(exist_ok=True, parents=True)
keymap_c.write_text(c_text)
# Write the version.h file
git_version = get_git_version()
build_date = strftime('%Y-%m-%d-%H:%M:%S')
chibios_version = get_git_version("lib/chibios", "lib/chibios/os")
chibios_contrib_version = get_git_version("lib/chibios-contrib", "lib/chibios-contrib/os")
write_version_h(git_version, build_date, chibios_version, chibios_contrib_version)
# 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'
make_command = [_find_make()]
if not cli.config.general.verbose:
make_command.append('-s')
make_command.extend([
'-j',
str(parallel),
'-r',
'-R',
'-f',
'build_keyboard.mk',
])
for key, value in env_vars.items():
make_command.append(f'{key}={value}')
make_command.extend([
f'GIT_VERSION={git_version}',
f'BUILD_DATE={build_date}',
f'CHIBIOS_VERSION={chibios_version}',
f'CHIBIOS_CONTRIB_VERSION={chibios_contrib_version}',
f'KEYBOARD={user_keymap["keyboard"]}',
f'KEYMAP={user_keymap["keymap"]}',
f'KEYBOARD_FILESAFE={keyboard_filesafe}',
f'TARGET={target}',
f'KEYBOARD_OUTPUT={keyboard_output}',
f'KEYMAP_OUTPUT={keymap_output}',
f'MAIN_KEYMAP_PATH_1={keymap_output}',
f'MAIN_KEYMAP_PATH_2={keymap_output}',
f'MAIN_KEYMAP_PATH_3={keymap_output}',
f'MAIN_KEYMAP_PATH_4={keymap_output}',
f'MAIN_KEYMAP_PATH_5={keymap_output}',
f'KEYMAP_C={keymap_c}',
f'KEYMAP_PATH={keymap_dir}',
f'VERBOSE={verbose}',
f'COLOR={color}',
'SILENT=false',
])
return make_command
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)
return user_keymap
def run(command, *args, **kwargs):
"""Run a command with subprocess.run
"""
platform_id = platform.platform().lower()
if isinstance(command, str):
raise TypeError('`command` must be a non-text sequence such as list or tuple.')
if 'windows' in platform_id:
safecmd = map(str, command)
safecmd = map(shlex.quote, safecmd)
safecmd = ' '.join(safecmd)
command = [os.environ['SHELL'], '-c', safecmd]
return subprocess.run(command, *args, **kwargs)