Linux iad1-shared-b7-18 6.6.49-grsec-jammy+ #10 SMP Thu Sep 12 23:23:08 UTC 2024 x86_64
Apache
: 67.205.6.31 | : 216.73.216.47
Cant Read [ /etc/named.conf ]
8.2.29
fernandoquevedo
Terminal
AUTO ROOT
Adminer
Backdoor Destroyer
Linux Exploit
Lock Shell
Lock File
Create User
CREATE RDP
PHP Mailer
BACKCONNECT
UNLOCK SHELL
HASH IDENTIFIER
README
+ Create Folder
+ Create File
/
usr /
lib /
python3 /
dist-packages /
genshi /
__pycache__ /
[ HOME SHELL ]
Name
Size
Permission
Action
__init__.cpython-310.pyc
632
B
-rw-r--r--
builder.cpython-310.pyc
11.87
KB
-rw-r--r--
compat.cpython-310.pyc
3.35
KB
-rw-r--r--
core.cpython-310.pyc
26.87
KB
-rw-r--r--
input.cpython-310.pyc
15.32
KB
-rw-r--r--
output.cpython-310.pyc
23.89
KB
-rw-r--r--
path.cpython-310.pyc
47.64
KB
-rw-r--r--
util.cpython-310.pyc
6.69
KB
-rw-r--r--
Delete
Unzip
Zip
${this.title}
Close
Code Editor : core.cpython-310.pyc
o !�b�d � @ sH d Z ddlmZ ddlZddlmZ ddlZddlZddlm Z ddl m Z m Z g d�Z dZG d d � d e�ZG d d � d e�ZejZejZejZejZejZejZejZejZejZej Z ej Z d d� Z G dd� de �Z G dd� dej!�Z"zddl#m"Z" W n e$y� Y nw e"j%Z%dd� Z&G dd� de�Z'e'd�Z(G dd� dej!�Z)dS )z#Core classes for markup processing.� )�reduceN)�chain)� stringrepr)� stripentities� striptags)�Stream�Markup�escape�unescape�Attrs� Namespace�QNamezrestructuredtext enc @ s e Zd ZdZg Zi Zdd� ZdS )�StreamEventKindz#A kind of event on a markup stream.c C s | j �|t�| |��S �N)� _instances� setdefault�str�__new__)�cls�val� r �-/usr/lib/python3/dist-packages/genshi/core.pyr $ � zStreamEventKind.__new__N)�__name__� __module__� __qualname__�__doc__� __slots__r r r r r r r s r c @ s� e Zd ZdZddgZed�Zed�Zed�Zed�Z ed�Z ed �Z ed �Z ed �Z ed �Zed �Zed�Zd%dd�Zdd� Zdd� Zdd� Zd&dd�Zd'dd�Zd(d d �Zd d � Zd!d"� Zd#d$� ZdS ))r a. Represents a stream of markup events. This class is basically an iterator over the events. Stream events are tuples of the form:: (kind, data, position) where ``kind`` is the event kind (such as `START`, `END`, `TEXT`, etc), ``data`` depends on the kind of event, and ``position`` is a ``(filename, line, offset)`` tuple that contains the location of the original element or text in the input. If the original location is unknown, ``position`` is ``(None, -1, -1)``. Also provided are ways to serialize the stream to text. The `serialize()` method will return an iterator over generated strings, while `render()` returns the complete generated text at once. Both accept various parameters that impact the way the stream is serialized. �events� serializer�START�END�TEXT�XML_DECL�DOCTYPE�START_NS�END_NS� START_CDATA� END_CDATA�PI�COMMENTNc C s || _ || _dS )a: Initialize the stream with a sequence of markup events. :param events: a sequence or iterable providing the events :param serializer: the default serialization method to use for this stream :note: Changed in 0.5: added the `serializer` argument N)r r )�selfr r r r r �__init__J s zStream.__init__c C � t | j�S r )�iterr �r+ r r r �__iter__V � zStream.__iter__c C s t t|| ��| jd�S )a� Override the "bitwise or" operator to apply filters or serializers to the stream, providing a syntax similar to pipes on Unix shells. Assume the following stream produced by the `HTML` function: >>> from genshi.input import HTML >>> html = HTML('''<p onclick="alert('Whoa')">Hello, world!</p>''', encoding='utf-8') >>> print(html) <p onclick="alert('Whoa')">Hello, world!</p> A filter such as the HTML sanitizer can be applied to that stream using the pipe notation as follows: >>> from genshi.filters import HTMLSanitizer >>> sanitizer = HTMLSanitizer() >>> print(html | sanitizer) <p>Hello, world!</p> Filters can be any function that accepts and produces a stream (where a stream is anything that iterates over events): >>> def uppercase(stream): ... for kind, data, pos in stream: ... if kind is TEXT: ... data = data.upper() ... yield kind, data, pos >>> print(html | sanitizer | uppercase) <p>HELLO, WORLD!</p> Serializers can also be used with this notation: >>> from genshi.output import TextSerializer >>> output = TextSerializer() >>> print(html | sanitizer | uppercase | output) HELLO, WORLD! Commonly, serializers should be used at the end of the "pipeline"; using them somewhere in the middle may produce unexpected results. :param function: the callable object that should be applied as a filter :return: the filtered stream :rtype: `Stream` )r )r �_ensurer )r+ �functionr r r �__or__Y s ,z Stream.__or__c G s t tj| f| �S )aL Apply filters to the stream. This method returns a new stream with the given filters applied. The filters must be callables that accept the stream object as parameter, and return the filtered stream. The call:: stream.filter(filter1, filter2) is equivalent to:: stream | filter1 | filter2 :param filters: one or more callable objects that should be applied as filters :return: the filtered stream :rtype: `Stream` )r �operator�or_)r+ �filtersr r r �filter� s z Stream.filterc K sB ddl m} |du r| jpd}| jdd|i|��}|||||d�S )a� Return a string representation of the stream. Any additional keyword arguments are passed to the serializer, and thus depend on the `method` parameter value. :param method: determines how the stream is serialized; can be either "xml", "xhtml", "html", "text", or a custom serializer class; if `None`, the default serialization method of the stream is used :param encoding: how the output string should be encoded; if set to `None`, this method returns a `unicode` object :param out: a file-like object that the output should be written to instead of being returned as one big string; note that if this is a file or socket (or similar), the `encoding` must not be `None` (that is, the output must be encoded) :return: a `str` or `unicode` object (depending on the `encoding` parameter), or `None` if the `out` parameter is provided :rtype: `basestring` :see: XMLSerializer, XHTMLSerializer, HTMLSerializer, TextSerializer :note: Changed in 0.5: added the `out` parameter r )�encodeN�xml�method)r; �encoding�outr )� genshi.outputr9 r � serialize)r+ r; r< r= �kwargsr9 � generatorr r r �render� s z Stream.renderc C s ddl m} ||��| ||�S )aT Return a new stream that contains the events matching the given XPath expression. >>> from genshi import HTML >>> stream = HTML('<doc><elem>foo</elem><elem>bar</elem></doc>', encoding='utf-8') >>> print(stream.select('elem')) <elem>foo</elem><elem>bar</elem> >>> print(stream.select('elem/text()')) foobar Note that the outermost element of the stream becomes the *context node* for the XPath test. That means that the expression "doc" would not match anything in the example above, because it only tests against child elements of the outermost element: >>> print(stream.select('doc')) <BLANKLINE> You can use the "." expression to match the context node itself (although that usually makes little sense): >>> print(stream.select('.')) <doc><elem>foo</elem><elem>bar</elem></doc> :param path: a string containing the XPath expression :param namespaces: mapping of namespace prefixes used in the path :param variables: mapping of variable names to values :return: the selected substream :rtype: `Stream` :raises PathSyntaxError: if the given path expression is invalid or not supported r )�Path)� genshi.pathrC �select)r+ �path� namespaces� variablesrC r r r rE � s !z Stream.selectr: c K s6 ddl m} |du r| jpd}||fi |��t| ��S )a� Generate strings corresponding to a specific serialization of the stream. Unlike the `render()` method, this method is a generator that returns the serialized output incrementally, as opposed to returning a single string. Any additional keyword arguments are passed to the serializer, and thus depend on the `method` parameter value. :param method: determines how the stream is serialized; can be either "xml", "xhtml", "html", "text", or a custom serializer class; if `None`, the default serialization method of the stream is used :return: an iterator over the serialization results (`Markup` or `unicode` objects, depending on the serialization method) :rtype: ``iterator`` :see: XMLSerializer, XHTMLSerializer, HTMLSerializer, TextSerializer r )�get_serializerNr: )r> rI r r2 )r+ r; r@ rI r r r r? � s zStream.serializec C s | � � S r �rB r/ r r r �__str__� � zStream.__str__c C s | j d d�S )N)r< rJ r/ r r r � __unicode__� � zStream.__unicode__c C s | S r r r/ r r r �__html__� s zStream.__html__r )NNN)NN)r: )r r r r r r r r! r" r# r$ r% r& r' r( r) r* r, r0 r4 r8 rB rE r? rK rM rO r r r r r ( s0 . $ r c c s� � t | �} zt| �}W n ty Y dS w t|�tus"t|�dkrBt|g| �D ]}t|d�r4|�� }nt t � |�df}|V q(dS |V | D ]}|V qGdS )z@Ensure that every item on the stream is actually a markup event.N� �totuple�N���rS ) r. �next� StopIteration�type�tuple�lenr �hasattrrQ r" �six� text_type)�stream�eventr r r r2 s$ � � �r2 c @ sV e Zd ZdZg Zdd� Zdd� Zdd� Zdd � Zd d � Z d d � Z ddd�Z dd� Z dS )r a? Immutable sequence type that stores the attributes of an element. Ordering of the attributes is preserved, while access by name is also supported. >>> attrs = Attrs([('href', '#'), ('title', 'Foo')]) >>> attrs Attrs([('href', '#'), ('title', 'Foo')]) >>> 'href' in attrs True >>> 'tabindex' in attrs False >>> attrs.get('title') 'Foo' Instances may not be manipulated directly. Instead, the operators ``|`` and ``-`` can be used to produce new instances that have specific attributes added, replaced or removed. To remove an attribute, use the ``-`` operator. The right hand side can be either a string or a set/sequence of strings, identifying the name(s) of the attribute(s) to remove: >>> attrs - 'title' Attrs([('href', '#')]) >>> attrs - ('title', 'href') Attrs() The original instance is not modified, but the operator can of course be used with an assignment: >>> attrs Attrs([('href', '#'), ('title', 'Foo')]) >>> attrs -= 'title' >>> attrs Attrs([('href', '#')]) To add a new attribute, use the ``|`` operator, where the right hand value is a sequence of ``(name, value)`` tuples (which includes `Attrs` instances): >>> attrs | [('title', 'Bar')] Attrs([('href', '#'), ('title', 'Bar')]) If the attributes already contain an attribute with a given name, the value of that attribute is replaced: >>> attrs | [('href', 'http://example.org/')] Attrs([('href', 'http://example.org/')]) c C s | D ] \}}||kr dS qdS )z�Return whether the list includes an attribute with the specified name. :return: `True` if the list includes the attribute :rtype: `bool` TFr )r+ �name�attr�_r r r � __contains__^ s �zAttrs.__contains__c C s$ t �| |�}t|�tu rt|�S |S )z�Return an item or slice of the attributes list. >>> attrs = Attrs([('href', '#'), ('title', 'Foo')]) >>> attrs[1] ('title', 'Foo') >>> attrs[1:] Attrs([('title', 'Foo')]) )rW � __getitem__rV �slicer )r+ �i�itemsr r r rb j s zAttrs.__getitem__c C s t t�| ||��S )z�Return a slice of the attributes list. >>> attrs = Attrs([('href', '#'), ('title', 'Foo')]) >>> attrs[1:] Attrs([('title', 'Foo')]) )r rW � __getslice__)r+ rd �jr r r rf x s zAttrs.__getslice__c sT t dd� |D ��� t�fdd�|D ���t� �fdd��D �� �fdd�|D � �S )a) Return a new instance that contains the attributes in `attrs` in addition to any already existing attributes. Any attributes in the new set that have a value of `None` are removed. :return: a new instance with the merged attributes :rtype: `Attrs` c S s g | ] \}}|d u r|�qS r r ��.0�an�avr r r � <listcomp>� s z Attrs.__or__.<locals>.<listcomp>c s( g | ]\}}|� v r|d ur||f�qS r r rh r/ r r rl � � �c s( g | ]\}}|� vr|�� ||�f�qS r )�get)ri �sn�sv)�remove�replacer r rl � s �c s( g | ]\}}|�vr|� vr||f�qS r r rh )rq r+ r r rl � rm )�set�dictr )r+ �attrsr )rq rr r+ r r4 � s �z Attrs.__or__c C s | sdS dd� dd� | D �� S )NzAttrs()z Attrs([%s])z, c S s g | ]}t |��qS r )�repr�ri �itemr r r rl � � z"Attrs.__repr__.<locals>.<listcomp>)�joinr/ r r r �__repr__� s zAttrs.__repr__c s( t � tj�r � f� t� fdd�| D ��S )z�Return a new instance with all attributes with a name in `names` are removed. :param names: the names of the attributes to remove :return: a new instance with the attribute removed :rtype: `Attrs` c s g | ] \}}|� vr||f�qS r r )ri r^ r ��namesr r rl � s z!Attrs.__sub__.<locals>.<listcomp>)� isinstancerZ � string_typesr )r+ r} r r| r �__sub__� s z Attrs.__sub__Nc C s" | D ] \}}||kr| S q|S )a� Return the value of the attribute with the specified name, or the value of the `default` parameter if no such attribute is found. :param name: the name of the attribute :param default: the value to return when the attribute does not exist :return: the attribute value, or the `default` value if that attribute does not exist :rtype: `object` r )r+ r^ �defaultr_ �valuer r r rn � s �z Attrs.getc C s t d�dd� | D ��dfS )a[ Return the attributes as a markup event. The returned event is a `TEXT` event, the data is the value of all attributes joined together. >>> Attrs([('href', '#'), ('title', 'Foo')]).totuple() ('TEXT', '#Foo', (None, -1, -1)) :return: a `TEXT` event :rtype: `tuple` � c S s g | ]}|d �qS )� r )ri �xr r r rl � ry z!Attrs.totuple.<locals>.<listcomp>rR )r" rz r/ r r r rQ � s z Attrs.totupler ) r r r r r ra rb rf r4 r{ r� rn rQ r r r r r ( s 3 r c @ sr e Zd ZdZg Zdd� Zdd� Zdd� Zdd � ZeZ d d � Z dd d�Z e ddd��Z dd� Zddd�Zdd� ZdS )r zeMarks a string as being safe for inclusion in HTML/XML output without needing to be escaped. c C s t tj�| t|���S r �r rZ r[ �__add__r �r+ �otherr r r r� � r zMarkup.__add__c C s t tj�t|�| ��S r r� r� r r r �__radd__� r zMarkup.__radd__c C s` t |t�rtt|�� tt|�� ���}nt |ttf�r#ttt|��}nt|�}t t j � | |��S r ) r~ rt �zip�keys�mapr �values�listrW r rZ r[ �__mod__)r+ �argsr r r r� � s zMarkup.__mod__c C s t tj�| |��S r )r rZ r[ �__mul__)r+ �numr r r r� � � zMarkup.__mul__c C s dt | �jtj�| �f S )Nz<%s %s>)rV r rZ r[ r{ r/ r r r r{ � s zMarkup.__repr__Tc s$ � fdd�|D �}t tj�| |��S )aA Return a `Markup` object which is the concatenation of the strings in the given sequence, where this `Markup` object is the separator between the joined elements. Any element in the sequence that is not a `Markup` instance is automatically escaped. :param seq: the sequence of strings to join :param escape_quotes: whether double quote characters in the elements should be escaped :return: the joined `Markup` object :rtype: `Markup` :see: `escape` c s g | ]}t |� d ��qS ))�quotes)r rw �� escape_quotesr r rl � s z Markup.join.<locals>.<listcomp>)r rZ r[ rz )r+ �seqr� � escaped_itemsr r� r rz � s z Markup.joinc C sd |s| � S t |�| u r |S t|d�r| |�� �S |�dd��dd��dd�}|r.|�dd �}| |�S ) a� Create a Markup instance from a string and escape special characters it may contain (<, >, & and "). >>> escape('"1 < 2"') <Markup '"1 < 2"'> If the `quotes` parameter is set to `False`, the " character is left as is. Escaping quotes is generally only required for strings that are to be used in attribute values. >>> escape('"1 < 2"', quotes=False) <Markup '"1 < 2"'> :param text: the text to escape :param quotes: if ``True``, double quote characters are escaped in addition to the other special characters :return: the escaped `Markup` string :rtype: `Markup` rO �&�&�<�<�>�>�"�")rV rY rO rr )r �textr� r r r r � s � z Markup.escapec C s2 | sdS t �| ��dd��dd��dd��dd �S ) z�Reverse-escapes &, <, >, and " and returns a `unicode` object. >>> Markup('1 < 2').unescape() '1 < 2' :return: the unescaped string :rtype: `unicode` :see: `genshi.core.unescape` r� r� r� r� r� r� r� r� r� )rZ r[ rr r/ r r r r s �zMarkup.unescapeFc C s t t| |d��S )a� Return a copy of the text with any character or numeric entities replaced by the equivalent UTF-8 characters. If the `keepxmlentities` parameter is provided and evaluates to `True`, the core XML entities (``&``, ``'``, ``>``, ``<`` and ``"``) are not stripped. :return: a `Markup` instance with entities removed :rtype: `Markup` :see: `genshi.util.stripentities` )�keepxmlentities)r r )r+ r� r r r r " s zMarkup.stripentitiesc C s t t| ��S )z�Return a copy of the text with all XML/HTML tags removed. :return: a `Markup` instance with all tags removed :rtype: `Markup` :see: `genshi.util.striptags` )r r r/ r r r r 0 s zMarkup.striptagsN)T)F)r r r r r r� r� r� r� �__rmul__r{ rz � classmethodr r r r r r r r r � s " r )r c C s t | t�s| S | �� S )ao Reverse-escapes &, <, >, and " and returns a `unicode` object. >>> unescape(Markup('1 < 2')) '1 < 2' If the provided `text` object is not a `Markup` instance, it is returned unchanged. >>> unescape('1 < 2') '1 < 2' :param text: the text to unescape :return: the unescsaped string :rtype: `unicode` )r~ r r )r� r r r r C s r c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z e Z dd� Zejd dkr<dd� Zndd� Zdd � Zd d � Zd S ) r a� Utility class creating and testing elements with a namespace. Internally, namespace URIs are encoded in the `QName` of any element or attribute, the namespace URI being enclosed in curly braces. This class helps create and test these strings. A `Namespace` object is instantiated with the namespace URI. >>> html = Namespace('http://www.w3.org/1999/xhtml') >>> html Namespace('http://www.w3.org/1999/xhtml') >>> html.uri 'http://www.w3.org/1999/xhtml' The `Namespace` object can than be used to generate `QName` objects with that namespace: >>> html.body QName('http://www.w3.org/1999/xhtml}body') >>> html.body.localname 'body' >>> html.body.namespace 'http://www.w3.org/1999/xhtml' The same works using item access notation, which is useful for element or attribute names that are not valid Python identifiers: >>> html['body'] QName('http://www.w3.org/1999/xhtml}body') A `Namespace` object can also be used to test whether a specific `QName` belongs to that namespace using the ``in`` operator: >>> qname = html.body >>> qname in html True >>> qname in Namespace('http://www.w3.org/2002/06/xhtml2') False c C s t |�| u r|S t�| �S r )rV �objectr )r �urir r r r � s zNamespace.__new__c C s | j fS r �r� r/ r r r �__getnewargs__� rL zNamespace.__getnewargs__c C � | j S r r� r/ r r r � __getstate__� � zNamespace.__getstate__c C s || _ d S r r� �r+ r� r r r � __setstate__� r1 zNamespace.__setstate__c C s t �|�| _d S r )rZ r[ r� r� r r r r, � s zNamespace.__init__c C s |j | jkS r )� namespacer� )r+ �qnamer r r ra � rN zNamespace.__contains__c C s | |k S r r r� r r r �__ne__� r1 zNamespace.__ne__c C s t |t�r | j|jkS | j|kS r )r~ r r� r� r r r �__eq__� s zNamespace.__eq__c C s t | jd | �S )N�})r r� )r+ r^ r r r rb � r� zNamespace.__getitem__c C r- r )�hashr� r/ r r r �__hash__� r1 zNamespace.__hash__r � c C s dt | �jt| j�f S )N�%s(%s))rV r r r� r/ r r r r{ � � zNamespace.__repr__c C s dt | �j| jf S )N�%s(%r))rV r r� r/ r r r r{ � s c C s | j �d�S )Nzutf-8)r� r9 r/ r r r rK � rN zNamespace.__str__c C r� r r� r/ r r r rM � r� zNamespace.__unicode__N)r r r r r r� r� r� r, ra r� r� rb � __getattr__r� �sys� version_infor{ rK rM r r r r r X s$ ' r z$http://www.w3.org/XML/1998/namespacec @ sJ e Zd ZdZddgZdd� Zdd� Zejd d kr d d � Z d S d d � Z d S )r a� A qualified element or attribute name. The unicode value of instances of this class contains the qualified name of the element or attribute, in the form ``{namespace-uri}local-name``. The namespace URI can be obtained through the additional `namespace` attribute, while the local name can be accessed through the `localname` attribute. >>> qname = QName('foo') >>> qname QName('foo') >>> qname.localname 'foo' >>> qname.namespace >>> qname = QName('http://www.w3.org/1999/xhtml}body') >>> qname QName('http://www.w3.org/1999/xhtml}body') >>> qname.localname 'body' >>> qname.namespace 'http://www.w3.org/1999/xhtml' r� � localnamec C s� t |�| u r|S |�d�}|�dd�}t|�dkr.tj�| d| �}ttj|�\|_|_ |S tj�| |�}dt�|�|_|_ |S )z�Create the `QName` instance. :param qname: the qualified name as a string of the form ``{namespace-uri}local-name``, where the leading curly brace is optional �{r� r� z{%sN) rV �lstrip�splitrX rZ r[ r r� r� r� )r r� �partsr+ r r r r � s �z QName.__new__c C s | � d�fS )Nr� )r� r/ r r r r� � rN zQName.__getnewargs__r r� c C s dt | �jt| �d��f S )Nr� r� )rV r r r� r/ r r r r{ � s zQName.__repr__c C s dt | �j| �d�f S )Nr� r� )rV r r� r/ r r r r{ � r� N) r r r r r r r� r� r� r{ r r r r r � s r )*r � functoolsr r� � itertoolsr r5 rZ � genshi.compatr � genshi.utilr r �__all__� __docformat__r r r� r r r! r" r# r$ r% r& r' r( r) r* r2 rW r r[ r �genshi._speedups� ImportErrorr r r � XML_NAMESPACEr r r r r �<module> sL Z z �[
Close
