How to use the milc.cli.log.error function in milc

# Make sure the basic CLI tools we need are available and can be executed.
    binaries = ['dfu-programmer', 'avrdude', 'dfu-util', 'avr-gcc', 'arm-none-eabi-gcc']
    binaries += glob('bin/qmk-*')
    ok = True

    for binary in binaries:
        res = shutil.which(binary)
        if res is None:
            cli.log.error("{fg_red}QMK can't find %s in your path.", binary)
            ok = False
        else:
            try:
                subprocess.run([binary, '--version'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=5, check=True)
                cli.log.info('Found {fg_cyan}%s', binary)
            except subprocess.CalledProcessError:
                cli.log.error("{fg_red}Can't run `%s --version`", binary)
                ok = False

    # Determine our OS and run platform specific tests
    OS = platform.system()

    if OS == "Darwin":
        cli.log.info("Detected {fg_cyan}macOS.")

    elif OS == "Linux":
        cli.log.info("Detected {fg_cyan}Linux.")
        if shutil.which('systemctl'):
            mm_check = subprocess.run(['systemctl', 'list-unit-files'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=10, universal_newlines=True)
            if mm_check.returncode == 0:
                mm = False
                for line in mm_check.stdout.split('\n'):
                    if 'ModemManager' in line and 'enabled' in line:

# Extract the section, config_key, and value to write from the supplied config_token.
            if '=' in config_token:
                key, value = config_token.split('=')
            else:
                key = config_token
                value = None

            if '.' in key:
                section, config_key = key.split('.', 1)
            else:
                section = key
                config_key = None

            # Validation
            if config_key and '.' in config_key:
                cli.log.error('Config keys may not have more than one period! "%s" is not valid.', key)
                return False

            # Do what the user wants
            if section and config_key and value:
                # Write a config key
                log_string = '%s.%s{fg_cyan}:{fg_reset} %s {fg_cyan}->{fg_reset} %s'
                if cli.args.read_only:
                    log_string += ' {fg_red}(change not written)'

                cli.echo(log_string, section, config_key, cli.config[section][config_key], value)

                if not cli.args.read_only:
                    if value == 'None':
                        del cli.config[section][config_key]
                    else:
                        cli.config[section][config_key] = value

elif OS == "Linux":
        cli.log.info("Detected {fg_cyan}Linux.")
        if shutil.which('systemctl'):
            mm_check = subprocess.run(['systemctl', 'list-unit-files'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=10, universal_newlines=True)
            if mm_check.returncode == 0:
                mm = False
                for line in mm_check.stdout.split('\n'):
                    if 'ModemManager' in line and 'enabled' in line:
                        mm = True

                if mm:
                    cli.log.warn("{bg_yellow}Detected ModemManager. Please disable it if you are using a Pro-Micro.")

            else:
                cli.log.error('{bg_red}Could not run `systemctl list-unit-files`:')
                cli.log.error(mm_check.stderr)

        else:
            cli.log.warn("Can't find systemctl to check for ModemManager.")

    else:
        cli.log.info("Assuming {fg_cyan}Windows.")

    # Report a summary of our findings to the user
    if ok:
        cli.log.info('{fg_green}QMK is ready to go')
    else:
        cli.log.info('{fg_yellow}Problems detected, please fix these problems before proceeding.')
        # FIXME(skullydazed): Link to a document about troubleshooting, or discord or something

def json_keymap(cli):
    """Generate a keymap.c from a configurator export.

    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.
    """
    # Error checking
    if cli.args.filename == ('-'):
        cli.log.error('Reading from STDIN is not (yet) supported.')
        cli.print_usage()
        exit(1)
    if not os.path.exists(qmk.path.normpath(cli.args.filename)):
        cli.log.error('JSON file does not exist!')
        cli.print_usage()
        exit(1)

    # Environment processing
    if cli.args.output == ('-'):
        cli.args.output = None

    # Parse the configurator json
    with open(qmk.path.normpath(cli.args.filename), 'r') as fd:
        user_keymap = json.load(fd)

    # Generate the keymap
    keymap_c = qmk.keymap.generate(user_keymap['keyboard'], user_keymap['layout'], user_keymap['layers'])

    if cli.args.output:
        output_dir = os.path.dirname(cli.args.output)

if not file_path.exists():
        return cli.log.error('File {fg_cyan}%s{style_reset_all} was not found.', str(file_path))
    out_path = file_path.parent
    raw_code = file_path.open().read()
    # Check if info.json exists, allow overwrite with force
    if Path(out_path, "info.json").exists() and not cli.args.force:
        cli.log.error('File {fg_cyan}%s/info.json{style_reset_all} already exists, use -f or --force to overwrite.', str(out_path))
        return False
    try:
        # Convert KLE raw to x/y coordinates (using kle2xy package from skullydazed)
        kle = KLE2xy(raw_code)
    except Exception as e:
        cli.log.error('Could not parse KLE raw data: %s', raw_code)
        cli.log.exception(e)
        # FIXME: This should be better
        return cli.log.error('Could not parse KLE raw data.')
    keyboard = OrderedDict(
        keyboard_name=kle.name,
        url='',
        maintainer='qmk',
        width=kle.columns,
        height=kle.rows,
        layouts={'LAYOUT': {
            'layout': 'LAYOUT_JSON_HERE'
        }},
    )
    # Initialize keyboard with json encoded from ordered dict
    keyboard = json.dumps(keyboard, indent=4, separators=(', ', ': '), sort_keys=False, cls=CustomJSONEncoder)
    # Initialize layout with kle2qmk from converter module
    layout = json.dumps(kle2qmk(kle), separators=(', ', ':'), cls=CustomJSONEncoder)
    # Replace layout in keyboard json
    keyboard = keyboard.replace('"LAYOUT_JSON_HERE"', layout)

def kle2json(cli):
    """Convert a KLE layout to QMK's layout format.
    """  # If filename is a path
    if cli.args.filename.startswith("/") or cli.args.filename.startswith("./"):
        file_path = Path(cli.args.filename)
    # Otherwise assume it is a file name
    else:
        file_path = Path(os.environ['ORIG_CWD'], cli.args.filename)
    # Check for valid file_path for more graceful failure
    if not file_path.exists():
        return cli.log.error('File {fg_cyan}%s{style_reset_all} was not found.', str(file_path))
    out_path = file_path.parent
    raw_code = file_path.open().read()
    # Check if info.json exists, allow overwrite with force
    if Path(out_path, "info.json").exists() and not cli.args.force:
        cli.log.error('File {fg_cyan}%s/info.json{style_reset_all} already exists, use -f or --force to overwrite.', str(out_path))
        return False
    try:
        # Convert KLE raw to x/y coordinates (using kle2xy package from skullydazed)
        kle = KLE2xy(raw_code)
    except Exception as e:
        cli.log.error('Could not parse KLE raw data: %s', raw_code)
        cli.log.exception(e)
        # FIXME: This should be better
        return cli.log.error('Could not parse KLE raw data.')
    keyboard = OrderedDict(
        keyboard_name=kle.name,
        url='',
        maintainer='qmk',
        width=kle.columns,
        height=kle.rows,
        layouts={'LAYOUT': {

print()
        answer = input(format_ansi(prompt % args))
        print()

        if answer:
            if confirm:
                if yesno('Is the answer "%s" correct?', answer, default=True):
                    try:
                        return answer_type(answer)
                    except Exception as e:
                        cli.log.error('Could not convert answer (%s) to type %s: %s', answer, answer_type.__name__, str(e))
            else:
                try:
                    return answer_type(answer)
                except Exception as e:
                    cli.log.error('Could not convert answer (%s) to type %s: %s', answer, answer_type.__name__, str(e))

        elif default is not None:
            return default

for dir in ['drivers', 'quantum', 'tests', 'tmk_core']:
            for dirpath, dirnames, filenames in os.walk(dir):
                if 'tmk_core/protocol/usb_hid' in dirpath:
                    continue

                for name in filenames:
                    if name.endswith('.c') or name.endswith('.h') or name.endswith('.cpp'):
                        cli.args.files.append(os.path.join(dirpath, name))

    # Run clang-format on the files we've found
    try:
        subprocess.run(clang_format + cli.args.files, check=True)
        cli.log.info('Successfully formatted the C code.')

    except subprocess.CalledProcessError:
        cli.log.error('Error formatting C code!')
        return False

TODO(unclaimed):
        * [ ] Compile a trivial program with each compiler
        * [ ] Check for udev entries on linux
    """
    cli.log.info('QMK Doctor is checking your environment.')

    # Make sure the basic CLI tools we need are available and can be executed.
    binaries = ['dfu-programmer', 'avrdude', 'dfu-util', 'avr-gcc', 'arm-none-eabi-gcc']
    binaries += glob('bin/qmk-*')
    ok = True

    for binary in binaries:
        res = shutil.which(binary)
        if res is None:
            cli.log.error("{fg_red}QMK can't find %s in your path.", binary)
            ok = False
        else:
            try:
                subprocess.run([binary, '--version'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=5, check=True)
                cli.log.info('Found {fg_cyan}%s', binary)
            except subprocess.CalledProcessError:
                cli.log.error("{fg_red}Can't run `%s --version`", binary)
                ok = False

    # Determine our OS and run platform specific tests
    OS = platform.system()

    if OS == "Darwin":
        cli.log.info("Detected {fg_cyan}macOS.")

    elif OS == "Linux":

# Generate the keymap
        keymap_path = qmk.path.keymap(user_keymap['keyboard'])
        cli.log.info('Creating {fg_cyan}%s{style_reset_all} keymap in {fg_cyan}%s', user_keymap['keymap'], keymap_path)

        # Compile the keymap
        command = compile_configurator_json(cli.args.filename)

        cli.log.info('Wrote keymap to {fg_cyan}%s/%s/keymap.c', keymap_path, user_keymap['keymap'])

    elif cli.config.compile.keyboard and cli.config.compile.keymap:
        # Generate the make command for a specific keyboard/keymap.
        command = create_make_command(cli.config.compile.keyboard, cli.config.compile.keymap)

    else:
        cli.log.error('You must supply a configurator export or both `--keyboard` and `--keymap`.')
        return False

    cli.log.info('Compiling keymap with {fg_cyan}%s\n\n', ' '.join(command))
    subprocess.run(command)