DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Mercurial (a41a482b7876)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
Metadata-Version: 1.0
Name: MarkupSafe
Version: 0.23
Summary: Implements a XML/HTML/XHTML Markup safe string for Python
Home-page: http://github.com/mitsuhiko/markupsafe
Author: Armin Ronacher
Author-email: armin.ronacher@active-4.com
License: BSD
Description: MarkupSafe
        ==========
        
        Implements a unicode subclass that supports HTML strings:
        
        >>> from markupsafe import Markup, escape
        >>> escape("<script>alert(document.cookie);</script>")
        Markup(u'&lt;script&gt;alert(document.cookie);&lt;/script&gt;')
        >>> tmpl = Markup("<em>%s</em>")
        >>> tmpl % "Peter > Lustig"
        Markup(u'<em>Peter &gt; Lustig</em>')
        
        If you want to make an object unicode that is not yet unicode
        but don't want to lose the taint information, you can use the
        `soft_unicode` function.  (On Python 3 you can also use `soft_str` which
        is a different name for the same function).
        
        >>> from markupsafe import soft_unicode
        >>> soft_unicode(42)
        u'42'
        >>> soft_unicode(Markup('foo'))
        Markup(u'foo')
        
        HTML Representations
        --------------------
        
        Objects can customize their HTML markup equivalent by overriding
        the `__html__` function:
        
        >>> class Foo(object):
        ...  def __html__(self):
        ...   return '<strong>Nice</strong>'
        ...
        >>> escape(Foo())
        Markup(u'<strong>Nice</strong>')
        >>> Markup(Foo())
        Markup(u'<strong>Nice</strong>')
        
        Silent Escapes
        --------------
        
        Since MarkupSafe 0.10 there is now also a separate escape function
        called `escape_silent` that returns an empty string for `None` for
        consistency with other systems that return empty strings for `None`
        when escaping (for instance Pylons' webhelpers).
        
        If you also want to use this for the escape method of the Markup
        object, you can create your own subclass that does that::
        
            from markupsafe import Markup, escape_silent as escape
        
            class SilentMarkup(Markup):
                __slots__ = ()
        
                @classmethod
                def escape(cls, s):
                    return cls(escape(s))
        
        New-Style String Formatting
        ---------------------------
        
        Starting with MarkupSafe 0.21 new style string formats from Python 2.6 and
        3.x are now fully supported.  Previously the escape behavior of those
        functions was spotty at best.  The new implementations operates under the
        following algorithm:
        
        1.  if an object has an ``__html_format__`` method it is called as
            replacement for ``__format__`` with the format specifier.  It either
            has to return a string or markup object.
        2.  if an object has an ``__html__`` method it is called.
        3.  otherwise the default format system of Python kicks in and the result
            is HTML escaped.
        
        Here is how you can implement your own formatting::
        
            class User(object):
        
                def __init__(self, id, username):
                    self.id = id
                    self.username = username
        
                def __html_format__(self, format_spec):
                    if format_spec == 'link':
                        return Markup('<a href="/user/{0}">{1}</a>').format(
                            self.id,
                            self.__html__(),
                        )
                    elif format_spec:
                        raise ValueError('Invalid format spec')
                    return self.__html__()
        
                def __html__(self):
                    return Markup('<span class=user>{0}</span>').format(self.username)
        
        And to format that user:
        
        >>> user = User(1, 'foo')
        >>> Markup('<p>User: {0:link}').format(user)
        Markup(u'<p>User: <a href="/user/1"><span class=user>foo</span></a>')
        
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Environment :: Web Environment
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: BSD License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 3
Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Topic :: Text Processing :: Markup :: HTML