| Dir : /usr/lib64/python3.6/site-packages/markupsafe/__pycache__/ |
| Server: Linux red.truehostdns.com 4.18.0-553.150.1.el8_10.x86_64 #1 SMP Fri Jul 31 15:23:31 EDT 2026 x86_64 IP: 51.161.15.103 |
| Dir : //usr/lib64/python3.6/site-packages/markupsafe/__pycache__/__init__.cpython-36.pyc |
3
2�kSb( � @ s d Z ddlZddlZddlmZ ddlmZmZmZm Z m
Z
m Z ddddgZ ej
d �Zej
d
�ZG d d� de�ZG d d
� d
e�Zeed�r�G dd� dej�Zdd� ZG dd� de�ZyddlmZmZmZ W n( e k
r� ddl mZmZmZ Y nX e �s
eZ e j d� dS )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 s2 e Zd ZdZf Zd>dd�Zdd� Z� fd d
�Zd d � Zd
d� Z e Z
dd� Z dd� Z dd� Z
ej
je
_dd� Zejje_dd� Zejje_dd� Zejje_dd � Zd d � Zed d � �Zd!d"� Zxd?D ]Zee�e� e< q�W eed3�� r�d4d5� Zd6d7� Zeed8��rd9d:� Z d;d<� Z eed=��r&ed=�Z [[� 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 s6 t |d�r|j� }|d kr&tj| |�S tj| |||�S )N�__html__)�hasattrr r �__new__)�cls�base�encoding�errors� r � /usr/lib64/python3.6/__init__.pyr F s
zMarkup.__new__c C s | S )Nr )�selfr r r r M s zMarkup.__html__c s4 t |t�st|d�r0| jtt| �j| j|���S tS )Nr ) �
isinstancer r � __class__�superr �__add__r �NotImplemented)r �other)r r r r P s zMarkup.__add__c C s( t |d�st|t�r$| j|�j| �S tS )Nr )r r r r r r )r r r r r �__radd__U s zMarkup.__radd__c C s t |t�r | jtj| |��S tS )N)r r r r �__mul__r )r Znumr r r r Z s
zMarkup.__mul__c s@ t |t�r"t� fdd�|D ��}n t|� j�}� jtj� |��S )Nc 3 s | ]}t |� j�V qd 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 jtj| �f S )Nz%s(%s))r �__name__r �__repr__)r r r r r) g s zMarkup.__repr__c C s | j tj| t| j|���S )N)r r �join�mapr )r �seqr r r r* m s z Markup.joinc O s t t| jtj| f|�|���S )N)�listr+ r r �split)r �args�kwargsr r r r. q s z Markup.splitc O s t t| jtj| f|�|���S )N)r- r+ r r �rsplit)r r/ r0 r r r r1 u s z
Markup.rsplitc O s t t| jtj| f|�|���S )N)r- r+ r r �
splitlines)r r/ r0 r r r r2 y s zMarkup.splitlinesc s( ddl m� � fdd�}tj|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�}|� kr t� | �S yH|d d� dkrFtt|dd � d��S |jd�rdtt|dd � ��S W n tk
rz Y nX dS ) N� � �#x�#X� �#r
)r6 r7 )�groupr �int�
startswith�
ValueError)�m�name)r3 r r � handle_match� s
z%Markup.unescape.<locals>.handle_match)Zmarkupsafe._constantsr3 �
_entity_re�subr )r r@ r )r3 r �unescape~ s zMarkup.unescapec C s" dj tjd| �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_rerB r. r rC )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| �� � fdd�}� j|_� j|_|S )Nc s> t t|�t|�| j�}t |t|�| j� | j� | f|�|��S )N)�_escape_argspecr- � enumerater r r )r r/ r0 )�origr r �func� s z1Markup.make_simple_escaping_wrapper.<locals>.func)�getattrr r( �__doc__)r? rM r )rL 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| jtj| | j|����S )N)r% r+ r r ra r )r �sepr r r ra � s zMarkup.partitionc C s t t| jtj| | j|����S )N)r% r+ r r �
rpartitionr )r rb r r r rc � s zMarkup.rpartition�formatc O s> | d | dd � }} t |j�}t| |�}|j|j|| |��S )Nr r4 )�EscapeFormatterr �_MagicFormatMappingr Zvformat)r/ r0 r Z formatterr r r rd � 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__)r
Nr )rQ rR rS rT rU rV rW rX rY rZ r[ r\ r] r^ r_ r` ) r( �
__module__� __qualname__rO � __slots__r r r r r �__rmul__r& r) r* r r. r1 r2 rC rG � classmethodr rP �method�localsr ra rc rd rh ri �
__classcell__r r )r r r sH *
c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
S ) rf 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 r/ r0 r r r �__init__� s z _MagicFormatMapping.__init__c C sN |dkrD| j }| j d7 _ y
| j| S tk
r: Y nX t|�}| j| S )Nr
r4 )rt rr � LookupError�strrs )r �key�idxr r r rQ � s
z _MagicFormatMapping.__getitem__c C s
t | j�S )N)�iterrs )r r r r �__iter__� s z _MagicFormatMapping.__iter__c C s
t | j�S )N)�lenrs )r r r r �__len__� s z_MagicFormatMapping.__len__N)r( rj rk rO ru rQ r{ r} r r r r rf � s
rf rd c @ s e Zd Zdd� Zdd� ZdS )re c C s
|| _ d S )N)r )r r r r r ru � s zEscapeFormatter.__init__c C sT t |d�r|j|�}n0t |d�r6|r,td��|j� }ntjj| ||�}t| j|��S )Nrh r zSNo format specification allowed when formatting an object with its __html__ method.) r rh r= r �string� Formatter� format_fieldr r )r �valuerg rI r r r r� � s
z EscapeFormatter.format_fieldN)r( rj rk ru r� r r r r re � s re c C s6 x0|D ](\}}t |d�s"t|t�r||�| |< qW | S )z,Helper for various string-wrapped functions.r )r r r )�obj�iterabler rx r� r r r rJ s rJ c @ sD e Zd ZdZdd� Zdd� Zdd� ZZdd� Zdd� 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 ru s z _MarkupEscapeHelper.__init__c C s t | j| | j�S )N)r! r� r )rH r# r r r �<lambda> s z _MarkupEscapeHelper.<lambda>c C s t | j| j��S )N)r r r� )rH r r r r� s c C s t | jt| j���S )N)rw r �reprr� )rH r r r r� s c C s
t | j�S )N)r; r� )rH r r r r� s c C s
t | j�S )N)�floatr� )rH r r r r� s N) r( rj rk rO ru rQ Z __unicode__�__str__r) �__int__� __float__r r r r r! s r! )r r r
�soft_str) rO �rer~ � collectionsr Zmarkupsafe._compatr r r r r r �__all__�compilerE rA r rf r r re rJ �objectr! Zmarkupsafe._speedupsr r r
� ImportErrorZmarkupsafe._nativer� �appendr r r r �<module>
s*
@