def _filter_sort_localizeds(context, preferred_locale: str,
localizeds: Iterable[Localized],
localized_attribute: str, sort_attribute: str):
get_localized_attr = make_attrgetter(context.environment,
localized_attribute)
get_sort_attr = make_attrgetter(context.environment, sort_attribute)
def get_sort_key(x):
return get_sort_attr(
negotiate_localizeds(preferred_locale, get_localized_attr(x)))
return sorted(localizeds, key=get_sort_key)
def _filter_sort_localizeds(context: Context, localizeds: Iterable[Localized],
localized_attribute: str,
sort_attribute: str) -> Iterable[Localized]:
locale = resolve_or_missing(context, 'locale')
get_localized_attr = make_attrgetter(context.environment,
localized_attribute)
get_sort_attr = make_attrgetter(context.environment, sort_attribute)
def _get_sort_key(x):
return get_sort_attr(
negotiate_localizeds(locale, get_localized_attr(x)))
return sorted(localizeds, key=_get_sort_key)
async def do_groupby(environment, value, attribute):
expr = filters.make_attrgetter(environment, attribute)
return [
filters._GroupTuple(key, await auto_to_seq(values))
for key, values in filters.groupby(
sorted(await auto_to_seq(value), key=expr), expr)
]
def natsort(environment,
value,
reverse=False,
case_sensitive=False,
attribute=None):
"""Sort an iterable in natural order. Per default it sorts ascending,
if you pass it true as first argument it will reverse the sorting.
If the iterable is made of strings the third parameter can be used to
control the case sensitiveness of the comparison which is disabled by
default.
Based on Jinja2's `sort` filter.
"""
if not case_sensitive:
def sort_func(item):
if isinstance(item, basestring):
item = item.lower()
return natural_sort_key(item)
else:
sort_func = natural_sort_key
if attribute is not None:
getter = make_attrgetter(environment, attribute)
def sort_func(item, processor=sort_func or (lambda x: x)):
return processor(getter(item))
return sorted(value, key=sort_func, reverse=reverse)
def groupby(environment, value, attribute, reverse=False):
"""Like Jinja's builtin `groupby` filter, but allows reversed order."""
expr = make_attrgetter(environment, attribute)
return [
_GroupTuple(key, list(values)) for key, values in itertools.groupby(
sorted(value, key=expr, reverse=reverse), expr)
]
def natsort(environment, value, reverse=False, case_sensitive=False, attribute=None):
"""Sort an iterable in natural order. Per default it sorts ascending,
if you pass it true as first argument it will reverse the sorting.
If the iterable is made of strings the third parameter can be used to
control the case sensitiveness of the comparison which is disabled by
default.
Based on Jinja2's `sort` filter.
"""
if not case_sensitive:
def sort_func(item):
if isinstance(item, basestring):
item = item.lower()
return natural_sort_key(item)
else:
sort_func = natural_sort_key
if attribute is not None:
getter = make_attrgetter(environment, attribute)
def sort_func(item, processor=sort_func or (lambda x: x)):
return processor(getter(item))
return sorted(value, key=sort_func, reverse=reverse)
def group_by_humanize_date(environment, value, attribute):
sorted_collections = sorted(value,
key=make_attrgetter(
environment, attribute))
return map(
_GroupTuple,
groupby(sorted_collections,
_make_attr_getter_for_date(environment, attribute)))
async def do_sum(environment, iterable, attribute=None, start=0):
rv = start
if attribute is not None:
func = filters.make_attrgetter(environment, attribute)
else:
func = lambda x: x
async for item in auto_aiter(iterable):
rv += func(item)
return rv
async def do_sum(environment, iterable, attribute=None, start=0):
rv = start
if attribute is not None:
func = filters.make_attrgetter(environment, attribute)
else:
func = lambda x: x
async for item in auto_aiter(iterable):
rv += func(item)
return rv
def groupattr_filter(_eval_ctx, iterable, num, attr, *args, **kwargs):
"""Similar to `group`, but as an attribute filter."""
attr_getter = make_attrgetter(_eval_ctx.environment, attr)
try:
name = args[0]
args = args[1:]
test_func = lambda item: _eval_ctx.environment.call_test(
name, item, args, kwargs)
except LookupError:
test_func = bool
return group(iterable, num, lambda item: test_func(attr_getter(item)))
def count_sum(environment, iterable, attribute=None, start=0):
"""
类是jinja2中的sum过滤器
:param iterable:
:param attribute:
:param start:
:return:
"""
if attribute is not None:
func = make_attrgetter(environment, attribute)
iterable = map(func, iterable)
iterable = filter(None, iterable)
return sum(iterable, start)
def count_sum(environment, iterable, attribute=None, start=0):
"""
类是jinja2中的sum过滤器
:param iterable:
:param attribute:
:param start:
:return:
"""
if attribute is not None:
func = make_attrgetter(environment, attribute)
iterable = map(func, iterable)
iterable = filter(None, iterable)
return sum(iterable, start)
def get_attr(environment, value, attribute, default=None):
"""
获取值，
:param value:
:param attribute:
:param default:
:return:
"""
if value:
func = make_attrgetter(environment, attribute)
result = func(value)
else:
result = default
return result
def get_attr(environment, value, attribute, default=None):
"""
获取值，
:param value:
:param attribute:
:param default:
:return:
"""
if value:
func = make_attrgetter(environment, attribute)
result = func(value)
else:
result = default
return result
def option(context, attribute, default_value=u'', source='options'):
""" Get attribute from options data structure, default_value otherwise """
environment = context.environment
options = environment.globals['_config'][source]
if not attribute:
return default_value
try:
getter = make_attrgetter(environment, attribute)
value = getter(options)
if isinstance(value, Undefined):
return default_value
return value
except (jinja2.exceptions.UndefinedError):
return default_value
def unique_together(environment, value, case_sensitive=False, attributes=None):
"""
Return a list of unique items from an iterable. Unicity is checked when
considering together all the values of an "attributes" list of attribute
names available on each iterable item.. The items order is preserved. Ignore
the case of strings unless "case_sensitive" is "true".
.. sourcecode:: jinja
{% for item in iterable|unique_together(attributes=['date', 'name']) %}
...
{% endfor %}
"""
if not attributes:
raise FilterArgumentError(
'The unique_together filter requires a list of attributes as argument, '
'such as in: '
"{% for item in iterable|unique_together(attributes=['date', 'name']) %} "
)
# build a list of attribute getters, one for each attribute
do_ignore_case = ignore_case if not case_sensitive else None
attribute_getters = []
for attribute in attributes:
ag = make_attrgetter(environment,
attribute,
postprocess=do_ignore_case)
attribute_getters.append(ag)
# build a unique_key function that has runs all attribute getters
# and returns a hashable tuple
def unique_key(v):
return tuple(repr(a(v)) for a in attribute_getters)
unique = []
seen = set()
for item in value:
key = unique_key(item)
if key not in seen:
seen.add(key)
unique.append(item)
return unique
def do_groupby(environment, value, attribute, sort=True):
expr = make_attrgetter(environment, attribute)
# Original behavior: groups are sorted
if sort:
return [
_GroupTuple(key, list(values))
for key, values in groupby(sorted(value, key=expr), expr)
]
# Added behavior: original order of appearance is kept
all_groups = [expr(_) for _ in value]
group_set = set()
unique_groups = []
for group in all_groups:
if group not in group_set:
unique_groups.append(group)
group_set.add(group)
grouped = {k: list(v) for k, v in groupby(sorted(value, key=expr), expr)}
return [_GroupTuple(group, grouped[group]) for group in unique_groups]
def do_groupby(environment, value, attribute):
"""Group a sequence of objects by a common attribute.
If you for example have a list of dicts or objects that represent persons
with `gender`, `first_name` and `last_name` attributes and you want to
group all users by genders you can do something like the following
snippet:
.. sourcecode:: html+jinja
<ul>
{% for group in persons|groupby('gender') %}
<li>{{ group.grouper }}<ul>
{% for person in group.list %}
<li>{{ person.first_name }} {{ person.last_name }}</li>
{% endfor %}</ul></li>
{% endfor %}
</ul>
Additionally it's possible to use tuple unpacking for the grouper and
list:
.. sourcecode:: html+jinja
<ul>
{% for grouper, list in persons|groupby('gender') %}
...
{% endfor %}
</ul>
As you can see the item we're grouping by is stored in the `grouper`
attribute and the `list` contains all the objects that have this grouper
in common.
.. versionchanged:: 2.6
It's now possible to use dotted notation to group by the child
attribute of another attribute.
"""
expr = make_attrgetter(environment, attribute, lambda val: '' if val is None else val)
return [_GroupTuple(key, list(values)) for key, values
in groupby(sorted(value, key=expr), expr)]
def multi_sort(environment,
value,
reverse=False,
case_sensitive=False,
attributes=None):
"""
Sort an iterable using an "attributes" list of attribute names available on
each iterable item. Sort ascending unless reverse is "true". Ignore the case
of strings unless "case_sensitive" is "true".
.. sourcecode:: jinja
{% for item in iterable|multi_sort(attributes=['date', 'name']) %}
...
{% endfor %}
"""
if not attributes:
raise FilterArgumentError(
'The multi_sort filter requires a list of attributes as argument, '
'such as in: '
"for item in iterable|multi_sort(attributes=['date', 'name'])")
# build a list of attribute getters, one for each attribute
do_ignore_case = ignore_case if not case_sensitive else None
attribute_getters = []
for attribute in attributes:
ag = make_attrgetter(environment,
attribute,
postprocess=do_ignore_case)
attribute_getters.append(ag)
# build a key function that has runs all attribute getters
def key(v):
return [a(v) for a in attribute_getters]
return sorted(value, key=key, reverse=reverse)
def groupby(environment, value, attribute, reverse=False):
"""Like Jinja's builtin `groupby` filter, but allows reversed order."""
expr = make_attrgetter(environment, attribute)
return sorted(map(_GroupTuple, itertools.groupby(sorted(value, key=expr), expr)), reverse=reverse)
def group_by_humanize_date(environment, value, attribute):
sorted_collections = sorted(value, key=make_attrgetter(environment, attribute))
return map(_GroupTuple, groupby(sorted_collections, _make_attr_getter_for_date(environment, attribute)))
def do_stringify_key_group_by(environment, value, attribute):
expr = make_attrgetter(environment, attribute)
key = lambda item: '' if expr(item) is None else str(expr(item))
return groupby(sorted(value, key=key), expr)
async def do_groupby(environment, value, attribute):
expr = filters.make_attrgetter(environment, attribute)
return [filters._GroupTuple(key, await auto_to_seq(values))
for key, values in filters.groupby(sorted(
await auto_to_seq(value), key=expr), expr)]
def groupby(environment, value, attribute, reverse=False):
"""Like Jinja's builtin `groupby` filter, but allows reversed order."""
expr = make_attrgetter(environment, attribute)
return [_GroupTuple(key, list(values))
for key, values in itertools.groupby(sorted(value, key=expr, reverse=reverse), expr)]
