diff venv/lib/python2.7/site-packages/MarkupSafe-0.23-py2.7.egg-info/PKG-INFO @ 0:d67268158946 draft

planemo upload commit a3f181f5f126803c654b3a66dd4e83a48f7e203b

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/venv/lib/python2.7/site-packages/MarkupSafe-0.23-py2.7.egg-info/PKG-INFO	Mon Oct 12 17:43:33 2015 -0400
@@ -0,0 +1,119 @@
+Metadata-Version: 1.1
+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: [e-mail]
+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