tornavis/tests/python/bl_keymap_validate.py

# SPDX-License-Identifier: GPL-2.0-or-later

# <pep8 compliant>

# ./blender.bin --background -noaudio --factory-startup --python tests/python/bl_keymap_validate.py
#

"""
This catches the following kinds of issues:

- Arguments that don't make sense, e.g.
  - 'repeat' for non keyboard events.
  - 'any' argument with other modifiers also enabled.
  - Duplicate property entries.
- Unknown/unused dictionary keys.
- Unused keymaps (keymaps which are defined but not used anywhere).
- Event values that don't make sense for the event type, e.g.
  An escape key could have the value "NORTH" instead of "PRESS".

This works by taking the keymap data (before it's loaded into Blender),
then comparing it with that same keymap after exporting and importing.

NOTE:

   Append ' -- --relaxed' not to fail on small issues,
   this is so minor inconsistencies don't break the tests.
"""

import types
import typing

import contextlib

import bpy

# Useful for diffing the output to see what changed in context.
# this writes keymaps into the current directory with `.orig.py` & `.rewrite.py` extensions.
WRITE_OUTPUT_DIR = None  # "/tmp", defaults to the systems temp directory.


# -----------------------------------------------------------------------------
# Generic Utilities

@contextlib.contextmanager
def temp_fn_argument_extractor(
        mod: types.ModuleType,
        mod_attr: str,
) -> typing.Iterator[typing.List[typing.Tuple[list, dict]]]:
    """
    Temporarily intercept a function, so it's arguments can be extracted.
    The context manager gives us a list where each item is a tuple of
    arguments & keywords, stored each time the function was called.
    """
    args_collected = []
    real_fn = getattr(mod, mod_attr)

    def wrap_fn(*args, **kw):
        args_collected.append((args, kw))
        return real_fn(*args, **kw)
    setattr(mod, mod_attr, wrap_fn)
    try:
        yield args_collected
    finally:
        setattr(mod, mod_attr, real_fn)


def round_float_32(f: float) -> float:
    from struct import pack, unpack
    return unpack("f", pack("f", f))[0]


def report_humanly_readable_difference(a: typing.Any, b: typing.Any) -> typing.Optional[str]:
    """
    Compare strings, return None whrn they match,
    otherwise a humanly readable difference message.
    """
    import unittest
    cls = unittest.TestCase()
    try:
        cls.assertEqual(a, b)
    except AssertionError as ex:
        return str(ex)
    return None


# -----------------------------------------------------------------------------
# Keymap Utilities.

def keyconfig_preset_scan() -> typing.List[str]:
    """
    Return all bundled presets (keymaps), not user presets.
    """
    import os
    from bpy import context
    # This assumes running with `--factory-settings`.
    default_keyconfig = context.window_manager.keyconfigs.active.name
    default_preset_filepath = bpy.utils.preset_find(default_keyconfig, "keyconfig")
    dirname, filename = os.path.split(default_preset_filepath)
    return [
        os.path.join(dirname, f)
        for f in sorted(os.listdir(dirname))
        if f.lower().endswith(".py")
        if not f.startswith((".", "_"))
    ]


def keymap_item_property_clean(value: typing.Any) -> typing.Any:
    """
    Recursive property sanitize.

    - Make all floats 32bit (since internally they are).
    - Sort all properties (since the order isn't important).
    """
    if type(value) is float:
        # Once the value is loaded back from Blender, it will be 32bit.
        return round_float_32(value)
    if type(value) is list:
        return sorted(
            # Convert to `dict` to de-duplicate.
            dict([(k, keymap_item_property_clean(v)) for k, v in value]).items(),
            key=lambda item: item[0],
        )
    return value


def keymap_data_clean(keyconfig_data: typing.List, *, relaxed: bool) -> None:
    """
    Order & sanitize keymap data so the result
    from the hand written Python script is comparable with data exported & imported.
    """
    keyconfig_data.sort(key=lambda a: a[0])
    for _, _, km_items_data in keyconfig_data:
        items = km_items_data["items"]
        for i, (item_op, item_event, item_prop) in enumerate(items):
            if relaxed:
                # Prevent "alt": False from raising an error.
                defaults = {"alt": False, "ctrl": False, "shift": False, "any": False}
                defaults.update(item_event)
                item_event.update(defaults)

            if item_prop:
                properties = item_prop.get("properties")
                if properties:
                    properties[:] = keymap_item_property_clean(properties)
                else:
                    item_prop.pop("properties")

            # Needed so: `{"properties": ()}` matches `None` as there is no meaningful difference.
            # Writing `None` makes the most sense when explicitly written, however generated properties
            # might be empty and it's not worth adding checks in the generation logic to use `None`
            # just to satisfy this check.
            if not item_prop:
                items[i] = item_op, item_event, None


def keyconfig_activate_and_extract_data(filepath: str, *, relaxed: bool) -> typing.List:
    """
    Activate the key-map by filepath,
    return the key-config data (cleaned for comparison).
    """
    import bl_keymap_utils.io
    with temp_fn_argument_extractor(bl_keymap_utils.io, "keyconfig_init_from_data") as args_collected:
        bpy.ops.preferences.keyconfig_activate(filepath=filepath)
        # If called multiple times, something strange is happening.
        assert(len(args_collected) == 1)
        args, _kw = args_collected[0]
        keyconfig_data = args[1]
        keymap_data_clean(keyconfig_data, relaxed=relaxed)
        return keyconfig_data


def main() -> None:
    import os
    import sys
    import pprint
    import tempfile

    argv = (sys.argv[sys.argv.index("--") + 1:] if "--" in sys.argv else [])

    # Use `argparse` for full arg parsing, for now this is enough.
    relaxed = "--relaxed" not in argv

    has_error = False

    presets = keyconfig_preset_scan()
    for filepath in presets:
        name_only = os.path.splitext(os.path.basename(filepath))[0]

        print("KeyMap Validate:", name_only, end=" ... ")

        data_orig = keyconfig_activate_and_extract_data(filepath, relaxed=relaxed)

        with tempfile.TemporaryDirectory() as dir_temp:
            filepath_temp = os.path.join(dir_temp, name_only + ".test.py")
            bpy.ops.preferences.keyconfig_export(filepath=filepath_temp, all=True)
            data_reimport = keyconfig_activate_and_extract_data(filepath_temp, relaxed=relaxed)

        # Comparing a pretty printed string tends to give more useful
        # text output compared to the data-structure. Both will work.
        if (cmp_message := report_humanly_readable_difference(
                pprint.pformat(data_orig, indent=0, width=120),
                pprint.pformat(data_reimport, indent=0, width=120),
        )):
            print("FAILED!")
            sys.stdout.write((
                "Keymap %s has inconsistency on re-importing:\n"
                "  %r"
            ) % (filepath, cmp_message))
            has_error = True
        else:
            print("OK!")

        if WRITE_OUTPUT_DIR:
            name_only_temp = os.path.join(WRITE_OUTPUT_DIR, name_only)
            print("Writing data to:", name_only_temp + ".*.py")
            with open(name_only_temp + ".orig.py", 'w') as fh:
                fh.write(pprint.pformat(data_orig, indent=0, width=120))
            with open(name_only_temp + ".rewrite.py", 'w') as fh:
                fh.write(pprint.pformat(data_reimport, indent=0, width=120))
    if has_error:
        sys.exit(1)


if __name__ == "__main__":
    main()