event_match: always match on None value
PATCH 1/1 event_match: always match on None value
Before, event_match didn't always recurse if the event value was not a dictionary, and would instead check for equality immediately.
By delaying equality checking to post-recursion, we can allow leaf values like "5" to match "None" and take advantage of the generic None-returns-True clause.
This makes the matching a little more obviously consistent at the expense of being able to check for explicit None values, which is probably not that important given what this function is used for.
--- python/qemu/__init__.py | 27 +++++++++++++++------------ 1 file changed, 15 insertions(+), 12 deletions(-)
python/qemu/__init__.py +15 -12
@@ -409,27 +409,30 @@ class QEMUMachine(object): The match criteria takes the form of a matching subdict. The event is checked to be a superset of the subdict, recursively, with matching - values whenever those values are not None. + values whenever the subdict values are not None. + + This has a limitation that you cannot explicitly check for None values. Examples, with the subdict queries on the left: - None matches any object. - {"foo": None} matches {"foo": {"bar": 1}} - - {"foo": {"baz": None}} does not match {"foo": {"bar": 1}} - - {"foo": {"baz": 2}} matches {"foo": {"bar": 1, "baz": 2}} + - {"foo": None} matches {"foo": 5} + - {"foo": {"abc": None}} does not match {"foo": {"bar": 1}} + - {"foo": {"rab": 2}} matches {"foo": {"bar": 1, "rab": 2}} """ if match is None: return True - for key in match: - if key in event: - if isinstance(event[key], dict): - if not QEMUMachine.event_match(event[key], match[key]): - return False - elif event[key] != match[key]: + try: + for key in match: + if key in event: + return QEMUMachine.event_match(event[key], match[key]) + else: return False - else: - return False - return True + return True + except TypeError: + # either match or event wasn't iterable (not a dict) + return match == event def event_wait(self, name, timeout=60.0, match=None): """
Signature · 1 line
2.20.1
Quoted 41 lines · John Snow
Before,
event_matchdidn't always recurse if the event value was not a dictionary, and would instead check for equality immediately.By delaying equality checking to post-recursion, we can allow leaf values like "5" to match "None" and take advantage of the generic None-returns-True clause.
This makes the matching a little more obviously consistent at the expense of being able to check for explicit None values, which is probably not that important given what this function is used for.
Signed-off-by John Snow <[email protected]>--- python/qemu/__init__.py | 27 +++++++++++++++------------ 1 file changed, 15 insertions(+), 12 deletions(-)python/qemu/__init__.py +6
-3@@ -409,27 +409,30 @@ class QEMUMachine(object): The match criteria takes the form of a matching subdict. The event is checked to be a superset of the subdict, recursively, with matching - values whenever those values are not None. + values whenever the subdict values are not None. + + This has a limitation that you cannot explicitly check for None values. Examples, with the subdict queries on the left: - None matches any object. - {"foo": None} matches {"foo": {"bar": 1}} - - {"foo": {"baz": None}} does not match {"foo": {"bar": 1}} - - {"foo": {"baz": 2}} matches {"foo": {"bar": 1, "baz": 2}} + - {"foo": None} matches {"foo": 5} + - {"foo": {"abc": None}} does not match {"foo": {"bar": 1}} + - {"foo": {"rab": 2}} matches {"foo": {"bar": 1, "rab": 2}} """ if match is None: return True
python/qemu/__init__.py class QEMUMachine(object): · line 429
Quoted 10 lines
python/qemu/__init__.py +4
-6- for key in match: - if key in event: - if isinstance(event[key], dict): - if not QEMUMachine.event_match(event[key], match[key]): - return False - elif event[key] != match[key]: + try: + for key in match: + if key in event: + return QEMUMachine.event_match(event[key], match[key])
With this change, we only check a single key that is both in @match and @event. I think we want to keep the "if not -- return False" pattern, don’t we?
Max
Quoted 13 lines
python/qemu/__init__.py +5
-3+ else: return False - else: - return False - return True + return True + except TypeError: + # either match or event wasn't iterable (not a dict) + return match == event def event_wait(self, name, timeout=60.0, match=None): """
Quoted 57 lines · Max Reitz
Quoted 41 lines · John Snow
Before,
event_matchdidn't always recurse if the event value was not a dictionary, and would instead check for equality immediately.By delaying equality checking to post-recursion, we can allow leaf values like "5" to match "None" and take advantage of the generic None-returns-True clause.
This makes the matching a little more obviously consistent at the expense of being able to check for explicit None values, which is probably not that important given what this function is used for.
Signed-off-by John Snow <[email protected]>--- python/qemu/__init__.py | 27 +++++++++++++++------------ 1 file changed, 15 insertions(+), 12 deletions(-)python/qemu/__init__.py +6
-3@@ -409,27 +409,30 @@ class QEMUMachine(object): The match criteria takes the form of a matching subdict. The event is checked to be a superset of the subdict, recursively, with matching - values whenever those values are not None. + values whenever the subdict values are not None. + + This has a limitation that you cannot explicitly check for None values. Examples, with the subdict queries on the left: - None matches any object. - {"foo": None} matches {"foo": {"bar": 1}} - - {"foo": {"baz": None}} does not match {"foo": {"bar": 1}} - - {"foo": {"baz": 2}} matches {"foo": {"bar": 1, "baz": 2}} + - {"foo": None} matches {"foo": 5} + - {"foo": {"abc": None}} does not match {"foo": {"bar": 1}} + - {"foo": {"rab": 2}} matches {"foo": {"bar": 1, "rab": 2}} """ if match is None: return Truepython/qemu/__init__.py class QEMUMachine(object): · line 429
Quoted 10 lines
python/qemu/__init__.py +4
-6- for key in match: - if key in event: - if isinstance(event[key], dict): - if not QEMUMachine.event_match(event[key], match[key]): - return False - elif event[key] != match[key]: + try: + for key in match: + if key in event: + return QEMUMachine.event_match(event[key], match[key])With this change, we only check a single key that is both in @match and @event. I think we want to keep the "if not -- return False" pattern, don’t we?
Quoted 2 lines
Max
Whoops, way too fast on the send button. Sorry about that.