def test_no_evaluate_recursive():
def f(x):
return x * 2
subject = Struct(foo=f, bar=should_not_evaluate(f))
assert 34 == evaluate_recursive(subject, x=17).foo
assert 38 == evaluate_recursive(subject, x=17).bar(19)
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 __init__(self, table, row, **kwargs):
"""
:type table: Table
"""
self.table = table
self.row = row
super(BoundRow, self).__init__(**evaluate_recursive(kwargs, table=table, row=row))
def render_cell(self, bound_row):
assert self.show
row = bound_row.row
value = self.cell_contents(bound_row=bound_row)
table = bound_row.table
if self.cell__template:
cell_contents = render_to_string(self.cell__template, {'table': table, 'bound_column': self, 'bound_row': bound_row, 'row': bound_row.row, 'value': value})
else:
cell_contents = evaluate(self.cell__format, table=self.table, column=self, row=row, value=value)
if self.cell__url:
cell__url = self.cell__url(table=table, column=self, row=row, value=value) if callable(self.cell__url) else self.cell__url
cell__url_title = self.cell__url_title(table=table, column=self, row=row, value=value) if callable(self.cell__url_title) else self.cell__url_title
cell_contents = '<a href="{}"{}>{}</a>'.format(
cell__url,
' title=%s' % cell__url_title if cell__url_title else '',
cell_contents,
)
return '<td{attrs}>{cell_contents}</td>'.format(
attrs=render_attrs(evaluate_recursive(self.cell__attrs, table=table, column=self, row=row, value=value)),
cell_contents=cell_contents,
)
def bind_columns():
for index, column in enumerate(self.columns):
values = evaluate_recursive(Struct(column),
table=self,
column=column)
values = merged(values, column=column, table=self, index=index)
yield BoundColumn(**values)
def _prepare_evaluate_members(self):
self.shown_bound_columns = [
bound_column for bound_column in self.bound_columns
if bound_column.show
]
self.Meta = evaluate_recursive(self.Meta, table=self)
if 'class' in self.Meta.attrs and isinstance(self.Meta.attrs['class'],
string_types):
self.Meta.attrs['class'] = {
k: True
for k in self.Meta.attrs['class'].split(' ')
}
else:
self.Meta.attrs['class'] = {}
self.Meta.attrs.update(extract_subkeys(self.Meta, 'attrs'))
self.Meta.attrs = collect_namespaces(self.Meta.attrs)
if 'class' in self.Meta.row__attrs and isinstance(
self.Meta.row__attrs['class'], string_types):
self.Meta.row__attrs['class'] = {
k: True
for k in self.Meta.row__attrs['class'].split(' ')
}
else:
self.Meta.row__attrs['class'] = {}
self.Meta.row__attrs.update(extract_subkeys(self.Meta, 'row__attrs'))
self.Meta.row__attrs = collect_namespaces(self.Meta.row__attrs)
if not self.Meta.sortable:
for bound_column in self.bound_columns:
bound_column.sortable = False
def bind_columns():
for index, column in enumerate(self.columns):
values = evaluate_recursive(Struct(column), table=self, column=column)
values = setdefaults_path(
Struct(), self.column.get(column.name, {}), values, column=column, table=self, index=index
)
yield BoundColumn(**values)
def test_evaluate_recursive():
foo = {
'foo': {'foo': lambda x: x * 2},
'bar': [{'foo': lambda x: x * 2}],
'baz': {lambda x: x * 2},
}
assert {'bar': [{'foo': 4}], 'foo': {'foo': 4}, 'baz': {4}} == evaluate_recursive(foo, x=2)
def __init__(self, table, row, row_index):
self.table = table
""" :type : Table """
self.row = row
""" :type : object """
self.row_index = row_index
args = Struct(evaluate_recursive(extract_subkeys(table.Meta, 'row'), table=table, row=row))
self.template = args.template
self.attrs = args.attrs
def evaluate(self):
"""
Evaluates callable/lambda members. After this function is called all members will be values.
"""
members_to_evaluate = {k: v for k, v in self.items() if k != 'post_validation'}
for k, v in members_to_evaluate.items():
self[k] = evaluate_recursive(v, form=self.form, field=self)
if not self.editable:
# noinspection PyAttributeOutsideInit
self.input_template = 'tri_form/non_editable.html'
def evaluate(self):
"""
Evaluates callable/lambda members. After this function is called all members will be values.
"""
members_to_evaluate = {k: v for k, v in self.items() if k != 'post_validation'}
for k, v in members_to_evaluate.items():
self[k] = evaluate_recursive(v, form=self.form, field=self)
if not self.editable:
# noinspection PyAttributeOutsideInit
self.input_template = 'tri_form/non_editable.html'
def _prepare_evaluate_members(self):
self.shown_bound_columns = [bound_column for bound_column in self.bound_columns if bound_column.show]
model = self.Meta.pop('model') # avoid trying to eval model, since it's callable
self.Meta = evaluate_recursive(self.Meta, table=self)
self.Meta.model = model
if not self.Meta.sortable:
for bound_column in self.bound_columns:
bound_column.sortable = False
def __init__(self, table, row, row_index):
self.table = table
""" :type : Table """
self.row = row
""" :type : object """
self.row_index = row_index
args = Struct(
evaluate_recursive(extract_subkeys(table.Meta, 'row'),
table=table,
row=row))
self.template = args.template
self.attrs = args.attrs
def __init__(self, request=None, variables=None, **kwargs): # variables=None to make pycharm tooling not confused
"""
:type variables: list of Variable
:type request: django.http.request.HttpRequest
"""
self.request = request
assert variables is not None
if isinstance(variables, dict): # Declarative case
self.variables = [merged(variable, name=name) for name, variable in variables.items()]
else:
self.variables = variables
bound_variables = [BoundVariable(**merged(Struct(x), query=self)) for x in self.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 test_evaluate_recursive():
foo = {
'foo': {
'foo': lambda x: x * 2
},
'bar': [{
'foo': lambda x: x * 2
}],
'baz': {lambda x: x * 2},
'boo': 17
}
assert {
'bar': [{
'foo': 4
}],
'foo': {
'foo': 4
},
'baz': {4},
'boo': 17
} == evaluate_recursive(foo, x=2)
def _prepare_evaluate_members(self):
self.shown_bound_columns = [bound_column for bound_column in self.bound_columns if bound_column.show]
self.Meta = evaluate_recursive(self.Meta, table=self)
if 'class' in self.Meta.attrs and isinstance(self.Meta.attrs['class'], basestring):
self.Meta.attrs['class'] = {k: True for k in self.Meta.attrs['class'].split(' ')}
else:
self.Meta.attrs['class'] = {}
self.Meta.attrs.update(extract_subkeys(self.Meta, 'attrs'))
self.Meta.attrs = collect_namespaces(self.Meta.attrs)
if 'class' in self.Meta.row__attrs and isinstance(self.Meta.row__attrs['class'], basestring):
self.Meta.row__attrs['class'] = {k: True for k in self.Meta.row__attrs['class'].split(' ')}
else:
self.Meta.row__attrs['class'] = {}
self.Meta.row__attrs.update(extract_subkeys(self.Meta, 'row__attrs'))
self.Meta.row__attrs = collect_namespaces(self.Meta.row__attrs)
if not self.Meta.sortable:
for bound_column in self.bound_columns:
bound_column.sortable = False
def _prepare_evaluate_members(self):
self.shown_bound_columns = [bound_column for bound_column in self.bound_columns if bound_column.show]
for attr in (
"column",
"bulk_filter",
"bulk_exclude",
"sortable",
"attrs",
"row",
"filter",
"header",
"links",
"model",
"query",
"bulk",
"endpoint",
):
setattr(self, attr, evaluate_recursive(getattr(self, attr), table=self))
if not self.sortable:
for bound_column in self.bound_columns:
bound_column.sortable = False
def table_context(request,
table,
links=None,
paginate_by=None,
page=None,
extra_context=None,
context_processors=None,
paginator=None,
show_hits=False,
hit_label='Items'):
"""
:type table: Table
"""
if extra_context is None: # pragma: no cover
extra_context = {}
assert table.data is not None
grouped_links = {}
if links is not None:
links = evaluate_recursive(links, table=table)
links = [link for link in links if link.show and link.url]
grouped_links = groupby(
(link for link in links if link.group is not None),
key=lambda l: l.group)
grouped_links = [(g, slugify(g), list(lg)) for g, lg in grouped_links
] # because django templates are crap!
links = [link for link in links if link.group is None]
base_context = {
'links': links,
'grouped_links': grouped_links,
'table': table,
}
if paginate_by:
try:
paginate_by = int(request.GET.get('page_size', paginate_by))
except ValueError: # pragma: no cover
pass
if paginator is None:
paginator = Paginator(table.data, paginate_by)
object_list = None
else: # pragma: no cover
object_list = table.data
if not page:
page = request.GET.get('page', 1)
try:
page = int(page)
if page < 1: # pragma: no cover
page = 1
if page > paginator.num_pages: # pragma: no cover
page = paginator.num_pages
if object_list is None:
table.data = paginator.page(page).object_list
except (InvalidPage, ValueError): # pragma: no cover
if page == 1:
table.data = []
else:
raise Http404
base_context.update({
'request': request,
'is_paginated': paginator.num_pages > 1,
'results_per_page': paginate_by,
'has_next': paginator.num_pages > page,
'has_previous': page > 1,
'page_size': paginate_by,
'page': page,
'next': page + 1,
'previous': page - 1,
'pages': paginator.num_pages,
'hits': paginator.count,
'show_hits': show_hits,
'hit_label': hit_label
})
else: # pragma: no cover
base_context.update({'is_paginated': False})
base_context.update(extra_context)
return RequestContext(request, base_context, context_processors)
def attrs(self):
return evaluate_recursive(self.bound_column.cell.attrs,
table=self.table,
column=self.bound_column,
row=self.row,
value=self.value)
def attrs(self):
return evaluate_recursive(
self.bound_column.cell.attrs, table=self.table, column=self.bound_column, row=self.row, value=self.value
)
def table_context(
request,
table,
links=None,
paginate_by=None,
page=None,
extra_context=None,
context_processors=None,
paginator=None,
show_hits=False,
hit_label="Items",
):
"""
:type table: Table
"""
if extra_context is None: # pragma: no cover
extra_context = {}
assert table.data is not None
grouped_links = {}
if links is not None:
links = evaluate_recursive(links, table=table)
links = [link for link in links if link.show and link.url]
grouped_links = groupby((link for link in links if link.group is not None), key=lambda l: l.group)
grouped_links = [(g, slugify(g), list(lg)) for g, lg in grouped_links] # because django templates are crap!
links = [link for link in links if link.group is None]
base_context = {"links": links, "grouped_links": grouped_links, "table": table}
if paginate_by:
try:
paginate_by = int(request.GET.get("page_size", paginate_by))
except ValueError: # pragma: no cover
pass
if paginator is None:
paginator = Paginator(table.data, paginate_by)
object_list = None
else: # pragma: no cover
object_list = table.data
if not page:
page = request.GET.get("page", 1)
try:
page = int(page)
if page < 1: # pragma: no cover
page = 1
if page > paginator.num_pages: # pragma: no cover
page = paginator.num_pages
if object_list is None:
table.data = paginator.page(page).object_list
except (InvalidPage, ValueError): # pragma: no cover
if page == 1:
table.data = []
else:
raise Http404
base_context.update(
{
"request": request,
"is_paginated": paginator.num_pages > 1,
"results_per_page": paginate_by,
"has_next": paginator.num_pages > page,
"has_previous": page > 1,
"page_size": paginate_by,
"page": page,
"next": page + 1,
"previous": page - 1,
"pages": paginator.num_pages,
"hits": paginator.count,
"show_hits": show_hits,
"hit_label": hit_label,
}
)
else: # pragma: no cover
base_context.update({"is_paginated": False})
base_context.update(extra_context)
return RequestContext(request, base_context, context_processors)
def __iter__(self):
self.prepare(self.request)
for i, row in enumerate(self.data):
yield BoundRow(table=self, row=row, row_index=i, **evaluate_recursive(self.row, table=self, row=row))
def table_context(request,
table,
links=None,
paginate_by=None,
page=None,
extra_context=None,
context_processors=None,
paginator=None,
show_hits=False,
hit_label='Items'):
"""
:type table: Table
"""
if extra_context is None: # pragma: no cover
extra_context = {}
grouped_links = {}
if links is not None:
links = evaluate_recursive(links, table=table)
links = [link for link in links if link.show and link.url]
grouped_links = groupby((link for link in links if link.group is not None), key=lambda l: l.group)
grouped_links = [(g, slugify(g), list(lg)) for g, lg in grouped_links] # because django templates are crap!
links = [link for link in links if link.group is None]
base_context = {
'links': links,
'grouped_links': grouped_links,
'table': table,
}
if paginate_by:
try:
paginate_by = int(request.GET.get('page_size', paginate_by))
except ValueError: # pragma: no cover
pass
if paginator is None:
paginator = Paginator(table.data, paginate_by)
object_list = None
else: # pragma: no cover
object_list = table.data
if not page:
page = request.GET.get('page', 1)
try:
page = int(page)
if page < 1: # pragma: no cover
page = 1
if page > paginator.num_pages: # pragma: no cover
page = paginator.num_pages
if object_list is None:
table.data = paginator.page(page).object_list
except (InvalidPage, ValueError): # pragma: no cover
if page == 1:
table.data = []
else:
raise Http404
base_context.update({
'request': request,
'is_paginated': paginator.num_pages > 1,
'results_per_page': paginate_by,
'has_next': paginator.num_pages > page,
'has_previous': page > 1,
'page_size': paginate_by,
'page': page,
'next': page + 1,
'previous': page - 1,
'pages': paginator.num_pages,
'hits': paginator.count,
'show_hits': show_hits,
'hit_label': hit_label})
else: # pragma: no cover
base_context.update({
'is_paginated': False})
base_context.update(extra_context)
return RequestContext(request, base_context, context_processors)
def bind_columns():
for index, column in enumerate(self.columns):
values = evaluate_recursive(Struct(column), table=self, column=column)
values = merged(values, column=column, table=self, index=index)
yield BoundColumn(**values)
def render_attrs(self):
attrs = evaluate_recursive(self.bound_column.cell.attrs, table=self.table, column=self.bound_column, row=self.row, value=self.value)
return render_attrs(attrs)