我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用django.utils.safestring.SafeData()。
def render(self, context): self.filter_expression.var.translate = not self.noop if self.message_context: self.filter_expression.var.message_context = ( self.message_context.resolve(context)) output = self.filter_expression.resolve(context) value = render_value_in_context(output, context) # Restore percent signs. Percent signs in template text are doubled # so they are not interpreted as string format flags. is_safe = isinstance(value, SafeData) value = value.replace('%%', '%') value = systemtext(value, group=self.group, default=self.default) value = mark_safe(value) if is_safe else value if self.asvar: context[self.asvar] = value return '' else: return value
def render(self, context): self.filter_expression.var.translate = not self.noop if self.message_context: self.filter_expression.var.message_context = ( self.message_context.resolve(context)) output = self.filter_expression.resolve(context) value = render_value_in_context(output, context) # Restore percent signs. Percent signs in template text are doubled # so they are not interpreted as string format flags. is_safe = isinstance(value, SafeData) value = value.replace('%%', '%') value = mark_safe(value) if is_safe else value if self.asvar: context[self.asvar] = value return '' else: return value
def test_safedata(self): """ Tests that a message containing SafeData is keeping its safe status when retrieved from the message storage. """ def encode_decode(data): message = Message(constants.DEBUG, data) encoded = storage._encode(message) decoded = storage._decode(encoded) return decoded.message storage = self.get_storage() self.assertIsInstance( encode_decode(mark_safe("<b>Hello Django!</b>")), SafeData) self.assertNotIsInstance( encode_decode("<b>Hello Django!</b>"), SafeData)
def render(self, context): try: output = self.filter_expression.resolve(context) output = template_localtime(output, use_tz=context.use_tz) output = localize(output, use_l10n=context.use_l10n) output = force_text(output) except UnicodeDecodeError: return '' except Exception as e: if not hasattr(e, 'django_template_source'): e.django_template_source = self.source raise if (context.autoescape and not isinstance(output, SafeData)) or isinstance(output, EscapeData): return conditional_escape(output) else: return output
def default(self, obj): if isinstance(obj, Message): # Using 0/1 here instead of False/True to produce more compact json is_safedata = 1 if isinstance(obj.message, SafeData) else 0 message = [self.message_key, is_safedata, obj.level, obj.message] if obj.extra_tags: message.append(obj.extra_tags) return message return super(MessageEncoder, self).default(obj)
def stringfilter(func): """ Decorator for filters which should only receive unicode objects. The object passed as the first positional argument will be converted to a unicode object. """ def _dec(*args, **kwargs): if args: args = list(args) args[0] = force_text(args[0]) if (isinstance(args[0], SafeData) and getattr(_dec._decorated_function, 'is_safe', False)): return mark_safe(func(*args, **kwargs)) return func(*args, **kwargs) # Include a reference to the real function (used to check original # arguments by the template parser, and to bear the 'is_safe' attribute # when multiple decorators are applied). _dec._decorated_function = getattr(func, '_decorated_function', func) return wraps(func)(_dec) ################### # STRINGS # ###################
def linenumbers(value, autoescape=True): """Displays text with line numbers.""" lines = value.split('\n') # Find the maximum width of the line count, for use with zero padding # string format command width = six.text_type(len(six.text_type(len(lines)))) if not autoescape or isinstance(value, SafeData): for i, line in enumerate(lines): lines[i] = ("%0" + width + "d. %s") % (i + 1, line) else: for i, line in enumerate(lines): lines[i] = ("%0" + width + "d. %s") % (i + 1, escape(line)) return mark_safe('\n'.join(lines))
def cut(value, arg): """ Removes all values of arg from the given string. """ safe = isinstance(value, SafeData) value = value.replace(arg, '') if safe and arg != ';': return mark_safe(value) return value ################### # HTML STRINGS # ###################
def linebreaks_filter(value, autoescape=True): """ Replaces line breaks in plain text with appropriate HTML; a single newline becomes an HTML line break (``<br />``) and a new line followed by a blank line becomes a paragraph break (``</p>``). """ autoescape = autoescape and not isinstance(value, SafeData) return mark_safe(linebreaks(value, autoescape))
def do_translate(message, translation_function): """ Translates 'message' using the given 'translation_function' name -- which will be either gettext or ugettext. It uses the current thread to find the translation object to use. If no current translation is activated, the message will be run through the default translation object. """ global _default # str() is allowing a bytestring message to remain bytestring on Python 2 eol_message = message.replace(str('\r\n'), str('\n')).replace(str('\r'), str('\n')) if len(eol_message) == 0: # Returns an empty value of the corresponding type if an empty message # is given, instead of metadata, which is the default gettext behavior. result = type(message)("") else: _default = _default or translation(settings.LANGUAGE_CODE) translation_object = getattr(_active, "value", _default) result = getattr(translation_object, translation_function)(eol_message) if isinstance(message, SafeData): return mark_safe(result) return result
def conditional_escape(text): """ Similar to escape(), except that it doesn't operate on pre-escaped strings. This function relies on the __html__ convention used both by Django's SafeData class and by third-party libraries like markupsafe. """ if hasattr(text, '__html__'): return text.__html__() else: return escape(text)
def django_filter_to_jinja2(filter_func): """ Note: Due to the way this function is used by ``coffin.template.Library``, it needs to be able to handle native Jinja2 filters and pass them through unmodified. This necessity stems from the fact that it is not always possible to determine the type of a filter. TODO: Django's "func.is_safe" is not yet handled """ def _convert_out(v): if isinstance(v, SafeData): return Markup(v) if isinstance(v, EscapeData): return Markup.escape(v) # not 100% equivalent, see mod docs return v def _convert_in(v): if isinstance(v, Undefined): # Essentially the TEMPLATE_STRING_IF_INVALID default # setting. If a non-default is set, Django wouldn't apply # filters. This is something that we neither can nor want to # simulate in Jinja. return '' return v def conversion_wrapper(value, *args, **kwargs): result = filter_func(_convert_in(value), *args, **kwargs) return _convert_out(result) # Jinja2 supports a similar machanism to Django's # ``needs_autoescape`` filters: environment filters. We can # thus support Django filters that use it in Jinja2 with just # a little bit of argument rewriting. if hasattr(filter_func, 'needs_autoescape'): @environmentfilter def autoescape_wrapper(environment, *args, **kwargs): kwargs['autoescape'] = environment.autoescape return conversion_wrapper(*args, **kwargs) return autoescape_wrapper else: return conversion_wrapper
def test_render_safe_html(self): html = self.widget.render('honeypot_field', '') self.assertIsInstance(html, SafeData)
def test_render_return_html(self): html = self.widget.render('captcha', '1234') self.assertIsInstance(html, SafeData)
def blog(value, autoescape=True): """[spam]ham[end]????????????HTML???????. >>> blog('[filter html]<h1>Hello</h1>[end]') '<h1>Hello</h1>' >>> blog('[filter html]<h1>Hello</h1>[end]\ [filter url]https://torina.top[end]') '<h1>Hello</h1><a target="_blank" rel="nofollow" \ href="https://torina.top" rel="nofollow">https://torina.top</a>' """ autoescape = autoescape and not isinstance(value, SafeData) if autoescape: value = escape(value) filters = re.finditer(r'\[filter (?P<tag_name>.*?)\].*?\[end\]', value) results = [] for f in filters: filter_name = f.group('tag_name') origin_text = f.group() filter_function = globals().get(filter_name) if filter_function and callable(filter_function): result_text = filter_function(origin_text) else: result_text = origin_text results.append((origin_text, result_text)) for origin_text, result_text in results: if origin_text != result_text: value = value.replace(origin_text, result_text) return mark_safe(value)
