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