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():