VisEvol: Visual Analytics to Support Hyperparameter Search through Evolutionary Optimization
https://doi.org/10.1111/cgf.14300
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
135 lines
4.1 KiB
135 lines
4.1 KiB
Metadata-Version: 2.1
|
|
Name: MarkupSafe
|
|
Version: 1.0
|
|
Summary: Implements a XML/HTML/XHTML Markup safe string for Python
|
|
Home-page: http://github.com/pallets/markupsafe
|
|
Author: Armin Ronacher
|
|
Author-email: armin.ronacher@active-4.com
|
|
License: BSD
|
|
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
|
|
|
|
MarkupSafe
|
|
==========
|
|
|
|
Implements a unicode subclass that supports HTML strings:
|
|
|
|
.. code-block:: python
|
|
|
|
>>> from markupsafe import Markup, escape
|
|
>>> escape("<script>alert(document.cookie);</script>")
|
|
Markup(u'<script>alert(document.cookie);</script>')
|
|
>>> tmpl = Markup("<em>%s</em>")
|
|
>>> tmpl % "Peter > Lustig"
|
|
Markup(u'<em>Peter > 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).
|
|
|
|
.. code-block:: python
|
|
|
|
>>> 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:
|
|
|
|
.. code-block:: python
|
|
|
|
>>> 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:
|
|
|
|
.. code-block:: python
|
|
|
|
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:
|
|
|
|
.. code-block:: python
|
|
|
|
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:
|
|
|
|
.. code-block:: python
|
|
|
|
>>> 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>')
|
|
|
|
Markupsafe supports Python 2.6, 2.7 and Python 3.3 and higher.
|
|
|
|
|
|
|