def urlize(text, trim_url_limit=None, nofollow=False, autoescape=False):
"""
Converts any URLs in text into clickable links.
Works on http://, https://, www. links and links ending in .org, .net or
.com. Links can have trailing punctuation (periods, commas, close-parens)
and leading punctuation (opening parens) and it'll still do the right
thing.
If trim_url_limit is not None, the URLs in link text longer than this limit
will truncated to trim_url_limit-3 characters and appended with an elipsis.
If nofollow is True, the URLs in link text will get a rel="nofollow"
attribute.
If autoescape is True, the link text and URLs will get autoescaped.
"""
trim_url = lambda x, limit=trim_url_limit: limit is not None and (len(x) > limit and ('%s...' % x[:max(0, limit - 3)])) or x
safe_input = isinstance(text, SafeData)
words = word_split_re.split(force_unicode(text))
nofollow_attr = nofollow and ' rel="nofollow"' or ''
for i, word in enumerate(words):
match = None
if '.' in word or '@' in word or ':' in word:
match = punctuation_re.match(word)
if match:
lead, middle, trail = match.groups()
# Make URL we want to point to.
url = None
if middle.startswith('http://') or middle.startswith('https://'):
url = urlquote(middle, safe='/&=:;#?+*')
elif middle.startswith('www.') or ('@' not in middle and \
middle and middle[0] in string.ascii_letters + string.digits and \
(middle.endswith('.org') or middle.endswith('.net') or middle.endswith('.com'))):
url = urlquote('http://%s' % middle, safe='/&=:;#?+*')
elif '@' in middle and not ':' in middle and simple_email_re.match(middle):
url = 'mailto:%s' % middle
nofollow_attr = ''
# Make link.
if url:
trimmed = trim_url(middle)
if autoescape and not safe_input:
lead, trail = escape(lead), escape(trail)
url, trimmed = escape(url), escape(trimmed)
middle = '<a href="%s"%s>%s</a>' % (url, nofollow_attr, trimmed)
words[i] = mark_safe('%s%s%s' % (lead, middle, trail))
else:
if safe_input:
words[i] = mark_safe(word)
elif autoescape:
words[i] = escape(word)
elif safe_input:
words[i] = mark_safe(word)
elif autoescape:
words[i] = escape(word)
return u''.join(words)
def render(self, name, value):
if not self.attachments or not self.attachments.count():
return ""
output = []
for doc in self.attachments:
storage_info = doc["storage_info"]
if not storage_info:
thumb = ""
elif storage_info.get("thumb_url", None):
thumb = '<div class="thumb" style="background-image:url(\'%s\')"/>' % storage_info["thumb_url"]
else:
thumb = '<div class="no-thumb">%s</div>' % MIME_LABELS.get(doc["mime_type"], doc["mime_type"])
output.append(
'<li><a href="%(url)s">%(title)s %(thumb)s</a><br/><span><input type="checkbox" value="%(id)s" name="%(name)s"/>Remove</span></li>'
% {
"url": storage_info["download_url"] if storage_info else "",
"title": doc["title"],
"thumb": thumb,
"id": doc["pk"],
"name": name,
}
)
return mark_safe(u'<ul class="attachments">%s</ul>' % u"".join(output))
def get_content(self, lang='default'):
regex = re.compile("\{(IMAGE|COLLECTION|ALL|FORM):(.*?)\}")
content = page_get_content.send(instance=self, lang=lang, regex=regex)
if not len(content) or not content[0]:
content = mark_safe(regex.sub('', self['text']))
else:
content = content[0]
return content
def get_content(self, lang='default'):
regex = re.compile("\{(IMAGE|COLLECTION|ALL|FORM):(.*?)\}")
content = page_get_content.send(instance=self, lang=lang, regex=regex)
if not len(content) or not content[0]:
content = mark_safe(regex.sub('', self['text']))
else:
content = content[0]
return content
def render(self, name, value, attrs=None):
self.attrs = attrs or {}
self.attrs['name'] = name
self.attrs.setdefault('id', 'id_'+name)
return mark_safe(u'<textarea %(attrs)s>%(value)s</textarea>'%{
'attrs': ' '.join(['%s="%s"'%(k,v) for k,v in self.attrs.items()]),
'value': value or '',
})
def render(self, name, value, attrs=None):
self.attrs = attrs or {}
self.attrs['name'] = name
self.attrs.setdefault('id', 'id_'+name)
options = [u'<option value="%s"%s>%s</option>'%(k, self.get_selected(value, k), v)
for k,v in self.choices]
return mark_safe(u'<select %(attrs)s>%(options)s</select>'%{
'attrs': ' '.join(['%s="%s"'%(k,v) for k,v in self.attrs.items()]),
'options': ''.join(options),
})
def clean(self, value):
value = super(MarkdownField, self).clean(value)
if not isinstance(value, basestring):
raise ValidationError('Invalid type. Expected string: %s'%value)
try:
value = markdown2.markdown(mark_safe(value))
except:
raise ValidationError('Error markdown: %s'%value)
#value = ''
else:
return value or ''
def render(self, name, value, attrs=None):
value = unicode(value or '')
choices_dict = dict([(unicode(k), unicode(v)) for k,v in self.choices if k])
attrs = attrs or {}
attrs['autocomplete'] = 'off'
if self.accept_not_found:
attrs['class'] = attrs.get('class', '') + ' accept-not-found'
ret = super(StaticAutoCompleteWidget, self).render('_'+name, choices_dict.get(value, value), attrs)
options = '<ul class="static-auto-complete-options">%(options)s</ul>'%{
'options': ''.join(['<li class="auto-complete-option" rel="%s"><a href="javascript:void(0)">%s</a></li>'%(k,v) for k,v in self.choices if k not in ('',None)]),
}
hidden = '<input type="hidden" name="%s" value="%s"/>'%(name, value or '')
return mark_safe('<span class="static-auto-complete-container">%s %s %s</span>'%(ret, options, hidden))
def clean_value(self, inst, value):
# Try to import markdonw2
try:
import markdown2
except ImportError:
markdown2 = None
#raise ValidationError('Cannot import markdown2')
if not isinstance(value, basestring):
raise ValidationError('Invalid type. Expected string: %s'%value)
try:
value = markdown2.markdown(mark_safe(value))
except:
raise ValidationError('Error markdown: %s'%value)
else:
return value or ''
def render(self, name, value, attrs=None):
attrs = attrs or {}
if self.attrs:
attrs.update(self.attrs)
attrs['name'] = name
# FIXME: maybe this should be moved with an opposite way to CheckboxInput
if self.input_type != 'checkbox':
attrs['value'] = self._format_value(value) if value is not None else ''
attrs.setdefault('id', 'id_'+name)
if self.readonly:
attrs.setdefault('readonly', 'readonly')
if self.input_type:
attrs['type'] = self.input_type
self.attrs.update(attrs) # XXX from the MERGE
return mark_safe(u'<input %s/>'%' '.join(['%s="%s"'%(key,value) for key,value in attrs.items()]))
def format(number, decimal_sep, decimal_pos=None, grouping=0, thousand_sep='', force_grouping=False):
"""
Gets a number (as a number or string), and returns it as a string,
using formats definied as arguments:
* decimal_sep: Decimal separator symbol (for example ".")
* decimal_pos: Number of decimal positions
* grouping: Number of digits in every group limited by thousand separator
* thousand_sep: Thousand separator symbol (for example ",")
"""
use_grouping = force_grouping or settings.USE_L10N and \
settings.USE_THOUSAND_SEPARATOR and grouping
# Make the common case fast:
if isinstance(number, int) and not use_grouping and not decimal_pos:
return mark_safe(unicode(number))
# sign
if float(number) < 0:
sign = '-'
else:
sign = ''
str_number = unicode(number)
if str_number[0] == '-':
str_number = str_number[1:]
# decimal part
if '.' in str_number:
int_part, dec_part = str_number.split('.')
if decimal_pos is not None:
dec_part = dec_part[:decimal_pos]
else:
int_part, dec_part = str_number, ''
if decimal_pos is not None:
dec_part = dec_part + ('0' * (decimal_pos - len(dec_part)))
if dec_part: dec_part = decimal_sep + dec_part
# grouping
if use_grouping:
int_part_gd = ''
for cnt, digit in enumerate(int_part[::-1]):
if cnt and not cnt % grouping:
int_part_gd += thousand_sep
int_part_gd += digit
int_part = int_part_gd[::-1]
return sign + int_part + dec_part
def localize(value, use_l10n=None):
"""
Checks if value is a localizable type (date, number...) and returns it
formatted as a string using current locale format.
If use_l10n is provided and is not None, that will force the value to
be localized (or not), overriding the value of settings.USE_L10N.
"""
if isinstance(value, bool):
return mark_safe(unicode(value))
elif isinstance(value, (decimal.Decimal, float, int, long)):
return number_format(value, use_l10n=use_l10n)
elif isinstance(value, datetime.datetime):
return date_format(value, 'DATETIME_FORMAT', use_l10n=use_l10n)
elif isinstance(value, datetime.date):
return date_format(value, use_l10n=use_l10n)
elif isinstance(value, datetime.time):
return time_format(value, 'TIME_FORMAT', use_l10n=use_l10n)
else:
return value
def render(self, page_number=None):
page_number = page_number or self.request.GET.get('_page', 1)
try:
page_obj = self.page(page_number)
except EmptyPage:
raise Http404
pages = get_page_range(self.page_range, page_number, self.pages_around_current)
query_params = self.request.META.get('QUERY_STRING','').split('&')
query_params = '&'.join([q for q in query_params if not q.startswith('_page')])
html = render_to_string(
'pagination/pagination.html',
{
'pages': pages,
'page_obj': page_obj,
'paginator': self,
'is_paginated': self.count > self.per_page,
'query_params': '&'+query_params,
},
)
return mark_safe(html)
def canonical_url_tag():
protocol = 'https' if request.is_secure() else 'http'
host = request.site['hostname'] if getattr(request, 'site', None) else request.META['HTTP_HOST']
query_string = ('?'+request.META['QUERY_STRING']) if request.META.get('QUERY_STRING','') else ''
current_url = '%s://%s%s%s'%(protocol, request.META['HTTP_HOST'], request.path_info, query_string)
canonical_url = None
if app_settings.CANONICAL_URL_FUNCTION:
try:
func = import_anything(app_settings.CANONICAL_URL_FUNCTION)
canonical_url = func(request)
except ImportError:
pass
if not canonical_url:
canonical_url = '%s://%s%s%s'%(protocol, host, request.path_info, query_string)
if current_url != canonical_url:
return mark_safe('<link rel="canonical" href="%s"/>'%canonical_url)
else:
return ''
def render(self, name, value, attrs=None):
self.attrs = attrs or {}
self.attrs.setdefault('id', 'id_'+name)
options = []
for pk,display in self.choices:
item_attrs = self.get_item_attrs(pk, display)
options.append(
u'<li><input type="checkbox" name="%(name)s[%(pk)s]" value="%(pk)s" id="%(id)s" %(sel)s %(attrs)s /> <label for="%(id)s">%(display)s</label></li>'%{
'name': name,
'pk': pk,
'id': 'id_%s_%s'%(name,pk),
'sel': self.get_selected(value, pk),
'display': display,
'attrs': ' '.join(['%s="%s"'%(k,v) for k,v in item_attrs.items()]),
})
return mark_safe(u'<ul %(attrs)s>%(options)s</ul>'%{
'attrs': ' '.join(['%s="%s"'%(k,v) for k,v in self.attrs.items()]),
'options': ''.join(options),
})
def render(self, name, value, attrs=None):
substitutions = {
'initial_text': self.initial_text,
'input_text': self.input_text,
'clear_template': '',
'clear_checkbox_label': self.clear_checkbox_label,
}
template = u'%(input)s'
substitutions['input'] = super(ClearableFileInput, self).render(name, value, attrs)
if value and hasattr(value, "url"):
template = self.template_with_initial
substitutions['initial'] = (u'<a href="%s" rel="nohistory">%s</a>'
% (escape(value.url), escape(force_unicode(value))))
if not self.is_required:
checkbox_name = self.clear_checkbox_name(name)
checkbox_id = self.clear_checkbox_id(checkbox_name)
substitutions['clear_checkbox_name'] = conditional_escape(checkbox_name)
substitutions['clear_checkbox_id'] = conditional_escape(checkbox_id)
substitutions['clear'] = CheckboxInput().render(checkbox_name, False, attrs={'id': checkbox_id})
substitutions['clear_template'] = self.template_with_clear % substitutions
return mark_safe(template % substitutions)
def render(self, name, value):
if not self.attachments or not self.attachments.count():
return ''
output = []
for doc in self.attachments:
storage_info = doc['storage_info']
if not storage_info:
thumb = ''
elif storage_info.get('thumb_url',None):
thumb = '<div class="thumb" style="background-image:url(\'%s\')"/>' % storage_info['thumb_url']
else:
thumb = '<div class="no-thumb">%s</div>' % MIME_LABELS.get(doc['mime_type'],doc['mime_type'])
output.append('<li><a href="%(url)s">%(title)s %(thumb)s</a><br/><span><input type="checkbox" value="%(id)s" name="%(name)s"/>Remove</span></li>' % {
'url': storage_info['download_url'] if storage_info else '',
'title': doc['title'],
'thumb': thumb,
'id': doc['pk'],
'name': name,
})
return mark_safe(u'<ul class="attachments">%s</ul>' % u''.join(output))
def get_content(self):
return mark_safe(self['body'])
def get_teaser(self):
return mark_safe(self["teaser"])
def render(self, name, value, attrs=None):
output = self.render_in_separate(name, value, attrs)
return mark_safe(self.format_output(output))
def render(self):
return mark_safe(u'\n'.join(chain(*[getattr(self, 'render_' + name)() for name in MEDIA_TYPES])))
def get_teaser(self):
return mark_safe(self['teaser'])
def render_label(self, name, label):
return mark_safe(u'<h2><span>%s</span></h2>' % name)
def escape(html):
"""
Returns the given HTML with ampersands, quotes and angle brackets encoded.
"""
return mark_safe(force_unicode(html).replace('&', '&').replace('<', '<').replace('>', '>').replace('"', '"').replace("'", '''))
def render_help_box(self, name, help_text):
if not help_text:
return ''
return mark_safe(u'<span class="help_text" for="%s">%s</span>'%(self.attrs.get('id', name), help_text))
def render_errors(self, name, errors):
if not errors:
return ''
return mark_safe(unicode(errors))
def render_label(self, name, label):
return mark_safe(u'<label for="%s">%s:</label>'%(self.attrs.get('id', name), label))
def escapejs(value):
"""Hex encodes characters for use in JavaScript strings."""
for bad, good in _js_escapes:
value = mark_safe(force_unicode(value).replace(bad, good))
return value
def __unicode__(self):
return u"Breadcrumbs <%s>" % u", ".join([mark_safe(item.name) for item in \
self[:10]] + [u' ...'])
def get_content(self):
return mark_safe(self["text"])
def get_full_path(self):
return mark_safe(
self.path_info + ("?" + self.META["QUERY_STRING"] if self.META.get("QUERY_STRING", None) else "")
)
def render_label(self, name, label):
return mark_safe(u'<h2><span>%s</span></h2>' % name)
def get_content(self):
return mark_safe(self['text'])
def __unicode__(self):
return u"Breadcrumbs <%s>" % u", ".join([mark_safe(item.name) for item in \
self[:10]] + [u' ...'])