qmk find: Fix handling of functions in filters

[sigprof]

Description

Functions in filters did not work properly except when used in the last (or only) filter. The problem was caused by the peculiarity of the lambda behavior in Python — any variables from the outer scope are captured only by reference, therefore any subsequent reassignment of those variables is propagated to all lambdas created earlier in the same scope. Together with the laziness of filter() (it returns an iterator which performs filtering on demand) this resulted in all function filters using the values of the key and value variables which correspond to the last filter in the sequence, therefore the result of filtering was wrong if some filter with a function was not the last one in the sequence.

Apparently the shortest way to make a Python lambda capture some variables by value is to add arguments with default values for such variables (default values are evaluated when the lambda is created, and any subsequent reassignments in the outer scope no longer changes them). This makes filters with functions work properly even when such filters are not at the last position in the sequence.

---

An alternate solution is to wrap all filter() calls with list() to force immediate evaluation — in that case the fact that lambda captures variables from the outer scope by reference does not matter, because the lambda is invoked only while those variables still have the expected values. However, in this case the actual problem (the need to capture values instead of references) is not immediately obvious from the code.

Types of Changes

• Core
• Bugfix
• New feature
• Enhancement/optimization
• Keyboard (addition or update)
• Keymap/layout/userspace (addition or update)
• Documentation

Issues Fixed or Closed by This PR

These commands gave different results (the first one correctly printed some keyboard names matching the specified filters, while the second one, which differs only in the order of -f options, did not print anything):

qmk find -f 'split.enabled=true' -f 'features.rgblight=true' -f 'absent(rgblight.split_count)'
qmk find -f 'absent(rgblight.split_count)' -f 'split.enabled=true' -f 'features.rgblight=true'

With the change in this PR both commands give the same result.

Checklist

• My code follows the code style of this project: C, Python
• I have read the PR Checklist document and have made the appropriate changes.
• My change requires a change to the documentation.
• I have updated the documentation accordingly.
• I have read the CONTRIBUTING document.
• I have added tests to cover my changes.
• I have tested the changes and verified that they work and don't break anything (as well as I can manage).

[elpekenin]

Could be benefitial moving away from if/else into a name: lamba mapping, and perhaps use functools.partial for the "capturing"(maybe there are some optimizations on it?) My proposal would be something like (not tested yet)

FUNCTIONS = {
    'length': lambda e, k, v: k in e[2] and len(e[2].get(k)) == int(v),
    'contains': lambda e, k, v: k in e[2] and v in e[2].get(k),
    'exists': lambda e, k, v: k in e[2],
    'absent': lambda e, k, v: k not in e[2],
}

...

                if function_match is not None:
                    func_name = function_match.group('function').lower()
                    key = function_match.group('key')
                    value = function_match.group('value')

                    filter_fn = FUNCTIONS.get(func_name)
                    if filter_fn is None:
                        cli.log.warning(f'Unrecognized filter expression: {function_match.group(0)}')
                        continue

                    valid_keymaps = filter(partial(filter_fn, k=key, v=value), valid_keymaps)

                    cli.log.info(f'Filtering on condition: {{fg_green}}{func_name}{{fg_reset}}({{fg_cyan}}{key}{{fg_reset}}, {{fg_cyan}}{value}{{fg_reset}})...')

                elif equals_match is not None:

[zvecr]

Merging as is as its fairly isolated small fixes. Any re-writing of functionallity would have to go to develop.