class FilterRegistrationTests(TestCase):
def setUp(self):
self.library = Library()
def test_filter(self):
@self.library.filter
def func():
return ''
self.assertEqual(self.library.filters['func'], func)
def test_filter_parens(self):
@self.library.filter()
def func():
return ''
self.assertEqual(self.library.filters['func'], func)
def test_filter_name_arg(self):
@self.library.filter('name')
def func():
return ''
self.assertEqual(self.library.filters['name'], func)
def test_filter_name_kwarg(self):
@self.library.filter(name='name')
def func():
return ''
self.assertEqual(self.library.filters['name'], func)
def test_filter_call(self):
def func():
return ''
self.library.filter('name', func)
self.assertEqual(self.library.filters['name'], func)
def test_filter_invalid(self):
msg = "Unsupported arguments to Library.filter: (None, '')"
with self.assertRaisesMessage(ValueError, msg):
self.library.filter(None, '')
class FilterRegistrationTests(TestCase):
def setUp(self):
self.library = Library()
def test_filter(self):
@self.library.filter
def func():
return ''
self.assertEqual(self.library.filters['func'], func)
def test_filter_parens(self):
@self.library.filter()
def func():
return ''
self.assertEqual(self.library.filters['func'], func)
def test_filter_name_arg(self):
@self.library.filter('name')
def func():
return ''
self.assertEqual(self.library.filters['name'], func)
def test_filter_name_kwarg(self):
@self.library.filter(name='name')
def func():
return ''
self.assertEqual(self.library.filters['name'], func)
def test_filter_call(self):
def func():
return ''
self.library.filter('name', func)
self.assertEqual(self.library.filters['name'], func)
def test_filter_invalid(self):
msg = "Unsupported arguments to Library.filter: (None, '')"
with self.assertRaisesMessage(ValueError, msg):
self.library.filter(None, '')
t = loader.get_template("post_template.html")
render = t.render(c)
cache.set("%s_%s" % (zr,ulogin),render,360000)
return render
@register.filter
def coord(post):
x,y = post.split(",")
return "left:"+x+"px;top:"+y+"px";
register.filter('coord', coord)
@register.filter
def perms(user,perm):
return getPerms(user,perm)
@register.filter
def isfallow(user,touser):
if user == touser:
return 1
f = fallowers.objects.filter(from_user = user , to_user =touser)
if f.count()==0:
return 0
from django.template import Library
register = Library() # 必须用register这个变量名
def truncate_word(value):
# 截断多余字符
if value:
if len(value) > 10:
return value[:10] + '...'
else:
return value
else:
return value
register.filter(truncate_word) # 注册convert_male这个过滤器
#!/usr/bin/python
# -*- coding: utf-8 -*-
from django.template import Library
from django.template.defaultfilters import stringfilter
from django.utils.html import conditional_escape
from django.utils.safestring import mark_safe
import re
register = Library()
@stringfilter
def spacify(value, autoescape=None):
if autoescape:
esc = conditional_escape
else:
esc = lambda x: x
return mark_safe(re.sub(' ', '&'+'nbsp; ', esc(value)))
spacify.needs_autoescape = True
register.filter(spacify)
from django.template import Context, Library, RequestContext
from django.template import resolve_variable
register = Library()
def textile(value):
try:
import textile
except ImportError:
return value
else:
return textile.textile(value, encoding='utf-8')
register.filter(textile)
except ValueError: # invalid literal for int()
return value # Fail silently
if not isinstance(value, basestring):
value = str(value)
if len(value) > (length):
truncated = value[:length - 3]
if not truncated.endswith('...'):
truncated += '...'
return truncated
if len(value) <= length:
padded = value
spaces_needed = (length - len(value)) + 1
for space_needed in range(1, spaces_needed):
padded = "%s " % padded
#print 'padded: %s--' % padded
return padded
return value
@stringfilter
def spacify(value, autoescape=None):
if autoescape:
esc = conditional_escape
else:
esc = lambda x: x
return mark_safe(re.sub('\s', '&'+'nbsp;', esc(value)))
spacify.needs_autoescape = True
register.filter(spacify)
register.filter('gteducfixedwidth', gteducfixedwidth)
from podcast.utils.dateformat import format, time_format
register = Library()
def fixed_date(value, arg=None):
"""Formats a date according to the given format."""
if not value:
return u''
if arg is None:
arg = settings.DATE_FORMAT
try:
return format(value, arg)
except AttributeError:
return ''
fixed_date.is_safe = False
def fixed_time(value, arg=None):
"""Formats a time according to the given format."""
if value in (None, u''):
return u''
if arg is None:
arg = settings.TIME_FORMAT
try:
return time_format(value, arg)
except AttributeError:
return ''
fixed_time.is_safe = False
register.filter(fixed_date)
register.filter(fixed_time)
{% endwith %}
"""
thumbnailer = get_thumbnailer(obj)
thumbnailer.generate = False
return thumbnailer
def thumbnail_url(source, alias):
"""
Return the thumbnail url for a source file using an aliased set of
thumbnail options.
If no matching alias is found, returns an empty string.
Example usage::
<img src="{{ person.photo|thumbnail_url:'small' }}" alt="">
"""
try:
thumb = get_thumbnailer(source)[alias]
except Exception:
logger.exception("Failed generating thumbnail for {0}, {1}".format(source, alias))
return ''
return thumb.url
register.tag(thumbnail)
register.filter(thumbnailer)
register.filter(thumbnailer_passive)
register.filter(thumbnail_url)
comment = r'''#!markdown\n\rAn [example](http://url.com/ "Title")'''
Would be rendered as a markdown text, producing the output::
<p><a href="http://url.com/" title="Title">example</a></p>
"""
lines = value.splitlines()
rawstr = r"""^#!(?P<markup_filter>\w+)$"""
match_obj = re.search(rawstr, lines[0])
if match_obj:
markup_filter = match_obj.group('markup_filter')
try:
if formatter:
return mark_safe(
formatter("\n".join(lines[1:]), filter_name=markup_filter))
else:
raise TemplateSyntaxError(
"In order to use this templatetag you need django-markup, docutils and markdown installed"
)
except ValueError as exc:
output = "<p>Warning: %s</p>" % exc
return output + value
else:
return value
register.tag(get_xtdcomment_count)
register.tag(render_last_xtdcomments)
register.tag(get_last_xtdcomments)
register.filter(render_markup_comment)
if not isinstance(value, models.Model):
return value
arg = arg.strip()
names = arg and arg.split(',') or ['id']
tr_list = []
for f in value._meta.fields:
if f.name in names:
continue
tr = '<tr>%s</tr>' % renderField(value, f)
tr_list.append(tr)
return mark_safe('\n'.join(tr_list))
register.filter(model_as_table)
def model_as_table_with(value, arg=''): #arg标示要显示的字段的name，以逗号分开。并且按arg中的顺序来显示
if not isinstance(value, models.Model):
return value
arg = arg.strip()
names = arg and arg.split(',')
colsnum = 1
if len(names) > 0: #传入了arg
if names[0].isdigit(): #第一个是数字
colsnum = int(names[0])
if len(names) == 1: #只有一个参数
names = [f.name for f in value._meta.fields if f.name != 'id']
else:
names = names[1:]
value = Decimal(force_text(value))
if value == 0:
return '0 s'
if value % 604800 == 0:
return '%.2f w' % (value / Decimal('604800.0'))
if value % 3600 != 0 and value < 86400:
return '%.2f s' % value
if value % 86400 != 0 and value < 604800:
return '%.2f h' % (value / Decimal('3600'))
return '%.2f d' % (value / Decimal('86400'))
except Exception:
return ''
duration.is_safe = True
register.filter('duration', duration)
#
# Filters to get metadata of a model
#
def verbose_name(obj):
return obj._meta.verbose_name
register.filter(verbose_name)
def verbose_name_plural(obj):
return obj._meta.verbose_name_plural
try:
bits.remove("as")
except ValueError:
pass # We don't care if `as` part is not there.
finally:
return StatusNode(*bits)
def has_group(obj, group):
if isinstance(obj, User):
return obj.profile.has_group(group)
raise TemplateSyntaxError(
"has_group can only be applied to User instances")
register.filter(has_group)
register.tag(status)
@register.inclusion_tag("profiles/profile_todo_list.html")
def show_todo_list(user):
profile = user.profile
filled_out_address = bool(profile.city and profile.state
and profile.country and profile.address)
verified_email = bool(user.profile.email_verified)
verified_phone = bool(get_validation(user, "phone_mobile"))
uploaded_document = bool(user.documents.active().exists())
percent_complete = 25 * (filled_out_address + verified_email +
verified_phone + uploaded_document)
return {
"filled_out_address": filled_out_address,
length = length - 3
if s[length - 1] == ' ' or s[length] == ' ':
s = s[:length].strip()
else:
words = s[:length].split()
if len(words) > 1:
del words[-1]
s = u' '.join(words)
s += '...'
return s
truncate_chars = allow_lazy(truncate_chars, unicode)
def truncatechars(value, arg):
"""
Truncates a string after a certain number of characters, but respects word
boundaries.
Argument: Number of characters to truncate after.
"""
try:
length = int(arg)
except ValueError:
# Fail silently if the argument is not a valid integer.
return value
return truncate_chars(value, length)
truncatechars.is_safe = True
truncatechars = stringfilter(truncatechars)
register.filter(truncatechars)
"""
autotriage - A Django powered ticket tracker for small enterprise.
templatetags/load_helpdesk_settings.py - returns the settings as defined in
django-helpdesk/helpdesk/settings.py
"""
from __future__ import print_function
from django.template import Library
from autotriage import settings as helpdesk_settings_config
def load_helpdesk_settings(request):
try:
return helpdesk_settings_config
except Exception as e:
import sys
print("'autotriage' template tag (autotriage) crashed with following error:",
file=sys.stderr)
print(e, file=sys.stderr)
return ''
register = Library()
register.filter('load_helpdesk_settings', load_helpdesk_settings)
phone2numeric.is_safe = True
def pprint(value):
"""A wrapper around pprint.pprint -- for debugging, really."""
from pprint import pformat
try:
return pformat(value)
except Exception, e:
return u"Error in formatting: %s" % force_unicode(e, errors="replace")
pprint.is_safe = True
# Syntax: register.filter(name of filter, callback)
register.filter(add)
register.filter(addslashes)
register.filter(capfirst)
register.filter(center)
register.filter(cut)
register.filter(date)
register.filter(default)
register.filter(default_if_none)
register.filter(dictsort)
register.filter(dictsortreversed)
register.filter(divisibleby)
register.filter(escape)
register.filter(escapejs)
register.filter(filesizeformat)
register.filter(first)
register.filter(fix_ampersands)
words.
Examples:
>>> print widont_html('<h2>Here is a simple example </h2> <p>Single</p>')
<h2>Here is a simple example </h2> <p>Single</p>
>>> print widont_html('<p>test me<br /> out</p><h2>Ok?</h2>Not in a p<p title="test me">and this</p>')
<p>test me<br /> out</p><h2>Ok?</h2>Not in a p<p title="test me">and this</p>
>>> print widont_html('leading text <p>test me out</p> trailing text')
leading text <p>test me out</p> trailing text
"""
def replace(matchobj):
return u'%s %s%s' % matchobj.groups()
return re_widont_html.sub(replace, force_unicode(value))
register.filter(widont)
register.filter(widont_html)
def _test():
import doctest
doctest.testmod()
if __name__ == "__main__":
_test()
GREEK_LETTERS = \
'[Aa]lpha|[Bb]eta|[Gg]amma|[Dd]elta|[Ee]psilon|[Zz]eta|' + \
'[Ee]ta|[Tt]heta|[Ll]ambda|[Mm]u|[Nn]u|[Pp]i|[Ss]igma|[Tt]au|' + \
'[Pp]hi|[Pp]si|[Cc]hi|[Oo]mega|[Rr]ho|[Xx]i|[Kk]appa'
def get_publication(id):
pbl = Publication.objects.filter(pk=int(id))
if len(pbl) < 1:
return ''
return get_template('publications/publication.html').render(
Context({'publication': pbl[0]}))
def tex_parse(string):
def tex_replace(match):
return \
sub(r'\^(\w)', r'<sup>\1</sup>',
sub(r'\^\{(.*?)\}', r'<sup>\1</sup>',
sub(r'\_(\w)', r'<sub>\1</sub>',
sub(r'\_\{(.*?)\}', r'<sub>\1</sub>',
sub(r'\\(' + GREEK_LETTERS + ')', r'&\1;', match.group(1))))))
return mark_safe(sub(r'\$([^\$]*)\$', tex_replace, escape(string)))
register.simple_tag(get_publication)
register.filter('tex_parse', tex_parse)
from django.contrib.humanize.templatetags.humanize import intcomma
from django.template import Library, Context
from django.conf import settings
from django.utils.timezone import utc
from django.db.models import Q, Avg, Max, Min, Sum, Count
from django.core.serializers import serialize
from django.db.models.query import QuerySet
from django.template import Library
from dateutil import parser
from datetime import datetime, date, time, timedelta
import json
import logging
import decimal
logger = logging.getLogger("kpcc_backroom_handshakes")
register = Library()
def currency(dollars):
dollars = round(int(dollars), 2)
return "$%s" % (intcomma(int(dollars)))
register.filter(currency)
else: return value[:arg] + '...' register.simple_tag(tags) register.simple_tag(tagvalid) register.simple_tag(tagtaskliststatus) register.simple_tag(tagnonprojecttaskstatus) register.simple_tag(tagstatus) register.simple_tag(seltaskname) register.simple_tag(seltaskid) register.simple_tag(validdate) register.simple_tag(validdateactual) register.simple_tag(artifactreadonly) register.simple_tag(fileexists) register.filter(truncchar)
def _get_format():
locale = get_current_locale()
if not locale:
locale = Locale.parse(to_locale(get_language()))
if timezone:
tzinfo = timezone(settings.TIME_ZONE)
else:
tzinfo = None
return Format(locale, tzinfo)
def datefmt(date=None, format='medium'):
return _get_format().date(date, format=format)
datefmt = register.filter(datefmt)
def datetimefmt(datetime=None, format='medium'):
return _get_format().datetime(datetime, format=format)
datetimefmt = register.filter(datetimefmt)
def timefmt(time=None, format='medium'):
return _get_format().time(time, format=format)
timefmt = register.filter(timefmt)
def numberfmt(number):
return _get_format().number(number)
numberfmt = register.filter(numberfmt)
{% for row in mylist|columns:3 %}
<tr>
{% for item in row %}
<td>{{ item }}</td>
{% endfor %}
</tr>
{% endfor %}
</table>
"""
from django.template import Library
register = Library()
def columnss(data, cols):
rows = []
row = []
index = 0
for user in data:
row.append(user)
index = index + 1
if index % cols == 0:
rows.append(row)
row = []
# Still stuff missing?
if len(row) > 0:
rows.append(row)
return rows
register.filter(columnss)
return ""
value = Decimal(force_text(value))
if value == 0:
return "0 s"
if value % 604800 == 0:
return "%.2f w" % (value / Decimal("604800.0"))
if value % 3600 != 0 and value < 86400:
return "%.2f s" % value
if value % 86400 != 0 and value < 604800:
return "%.2f h" % (value / Decimal("3600"))
return "%.2f d" % (value / Decimal("86400"))
except Exception:
return ""
register.filter("duration", duration, is_safe=True)
#
# A filter to order a list
#
def sortList(inputList):
return sorted(inputList)
register.filter("sortList", sortList)
#
# Filters to get metadata of a model
#
register = Library()
def stripcomments(value):
"""
Remove HTML comments from string.
"""
if value:
#remove comments
value = re.sub('<!--.*?-->', '', value, flags=re.DOTALL)
#remove weird XML crap
value = re.sub('<\?.*?>', '', value, flags=re.DOTALL)
return value
register.filter('stripcomments', stripcomments)
def silence_without_field(fn):
def wrapped(field, attr):
if not field:
return ""
else:
return fn(field, attr)
return wrapped
def _process_field_attributes(field, attr, process):
# split attribute name and value from 'attr:value' string
from django.core.serializers import serialize
from django.db.models.query import QuerySet
import json
from django.template import Library
from django.utils.encoding import smart_text
register = Library()
from django.core.serializers.json import Serializer
class JSONSerializer(Serializer):
def get_dump_object(self, obj):
model = self._current
model['id'] = smart_text(obj._get_pk_val(), strings_only=True)
return model
s = JSONSerializer()
def jsonify(object):
if isinstance(object, QuerySet):
return s.serialize(object)
return json.dumps(object)
register.filter('jsonify', jsonify)
# See http://djangosnippets.org/snippets/201/
import json
from django.core.serializers import serialize
from django.db.models.query import QuerySet
from django.template import Library
register = Library()
def to_json(object):
if isinstance(object, QuerySet):
return serialize('json', object)
return json.dumps(object)
register.filter('to_json', to_json)
if value in (None, ''):
return ''
if arg is None:
arg = settings.TIME_FORMAT
return time_format(value, arg, get_language())
# below here nothing works
def ltimesince(value, arg=None):
'Formats a date as the time since that date (i.e. "4 days, 6 hours")'
from django.utils.timesince import timesince
if not value:
return ''
if arg:
return timesince(arg, value)
return timesince(value)
def ltimeuntil(value, arg=None):
'Formats a date as the time until that date (i.e. "4 days, 6 hours")'
from django.utils.timesince import timesince
from datetime import datetime
if not value:
return ''
if arg:
return timesince(arg, value)
return timesince(datetime.now(), value)
register.filter(ldate)
register.filter(ltime)
register.filter(ltimesince)
register.filter(ltimeuntil)
queries. Therefore you don't need to modify
any views.
"""
import sys
import traceback
import six
from django.template import Library
from django.db.models import Q
from helpdesk.models import SavedSearch
def saved_queries(request):
try:
if not request.user.is_authenticated():
return ''
user_saved_queries = SavedSearch.objects.filter(
Q(user=request.user) | Q(shared__exact=True))
return user_saved_queries
except Exception:
six.print_("Error in 'saved_queries' template tag (django-helpdesk):",
file=sys.stderr)
traceback.print_exc()
return ''
register = Library()
register.filter('saved_queries', saved_queries)
# -*- coding: utf-8 -*-
from django.template import Library
register = Library()
def summary(src):
return ' '.join(filter(lambda t: len(t.strip()) < 30, src.split()))
register.filter('summary', summary)
# present:
>>> pprint(columns(range(4), 3), width=10)
[[0, 2],
[1, 3]]
"""
try:
n = int(n)
thelist = list(thelist)
except (ValueError, TypeError):
return [thelist]
list_len = len(thelist)
split = list_len // n
if list_len % n != 0:
split += 1
return [thelist[i::split] for i in range(split)]
register.filter(rows)
register.filter(rows_distributed)
register.filter(columns)
def _test():
import doctest
doctest.testmod()
if __name__ == "__main__":
_test()
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
'''
from django.template import Library
register = Library()
def abbr(str, length):
if len(str) > length:
return str[:length] + ' ...'
return str
register.filter(abbr)
bits = token.split_contents()
if len(bits) != 4:
raise TemplateSyntaxError, "Accepted format {% follow_label [instance] [follow_string] [unfollow_string] %}"
else:
return DisplayActivityFollowLabel(*bits[1:])
def actor_url(parser, token):
"""
Renders the URL for a particular actor instance
Example::
<a href="{% actor_url request.user %}">View your actions</a>
<a href="{% actor_url another_user %}">{{ another_user }}'s actions</a>
"""
bits = token.split_contents()
if len(bits) != 2:
raise TemplateSyntaxError, "Accepted format {% actor_url [actor_instance] %}"
else:
return DisplayActivityActorUrl(*bits[1:])
register.filter(is_following)
register.tag(display_action)
register.tag(display_action_short)
register.tag(display_grouped_actions)
register.tag(follow_url)
register.tag(follow_label)
register.tag(actor_url)
"""
Renders an activity stream as a list into the template's context.
Streams loaded by stream_type can be the default ones (eg user, actor, etc.) or a user defined stream.
Extra args/kwargs are passed into the stream call.
::
{% activity_stream 'actor' user %}
{% for action in stream %}
{% display_action action %}
{% endfor %}
"""
if stream_type == 'model':
stream_type = 'model_actions'
if not hasattr(Action.objects, stream_type):
raise TemplateSyntaxError('Action manager has no attribute: %s' %
stream_type)
ctxvar = kwargs.pop('as', 'stream')
context[ctxvar] = getattr(Action.objects, stream_type)(*args, **kwargs)
return ''
register.filter(activity_stream)
register.filter(is_following)
register.tag('is_following', is_following_tag)
register.tag(display_action)
register.tag(follow_url)
register.tag(follow_all_url)
register.tag(actor_url)
register.simple_tag(takes_context=True)(activity_stream)
Takes an optional argument to specify the name of a filter to use.
"""
if arg is not None:
return mark_safe(formatter(value, filter_name=arg))
return mark_safe(formatter(value))
apply_markup.is_safe = True
def smartypants(value):
"""
Applies SmartyPants to a piece of text, applying typographic
niceties.
Requires the Python SmartyPants library to be installed; see
http://web.chad.org/projects/smartypants.py/
"""
try:
from smartypants import smartyPants
except ImportError:
if settings.DEBUG:
raise template.TemplateSyntaxError("Error in smartypants filter: the Python smartypants module is not installed or could not be imported")
return value
else:
return mark_safe(smartyPants(value))
register = Library()
register.filter(apply_markup)
register.filter(smartypants)
from django.template import Library
from django.template.defaultfilters import stringfilter
import re
register = Library()
@stringfilter
def replace(val):
return re.sub('_|-',' ',val)
register.filter(replace)
except ImportError:
import json
register = Library()
def is_active(url, arg, has_replied=False):
if not url:
return False
print url
print arg
return True
register.filter("is_active", is_active) # 注册该函数，函数名称，过滤函数本身
def bbcode(context, s, has_replied=False):
if not s:
return ""
tag_data = {"has_replied": has_replied}
html = _postmarkup(
s, tag_data=tag_data, auto_urls=getattr(settings, "BBCODE_AUTO_URLS", True) # cosmetic_replace=False,
)
context["hide_attachs"] = tag_data.get("hide_attachs", [])
return html
@register.filter
def natural_time(value, time_range="86400"):
Display the required ``<div>`` elements to let the Ajax comment functionality work with your form.
"""
new_context = {
'STATIC_URL': context.get('STATIC_URL', None)
}
# Be configuration independent:
if new_context['STATIC_URL'] is None:
try:
request = context['request']
except KeyError:
new_context.update({'STATIC_URL': settings.STATIC_URL})
else:
new_context.update(context_processors.static(request))
return new_context
register.filter('comments_are_open', comments_are_open)
register.filter('comments_are_moderated', comments_are_moderated)
@register.filter
def comments_count(content_object):
"""
Return the number of comments posted at a target object.
You can use this instead of the ``{% get_comment_count for [object] as [varname] %}`` tag.
"""
return get_comments_for_model(content_object).count()
# We've processed the next item now too.
i += 1
if sublist_item:
sublist = _helper(sublist_item, tabs+1)
sublist = '\n%s<ul>\n%s\n%s</ul>\n%s' % (indent, sublist,
indent, indent)
hyperlink = "<a href='%s'>%s</a>" % (title.get_absolute_url(),
title.name)
output.append('%s<li>%s%s</li>' % (indent,
escaper(force_unicode(hyperlink)), sublist))
i += 1
return '\n'.join(output)
value, converted = convert_old_style_list(value)
return mark_safe(_helper(value))
org_outline.is_safe = True
org_outline.needs_autoescape = True
register.filter(org_outline)
def show_task(task):
return {"task": task}
register.inclusion_tag("orgs/task_item.html")(show_task)
def show_aim(aim):
return {"aim": aim}
register.inclusion_tag("orgs/aim_item.html")(show_aim)
def show_meeting_topic(topic):
return {"topic": topic}
register.inclusion_tag("orgs/topic_item.html")(show_meeting_topic)
split = list_len // n
if list_len % n != 0:
split += 1
return [thelist[i::split] for i in range(split)]
def columns_horizontal(thelist, n):
try:
n = int(n)
thelist = list(thelist)
except (ValueError, TypeError):
return [thelist]
list_len = len(thelist)
split = list_len // n
if list_len % n != 0:
split += 1
return [thelist[i * n: (i + 1) * n] for i in range(split)]
register.filter(rows)
register.filter(rows_distributed)
register.filter(columns)
register.filter(columns_horizontal)
def _test():
import doctest
doctest.testmod()
if __name__ == "__main__":
_test()
# Renamed in Django 1.5
from django.template.base import _render_value_in_context as render_value_in_context
trim_whitespace_re = re.compile('\s*\n\s*')
def trim_whitespace(s):
return trim_whitespace_re.sub(' ', s.strip())
register = Library()
register.tag("get_available_languages", do_get_available_languages)
register.tag("get_language_info", do_get_language_info)
register.tag("get_language_info_list", do_get_language_info_list)
register.filter('language_name', language_name)
register.filter('language_name_local', language_name_local)
register.filter('language_bidi', language_bidi)
register.tag("get_current_language", do_get_current_language)
register.tag("get_current_language_bidi", do_get_current_language_bidi)
register.tag("trans", do_translate)
register.tag('language', language)
class BlockTranslateNode(Node):
def __init__(
self, extra_context, singular, plural=None, countervar=None,
counter=None, message_context=None, trimmed=False):
self.extra_context = extra_context
self.singular = singular
new_x, new_y = _recalculate_size(original_size,
index,
divisor=divisor,
padding=padding,
keep_aspect_ratio=keep_aspect_ratio)
return (new_x, new_y)
def extra_padding_x(original_size, padding):
"""
Reduce the width of `original_size` by `padding`
"""
return _resize(original_size, 0, padding=padding)
extra_padding_x = register.filter(extra_padding_x)
def extra_padding_x_keep_ratio(original_size, padding):
"""
Reduce the width of `original_size` by `padding`, maintaining the aspect
ratio.
"""
return _resize(original_size, 0, padding=padding, keep_aspect_ratio=True)
extra_padding_x_keep_ratio = register.filter(extra_padding_x_keep_ratio)
def extra_padding_y(original_size, padding):
"""
from django.template import Library
from django.utils.safestring import mark_safe
from ..api import public_download_url
register = Library()
_hidden_data_field = '<input type="hidden" name="%s" value="%s" />'
@register.simple_tag
def render_upload_data(data):
inputs = ''.join(_hidden_data_field % item for item in data.items())
if inputs:
return mark_safe('<div style="display:none">%s</div>' % inputs)
return ''
register.filter(public_download_url)
new_context.update({'STATIC_URL': settings.STATIC_URL})
else:
new_context.update(context_processors.static(request))
return new_context
@register.tag
def ajax_comment_tags(parser, token):
"""
Display the required ``<div>`` elements to let the Ajax comment functionality work with your form.
"""
return AjaxCommentTags.parse(parser, token)
register.filter('comments_are_open', comments_are_open)
register.filter('comments_are_moderated', comments_are_moderated)
@register.filter
def comments_count(content_object):
"""
Return the number of comments posted at a target object.
You can use this instead of the ``{% get_comment_count for [object] as [varname] %}`` tag.
"""
return get_comments_for_model(content_object).count()
class FluentCommentsList(Node):
def render(self, context):
return ''
value = Decimal(force_text(value))
if value == 0:
return '0 s'
if value % 604800 == 0:
return '%.2f w' % (value / Decimal('604800.0'))
if value % 3600 != 0 and value < 86400:
return '%.2f s' % value
if value % 86400 != 0 and value < 604800:
return '%.2f h' % (value / Decimal('3600'))
return '%.2f d' % (value / Decimal('86400'))
except Exception:
return ''
duration.is_safe = True
register.filter('duration', duration)
#
# Filters to get metadata of a model
#
def verbose_name(obj):
return obj._meta.verbose_name
register.filter(verbose_name)
def verbose_name_plural(obj):
return obj._meta.verbose_name_plural
register.filter(verbose_name_plural)
context['page'] = original_page
bracket_start = marker_start % marker
bracket_end = marker_end % marker
start = rendered.find(bracket_start)
if not start == -1:
start = start + len(bracket_start)
end = rendered.find(bracket_end, start)
return rendered[start:end]
return ""
def hyde_thumbnail(url):
postfix = getattr(settings, 'THUMBNAIL_FILENAME_POSTFIX', '-thumb')
path, ext = url.rsplit('.', 1)
return ''.join([path, postfix, '.', ext])
register.filter(stringfilter(hyde_thumbnail))
@register.filter
def value_for_key(dictionary, key):
if not dictionary:
return ""
if not dictionary.has_key(key):
return ""
value = dictionary[key]
return value
@register.filter
def xmldatetime(dt):
if not dt:
dt = datetime.now()
def truncatehanzi(value, arg):
"""
Truncates a string after a certain number of words including
alphanumeric and CJK characters.
Argument: Number of words to truncate after.
"""
from truncate_hanzi import truncate_hanzi
try:
length = int(arg)
except ValueError: # Invalid literal for int().
return value # Fail silently.
return truncate_hanzi(value, length)
truncatehanzi.is_safe = True
register.filter('truncatehanzi', truncatehanzi)
def url_target_blank(text):
return text.replace('<a ', '<a target="_blank" ')
url_target_blank = register.filter(url_target_blank)
url_target_blank.is_safe = True
def trans_app_label(app_label):
"""
translate app label to Chinese
"""
return settings.APP_LABEL_LOCAL.get(app_label.lower(), app_label)
trans_app_label = register.filter(trans_app_label)
new_context.update({"STATIC_URL": settings.STATIC_URL})
else:
new_context.update(context_processors.static(request))
return new_context
@register.tag
def ajax_comment_tags(parser, token):
"""
Display the required ``<div>`` elements to let the Ajax comment functionality work with your form.
"""
return AjaxCommentTags.parse(parser, token)
register.filter("comments_are_open", comments_are_open)
register.filter("comments_are_moderated", comments_are_moderated)
@register.filter
def comments_count(content_object):
"""
Return the number of comments posted at a target object.
You can use this instead of the ``{% get_comment_count for [object] as [varname] %}`` tag.
"""
return get_comments_for_model(content_object).count()
class FluentCommentsList(Node):
def render(self, context):
from django.template import Library
from apps.Links.models import Link
register = Library()
def links_filter(object_list):
#Recorremos la lista y si el puerto de destino es igual puerto de entrada igualamos el id
for i in range(0, object_list.count()):
for j in range(0, object_list.count()):
if object_list[i].source.id == object_list[j].dest.id:
object_list[j].id = object_list[i].id
#Si dos ids son iguales lo borramos
for i in range(0, object_list.count()):
if object_list[i].id == object_list[i].dest.id:
object_list[i].id = " "
object_list[i].source.id = " "
object_list[i].dest.id = " "
# object_list[0].id = "aaa"
return object_list
register.filter("links_filter", links_filter)
from django.template import Library
import re
register = Library()
r_nofollow = re.compile('<a (?![^>]*nofollow)')
s_nofollow = '<a rel="nofollow" '
def nofollow(value):
return r_nofollow.sub(s_nofollow, value)
register.filter(nofollow)
#coding=utf-8
from datetime import datetime
from django.template import Library
register = Library()
'''{{ val | format_time }}'''
def format_time(value):
print(value)
cur_time= datetime.now().timestamp()
inter_time = int((cur_time - value.timestamp()))
if inter_time <= 60:
return "%s秒前" % inter_time
if inter_time <= 60*60:
return "%s分钟前" % int(inter_time/60)
if inter_time <= 60*60*24:
return "%s小时前" % int(inter_time/60/60)
if inter_time <= 60*60*24*30:
return "%s天前" % int(inter_time/60/60/24)
if inter_time <= 60*60*24*30*12:
return "%s月前" % int(inter_time/60/60/24/30)
return "%年前" % int(inter_time/60/60/24/30/12)
register.filter('format_time',format_time)
#name of the variable that will contain the subcube
subcube_var = bits[-1]
#turns the cube argument into a template.Variable
cube = parser.compile_filter(bits[1])
#gets all the nodes contained in the tag
nodelist = parser.parse(('end%s' % tagname,))
#next token is *endsubcubes* so we delete it
parser.delete_first_token()
return SubcubesNode(cube, dimensions, subcube_var, nodelist)
do_subcubes = register.tag("subcubes", do_subcubes)
def prettyconstraint(cube, dim_name):
"""
Filter to get the value of the constraint for a dimension. Use it as : ::
{{ cube|prettyconstraint:'dimension_name' }}
"""
return cube.dimensions[dim_name].pretty_constraint
register.filter('prettyconstraint', prettyconstraint)
s = s[:length].strip()
else:
words = s[:length].split()
if len(words) > 1:
del words[-1]
s = (u" ".join(words)).rstrip(":-,. ")
s += "..."
return s
truncate_chars = allow_lazy(truncate_chars, unicode)
def truncatechars(value, arg):
"""
Truncates a string after a certain number of characters, but respects word boundaries.
Argument: Number of characters to truncate after.
"""
try:
length = int(arg)
except ValueError: # If the argument is not a valid integer.
return value # Fail silently.
return truncate_chars(value, length)
truncatechars.is_safe = True
truncatechars = stringfilter(truncatechars)
register.filter(truncatechars)
from django.template import Library
register = Library()
def get_verbose_name(meta, field):
return meta.get_field(field).verbose_name
register.filter(get_verbose_name)
def activity_stream(context, stream_type, *args, **kwargs):
"""
Renders an activity stream as a list into the template's context.
Streams loaded by stream_type can be the default ones (eg user, actor, etc.) or a user defined stream.
Extra args/kwargs are passed into the stream call.
::
{% activity_stream 'actor' user %}
{% for action in stream %}
{% display_action action %}
{% endfor %}
"""
if stream_type == 'model':
stream_type = 'model_actions'
if not hasattr(Action.objects, stream_type):
raise TemplateSyntaxError('Action manager has no attribute: %s' % stream_type)
ctxvar = kwargs.pop('as', 'stream')
context[ctxvar] = getattr(Action.objects, stream_type)(*args, **kwargs)
return ''
register.filter(activity_stream)
register.filter(is_following)
register.tag(display_action)
register.tag(follow_url)
register.tag(follow_all_url)
register.tag(actor_url)
register.simple_tag(takes_context=True)(activity_stream)
return ''
value = Decimal(force_text(value))
if value == 0:
return '0 s'
if value % 604800 == 0:
return '%.2f w' % (value / Decimal('604800.0'))
if value % 3600 != 0 and value < 86400:
return '%.2f s' % value
if value % 86400 != 0 and value < 604800:
return '%.2f h' % (value / Decimal('3600'))
return '%.2f d' % (value / Decimal('86400'))
except Exception:
return ''
register.filter('duration', duration, is_safe=True)
#
# A filter to order a list
#
def sortList(inputList):
return sorted(inputList)
register.filter('sortList', sortList)
#
# Filters to get metadata of a model
#
"""Takes a phone number and converts it in to its numerical equivalent."""
from django.utils.text import phone2numeric
return phone2numeric(value)
phone2numeric.is_safe = True
def pprint(value):
"""A wrapper around pprint.pprint -- for debugging, really."""
from pprint import pformat
try:
return pformat(value)
except Exception as e:
return "Error in formatting: %s" % force_unicode(e, errors="replace")
pprint.is_safe = True
# Syntax: register.filter(name of filter, callback)
register.filter(add)
register.filter(addslashes)
register.filter(capfirst)
register.filter(center)
register.filter(cut)
register.filter(date)
register.filter(default)
register.filter(default_if_none)
register.filter(dictsort)
register.filter(dictsortreversed)
register.filter(divisibleby)
register.filter(escape)
register.filter(escapejs)
register.filter(filesizeformat)
register.filter(first)
register.filter(fix_ampersands)
from django.template import Node
from django.template import Library
from vendor.timezones.utilities import localtime_for_timezone
register = Library()
def localtime(value, timezone):
return localtime_for_timezone(value, timezone)
register.filter("localtime", localtime)
register = Library()
@stringfilter
def spacify(value, autoescape=None):
"""https://stackoverflow.com/questions/721035/django-templates-stripping-spaces"""
if autoescape:
esc = conditional_escape
else:
esc = lambda x: x
return mark_safe(re.sub('\s', '&' + 'nbsp;', esc(value)))
spacify.needs_autoescape = True
register.filter(spacify)
@stringfilter
def tablify_report(report: str):
report = eval(report)
t = """<table class="center">
<tr>
<th>Member</th>
<th>Precision</th>
<th>Recall</th>
<th>F1-Score</th>
<th>Support</th>
</tr>
"""
for name, metrics in report.items():
