Your IP : 216.73.216.213
2�kSb( � @ sp d Z d d l Z d d l Z d d l m Z d d l m Z m Z m Z m Z m
Z
m Z d d d d g Z e j
d � Z e j
d
� Z Gd d � d e � Z Gd d
� d
e � Z e e d � r� Gd d � d e j � Z d d � Z Gd d � d e � Z y d d l m Z m Z m Z Wn. e k
rRd d l m Z m Z m Z Yn Xe sle Z e j d � d S)z�
markupsafe
~~~~~~~~~~
Implements a Markup string.
:copyright: (c) 2010 by Armin Ronacher.
:license: BSD, see LICENSE for more details.
� N)�Mapping)� text_type� string_types� int_types�unichr� iteritems�PY2�Markup� soft_unicode�escape�
escape_silentz(<!--.*?-->|<[^>]*>)z &([^;]+);c s� e Z d Z d Z f Z d d d d d � Z d d � Z � f d d
� Z d d � Z d
d � Z e Z
d d � Z d d � Z d d � Z
e j
j e
_ d d � Z e j j e _ d d � Z e j j e _ d d � Z e j j e _ d d � Z d d � Z e d d � � Z d! d" � Z x! d> D] Z e e � e � e <q*We e d3 � rnd4 d5 � Z d6 d7 � Z e e d8 � r�d9 d: � Z d; d< � Z e e d= � r�e d= � Z [ [ � S)?r a Marks a string as being safe for inclusion in HTML/XML output without
needing to be escaped. This implements the `__html__` interface a couple
of frameworks and web applications use. :class:`Markup` is a direct
subclass of `unicode` and provides all the methods of `unicode` just that
it escapes arguments passed and always returns `Markup`.
The `escape` function returns markup objects so that double escaping can't
happen.
The constructor of the :class:`Markup` class can be used for three
different things: When passed an unicode object it's assumed to be safe,
when passed an object with an HTML representation (has an `__html__`
method) that representation is used, otherwise the object passed is
converted into a unicode string and then assumed to be safe:
>>> Markup("Hello <em>World</em>!")
Markup(u'Hello <em>World</em>!')
>>> class Foo(object):
... def __html__(self):
... return '<a href="#">foo</a>'
...
>>> Markup(Foo())
Markup(u'<a href="#">foo</a>')
If you want object passed being always treated as unsafe you can use the
:meth:`escape` classmethod to create a :class:`Markup` object:
>>> Markup.escape("Hello <em>World</em>!")
Markup(u'Hello <em>World</em>!')
Operations on a markup string are markup aware which means that all
arguments are passed through the :func:`escape` function:
>>> em = Markup("<em>%s</em>")
>>> em % "foo & bar"
Markup(u'<em>foo & bar</em>')
>>> strong = Markup("<strong>%(text)s</strong>")
>>> strong % {'text': '<blink>hacker here</blink>'}
Markup(u'<strong><blink>hacker here</blink></strong>')
>>> Markup("<em>Hello</em> ") + "<foo>"
Markup(u'<em>Hello</em> <foo>')
� N�strictc C sM t | d � r | j � } | d k r7 t j | | � St j | | | | � S)N�__html__)�hasattrr r �__new__)�cls�base�encoding�errors� r �F/opt/alt/python35/lib64/python3.5/site-packages/markupsafe/__init__.pyr F s
zMarkup.__new__c C s | S)Nr )�selfr r r r M s zMarkup.__html__c sJ t | t � s t | d � rF | j t t | � j | j | � � � St S)Nr ) �
isinstancer r � __class__�superr �__add__r �NotImplemented)r �other)r r r r P s (zMarkup.__add__c C s8 t | d � s t | t � r4 | j | � j | � St S)Nr )r r r r r r )r r r r r �__radd__U s zMarkup.__radd__c C s, t | t � r( | j t j | | � � St S)N)r r r r �__mul__r )r �numr r r r Z s zMarkup.__mul__c s\ t | t � r1 t � f d d � | D� � } n t | � j � } � j t j � | � � S)Nc 3 s! | ] } t | � j � Vq d S)N)�_MarkupEscapeHelperr )�.0�x)r r r � <genexpr>b s z!Markup.__mod__.<locals>.<genexpr>)r �tupler" r r r �__mod__)r �argr )r r r' ` s "zMarkup.__mod__c C s d | j j t j | � f S)Nz%s(%s))r �__name__r �__repr__)r r r r r* g s zMarkup.__repr__c C s% | j t j | t | j | � � � S)N)r r �join�mapr )r �seqr r r r+ m s z Markup.joinc O s% t t | j t j | | | � � � S)N)�listr, r r �split)r �args�kwargsr r r r/ q s z Markup.splitc O s% t t | j t j | | | � � � S)N)r. r, r r �rsplit)r r0 r1 r r r r2 u s z
Markup.rsplitc O s% t t | j t j | | | � � � S)N)r. r, r r �
splitlines)r r0 r1 r r r r3 y s zMarkup.splitlinesc s8 d d l m � � f d d � } t j | t | � � S)z�Unescape markup again into an text_type string. This also resolves
known HTML4 and XHTML entities:
>>> Markup("Main » <em>About</em>").unescape()
u'Main \xbb <em>About</em>'
r )�
HTML_ENTITIESc s� | j d � } | � k r) t � | � Sy` | d d � d k r_ t t | d d � d � � S| j d � r� t t | d d � � � SWn t k
r� Yn Xd S) N� � �#x�#X� �#r
)r7 r8 )�groupr �int�
startswith�
ValueError)�m�name)r4 r r � handle_match� s
z%Markup.unescape.<locals>.handle_match)Zmarkupsafe._constantsr4 �
_entity_re�subr )r rA r )r4 r �unescape~ s zMarkup.unescapec C s1 d j t j d | � j � � } t | � j � S)a Unescape markup into an text_type string and strip all tags. This
also resolves known HTML4 and XHTML entities. Whitespace is
normalized to one:
>>> Markup("Main » <em>About</em>").striptags()
u'Main \xbb About'
� r
)r+ �
_striptags_rerC r/ r rD )r �strippedr r r � striptags� s !zMarkup.striptagsc C s) t | � } | j | k r% | | � S| S)z�Escape the string. Works like :func:`escape` with the difference
that for subclasses of :class:`Markup` this function would return the
correct subclass.
)r r )r �s�rvr r r r � s
z
Markup.escapec s= t t | � � � f d d � } � j | _ � j | _ | S)Nc sS t t | � t | � | j � } t | t | � | j � | j � | | | � � S)N)�_escape_argspecr. � enumerater r r )r r0 r1 )�origr r �func� s !z1Markup.make_simple_escaping_wrapper.<locals>.func)�getattrr r) �__doc__)r@ rN r )rM r � make_simple_escaping_wrapper� s
z#Markup.make_simple_escaping_wrapper� __getitem__�
capitalize�title�lower�upper�replace�ljust�rjust�lstrip�rstrip�center�strip� translate�
expandtabs�swapcase�zfill� partitionc C s+ t t | j t j | | j | � � � � S)N)r& r, r r rb r )r �sepr r r rb � s zMarkup.partitionc C s+ t t | j t j | | j | � � � � S)N)r& r, r r �
rpartitionr )r rc r r r rd � s zMarkup.rpartition�formatc O sU | d | d d � } } t | j � } t | | � } | j | j | | | � � S)Nr r5 )�EscapeFormatterr �_MagicFormatMappingr �vformat)r0 r1 r � formatterr r r re � s z
Markup.formatc C s | r t d � � | S)Nz,Unsupported format specification for Markup.)r> )r � format_specr r r �__html_format__� s zMarkup.__html_format__� __getslice__)rR rS rT rU rV rW rX rY rZ r[ r\ r] r^ r_ r` ra ) r) �
__module__� __qualname__rP � __slots__r r r r r �__rmul__r' r* r+ r r/ r2 r3 rD rH � classmethodr rQ �method�localsr rb rd re rk rl r r )r r r sH *
c @ sF e Z d Z d Z d d � Z d d � Z d d � Z d d � Z d
S) rg z�This class implements a dummy wrapper to fix a bug in the Python
standard library for string formatting.
See http://bugs.python.org/issue13598 for information about why
this is necessary.
c C s | | _ | | _ d | _ d S)Nr )�_args�_kwargs� _last_index)r r0 r1 r r r �__init__� s z _MagicFormatMapping.__init__c C s_ | d k rT | j } | j d 7_ y | j | SWn t k
rG Yn Xt | � } | j | S)Nr
r5 )rv rt � LookupError�strru )r �key�idxr r r rR � s
z _MagicFormatMapping.__getitem__c C s
t | j � S)N)�iterru )r r r r �__iter__� s z _MagicFormatMapping.__iter__c C s
t | j � S)N)�lenru )r r r r �__len__� s z_MagicFormatMapping.__len__N)r) rm rn rP rw rR r} r r r r r rg � s
rg re c @ s( e Z d Z d d � Z d d � Z d S)rf c C s
| | _ d S)N)r )r r r r r rw � s zEscapeFormatter.__init__c C s| t | d � r! | j | � } nH t | d � rQ | rB t d � � | j � } n t j j | | | � } t | j | � � S)Nrk r zSNo format specification allowed when formatting an object with its __html__ method.) r rk r> r �string� Formatter� format_fieldr r )r �valuerj rJ r r r r� � s z EscapeFormatter.format_fieldN)r) rm rn rw r� r r r r rf � s rf c C sI xB | D]: \ } } t | d � s1 t | t � r | | � | | <q W| S)z,Helper for various string-wrapped functions.r )r r r )�obj�iterabler rz r� r r r rK s rK c @ sb e Z d Z d Z d d � Z d d � Z d d � Z Z d d � Z d d � Z d d � Z
d
S) r" zHelper for Markup.__mod__c C s | | _ | | _ d S)N)r� r )r r� r r r r rw s z _MarkupEscapeHelper.__init__c C s t | j | | j � S)N)r" r� r )rI r$ r r r �<lambda> s z _MarkupEscapeHelper.<lambda>c C s t | j | j � � S)N)r r r� )rI r r r r� s c C s t | j t | j � � � S)N)ry r �reprr� )rI r r r r� s c C s
t | j � S)N)r< r� )rI r r r r� s c C s
t | j � S)N)�floatr� )rI r r r r� s N) r) rm rn rP rw rR � __unicode__�__str__r* �__int__� __float__r r r r r" s r" )r r r
�soft_str) rP �rer� � collectionsr Zmarkupsafe._compatr r r r r r �__all__�compilerF rB r rg r r� rf rK �objectr" Zmarkupsafe._speedupsr r r
� ImportErrorZmarkupsafe._nativer� �appendr r r r �<module>
s( .�
!