def test_freeze():
collection = {
'1': 1,
'list': [2, 3, 4],
'tuple': (5, 6),
'set': {7, 8},
'dict': {
'7': 9,
'8': (10, 11),
},
(1, 2): 'an iterable key',
frozendict(some='value'): 'a structured key',
}
assert freeze(collection) == frozendict({
'1':
1,
'list': (2, 3, 4),
'tuple': (5, 6),
'set':
frozenset({8, 7}),
'dict':
frozendict({
'7': 9,
'8': (10, 11)
}),
(1, 2):
'an iterable key',
frozendict({'some': 'value'}):
'a structured key'
})
def any(self, cond):
# type: (Union[Predicate, Iterable]) -> Predicate
"""
Checks if a condition is met by any element in a list,
where a condition can also be a sequence (e.g. list).
>>> var('f1').any(var('f2').exists())
Matches::
{'f1': [{'f2': 1}, {'f2': 0}]}
>>> var('f1').any([1, 2, 3])
# Match f1 that contains any element from [1, 2, 3]
Matches::
{'f1': [1, 2]}
{'f1': [3, 4, 5]}
:param cond: Either a Predicate that at least one element has to match
or a list of which at least one element has to be contained
in the tested element.
- """
if callable(cond):
def _cmp(value):
return is_iterable(value) and any(cond(e) for e in value)
else:
def _cmp(value):
return is_iterable(value) and any(e in cond for e in value)
return self._build_predicate(lambda lhs, value: _cmp(lhs),
Operation.ANY, (self._path, freeze(cond)))
def all(self, cond: t.Union[Predicate, t.Iterable]) -> Predicate:
"""
Checks if a condition is met by any element in a list,
where a condition can also be a sequence (e.g. list).
>>> var('f1').all(var('f2').exists())
Matches::
{'f1': [{'f2': 1}, {'f2': 1}]}
>>> var('f1').all([1, 2, 3])
# Match f1 that contains any element from [1, 2, 3]
Matches::
{'f1': [1, 2, 3, 4, 5]}
:param cond: Either a Predicate that all elements have to match or
a list which has to be contained in the tested element.
"""
if callable(cond):
def _cmp(value):
return is_iterable(value) and all(cond(e) for e in value)
else:
def _cmp(value):
return is_iterable(value) and all(e in value for e in cond)
return self._build_predicate(
lambda lhs, value: _cmp(lhs),
Operation.ALL,
(self._path, freeze(cond))
)
def test_freeze():
collection = {
"1": 1,
"list": [2, 3, 4],
"tuple": (5, 6),
"set": {7, 8},
"dict": {
"7": 9,
"8": (10, 11),
},
(1, 2): "an iterable key",
frozendict(some="value"): "a structured key",
}
assert freeze(collection) == frozendict({
"1":
1,
"list": (2, 3, 4),
"tuple": (5, 6),
"set":
frozenset({8, 7}),
"dict":
frozendict({
"7": 9,
"8": (10, 11)
}),
(1, 2):
"an iterable key",
frozendict({"some": "value"}):
"a structured key",
})
def all(self, cond: t.Union[Predicate, t.Iterable]) -> Predicate:
"""
Checks if a condition is met by any element in a list,
where a condition can also be a sequence (e.g. list).
>>> var('f1').all(var('f2').exists())
Matches::
{'f1': [{'f2': 1}, {'f2': 1}]}
>>> var('f1').all([1, 2, 3])
# Match f1 that contains any element from [1, 2, 3]
Matches::
{'f1': [1, 2, 3, 4, 5]}
:param cond: Either a Predicate that all elements have to match or
a list which has to be contained in the tested element.
"""
if callable(cond):
def _cmp(value):
return is_iterable(value) and all(cond(e) for e in value)
else:
def _cmp(value):
return is_iterable(value) and all(e in value for e in cond)
return self._build_predicate(lambda lhs, value: _cmp(lhs),
Operation.ALL, (self._path, freeze(cond)))
def __set__(self, instance: Owner, value: Value) -> None:
try:
old_value = instance.__dict__[self._value_key]
except KeyError:
instance.__dict__[self._value_key] = freeze(value)
else:
if value != old_value:
__not_supported__(self.name, instance)
def __eq__(self, rhs: t.Any) -> Predicate:
"""
Test the value for equality.
>>> var('f1') == 42
:param rhs: The value to compare against. It can either be a plain
value or a Var instance which points to another field on the value
that will be used during evaluation.
:returns: A predicate of this comparison.
"""
rhs_curried = _curry_rhs(rhs)
return self._build_predicate(
lambda lhs, value: lhs == rhs_curried(value), Operation.EQ,
(self._path, freeze(rhs)))
def __eq__(self, rhs: t.Any) -> Predicate:
"""
Test the value for equality.
>>> var('f1') == 42
:param rhs: The value to compare against. It can either be a plain
value or a Var instance which points to another field on the value
that will be used during evaluation.
:returns: A predicate of this comparison.
"""
rhs_curried = _curry_rhs(rhs)
return self._build_predicate(
lambda lhs, value: lhs == rhs_curried(value),
Operation.EQ,
(self._path, freeze(rhs))
)
def test(self, func: t.Callable[..., bool], *args, **kwargs) -> Predicate:
"""
Run a user-defined test function against the value.
>>> def test_func(val):
... return val == 42
...
>>> var('f1').test(test_func)
:param func: The function to call, passing the dict as the first
argument
:param args:
:param kwargs:
Additional arguments to pass to the test function
"""
return self._build_predicate(
lambda lhs, value: func(lhs, *args, **kwargs), Operation.TEST,
(self._path, func, args, freeze(kwargs)))
class ValueClass:
set = set()
list = []
dict = {}
inner = freeze(Bunch(key=Bunch(inner_key="value")))
not_set: set
@property
def property_simple_value(self):
return []
@property
def property_inner_value(self):
return Bunch(key=Bunch(inner_key="value"))
def method(self, arg):
return arg
def test(self, func: t.Callable[..., bool], *args, **kwargs) -> Predicate:
"""
Run a user-defined test function against the value.
>>> def test_func(val):
... return val == 42
...
>>> var('f1').test(test_func)
:param func: The function to call, passing the dict as the first
argument
:param args:
:param kwargs:
Additional arguments to pass to the test function
"""
return self._build_predicate(
lambda lhs, value: func(lhs, *args, **kwargs),
Operation.TEST,
(self._path, func, args, freeze(kwargs))
)
def test_frozen_proxy_types():
frozen = freeze(ValueClass())
assert type(frozen) is FrozenProxy
assert type(frozen.set) is frozenset
assert type(frozen.list) is tuple
assert type(frozen.dict) is frozendict
assert type(frozen.property_simple_value) is tuple
assert type(frozen.method) is FrozenProxy
assert type(frozen.inner) is FrozenProxy
assert type(frozen.inner["key"]) is FrozenProxy
assert type(frozen.inner.key.inner_key) is str
assert type(frozen.property_inner_value) is FrozenProxy
method_result = frozen.method([1, set()])
assert method_result == (1, frozenset())
assert type(method_result) is tuple
assert type(method_result[1]) is frozenset
def test_frozen_proxy_setting_the_same_value(setter):
frozen = freeze(ValueClass())
with pytest.raises(TypeError):
setter(frozen)
def test_freeze_set_like(value, expected):
assert freeze(value) == expected
def test_freeze_sequence(value, expected):
assert freeze(value) == expected
def test_freeze_immutable(value):
assert freeze(value) is value
def test_frozen_proxy_setters_raises(setter):
frozen = freeze(ValueClass())
with pytest.raises(TypeError):
setter(frozen)
