def test_evaluate_strict(): with pytest.raises(AssertionError) as e: evaluate_strict(lambda foo: 1, bar=2, baz=4) assert str( e.value ) == "Evaluating lambda found at: `evaluate_strict(lambda foo: 1, bar=2, baz=4)` didn't resolve it into a value but strict mode was active, the signature doesn't match the given parameters. We had these arguments: bar, baz"
def evaluate_attrs(obj, **kwargs): attrs = obj.attrs or {} # Micro optimization from iommi.debug import iommi_debug_on if not attrs and not iommi_debug_on(): return '' return Attrs( obj, **{ 'class': { k: evaluate_strict(v, **kwargs) for k, v in items( evaluate_strict(attrs.get('class', {}), **kwargs)) } }, style={ k: evaluate_strict(v, **kwargs) for k, v in items(evaluate_strict(attrs.get('style', {}), ** kwargs)) }, **{ k: evaluate_strict(v, **kwargs) for k, v in items(attrs) if k not in ('class', 'style') }, )
def _read_raw_data(self): if self.raw_data is not None: self.raw_data = evaluate_strict(self.raw_data, **self.iommi_evaluate_parameters()) return if self.raw_data_list is not None: self.raw_data_list = evaluate_strict(self.raw_data_list, **self.iommi_evaluate_parameters()) return form = self.iommi_parent().iommi_parent() if self.is_list: if self.raw_data_list is not None: return try: # django and similar # noinspection PyUnresolvedReferences raw_data_list = form._request_data.getlist(self.iommi_path) except AttributeError: # pragma: no cover # werkzeug and similar raw_data_list = form._request_data.get(self.iommi_path) if raw_data_list and self.strip_input: raw_data_list = [x.strip() for x in raw_data_list] if raw_data_list is not None: self.raw_data_list = raw_data_list else: if self.raw_data is not None: return self.raw_data = form._request_data.get(self.iommi_path) if self.raw_data and self.strip_input: self.raw_data = self.raw_data.strip()
def on_bind(self) -> None: assert self.actions_template self._valid = None request = self.get_request() self._request_data = request_data(request) self.title = evaluate_strict(self.title, **self.iommi_evaluate_parameters()) if isinstance(self.h_tag, Namespace): if self.title not in (None, MISSING): self.h_tag = self.h_tag( _name='h_tag', children__text=capitalize(self.title), ).bind(parent=self) else: self.h_tag = '' else: self.h_tag = self.h_tag.bind(parent=self) # Actions have to be bound first because is_target() needs it bind_members(self, name='actions', cls=Actions) if self._request_data is not None and self.is_target(): self.mode = FULL_FORM_FROM_REQUEST bind_members(self, name='fields') bind_members(self, name='endpoints') self.is_valid() self.errors = Errors(parent=self, errors=self.errors)
def bind(self, *, parent=None, request=None): assert parent is None or parent._is_bound assert not self._is_bound result = copy.copy(self) if parent: is_root = False iommi_style = get_iommi_style_name(parent) else: is_root = True iommi_style = get_iommi_style_name(self) result = apply_style(iommi_style, result, is_root) result._declared = self del self # to prevent mistakes when changing the code below if parent is None: result._request = request if result._name is None: result._name = 'root' result._iommi_collected_assets = {} result._parent = parent result._bound_members = Struct() result._is_bound = True evaluate_parameters = { **(parent.iommi_evaluate_parameters() if parent is not None else {}), **result.own_evaluate_parameters(), 'traversable': result, } if parent is None: evaluate_parameters['request'] = request result._evaluate_parameters = evaluate_parameters if hasattr(result, 'include'): include = evaluate_strict(result.include, **evaluate_parameters) if not bool(include): return None result.include = True result.on_bind() # on_bind has a chance to hide itself if result.include is False: return None if hasattr(result, 'attrs'): result.attrs = evaluate_attrs(result, **result.iommi_evaluate_parameters()) evaluated_attributes = [k for k, v in items(result.get_declared('refinable_members')) if is_evaluated_refinable(v)] evaluate_members(result, evaluated_attributes, **evaluate_parameters) if hasattr(result, 'extra_evaluated'): result.extra_evaluated = evaluate_strict_container(result.extra_evaluated or {}, **evaluate_parameters) return result
def on_bind(self): super(MenuItem, self).on_bind() self.url = evaluate_strict(self.url, **self.iommi_evaluate_parameters()) # If this is a section header, and all sub-parts are hidden, hide myself if not self.url and self.sub_menu is not None and not self.sub_menu: self.include = False
def evaluate_attrs(obj, **kwargs): attrs = obj.attrs or {} # Micro optimization from iommi.debug import iommi_debug_on if not attrs and not iommi_debug_on(): return '' classes = evaluate_strict(attrs.get('class', {}), **kwargs) assert not isinstance( classes, str ), """CSS classes needs to be specified as dicts, not as strings. So you want something like: field__class__foo=True or field__class={'foo-bar': true}""" styles = evaluate_strict(attrs.get('style', {}), **kwargs) assert not isinstance( styles, str ), """CSS styles needs to be specified as dicts, not as strings. So you want something like: field__style__display='none' or field__style={'background-color': 'blue'}""" return Attrs( obj, **{ 'class': {k: evaluate_strict(v, **kwargs) for k, v in items(classes)} }, style={k: evaluate_strict(v, **kwargs) for k, v in items(styles)}, **{ k: evaluate_strict(v, **kwargs) for k, v in items(attrs) if k not in ('class', 'style') }, )
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 build_and_bind_h_tag(p): if isinstance(p.h_tag, Namespace): if p.title not in (None, MISSING): p.h_tag = p.h_tag( _name='h_tag', children__text=capitalize( evaluate_strict( p.title, **p.iommi_evaluate_parameters()))).bind(parent=p) else: p.h_tag = '' else: p.h_tag = p.h_tag.bind(parent=p)
def bind(self, *, parent=None, request=None): assert parent is None or parent._is_bound assert not self._is_bound if parent is None: self._request = request if self._name is None: self._name = 'root' result = copy.copy(self) result._declared = self del self # to prevent mistakes when changing the code below result._parent = parent result._is_bound = True evaluate_parameters = { 'traversable': result, **(parent.iommi_evaluate_parameters() if parent is not None else {}), **result.own_evaluate_parameters(), } if parent is None: evaluate_parameters['request'] = request result._evaluate_parameters = evaluate_parameters if hasattr(result, 'include'): include = evaluate_strict(result.include, **evaluate_parameters) if not bool(include): return None else: include = MISSING if include is not MISSING: result.include = True rest_of_style = apply_style(result) # Styling has another chance of setting include to False if include is not MISSING and result.include is False: return None result.include = True result.on_bind() if rest_of_style: rest = apply_style_recursively(style_data=rest_of_style, obj=result) assert not rest, f'There is still styling data left for {result}: {rest_of_style}' # on_bind has a chance to hide itself if result.include is False: return None if hasattr(result, 'attrs'): result.attrs = evaluate_attrs(result, **result.iommi_evaluate_parameters()) evaluated_attributes = [ k for k, v in items(result.get_declared('refinable_members')) if is_evaluated_refinable(v) ] evaluate_members(result, evaluated_attributes, **evaluate_parameters) if hasattr(result, 'extra_evaluated'): result.extra_evaluated = evaluate_strict_container( result.extra_evaluated or {}, **evaluate_parameters) return result