def test_sort_after_points_to_nothing(): with pytest.raises(KeyError) as e: sort_after([ Struct(name='quux'), Struct(name='foo'), Struct(name='quux6', after='does-not-exist'), ]) assert "'Tried to order after does-not-exist but that key does not exist'" == str(e.value)
def test_sort_after_points_to_nothing_plural(): with pytest.raises(KeyError) as e: sort_after([ Struct(name='quux'), Struct(name='foo', after='does-not-exist2'), Struct(name='quux6', after='does-not-exist'), ]) assert "'Tried to order after does-not-exist, does-not-exist2 but those keys do not exist'" == str(e.value)
def test_sort_after_points_to_nothing_plural(): with pytest.raises(KeyError) as e: sort_after([ Struct(name='quux'), Struct(name='foo', after='does-not-exist2'), Struct(name='quux6', after='does-not-exist'), ]) assert "'Tried to order after does-not-exist, does-not-exist2 but those keys do not exist'" == str( e.value).replace("u'", "'")
def test_sort_after_points_to_nothing(): objects = [ Struct(name='quux'), Struct(name='foo'), Struct(name='quux6', after='does-not-exist'), ] with pytest.raises(KeyError) as e: sort_after(objects) assert e.value.message == 'Tried to order after does-not-exist but that key does not exist'
def __init__(self, request=None, variables=None, variables_dict=None, endpoint_dispatch_prefix='query', **kwargs): # variables=None to make pycharm tooling not confused """ :type variables: list of Variable :type request: django.http.request.HttpRequest """ self.endpoint_dispatch_prefix = endpoint_dispatch_prefix self.request = request self._form = None def generate_variables(): if variables is not None: for variable in variables: yield variable for name, variable in variables_dict.items(): dict.__setitem__(variable, 'name', name) yield variable self.variables = sort_after(list(generate_variables())) def generate_bound_variables(): for x in self.variables: yield BoundVariable(**merged( Struct(x), query=self, attr=x.attr if x.attr is not MISSING else x.name )) bound_variables = list(generate_bound_variables()) bound_variables = [evaluate_recursive(x, query=self, variable=x) for x in bound_variables] self.bound_variables = filter_show_recursive(bound_variables) self.bound_variable_by_name = {variable.name: variable for variable in self.bound_variables} self.gui_kwargs = extract_subkeys(kwargs, 'gui')
def sorts_right(objects): expected_order = sorted(objects, key=lambda x: x.expected_position) assert [y.expected_position for y in expected_order ] == list(range(len(objects))), "Borken test" sorted_objects = sort_after(objects) assert list(range(len(objects))) == [ x.expected_position for x in sorted_objects ], [x.name for x in objects]
def __init__(self, request=None, data=None, instance=None, fields=None, model=None, post_validation=None): """ :type fields: list of Field :type data: dict[basestring, basestring] :type model: django.db.models.Model """ self.request = request if data is None and request: data = request.POST if request.method == 'POST' else request.GET if isinstance(fields, dict): # Declarative case fields = [merged(field, dict(name=name)) for name, field in fields.items()] self.fields = sort_after([BoundField(field, self) for field in fields]) if instance is not None: for field in self.fields: if field.attr: initial = getattr_path(instance, field.attr) if field.is_list: field.initial_list = initial else: field.initial = initial if data: for field in self.fields: if field.is_list: try: # noinspection PyUnresolvedReferences raw_data_list = data.getlist(field.name) except AttributeError: # pragma: no cover raw_data_list = data.get(field.name) if raw_data_list and field.strip_input: raw_data_list = [x.strip() for x in raw_data_list] if raw_data_list is not None: field.raw_data_list = raw_data_list else: field.raw_data = data.get(field.name) if field.raw_data and field.strip_input: field.raw_data = field.raw_data.strip() if post_validation is not None: self.post_validation = post_validation self.fields_by_name = {field.name: field for field in self.fields} self.style = None self.model = model self._valid = None self.errors = [] self.should_parse = bool(data) self.evaluate() self.is_valid()
def __init__(self, request=None, data=None, instance=None, fields=None, model=None, post_validation=None, fields_dict=None, endpoint_dispatch_prefix='form', is_full_form=True): """ :type fields: list of Field :type data: dict[basestring, basestring] :type model: django.db.models.Model """ self.endpoint_dispatch_prefix = endpoint_dispatch_prefix self.is_full_form = is_full_form self.request = request if data is None and request: data = request.POST if request.method == 'POST' else request.GET if data is None: data = {} def unbound_fields(): if fields is not None: for field in fields: yield field for name, field in fields_dict.items(): dict.__setitem__(field, 'name', name) yield field self.fields = sort_after([BoundField(f, self) for f in unbound_fields()]) """ :type: list of BoundField""" if instance is not None: for field in self.fields: if field.attr: initial = field.read_from_instance(field, instance) if field.is_list: field.initial_list = initial else: field.initial = initial self.instance = instance else: self.instance = None self.mode = FULL_FORM_FROM_REQUEST if '-' in data else INITIALS_FROM_GET if self.mode == INITIALS_FROM_GET and request: assert request.method == 'GET', 'Seems to be a POST but parameter "-" is not present' if data: for field in self.fields: if field.is_list: try: # django and similar # noinspection PyUnresolvedReferences raw_data_list = data.getlist(field.name) except AttributeError: # pragma: no cover # werkzeug and similar raw_data_list = data.get(field.name) if raw_data_list and field.strip_input: raw_data_list = [x.strip() for x in raw_data_list] if raw_data_list is not None: field.raw_data_list = raw_data_list else: field.raw_data = data.get(field.name) if field.raw_data and field.strip_input: field.raw_data = field.raw_data.strip() self.post_validation = post_validation if post_validation is not None else lambda form: None self.fields_by_name = None """ :type: dict[str, BoundField] """ self.style = None self.model = model """ :type model: django.db.models.Model """ self._valid = None self.errors = set() self.evaluate() self.is_valid() """ :type: list of str """
def __init__( self, data=None, request=None, columns=None, columns_dict=None, model=None, filter=None, bulk_exclude=None, sortable=None, links=None, column=None, bulk=None, header=None, bulk_filter=None, endpoint=None, attrs=None, query=None, endpoint_dispatch_prefix=None, row=None, instance=None, extra=None, ): """ :param data: a list or QuerySet of objects :param columns: (use this only when not using the declarative style) a list of Column objects :param attrs: dict of strings to string/callable of HTML attributes to apply to the table :param row__attrs: dict of strings to string/callable of HTML attributes to apply to the row. Callables are passed the row as argument. :param row__template: name of template to use for rendering the row :param bulk_filter: filters to apply to the QuerySet before performing the bulk operation :param bulk_exclude: exclude filters to apply to the QuerySet before performing the bulk operation :param sortable: set this to false to turn off sorting for all columns """ if data is None: # pragma: no cover warnings.warn("deriving model from data queryset is deprecated, use Table.from_model", DeprecationWarning) assert model is not None data = model.objects.all() if isinstance(data, QuerySet): model = data.model def generate_columns(): for column_ in columns if columns is not None else []: yield column_ for name, column_ in columns_dict.items(): dict.__setitem__(column_, "name", name) yield column_ columns = sort_after(list(generate_columns())) assert ( len(columns) > 0 ), "columns must be specified. It is only set to None to make linting tools not give false positives on the declarative style" self.data = data self.request = request self.columns = columns """ :type : list of Column """ self.model = model self.instance = instance self.filter = TemplateConfig(**filter) self.links = TemplateConfig(**links) self.header = TemplateConfig(**header) self.row = RowConfig(**row) self.bulk_exclude = bulk_exclude self.sortable = sortable self.column = column self.bulk = bulk self.bulk_filter = bulk_filter self.endpoint = endpoint self.endpoint_dispatch_prefix = endpoint_dispatch_prefix self.attrs = attrs self.query_args = query self.query = None """ :type : tri.query.Query """ self.query_form = None """ :type : tri.form.Form """ self.query_error = None """ :type : list of str """ self.bulk_form = None """ :type : tri.form.Form """ self.bound_columns = None """ :type : list of BoundColumn """ self.shown_bound_columns = None """ :type : list of BoundColumn """ self.bound_column_by_name = None """ :type: dict[str, BoundColumn] """ self._has_prepared = False """ :type: bool """ self.header_levels = None self.extra = extra """ :type: tri.declarative.Namespace """
def test_order_after(): objects = [ # header1 Struct(name='quux', expected_position=2), Struct(name='foo', expected_position=3), # header2 Struct(name='bar', expected_position=6), Struct(name='asd', expected_position=7), Struct(name='header1', after=0, expected_position=0), Struct(name='header1b', after=0, expected_position=1), Struct(name='header2', after='foo', expected_position=4), Struct(name='header2.b', after='foo', expected_position=5), Struct(name='header3', after='quux2', expected_position=9), Struct(name='quux2', expected_position=8), # header3 Struct(name='quux3', expected_position=10), Struct(name='quux4', expected_position=11), Struct(name='quux5', after=LAST, expected_position=12), Struct(name='quux6', after=LAST, expected_position=13), ] expected_order = sorted(objects, key=lambda x: x.expected_position) assert list(range(len(objects))) == [y.expected_position for y in expected_order], 'check expected_order' assert [x.expected_position for x in expected_order] == [x.expected_position for x in sort_after(objects)]
def test_sort_after_chaining(): objects = [ Struct(name='foo', after='bar'), Struct(name='bar', after=0), ] assert ['bar', 'foo'] == [x.name for x in sort_after(objects)]
def __init__(self, request=None, data=None, instance=None, fields=None, model=None, post_validation=None, fields_dict=None, endpoint_dispatch_prefix='form'): """ :type fields: list of Field :type data: dict[basestring, basestring] :type model: django.db.models.Model """ self.endpoint_dispatch_prefix = endpoint_dispatch_prefix self.request = request if data is None and request: data = request.POST if request.method == 'POST' else request.GET if data is None: data = {} def unbound_fields(): if fields is not None: for field in fields: yield field for name, field in fields_dict.items(): dict.__setitem__(field, 'name', name) yield field self.fields = sort_after([BoundField(f, self) for f in unbound_fields()]) """ :type: list of BoundField""" if instance is not None: for field in self.fields: if field.attr: initial = field.read_from_instance(field, instance) if field.is_list: field.initial_list = initial else: field.initial = initial self.instance = instance else: self.instance = None self.mode = FULL_FORM_FROM_REQUEST if '-' in data else INITIALS_FROM_GET if self.mode == INITIALS_FROM_GET and request: assert request.method == 'GET', 'Seems to be a POST but parameter "-" is not present' if data: for field in self.fields: if field.is_list: try: # django and similar # noinspection PyUnresolvedReferences raw_data_list = data.getlist(field.name) except AttributeError: # pragma: no cover # werkzeug and similar raw_data_list = data.get(field.name) if raw_data_list and field.strip_input: raw_data_list = [x.strip() for x in raw_data_list] if raw_data_list is not None: field.raw_data_list = raw_data_list else: field.raw_data = data.get(field.name) if field.raw_data and field.strip_input: field.raw_data = field.raw_data.strip() self.post_validation = post_validation if post_validation is not None else lambda form: None self.fields_by_name = None """ :type: dict[str, BoundField] """ self.style = None self.model = model """ :type model: django.db.models.Model """ self._valid = None self.errors = set() self.evaluate() self.is_valid() """ :type: list of str """
def __init__(self, data=None, request=None, columns=None, columns_dict=None, **kwargs): """ :param data: a list of QuerySet of objects :param columns: (use this only when not using the declarative style) a list of Column objects :param attrs: dict of strings to string/callable of HTML attributes to apply to the table :param row__attrs: dict of strings to string/callable of HTML attributes to apply to the row. Callables are passed the row as argument. :param row__template: name of template to use for rendering the row :param bulk_filter: filters to apply to the QuerySet before performing the bulk operation :param bulk_exclude: exclude filters to apply to the QuerySet before performing the bulk operation :param sortable: set this to false to turn off sorting for all columns :param filter__template: :param header__template: :param links__template: """ self._has_prepared = False if data is None: assert 'model' in kwargs and kwargs['model'] is not None data = kwargs['model'].objects.all() self.data = data self.request = request if isinstance(self.data, QuerySet): kwargs['model'] = data.model def generate_columns(): for column in columns if columns is not None else []: yield column for name, column in columns_dict.items(): dict.__setitem__(column, 'name', name) yield column self.columns = sort_after(list(generate_columns())) """:type : list of Column""" assert len( self.columns ) > 0, 'columns must be specified. It is only set to None to make linting tools not give false positives on the declarative style' self.bound_columns = None self.shown_bound_columns = None self.bound_column_by_name = None self.Meta = self.get_meta() self.Meta.update(**kwargs) self.header_levels = None self.query = None self.query_form = None self.query_error = None self.bulk_form = None self.query_kwargs = extract_subkeys(kwargs, 'query') self.bulk_kwargs = extract_subkeys(kwargs, 'bulk') self.endpoint = extract_subkeys(kwargs, 'endpoint')