def test_no_evaluate_kwargs_mismatch():
# noinspection PyUnusedLocal
def f(x):
assert False # pragma: no cover
assert evaluate(f) is f
assert evaluate(f, y=1) is f
def test_non_strict_evaluate():
def foo(bar):
return bar
assert evaluate(foo, bar=True) is True # first the evaluated case
assert evaluate(
foo, quuz=True
) is foo # now we missed the signature, so we get the function unevaluated back
def test_evaluate_on_methods():
class Foo:
# noinspection PyMethodMayBeStatic
def bar(self, x):
return x
@staticmethod
def baz(x):
return x
assert evaluate(Foo().bar, x=17) == 17
assert evaluate(Foo().baz, x=17) == 17
f = Foo().bar
assert evaluate(f, y=17) is f
def member_from_model(cls, model, factory_lookup, defaults_factory, factory_lookup_register_function=None, model_field_name=None, model_field=None, **kwargs):
if model_field is None:
assert model_field_name is not None, "Field can't be automatically created from model, you must specify it manually"
sub_field_name, _, field_path_rest = model_field_name.partition('__')
# noinspection PyProtectedMember
model_field = get_field(model, sub_field_name)
if field_path_rest:
result = member_from_model(
cls=cls,
model=model_field.remote_field.model,
factory_lookup=factory_lookup,
defaults_factory=defaults_factory,
factory_lookup_register_function=factory_lookup_register_function,
model_field_name=field_path_rest,
**kwargs)
set_and_remember_for_reinvoke(result, attr=model_field_name)
return result
factory = factory_lookup.get(type(model_field), MISSING)
if factory is MISSING:
for django_field_type, foo in reversed(list(factory_lookup.items())):
if isinstance(model_field, django_field_type):
factory = foo
break # pragma: no mutate optimization
if factory is MISSING:
message = f'No factory for {type(model_field).__name__}.'
if factory_lookup_register_function is not None:
message += ' Register a factory with register_factory or %s, you can also register one that returns None to not handle this field type' % factory_lookup_register_function.__name__
raise AssertionError(message)
if factory is None:
return None
# Not strict evaluate on purpose
factory = evaluate(factory, __match_empty=False, model_field=model_field, model_field_name=model_field_name)
setdefaults_path(
kwargs,
_name=model_field_name,
call_target__cls=cls,
)
defaults = defaults_factory(model_field)
if isinstance(factory, Namespace):
factory = setdefaults_path(
Namespace(),
factory,
defaults,
)
else:
kwargs.update(**defaults)
return factory(model_field=model_field, model_field_name=model_field_name, model=model, **kwargs)
def on_bind(self) -> None:
if self.attr is MISSING:
self.attr = self._name
# Not strict evaluate on purpose
self.model = evaluate(self.model, **self.iommi_evaluate_parameters())
if self.model and self.include and self.attr:
try:
self.search_fields = get_search_fields(model=self.model)
except NoRegisteredSearchFieldException:
self.search_fields = ['pk']
def on_bind(self) -> None:
if self.attr is MISSING:
self.attr = self._name
# Not strict evaluate on purpose
self.model = evaluate(self.model, **self.iommi_evaluate_parameters())
if self.model and self.include:
try:
self.search_fields = get_search_fields(model=self.model)
except NoRegisteredSearchFieldException:
self.search_fields = ['pk']
if iommi_debug_on():
print(f'Warning: falling back to primary key as lookup and sorting on {self._name}. \nTo get rid of this warning and get a nicer lookup and sorting use register_search_fields.')
def on_bind(self) -> None:
assert self.template
form = self.iommi_parent().iommi_parent()
if self.attr is MISSING:
self.attr = self._name
if self.display_name is MISSING:
self.display_name = capitalize(self._name).replace('_', ' ') if self._name else ''
self.errors = Errors(parent=self, **self.errors)
if form.editable is False:
self.editable = False
# Not strict evaluate on purpose
self.model = evaluate(self.model, **self.iommi_evaluate_parameters())
self.choices = evaluate_strict(self.choices, **self.iommi_evaluate_parameters())
self.initial = evaluate_strict(self.initial, **self.iommi_evaluate_parameters())
self._read_initial()
self._read_raw_data()
self.parsed_data = evaluate_strict(self.parsed_data, **self.iommi_evaluate_parameters())
self._parse()
self._validate()
self.input = self.input.bind(parent=self)
self.label = self.label.bind(parent=self)
assert not self.label.children
self.label.children = dict(text=evaluate_strict(self.display_name, **self.iommi_evaluate_parameters()))
self.non_editable_input = self.non_editable_input.bind(parent=self)
if self.model and self.include:
try:
self.search_fields = get_search_fields(model=self.model)
except NoRegisteredSearchFieldException:
self.search_fields = ['pk']
if iommi_debug_on():
print(f'Warning: falling back to primary key as lookup and sorting on {self._name}. \nTo get rid of this warning and get a nicer lookup and sorting use register_search_fields.')
def test_evaluate_no_explicit_parameters():
def f(**_):
return 17
assert evaluate(f, y=42) == 17
def test_evaluate_subset_parameters():
def f(x, **_):
return x
assert evaluate(f, x=17, y=42) == 17
def test_match_empty():
f = lambda **_: 17
assert evaluate(f, x=1, __match_empty=False) is f
assert evaluate(f, x=1, __match_empty=True) == 17
def test_evaluate_extra_kwargs_with_defaults():
# noinspection PyUnusedLocal
def f(x, y=17):
return x
assert evaluate(f, x=17) == 17
def test_no_evaluate_kwargs_mismatch():
def f(x):
return x * 2
assert evaluate(f) is f
assert evaluate(f, y=1) is f
