diff options
Diffstat (limited to 'lib/python/qmk/info.py')
| -rw-r--r-- | lib/python/qmk/info.py | 584 | 
1 files changed, 503 insertions, 81 deletions
| diff --git a/lib/python/qmk/info.py b/lib/python/qmk/info.py index f476dc666d..0ea5136a97 100644 --- a/lib/python/qmk/info.py +++ b/lib/python/qmk/info.py @@ -1,18 +1,64 @@  """Functions that help us generate and use info.json files.  """  import json +from collections.abc import Mapping  from glob import glob  from pathlib import Path +import jsonschema  from milc import cli -from qmk.constants import CHIBIOS_PROCESSORS, LUFA_PROCESSORS, VUSB_PROCESSORS +from qmk.constants import CHIBIOS_PROCESSORS, LUFA_PROCESSORS, VUSB_PROCESSORS, LED_INDICATORS  from qmk.c_parse import find_layouts  from qmk.keyboard import config_h, rules_mk  from qmk.keymap import list_keymaps  from qmk.makefile import parse_rules_mk_file  from qmk.math import compute +led_matrix_properties = { +    'driver_count': 'LED_DRIVER_COUNT', +    'driver_addr1': 'LED_DRIVER_ADDR_1', +    'driver_addr2': 'LED_DRIVER_ADDR_2', +    'driver_addr3': 'LED_DRIVER_ADDR_3', +    'driver_addr4': 'LED_DRIVER_ADDR_4', +    'led_count': 'LED_DRIVER_LED_COUNT', +    'timeout': 'ISSI_TIMEOUT', +    'persistence': 'ISSI_PERSISTENCE' +} + +rgblight_properties = { +    'led_count': ('RGBLED_NUM', int), +    'pin': ('RGB_DI_PIN', str), +    'max_brightness': ('RGBLIGHT_LIMIT_VAL', int), +    'hue_steps': ('RGBLIGHT_HUE_STEP', int), +    'saturation_steps': ('RGBLIGHT_SAT_STEP', int), +    'brightness_steps': ('RGBLIGHT_VAL_STEP', int) +} + +rgblight_toggles = { +    'sleep': 'RGBLIGHT_SLEEP', +    'split': 'RGBLIGHT_SPLIT', +} + +rgblight_animations = { +    'all': 'RGBLIGHT_ANIMATIONS', +    'alternating': 'RGBLIGHT_EFFECT_ALTERNATING', +    'breathing': 'RGBLIGHT_EFFECT_BREATHING', +    'christmas': 'RGBLIGHT_EFFECT_CHRISTMAS', +    'knight': 'RGBLIGHT_EFFECT_KNIGHT', +    'rainbow_mood': 'RGBLIGHT_EFFECT_RAINBOW_MOOD', +    'rainbow_swirl': 'RGBLIGHT_EFFECT_RAINBOW_SWIRL', +    'rgb_test': 'RGBLIGHT_EFFECT_RGB_TEST', +    'snake': 'RGBLIGHT_EFFECT_SNAKE', +    'static_gradient': 'RGBLIGHT_EFFECT_STATIC_GRADIENT', +    'twinkle': 'RGBLIGHT_EFFECT_TWINKLE' +} + +usb_properties = {'vid': 'VENDOR_ID', 'pid': 'PRODUCT_ID', 'device_ver': 'DEVICE_VER'} + +true_values = ['1', 'on', 'yes'] +false_values = ['0', 'off', 'no'] +  def info_json(keyboard):      """Generate the info.json data for a specific keyboard. @@ -38,8 +84,9 @@ def info_json(keyboard):          info_data['keymaps'][keymap.name] = {'url': f'https://raw.githubusercontent.com/qmk/qmk_firmware/master/{keymap}/keymap.json'}      # Populate layout data -    for layout_name, layout_json in _find_all_layouts(info_data, keyboard, rules).items(): +    for layout_name, layout_json in _find_all_layouts(info_data, keyboard).items():          if not layout_name.startswith('LAYOUT_kc'): +            layout_json['c_macro'] = True              info_data['layouts'][layout_name] = layout_json      # Merge in the data from info.json, config.h, and rules.mk @@ -47,54 +94,366 @@ def info_json(keyboard):      info_data = _extract_config_h(info_data)      info_data = _extract_rules_mk(info_data) +    # Validate against the jsonschema +    try: +        keyboard_api_validate(info_data) + +    except jsonschema.ValidationError as e: +        json_path = '.'.join([str(p) for p in e.absolute_path]) +        cli.log.error('Invalid API data: %s: %s: %s', keyboard, json_path, e.message) +        print(dir(e)) +        exit() + +    # Make sure we have at least one layout +    if not info_data.get('layouts'): +        _log_error(info_data, 'No LAYOUTs defined! Need at least one layout defined in the keyboard.h or info.json.') + +    # Make sure we supply layout macros for the community layouts we claim to support +    # FIXME(skullydazed): This should be populated into info.json and read from there instead +    if 'LAYOUTS' in rules and info_data.get('layouts'): +        # Match these up against the supplied layouts +        supported_layouts = rules['LAYOUTS'].strip().split() +        for layout_name in sorted(info_data['layouts']): +            layout_name = layout_name[7:] + +            if layout_name in supported_layouts: +                supported_layouts.remove(layout_name) + +        if supported_layouts: +            for supported_layout in supported_layouts: +                _log_error(info_data, 'Claims to support community layout %s but no LAYOUT_%s() macro found' % (supported_layout, supported_layout)) +      return info_data -def _extract_config_h(info_data): -    """Pull some keyboard information from existing rules.mk files +def _json_load(json_file): +    """Load a json file from disk. + +    Note: file must be a Path object. +    """ +    try: +        return json.load(json_file.open()) + +    except json.decoder.JSONDecodeError as e: +        cli.log.error('Invalid JSON encountered attempting to load {fg_cyan}%s{fg_reset}:\n\t{fg_red}%s', json_file, e) +        exit(1) + + +def _jsonschema(schema_name): +    """Read a jsonschema file from disk. + +    FIXME(skullydazed/anyone): Refactor to make this a public function. +    """ +    schema_path = Path(f'data/schemas/{schema_name}.jsonschema') + +    if not schema_path.exists(): +        schema_path = Path('data/schemas/false.jsonschema') + +    return _json_load(schema_path) + + +def keyboard_validate(data): +    """Validates data against the keyboard jsonschema. +    """ +    schema = _jsonschema('keyboard') +    validator = jsonschema.Draft7Validator(schema).validate + +    return validator(data) + + +def keyboard_api_validate(data): +    """Validates data against the api_keyboard jsonschema. +    """ +    base = _jsonschema('keyboard') +    relative = _jsonschema('api_keyboard') +    resolver = jsonschema.RefResolver.from_schema(base) +    validator = jsonschema.Draft7Validator(relative, resolver=resolver).validate + +    return validator(data) + + +def _extract_debounce(info_data, config_c): +    """Handle debounce. +    """ +    if 'debounce' in info_data and 'DEBOUNCE' in config_c: +        _log_warning(info_data, 'Debounce is specified in both info.json and config.h, the config.h value wins.') + +    if 'DEBOUNCE' in config_c: +        info_data['debounce'] = int(config_c['DEBOUNCE']) + +    return info_data + + +def _extract_diode_direction(info_data, config_c): +    """Handle the diode direction. +    """ +    if 'diode_direction' in info_data and 'DIODE_DIRECTION' in config_c: +        _log_warning(info_data, 'Diode direction is specified in both info.json and config.h, the config.h value wins.') + +    if 'DIODE_DIRECTION' in config_c: +        info_data['diode_direction'] = config_c.get('DIODE_DIRECTION') + +    return info_data + + +def _extract_indicators(info_data, config_c): +    """Find the LED indicator information. +    """ +    for json_key, config_key in LED_INDICATORS.items(): +        if json_key in info_data.get('indicators', []) and config_key in config_c: +            _log_warning(info_data, f'Indicator {json_key} is specified in both info.json and config.h, the config.h value wins.') + +        if 'indicators' not in info_data: +            info_data['indicators'] = {} + +        if config_key in config_c: +            if 'indicators' not in info_data: +                info_data['indicators'] = {} + +            info_data['indicators'][json_key] = config_c.get(config_key) + +    return info_data + + +def _extract_community_layouts(info_data, rules): +    """Find the community layouts in rules.mk. +    """ +    community_layouts = rules['LAYOUTS'].split() if 'LAYOUTS' in rules else [] + +    if 'community_layouts' in info_data: +        for layout in community_layouts: +            if layout not in info_data['community_layouts']: +                community_layouts.append(layout) + +    else: +        info_data['community_layouts'] = community_layouts + +    return info_data + + +def _extract_features(info_data, rules): +    """Find all the features enabled in rules.mk. +    """ +    # Special handling for bootmagic which also supports a "lite" mode. +    if rules.get('BOOTMAGIC_ENABLE') == 'lite': +        rules['BOOTMAGIC_LITE_ENABLE'] = 'on' +        del rules['BOOTMAGIC_ENABLE'] +    if rules.get('BOOTMAGIC_ENABLE') == 'full': +        rules['BOOTMAGIC_ENABLE'] = 'on' + +    # Skip non-boolean features we haven't implemented special handling for +    for feature in 'HAPTIC_ENABLE', 'QWIIC_ENABLE': +        if rules.get(feature): +            del rules[feature] + +    # Process the rest of the rules as booleans +    for key, value in rules.items(): +        if key.endswith('_ENABLE'): +            key = '_'.join(key.split('_')[:-1]).lower() +            value = True if value.lower() in true_values else False if value.lower() in false_values else value + +            if 'config_h_features' not in info_data: +                info_data['config_h_features'] = {} + +            if 'features' not in info_data: +                info_data['features'] = {} + +            if key in info_data['features']: +                _log_warning(info_data, 'Feature %s is specified in both info.json and rules.mk, the rules.mk value wins.' % (key,)) + +            info_data['features'][key] = value +            info_data['config_h_features'][key] = value + +    return info_data + + +def _extract_led_drivers(info_data, rules): +    """Find all the LED drivers set in rules.mk. +    """ +    if 'LED_MATRIX_DRIVER' in rules: +        if 'led_matrix' not in info_data: +            info_data['led_matrix'] = {} + +        if info_data['led_matrix'].get('driver'): +            _log_warning(info_data, 'LED Matrix driver is specified in both info.json and rules.mk, the rules.mk value wins.') + +        info_data['led_matrix']['driver'] = rules['LED_MATRIX_DRIVER'] + +    return info_data + + +def _extract_led_matrix(info_data, config_c): +    """Handle the led_matrix configuration. +    """ +    led_matrix = info_data.get('led_matrix', {}) + +    for json_key, config_key in led_matrix_properties.items(): +        if config_key in config_c: +            if json_key in led_matrix: +                _log_warning(info_data, 'LED Matrix: %s is specified in both info.json and config.h, the config.h value wins.' % (json_key,)) + +            led_matrix[json_key] = config_c[config_key] + + +def _extract_rgblight(info_data, config_c): +    """Handle the rgblight configuration. +    """ +    rgblight = info_data.get('rgblight', {}) +    animations = rgblight.get('animations', {}) + +    if 'RGBLED_SPLIT' in config_c: +        raw_split = config_c.get('RGBLED_SPLIT', '').replace('{', '').replace('}', '').strip() +        rgblight['split_count'] = [int(i) for i in raw_split.split(',')] + +    for json_key, config_key_type in rgblight_properties.items(): +        config_key, config_type = config_key_type + +        if config_key in config_c: +            if json_key in rgblight: +                _log_warning(info_data, 'RGB Light: %s is specified in both info.json and config.h, the config.h value wins.' % (json_key,)) + +            try: +                rgblight[json_key] = config_type(config_c[config_key]) +            except ValueError as e: +                cli.log.error('%s: config.h: Could not convert "%s" to %s: %s', info_data['keyboard_folder'], config_c[config_key], config_type.__name__, e) + +    for json_key, config_key in rgblight_toggles.items(): +        if config_key in config_c and json_key in rgblight: +            _log_warning(info_data, 'RGB Light: %s is specified in both info.json and config.h, the config.h value wins.', json_key) + +        rgblight[json_key] = config_key in config_c + +    for json_key, config_key in rgblight_animations.items(): +        if config_key in config_c: +            if json_key in animations: +                _log_warning(info_data, 'RGB Light: animations: %s is specified in both info.json and config.h, the config.h value wins.' % (json_key,)) + +            animations[json_key] = config_c[config_key] + +    if animations: +        rgblight['animations'] = animations + +    if rgblight: +        info_data['rgblight'] = rgblight + +    return info_data + + +def _pin_name(pin): +    """Returns the proper representation for a pin. +    """ +    pin = pin.strip() + +    if not pin: +        return None + +    elif pin.isdigit(): +        return int(pin) + +    elif pin == 'NO_PIN': +        return None + +    elif pin[0] in 'ABCDEFGHIJK' and pin[1].isdigit(): +        return pin + +    raise ValueError(f'Invalid pin: {pin}') + + +def _extract_pins(pins): +    """Returns a list of pins from a comma separated string of pins. +    """ +    return [_pin_name(pin) for pin in pins.split(',')] + + +def _extract_direct_matrix(info_data, direct_pins): +    """ +    """ +    info_data['matrix_pins'] = {} +    direct_pin_array = [] + +    while direct_pins[-1] != '}': +        direct_pins = direct_pins[:-1] + +    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) + +    return direct_pin_array + + +def _extract_matrix_info(info_data, config_c): +    """Populate the matrix information.      """ -    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 'MATRIX_ROWS' in config_c and 'MATRIX_COLS' in config_c: +        if 'matrix_size' in info_data: +            _log_warning(info_data, 'Matrix size is specified in both info.json and config.h, the config.h values win.') -    if row_pins: -        info_data['matrix_pins']['rows'] = row_pins.split(',') -    if col_pins: -        info_data['matrix_pins']['cols'] = col_pins.split(',') +        info_data['matrix_size'] = { +            'cols': compute(config_c.get('MATRIX_COLS', '0')), +            'rows': compute(config_c.get('MATRIX_ROWS', '0')), +        } + +    if row_pins and col_pins: +        if 'matrix_pins' in info_data: +            _log_warning(info_data, 'Matrix pins are specified in both info.json and config.h, the config.h values win.') + +        info_data['matrix_pins'] = { +            'cols': _extract_pins(col_pins), +            'rows': _extract_pins(row_pins), +        }      if direct_pins: -        direct_pin_array = [] -        for row in direct_pins.split('},{'): -            if row.startswith('{'): -                row = row[1:] -            if row.endswith('}'): -                row = row[:-1] +        if 'matrix_pins' in info_data: +            _log_warning(info_data, 'Direct pins are specified in both info.json and config.h, the config.h values win.') -            direct_pin_array.append([]) +        info_data['matrix_pins']['direct'] = _extract_direct_matrix(info_data, direct_pins) -            for pin in row.split(','): -                if pin == 'NO_PIN': -                    pin = None +    return info_data -                direct_pin_array[-1].append(pin) -        info_data['matrix_pins']['direct'] = direct_pin_array +def _extract_usb_info(info_data, config_c): +    """Populate the USB information. +    """ +    if 'usb' not in info_data: +        info_data['usb'] = {} -    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'), -    } +    for info_name, config_name in usb_properties.items(): +        if config_name in config_c: +            if info_name in info_data['usb']: +                _log_warning(info_data, '%s in config.h is overwriting usb.%s in info.json' % (config_name, info_name)) + +            info_data['usb'][info_name] = '0x' + config_c[config_name][2:].upper() + +    return info_data + + +def _extract_config_h(info_data): +    """Pull some keyboard information from existing config.h files +    """ +    config_c = config_h(info_data['keyboard_folder']) + +    _extract_debounce(info_data, config_c) +    _extract_diode_direction(info_data, config_c) +    _extract_indicators(info_data, config_c) +    _extract_matrix_info(info_data, config_c) +    _extract_usb_info(info_data, config_c) +    _extract_led_matrix(info_data, config_c) +    _extract_rgblight(info_data, config_c)      return info_data @@ -106,16 +465,53 @@ def _extract_rules_mk(info_data):      mcu = rules.get('MCU')      if mcu in CHIBIOS_PROCESSORS: -        return arm_processor_rules(info_data, rules) +        arm_processor_rules(info_data, rules)      elif mcu in LUFA_PROCESSORS + VUSB_PROCESSORS: -        return avr_processor_rules(info_data, rules) +        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) + +    _extract_community_layouts(info_data, rules) +    _extract_features(info_data, rules) +    _extract_led_drivers(info_data, rules) + +    return info_data + -    msg = "Unknown MCU: " + str(mcu) +def _merge_layouts(info_data, new_info_data): +    """Merge new_info_data into info_data in an intelligent way. +    """ +    for layout_name, layout_json in new_info_data['layouts'].items(): +        if layout_name in info_data['layouts']: +            # Pull in layouts we have a macro for +            if len(info_data['layouts'][layout_name]['layout']) != len(layout_json['layout']): +                msg = '%s: %s: Number of elements in info.json does not match! info.json:%s != %s:%s' +                _log_error(info_data, msg % (info_data['keyboard_folder'], layout_name, len(layout_json['layout']), layout_name, len(info_data['layouts'][layout_name]['layout']))) +            else: +                for i, key in enumerate(info_data['layouts'][layout_name]['layout']): +                    key.update(layout_json['layout'][i]) +        else: +            # Pull in layouts that have matrix data +            missing_matrix = False +            for key in layout_json.get('layout', {}): +                if 'matrix' not in key: +                    missing_matrix = True + +            if not missing_matrix: +                if layout_name in info_data['layouts']: +                    # Update an existing layout with new data +                    for i, key in enumerate(info_data['layouts'][layout_name]['layout']): +                        key.update(layout_json['layout'][i]) -    _log_warning(info_data, msg) +                else: +                    # Copy in the new layout wholesale +                    layout_json['c_macro'] = False +                    info_data['layouts'][layout_name] = layout_json -    return unknown_processor_rules(info_data, rules) +    return info_data  def _search_keyboard_h(path): @@ -131,34 +527,21 @@ def _search_keyboard_h(path):      return layouts -def _find_all_layouts(info_data, keyboard, rules): +def _find_all_layouts(info_data, keyboard):      """Looks for layout macros associated with this keyboard.      """      layouts = _search_keyboard_h(Path(keyboard))      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. -        _log_warning(info_data, 'Falling back to searching for KEYMAP/LAYOUT macros.') +        # If we don't find any layouts from info.json or keyboard.h we widen our search. This is error prone which is why we want to encourage people to follow the standard above. +        info_data['parse_warnings'].append('%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: -            _log_error(info_data, 'Missing LAYOUT() macro for %s' % (', '.join(supported_layouts))) -      return layouts @@ -180,13 +563,29 @@ 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 'MCU' in rules: +        if 'processor' in info_data: +            _log_warning(info_data, 'Processor/MCU is specified in both info.json and rules.mk, the rules.mk value wins.') + +        info_data['processor'] = rules['MCU'] + +    elif 'processor' not in info_data: +        info_data['processor'] = 'unknown' + +    if 'BOOTLOADER' in rules: +        # FIXME(skullydazed/anyone): need to remove the massive amounts of duplication first +        # if 'bootloader' in info_data: +        #     _log_warning(info_data, 'Bootloader is specified in both info.json and rules.mk, the rules.mk value wins.') + +        info_data['bootloader'] = rules['BOOTLOADER'] + +    else:          if 'STM32' in info_data['processor']:              info_data['bootloader'] = 'stm32-dfu' +        else: +            info_data['bootloader'] = 'unknown'      if 'STM32' in info_data['processor']:          info_data['platform'] = 'STM32' @@ -204,9 +603,26 @@ def avr_processor_rules(info_data, rules):      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' +    if 'MCU' in rules: +        if 'processor' in info_data: +            _log_warning(info_data, 'Processor/MCU is specified in both info.json and rules.mk, the rules.mk value wins.') + +        info_data['processor'] = rules['MCU'] + +    elif 'processor' not in info_data: +        info_data['processor'] = 'unknown' + +    if 'BOOTLOADER' in rules: +        # FIXME(skullydazed/anyone): need to remove the massive amounts of duplication first +        # if 'bootloader' in info_data: +        #     _log_warning(info_data, 'Bootloader is specified in both info.json and rules.mk, the rules.mk value wins.') + +        info_data['bootloader'] = rules['BOOTLOADER'] +    else: +        info_data['bootloader'] = 'atmel-dfu' +      # 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' @@ -225,38 +641,44 @@ def unknown_processor_rules(info_data, rules):      return info_data +def deep_update(origdict, newdict): +    """Update a dictionary in place, recursing to do a deep copy. +    """ +    for key, value in newdict.items(): +        if isinstance(value, Mapping): +            origdict[key] = deep_update(origdict.get(key, {}), value) + +        else: +            origdict[key] = value + +    return origdict + +  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 -        try: -            with info_file.open('r') as info_fd: -                new_info_data = json.load(info_fd) -        except Exception as e: -            _log_error(info_data, "Invalid JSON in file %s: %s: %s" % (str(info_file), e.__class__.__name__, e)) -            continue +        new_info_data = _json_load(info_file)          if not isinstance(new_info_data, dict):              _log_error(info_data, "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] +        try: +            keyboard_validate(new_info_data) +        except jsonschema.ValidationError as e: +            json_path = '.'.join([str(p) for p in e.absolute_path]) +            cli.log.error('Not including data from file: %s', info_file) +            cli.log.error('\t%s: %s', json_path, e.message) +            continue -        # 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']): -                        msg = '%s: Number of elements in info.json does not match! info.json:%s != %s:%s' -                        _log_error(info_data, msg % (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]) +        # Mark the layouts as coming from json +        for layout in new_info_data.get('layouts', {}).values(): +            layout['c_macro'] = False + +        # Update info_data with the new data +        deep_update(info_data, new_info_data)      return info_data | 
