File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/treewalkers.tar
Back
base.py 0000644 00000016464 15030125115 0006034 0 ustar 00 from __future__ import absolute_import, division, unicode_literals from xml.dom import Node from ..constants import namespaces, voidElements, spaceCharacters __all__ = ["DOCUMENT", "DOCTYPE", "TEXT", "ELEMENT", "COMMENT", "ENTITY", "UNKNOWN", "TreeWalker", "NonRecursiveTreeWalker"] DOCUMENT = Node.DOCUMENT_NODE DOCTYPE = Node.DOCUMENT_TYPE_NODE TEXT = Node.TEXT_NODE ELEMENT = Node.ELEMENT_NODE COMMENT = Node.COMMENT_NODE ENTITY = Node.ENTITY_NODE UNKNOWN = "<#UNKNOWN#>" spaceCharacters = "".join(spaceCharacters) class TreeWalker(object): """Walks a tree yielding tokens Tokens are dicts that all have a ``type`` field specifying the type of the token. """ def __init__(self, tree): """Creates a TreeWalker :arg tree: the tree to walk """ self.tree = tree def __iter__(self): raise NotImplementedError def error(self, msg): """Generates an error token with the given message :arg msg: the error message :returns: SerializeError token """ return {"type": "SerializeError", "data": msg} def emptyTag(self, namespace, name, attrs, hasChildren=False): """Generates an EmptyTag token :arg namespace: the namespace of the token--can be ``None`` :arg name: the name of the element :arg attrs: the attributes of the element as a dict :arg hasChildren: whether or not to yield a SerializationError because this tag shouldn't have children :returns: EmptyTag token """ yield {"type": "EmptyTag", "name": name, "namespace": namespace, "data": attrs} if hasChildren: yield self.error("Void element has children") def startTag(self, namespace, name, attrs): """Generates a StartTag token :arg namespace: the namespace of the token--can be ``None`` :arg name: the name of the element :arg attrs: the attributes of the element as a dict :returns: StartTag token """ return {"type": "StartTag", "name": name, "namespace": namespace, "data": attrs} def endTag(self, namespace, name): """Generates an EndTag token :arg namespace: the namespace of the token--can be ``None`` :arg name: the name of the element :returns: EndTag token """ return {"type": "EndTag", "name": name, "namespace": namespace} def text(self, data): """Generates SpaceCharacters and Characters tokens Depending on what's in the data, this generates one or more ``SpaceCharacters`` and ``Characters`` tokens. For example: >>> from html5lib.treewalkers.base import TreeWalker >>> # Give it an empty tree just so it instantiates >>> walker = TreeWalker([]) >>> list(walker.text('')) [] >>> list(walker.text(' ')) [{u'data': ' ', u'type': u'SpaceCharacters'}] >>> list(walker.text(' abc ')) # doctest: +NORMALIZE_WHITESPACE [{u'data': ' ', u'type': u'SpaceCharacters'}, {u'data': u'abc', u'type': u'Characters'}, {u'data': u' ', u'type': u'SpaceCharacters'}] :arg data: the text data :returns: one or more ``SpaceCharacters`` and ``Characters`` tokens """ data = data middle = data.lstrip(spaceCharacters) left = data[:len(data) - len(middle)] if left: yield {"type": "SpaceCharacters", "data": left} data = middle middle = data.rstrip(spaceCharacters) right = data[len(middle):] if middle: yield {"type": "Characters", "data": middle} if right: yield {"type": "SpaceCharacters", "data": right} def comment(self, data): """Generates a Comment token :arg data: the comment :returns: Comment token """ return {"type": "Comment", "data": data} def doctype(self, name, publicId=None, systemId=None): """Generates a Doctype token :arg name: :arg publicId: :arg systemId: :returns: the Doctype token """ return {"type": "Doctype", "name": name, "publicId": publicId, "systemId": systemId} def entity(self, name): """Generates an Entity token :arg name: the entity name :returns: an Entity token """ return {"type": "Entity", "name": name} def unknown(self, nodeType): """Handles unknown node types""" return self.error("Unknown node type: " + nodeType) class NonRecursiveTreeWalker(TreeWalker): def getNodeDetails(self, node): raise NotImplementedError def getFirstChild(self, node): raise NotImplementedError def getNextSibling(self, node): raise NotImplementedError def getParentNode(self, node): raise NotImplementedError def __iter__(self): currentNode = self.tree while currentNode is not None: details = self.getNodeDetails(currentNode) type, details = details[0], details[1:] hasChildren = False if type == DOCTYPE: yield self.doctype(*details) elif type == TEXT: for token in self.text(*details): yield token elif type == ELEMENT: namespace, name, attributes, hasChildren = details if (not namespace or namespace == namespaces["html"]) and name in voidElements: for token in self.emptyTag(namespace, name, attributes, hasChildren): yield token hasChildren = False else: yield self.startTag(namespace, name, attributes) elif type == COMMENT: yield self.comment(details[0]) elif type == ENTITY: yield self.entity(details[0]) elif type == DOCUMENT: hasChildren = True else: yield self.unknown(details[0]) if hasChildren: firstChild = self.getFirstChild(currentNode) else: firstChild = None if firstChild is not None: currentNode = firstChild else: while currentNode is not None: details = self.getNodeDetails(currentNode) type, details = details[0], details[1:] if type == ELEMENT: namespace, name, attributes, hasChildren = details if (namespace and namespace != namespaces["html"]) or name not in voidElements: yield self.endTag(namespace, name) if self.tree is currentNode: currentNode = None break nextSibling = self.getNextSibling(currentNode) if nextSibling is not None: currentNode = nextSibling break else: currentNode = self.getParentNode(currentNode) etree_lxml.py 0000644 00000014325 15030125115 0007254 0 ustar 00 from __future__ import absolute_import, division, unicode_literals from pip._vendor.six import text_type from collections import OrderedDict from lxml import etree from ..treebuilders.etree import tag_regexp from . import base from .. import _ihatexml def ensure_str(s): if s is None: return None elif isinstance(s, text_type): return s else: return s.decode("ascii", "strict") class Root(object): def __init__(self, et): self.elementtree = et self.children = [] try: if et.docinfo.internalDTD: self.children.append(Doctype(self, ensure_str(et.docinfo.root_name), ensure_str(et.docinfo.public_id), ensure_str(et.docinfo.system_url))) except AttributeError: pass try: node = et.getroot() except AttributeError: node = et while node.getprevious() is not None: node = node.getprevious() while node is not None: self.children.append(node) node = node.getnext() self.text = None self.tail = None def __getitem__(self, key): return self.children[key] def getnext(self): return None def __len__(self): return 1 class Doctype(object): def __init__(self, root_node, name, public_id, system_id): self.root_node = root_node self.name = name self.public_id = public_id self.system_id = system_id self.text = None self.tail = None def getnext(self): return self.root_node.children[1] class FragmentRoot(Root): def __init__(self, children): self.children = [FragmentWrapper(self, child) for child in children] self.text = self.tail = None def getnext(self): return None class FragmentWrapper(object): def __init__(self, fragment_root, obj): self.root_node = fragment_root self.obj = obj if hasattr(self.obj, 'text'): self.text = ensure_str(self.obj.text) else: self.text = None if hasattr(self.obj, 'tail'): self.tail = ensure_str(self.obj.tail) else: self.tail = None def __getattr__(self, name): return getattr(self.obj, name) def getnext(self): siblings = self.root_node.children idx = siblings.index(self) if idx < len(siblings) - 1: return siblings[idx + 1] else: return None def __getitem__(self, key): return self.obj[key] def __bool__(self): return bool(self.obj) def getparent(self): return None def __str__(self): return str(self.obj) def __unicode__(self): return str(self.obj) def __len__(self): return len(self.obj) class TreeWalker(base.NonRecursiveTreeWalker): def __init__(self, tree): # pylint:disable=redefined-variable-type if isinstance(tree, list): self.fragmentChildren = set(tree) tree = FragmentRoot(tree) else: self.fragmentChildren = set() tree = Root(tree) base.NonRecursiveTreeWalker.__init__(self, tree) self.filter = _ihatexml.InfosetFilter() def getNodeDetails(self, node): if isinstance(node, tuple): # Text node node, key = node assert key in ("text", "tail"), "Text nodes are text or tail, found %s" % key return base.TEXT, ensure_str(getattr(node, key)) elif isinstance(node, Root): return (base.DOCUMENT,) elif isinstance(node, Doctype): return base.DOCTYPE, node.name, node.public_id, node.system_id elif isinstance(node, FragmentWrapper) and not hasattr(node, "tag"): return base.TEXT, ensure_str(node.obj) elif node.tag == etree.Comment: return base.COMMENT, ensure_str(node.text) elif node.tag == etree.Entity: return base.ENTITY, ensure_str(node.text)[1:-1] # strip &; else: # This is assumed to be an ordinary element match = tag_regexp.match(ensure_str(node.tag)) if match: namespace, tag = match.groups() else: namespace = None tag = ensure_str(node.tag) attrs = OrderedDict() for name, value in list(node.attrib.items()): name = ensure_str(name) value = ensure_str(value) match = tag_regexp.match(name) if match: attrs[(match.group(1), match.group(2))] = value else: attrs[(None, name)] = value return (base.ELEMENT, namespace, self.filter.fromXmlName(tag), attrs, len(node) > 0 or node.text) def getFirstChild(self, node): assert not isinstance(node, tuple), "Text nodes have no children" assert len(node) or node.text, "Node has no children" if node.text: return (node, "text") else: return node[0] def getNextSibling(self, node): if isinstance(node, tuple): # Text node node, key = node assert key in ("text", "tail"), "Text nodes are text or tail, found %s" % key if key == "text": # XXX: we cannot use a "bool(node) and node[0] or None" construct here # because node[0] might evaluate to False if it has no child element if len(node): return node[0] else: return None else: # tail return node.getnext() return (node, "tail") if node.tail else node.getnext() def getParentNode(self, node): if isinstance(node, tuple): # Text node node, key = node assert key in ("text", "tail"), "Text nodes are text or tail, found %s" % key if key == "text": return node # else: fallback to "normal" processing elif node in self.fragmentChildren: return None return node.getparent() etree.py 0000644 00000010707 15030125115 0006220 0 ustar 00 from __future__ import absolute_import, division, unicode_literals from collections import OrderedDict import re from pip._vendor.six import string_types from . import base from .._utils import moduleFactoryFactory tag_regexp = re.compile("{([^}]*)}(.*)") def getETreeBuilder(ElementTreeImplementation): ElementTree = ElementTreeImplementation ElementTreeCommentType = ElementTree.Comment("asd").tag class TreeWalker(base.NonRecursiveTreeWalker): # pylint:disable=unused-variable """Given the particular ElementTree representation, this implementation, to avoid using recursion, returns "nodes" as tuples with the following content: 1. The current element 2. The index of the element relative to its parent 3. A stack of ancestor elements 4. A flag "text", "tail" or None to indicate if the current node is a text node; either the text or tail of the current element (1) """ def getNodeDetails(self, node): if isinstance(node, tuple): # It might be the root Element elt, _, _, flag = node if flag in ("text", "tail"): return base.TEXT, getattr(elt, flag) else: node = elt if not(hasattr(node, "tag")): node = node.getroot() if node.tag in ("DOCUMENT_ROOT", "DOCUMENT_FRAGMENT"): return (base.DOCUMENT,) elif node.tag == "<!DOCTYPE>": return (base.DOCTYPE, node.text, node.get("publicId"), node.get("systemId")) elif node.tag == ElementTreeCommentType: return base.COMMENT, node.text else: assert isinstance(node.tag, string_types), type(node.tag) # This is assumed to be an ordinary element match = tag_regexp.match(node.tag) if match: namespace, tag = match.groups() else: namespace = None tag = node.tag attrs = OrderedDict() for name, value in list(node.attrib.items()): match = tag_regexp.match(name) if match: attrs[(match.group(1), match.group(2))] = value else: attrs[(None, name)] = value return (base.ELEMENT, namespace, tag, attrs, len(node) or node.text) def getFirstChild(self, node): if isinstance(node, tuple): element, key, parents, flag = node else: element, key, parents, flag = node, None, [], None if flag in ("text", "tail"): return None else: if element.text: return element, key, parents, "text" elif len(element): parents.append(element) return element[0], 0, parents, None else: return None def getNextSibling(self, node): if isinstance(node, tuple): element, key, parents, flag = node else: return None if flag == "text": if len(element): parents.append(element) return element[0], 0, parents, None else: return None else: if element.tail and flag != "tail": return element, key, parents, "tail" elif key < len(parents[-1]) - 1: return parents[-1][key + 1], key + 1, parents, None else: return None def getParentNode(self, node): if isinstance(node, tuple): element, key, parents, flag = node else: return None if flag == "text": if not parents: return element else: return element, key, parents, None else: parent = parents.pop() if not parents: return parent else: assert list(parents[-1]).count(parent) == 1 return parent, list(parents[-1]).index(parent), parents, None return locals() getETreeModule = moduleFactoryFactory(getETreeBuilder) dom.py 0000644 00000002605 15030125115 0005671 0 ustar 00 from __future__ import absolute_import, division, unicode_literals from xml.dom import Node from . import base class TreeWalker(base.NonRecursiveTreeWalker): def getNodeDetails(self, node): if node.nodeType == Node.DOCUMENT_TYPE_NODE: return base.DOCTYPE, node.name, node.publicId, node.systemId elif node.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE): return base.TEXT, node.nodeValue elif node.nodeType == Node.ELEMENT_NODE: attrs = {} for attr in list(node.attributes.keys()): attr = node.getAttributeNode(attr) if attr.namespaceURI: attrs[(attr.namespaceURI, attr.localName)] = attr.value else: attrs[(None, attr.name)] = attr.value return (base.ELEMENT, node.namespaceURI, node.nodeName, attrs, node.hasChildNodes()) elif node.nodeType == Node.COMMENT_NODE: return base.COMMENT, node.nodeValue elif node.nodeType in (Node.DOCUMENT_NODE, Node.DOCUMENT_FRAGMENT_NODE): return (base.DOCUMENT,) else: return base.UNKNOWN, node.nodeType def getFirstChild(self, node): return node.firstChild def getNextSibling(self, node): return node.nextSibling def getParentNode(self, node): return node.parentNode __pycache__/__init__.cpython-310.pyc 0000644 00000007552 15030125115 0013216 0 ustar 00 o �7]hW � @ sZ d Z ddlmZmZmZ ddlmZ ddlmZ ddgZ i Z d d d�Z d d � Z d d� Z dS )a� A collection of modules for iterating through different kinds of tree, generating tokens identical to those produced by the tokenizer module. To create a tree walker for a new type of tree, you need to implement a tree walker object (called TreeWalker by convention) that implements a 'serialize' method which takes a tree as sole argument and returns an iterator which generates tokens. � )�absolute_import�division�unicode_literals� )� constants)� default_etree� getTreeWalker�pprintNc K s� | � � } | tvrR| dkrddlm} |jt| < n:| dkr(ddlm} |jt| < n*| dkr8ddlm} |jt| < n| dkrRdd lm} |d u rHt}|j |fi |��jS t� | �S ) a; Get a TreeWalker class for various types of tree with built-in support :arg str treeType: the name of the tree type required (case-insensitive). Supported values are: * "dom": The xml.dom.minidom DOM implementation * "etree": A generic walker for tree implementations exposing an elementtree-like interface (known to work with ElementTree, cElementTree and lxml.etree). * "lxml": Optimized walker for lxml.etree * "genshi": a Genshi stream :arg implementation: A module implementing the tree type e.g. xml.etree.ElementTree or cElementTree (Currently applies to the "etree" tree type only). :arg kwargs: keyword arguments passed to the etree walker--for other walkers, this has no effect :returns: a TreeWalker class �dom� )r �genshi)r �lxml)� etree_lxml�etree)r N) �lower�treeWalkerCache� r � TreeWalkerr r r r �getETreeModule�get)�treeType�implementation�kwargsr r r r � r �K/usr/lib/python3/dist-packages/pip/_vendor/html5lib/treewalkers/__init__.pyr s" c c sn � g }| D ]"}|d }|dv r|� |d � q|r$dd�|�d�V g }|V q|r5dd�|�d�V d S d S )N�type)� Characters�SpaceCharacters�datar r )r r )�append�join)�tokens�pendingCharacters�tokenr r r r �concatenateCharacterTokensA s ��r$ c C sF g }d}t | �D �]}|d }|dv r�|d r<|d tjd kr<|d tjv r/tj|d }n|d }d||d f }n|d }|�dd | |f � |d 7 }|d }t|�� �D ]*\\}} } |ru|tjv rltj| }n|}d|| f }n| }|�d d | || f � qY|d kr�|d 8 }q|dkr�|d 8 }q|dkr�|�dd | |d f � q|dkr�|d r�|d r�|�dd | |d |d |d r�|d ndf � q|d r�|�dd | |d |d f � q|�dd | |d f � q|�dd | f � q|dk�r|�dd | |d f � q|dk�rJ d ��td | ��d �|�S ) z�Pretty printer for tree walkers Takes a TreeWalker instance and pretty prints the output of walking the tree. :arg walker: a TreeWalker instance r r )�StartTag�EmptyTag� namespace�htmlz%s %s�namez%s<%s>� r r z %s%s="%s"r& �EndTag�Commentz %s<!-- %s -->�Doctype�publicIdz%s<!DOCTYPE %s "%s" "%s">�systemIdr z%s<!DOCTYPE %s "" "%s">z%s<!DOCTYPE %s>z %s<!DOCTYPE >r z%s"%s"r FzBconcatenateCharacterTokens should have got rid of all Space tokenszUnknown token type, %s� ) r$ r � namespaces�prefixesr �sorted�items� ValueErrorr ) �walker�output�indentr# r �nsr) �attrsr' � localname�valuer r r r P sp � ���� � )N)�__doc__� __future__r r r r r �_utilsr �__all__r r r$ r r r r r �<module> s , __pycache__/dom.cpython-310.pyc 0000644 00000003216 15030125115 0012227 0 ustar 00 o �7]h� � @ sB d dl mZmZmZ d dlmZ ddlmZ G dd� dej�Z dS )� )�absolute_import�division�unicode_literals)�Node� )�basec @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) � TreeWalkerc C s� |j tjkrtj|j|j|jfS |j tjtj fv r tj |j fS |j tj krWi }t |j�� �D ] }|�|�}|jrB|j||j|jf< q.|j|d |jf< q.tj|j|j||�� fS |j tjkrctj|j fS |j tjtjfv rptjfS tj |j fS �N) �nodeTyper �DOCUMENT_TYPE_NODEr �DOCTYPE�name�publicId�systemId� TEXT_NODE�CDATA_SECTION_NODE�TEXT� nodeValue� ELEMENT_NODE�list� attributes�keys�getAttributeNode� namespaceURI�value� localName�ELEMENT�nodeName� hasChildNodes� COMMENT_NODE�COMMENT� DOCUMENT_NODE�DOCUMENT_FRAGMENT_NODE�DOCUMENT�UNKNOWN)�self�node�attrs�attr� r) �F/usr/lib/python3/dist-packages/pip/_vendor/html5lib/treewalkers/dom.py�getNodeDetails s& � zTreeWalker.getNodeDetailsc C � |j S r )� firstChild�r% r& r) r) r* � getFirstChild$ � zTreeWalker.getFirstChildc C r, r )� nextSiblingr. r) r) r* �getNextSibling' r0 zTreeWalker.getNextSiblingc C r, r )� parentNoder. r) r) r* � getParentNode* r0 zTreeWalker.getParentNodeN)�__name__� __module__� __qualname__r+ r/ r2 r4 r) r) r) r* r s r N) � __future__r r r �xml.domr � r �NonRecursiveTreeWalkerr r) r) r) r* �<module> s __pycache__/genshi.cpython-310.pyc 0000644 00000003534 15030125115 0012730 0 ustar 00 o �7]h � @ s� d dl mZmZmZ d dlmZ d dlmZmZmZm Z m Z d dlm Z m Z m Z mZmZmZ ddlmZ ddlmZmZ G d d � d ej�Zd S ) � )�absolute_import�division�unicode_literals)�QName)�START�END� XML_NAMESPACE�DOCTYPE�TEXT)�START_NS�END_NS� START_CDATA� END_CDATA�PI�COMMENT� )�base� )� voidElements� namespacesc @ s e Zd Zdd� Zdd� ZdS )� TreeWalkerc c s^ � d }| j D ]}|d ur| �||�D ]}|V q|}q|d ur+| �|d �D ]}|V q%d S d S )N)�tree�tokens)�self�previous�event�token� r �I/usr/lib/python3/dist-packages/pip/_vendor/html5lib/treewalkers/genshi.py�__iter__ s � �zTreeWalker.__iter__c c s~ � |\}}}|t krb|\}}|j}|j} i } |D ]\} } t| t�r*| | | j| jf< q| | d | f< q| td krX|tv rX| �| || | pN|d tkpN|d |k�D ]} | V qPd S | � | || �V d S |tkr�|j}|j} | td ksv|tvr| � | |�V d S d S |t kr�| � |�V d S |t kr�| �|�D ]} | V q�d S |tkr�| j|� V d S |tttttttfv r�d S | �|�V d S )N�htmlr r )r � localname� namespace� isinstancer r r �emptyTagr �startTag�endTagr �commentr �textr �doctyper r r r r r �unknown)r r �next�kind�data�_�tag�attribs�namer" �converted_attribs�k�vr r r r r sL � ���� �zTreeWalker.tokensN)�__name__� __module__� __qualname__r r r r r r r s r N)� __future__r r r � genshi.corer r r r r r r r r r r r � r � constantsr r r r r r r �<module> s __pycache__/etree_lxml.cpython-310.pyc 0000644 00000014573 15030125115 0013620 0 ustar 00 o �7]h� � @ s� d dl mZmZmZ d dlmZ d dlmZ d dlm Z ddl m Z ddl m Z dd l mZ d d � ZG d d � d e�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de j�ZdS )� )�absolute_import�division�unicode_literals)� text_type)� OrderedDict)�etree� )� tag_regexp� )�base)� _ihatexmlc C s& | d u rd S t | t�r | S | �dd�S )N�ascii�strict)� isinstancer �decode)�s� r �M/usr/lib/python3/dist-packages/pip/_vendor/html5lib/treewalkers/etree_lxml.py� ensure_str s r c @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) �Rootc C s� || _ g | _z |jjr"| j�t| t|jj�t|jj�t|jj ��� W n t y, Y nw z|� � }W n t y> |}Y nw |� � d urO|� � }|� � d usE|d ura| j�|� |� � }|d usSd | _d | _d S �N)� elementtree�children�docinfo� internalDTD�append�Doctyper � root_name� public_id� system_url�AttributeError�getroot� getprevious�getnext�text�tail)�self�et�noder r r �__init__ s6 �� � � � � z Root.__init__c C � | j | S r )r �r& �keyr r r � __getitem__3 � zRoot.__getitem__c C � d S r r �r& r r r r# 6 � z Root.getnextc C s dS �Nr r r0 r r r �__len__9 r1 z Root.__len__N)�__name__� __module__� __qualname__r) r- r# r3 r r r r r s r c @ � e Zd Zdd� Zdd� ZdS )r c C s( || _ || _|| _|| _d | _d | _d S r )� root_node�namer � system_idr$ r% )r& r8 r9 r r: r r r r) > s zDoctype.__init__c C s | j jd S r2 )r8 r r0 r r r r# G � zDoctype.getnextN�r4 r5 r6 r) r# r r r r r = s r c @ r7 )� FragmentRootc s$ � fdd�|D �� _ d � _� _d S )Nc s g | ]}t � |��qS r )�FragmentWrapper)�.0�childr0 r r � <listcomp>M s z)FragmentRoot.__init__.<locals>.<listcomp>)r r$ r% )r& r r r0 r r) L s zFragmentRoot.__init__c C r/ r r r0 r r r r# P r1 zFragmentRoot.getnextNr< r r r r r= K s r= c @ sT e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dS )r> c C sV || _ || _t| jd�rt| jj�| _nd | _t| jd�r&t| jj�| _d S d | _d S )Nr$ r% )r8 �obj�hasattrr r$ r% )r& � fragment_rootrB r r r r) U s zFragmentWrapper.__init__c C s t | j|�S r )�getattrrB )r& r9 r r r � __getattr__a r; zFragmentWrapper.__getattr__c C s2 | j j}|�| �}|t|�d k r||d S d S r2 )r8 r �index�len)r& �siblings�idxr r r r# d s zFragmentWrapper.getnextc C r* r )rB r+ r r r r- l r. zFragmentWrapper.__getitem__c C � t | j�S r )�boolrB r0 r r r �__bool__o r. zFragmentWrapper.__bool__c C r/ r r r0 r r r � getparentr r1 zFragmentWrapper.getparentc C rK r ��strrB r0 r r r �__str__u r. zFragmentWrapper.__str__c C rK r rO r0 r r r � __unicode__x r. zFragmentWrapper.__unicode__c C rK r )rH rB r0 r r r r3 { r. zFragmentWrapper.__len__N) r4 r5 r6 r) rF r# r- rM rN rQ rR r3 r r r r r> T s r> c @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd S ) � TreeWalkerc C sJ t |t�rt|�| _t|�}nt� | _t|�}tj�| |� t � � | _ d S r ) r �list�set�fragmentChildrenr= r r �NonRecursiveTreeWalkerr) r � InfosetFilter�filter)r& �treer r r r) � s zTreeWalker.__init__c C s� t |t�r |\}}|dv sJ d| ��tjtt||��fS t |t�r&tjfS t |t�r5tj |j |j |j fS t |t �rGt|d�sGtjt|j�fS |jtjkrUtjt|j�fS |jtjkrgtjt|j�dd� fS t�t|j��}|rx|�� \}}nd }t|j�}t� }t|j � � �D ]&\}}t|�}t|�}t�|�}|r�|||� d�|� d�f< q�||d |f< q�tj || j �!|�|t"|�dkp�|jfS )N�r$ r% �%Text nodes are text or tail, found %s�tagr ���r r )#r �tupler �TEXTr rE r �DOCUMENTr �DOCTYPEr9 r r: r> rC rB r] r �Comment�COMMENTr$ �Entity�ENTITYr �match�groupsr rT �attrib�items�group�ELEMENTrY � fromXmlNamerH ) r& r( r, rg � namespacer] �attrsr9 �valuer r r �getNodeDetails� s< �zTreeWalker.getNodeDetailsc C s> t |t�r J d��t|�s|jsJ d��|jr|dfS |d S )NzText nodes have no childrenzNode has no childrenr$ r )r r_ rH r$ )r& r( r r r � getFirstChild� s zTreeWalker.getFirstChildc C s` t |t�r%|\}}|dv sJ d| ��|dkr!t|�r |d S d S |�� S |jr,|dfS |�� S )Nr[ r\ r$ r r% )r r_ rH r# r% �r& r( r, r r r �getNextSibling� s zTreeWalker.getNextSiblingc C sP t |t�r |\}}|dv sJ d| ��|dkr|S |�� S || jv r$d S |�� S )Nr[ r\ r$ )r r_ rV rN rs r r r � getParentNode� s �zTreeWalker.getParentNodeN)r4 r5 r6 r) rq rr rt ru r r r r rS s ) rS N)� __future__r r r �pip._vendor.sixr � collectionsr �lxmlr �treebuilders.etreer � r r r �objectr r r= r> rW rS r r r r �<module> s & + __pycache__/base.cpython-310.pyc 0000644 00000015373 15030125115 0012371 0 ustar 00 o �7]h4 � @ s� d dl mZmZmZ d dlmZ ddlmZmZm Z g d�Z ej Z ej ZejZejZejZejZdZd�e �Z G dd � d e�ZG d d � d e�Zd S ) � )�absolute_import�division�unicode_literals)�Node� )� namespaces� voidElements�spaceCharacters) �DOCUMENT�DOCTYPE�TEXT�ELEMENT�COMMENT�ENTITY�UNKNOWN� TreeWalker�NonRecursiveTreeWalkerz <#UNKNOWN#>� c @ sl e Zd ZdZdd� Zdd� Zdd� Zdd d �Zd d � Zd d� Z dd� Z dd� Z ddd�Z dd� Z dd� ZdS ) r z}Walks a tree yielding tokens Tokens are dicts that all have a ``type`` field specifying the type of the token. c C s || _ dS )zCCreates a TreeWalker :arg tree: the tree to walk N)�tree)�selfr � r �G/usr/lib/python3/dist-packages/pip/_vendor/html5lib/treewalkers/base.py�__init__ s zTreeWalker.__init__c C � t ��N��NotImplementedError)r r r r �__iter__# � zTreeWalker.__iter__c C � d|d�S )z�Generates an error token with the given message :arg msg: the error message :returns: SerializeError token �SerializeError��type�datar )r �msgr r r �error& � zTreeWalker.errorFc c s* � d|||d�V |r| � d�V dS dS )ar Generates an EmptyTag token :arg namespace: the namespace of the token--can be ``None`` :arg name: the name of the element :arg attrs: the attributes of the element as a dict :arg hasChildren: whether or not to yield a SerializationError because this tag shouldn't have children :returns: EmptyTag token �EmptyTag�r" �name� namespacer# zVoid element has childrenN�r% )r r* r) �attrs� hasChildrenr r r �emptyTag0 s ���zTreeWalker.emptyTagc C s d|||d�S )z�Generates a StartTag token :arg namespace: the namespace of the token--can be ``None`` :arg name: the name of the element :arg attrs: the attributes of the element as a dict :returns: StartTag token �StartTagr( r )r r* r) r, r r r �startTagE � �zTreeWalker.startTagc C s d||d�S )z�Generates an EndTag token :arg namespace: the namespace of the token--can be ``None`` :arg name: the name of the element :returns: EndTag token �EndTag)r" r) r* r )r r* r) r r r �endTagV s �zTreeWalker.endTagc c s~ � |}|� t�}|dt|�t|� � }|r d|d�V |}|�t�}|t|�d� }|r3d|d�V |r=d|d�V dS dS )at Generates SpaceCharacters and Characters tokens Depending on what's in the data, this generates one or more ``SpaceCharacters`` and ``Characters`` tokens. For example: >>> from html5lib.treewalkers.base import TreeWalker >>> # Give it an empty tree just so it instantiates >>> walker = TreeWalker([]) >>> list(walker.text('')) [] >>> list(walker.text(' ')) [{u'data': ' ', u'type': u'SpaceCharacters'}] >>> list(walker.text(' abc ')) # doctest: +NORMALIZE_WHITESPACE [{u'data': ' ', u'type': u'SpaceCharacters'}, {u'data': u'abc', u'type': u'Characters'}, {u'data': u' ', u'type': u'SpaceCharacters'}] :arg data: the text data :returns: one or more ``SpaceCharacters`` and ``Characters`` tokens N�SpaceCharactersr! � Characters)�lstripr �len�rstrip)r r# �middle�left�rightr r r �textd s � �zTreeWalker.textc C r )zdGenerates a Comment token :arg data: the comment :returns: Comment token �Commentr! r )r r# r r r �comment� r& zTreeWalker.commentNc C s d|||d�S )z�Generates a Doctype token :arg name: :arg publicId: :arg systemId: :returns: the Doctype token �Doctype)r" r) �publicId�systemIdr )r r) r@ rA r r r �doctype� r1 zTreeWalker.doctypec C r )zjGenerates an Entity token :arg name: the entity name :returns: an Entity token �Entity)r" r) r )r r) r r r �entity� r& zTreeWalker.entityc C s | � d| �S )zHandles unknown node typeszUnknown node type: r+ )r �nodeTyper r r �unknown� s zTreeWalker.unknown)F)NN)�__name__� __module__� __qualname__�__doc__r r r% r. r0 r3 r< r> rB rD rF r r r r r s & r c @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd S ) r c C r r r �r �noder r r �getNodeDetails� r z%NonRecursiveTreeWalker.getNodeDetailsc C r r r rK r r r � getFirstChild� r z$NonRecursiveTreeWalker.getFirstChildc C r r r rK r r r �getNextSibling� r z%NonRecursiveTreeWalker.getNextSiblingc C r r r rK r r r � getParentNode� r z$NonRecursiveTreeWalker.getParentNodec c s� � | j }|d ur�| �|�}|d |dd � }}d}|tkr%| j|� V ni|tkr5| j|� D ]}|V q.nY|tkre|\}}}}|rG|td kr\|tv r\| � ||||�D ]}|V qSd}n2| � |||�V n)|t krr| � |d �V n |t kr| �|d �V n|tkr�d}n| �|d �V |r�| �|�} nd } | d ur�| }nN|d ur�| �|�}|d |dd � }}|tkr�|\}}}}|r�|td ks�|tvr�| �||�V | j |u r�d }n| �|�} | d ur�| }n | �|�}|d us�|d usd S d S )Nr � F�htmlT)r rM r rB r r< r r r r. r0 r r> r rD r rF rN r3 rO rP ) r � currentNode�detailsr" r- �tokenr* r) � attributes� firstChild� nextSiblingr r r r � sd � � � ��z NonRecursiveTreeWalker.__iter__N)rG rH rI rM rN rO rP r r r r r r � s r N) � __future__r r r �xml.domr � constantsr r r �__all__� DOCUMENT_NODEr �DOCUMENT_TYPE_NODEr � TEXT_NODEr � ELEMENT_NODEr � COMMENT_NODEr � ENTITY_NODEr r �join�objectr r r r r r �<module> s ! __pycache__/etree.cpython-310.pyc 0000644 00000006554 15030125115 0012564 0 ustar 00 o �7]h� � @ sj d dl mZmZmZ d dlmZ d dlZd dlmZ ddl m Z ddl m Z e� d �Zd d � Ze e�ZdS ) � )�absolute_import�division�unicode_literals)� OrderedDictN)� string_types� )�base� )�moduleFactoryFactoryz {([^}]*)}(.*)c s, | }|� d�j� G � fdd�dtj�}t� S )N�asdc s4 e Zd ZdZ� fdd�Zdd� Zdd� Zdd � Zd S ) z#getETreeBuilder.<locals>.TreeWalkera� Given the particular ElementTree representation, this implementation, to avoid using recursion, returns "nodes" as tuples with the following content: 1. The current element 2. The index of the element relative to its parent 3. A stack of ancestor elements 4. A flag "text", "tail" or None to indicate if the current node is a text node; either the text or tail of the current element (1) c s@ t |t�r|\}}}}|dv rtjt||�fS |}t|d�s"|�� }|jdv r+tjfS |jdkr>tj |j |� d�|� d�fS |j� krItj |j fS t |jt �sVJ t|j���t�|j�}|re|�� \}}nd }|j}t� }t|j�� �D ] \} } t�| �}|r�| ||�d�|�d�f< qt| |d | f< qttj|||t|�p�|j fS ) N��text�tail�tag)� DOCUMENT_ROOT�DOCUMENT_FRAGMENTz <!DOCTYPE>�publicId�systemIdr r )� isinstance�tupler �TEXT�getattr�hasattr�getrootr �DOCUMENT�DOCTYPEr �get�COMMENTr �type� tag_regexp�match�groupsr �list�attrib�items�group�ELEMENT�len) �self�node�elt�_�flagr � namespacer �attrs�name�value��ElementTreeCommentType� �H/usr/lib/python3/dist-packages/pip/_vendor/html5lib/treewalkers/etree.py�getNodeDetails s< � �z2getETreeBuilder.<locals>.TreeWalker.getNodeDetailsc S sp t |t�r |\}}}}n |d g d f\}}}}|dv r d S |jr%|||dfS t|�r6|�|� |d d|d fS d S )Nr r r )r r r r' �append�r( r) �element�key�parentsr, r3 r3 r4 � getFirstChildH s z1getETreeBuilder.<locals>.TreeWalker.getFirstChildc S s� t |t�r |\}}}}nd S |dkr%t|�r#|�|� |d d|d fS d S |jr2|dkr2|||dfS |t|d �d k rJ|d |d |d |d fS d S )Nr r r ���r )r r r' r6 r r7 r3 r3 r4 �getNextSiblingY s z2getETreeBuilder.<locals>.TreeWalker.getNextSiblingc S s| t |t�r |\}}}}nd S |dkr |s|S |||d fS |�� }|s$|S t|d ��|�dks1J �|t|d ��|�|d fS )Nr r< r )r r �popr" �count�index)r( r) r8 r9 r: r, �parentr3 r3 r4 � getParentNodem s z1getETreeBuilder.<locals>.TreeWalker.getParentNodeN)�__name__� __module__� __qualname__�__doc__r5 r; r= rB r3 r1 r3 r4 � TreeWalker s ( rG )�Commentr r �NonRecursiveTreeWalker�locals)�ElementTreeImplementation� ElementTreerG r3 r1 r4 �getETreeBuilder s nrM )� __future__r r r � collectionsr �re�pip._vendor.sixr � r �_utilsr �compiler rM �getETreeModuler3 r3 r3 r4 �<module> s u genshi.py 0000644 00000004405 15030125115 0006367 0 ustar 00 from __future__ import absolute_import, division, unicode_literals from genshi.core import QName from genshi.core import START, END, XML_NAMESPACE, DOCTYPE, TEXT from genshi.core import START_NS, END_NS, START_CDATA, END_CDATA, PI, COMMENT from . import base from ..constants import voidElements, namespaces class TreeWalker(base.TreeWalker): def __iter__(self): # Buffer the events so we can pass in the following one previous = None for event in self.tree: if previous is not None: for token in self.tokens(previous, event): yield token previous = event # Don't forget the final event! if previous is not None: for token in self.tokens(previous, None): yield token def tokens(self, event, next): kind, data, _ = event if kind == START: tag, attribs = data name = tag.localname namespace = tag.namespace converted_attribs = {} for k, v in attribs: if isinstance(k, QName): converted_attribs[(k.namespace, k.localname)] = v else: converted_attribs[(None, k)] = v if namespace == namespaces["html"] and name in voidElements: for token in self.emptyTag(namespace, name, converted_attribs, not next or next[0] != END or next[1] != tag): yield token else: yield self.startTag(namespace, name, converted_attribs) elif kind == END: name = data.localname namespace = data.namespace if namespace != namespaces["html"] or name not in voidElements: yield self.endTag(namespace, name) elif kind == COMMENT: yield self.comment(data) elif kind == TEXT: for token in self.text(data): yield token elif kind == DOCTYPE: yield self.doctype(*data) elif kind in (XML_NAMESPACE, DOCTYPE, START_NS, END_NS, START_CDATA, END_CDATA, PI): pass else: yield self.unknown(kind) __init__.py 0000644 00000013127 15030125115 0006652 0 ustar 00 """A collection of modules for iterating through different kinds of tree, generating tokens identical to those produced by the tokenizer module. To create a tree walker for a new type of tree, you need to implement a tree walker object (called TreeWalker by convention) that implements a 'serialize' method which takes a tree as sole argument and returns an iterator which generates tokens. """ from __future__ import absolute_import, division, unicode_literals from .. import constants from .._utils import default_etree __all__ = ["getTreeWalker", "pprint"] treeWalkerCache = {} def getTreeWalker(treeType, implementation=None, **kwargs): """Get a TreeWalker class for various types of tree with built-in support :arg str treeType: the name of the tree type required (case-insensitive). Supported values are: * "dom": The xml.dom.minidom DOM implementation * "etree": A generic walker for tree implementations exposing an elementtree-like interface (known to work with ElementTree, cElementTree and lxml.etree). * "lxml": Optimized walker for lxml.etree * "genshi": a Genshi stream :arg implementation: A module implementing the tree type e.g. xml.etree.ElementTree or cElementTree (Currently applies to the "etree" tree type only). :arg kwargs: keyword arguments passed to the etree walker--for other walkers, this has no effect :returns: a TreeWalker class """ treeType = treeType.lower() if treeType not in treeWalkerCache: if treeType == "dom": from . import dom treeWalkerCache[treeType] = dom.TreeWalker elif treeType == "genshi": from . import genshi treeWalkerCache[treeType] = genshi.TreeWalker elif treeType == "lxml": from . import etree_lxml treeWalkerCache[treeType] = etree_lxml.TreeWalker elif treeType == "etree": from . import etree if implementation is None: implementation = default_etree # XXX: NEVER cache here, caching is done in the etree submodule return etree.getETreeModule(implementation, **kwargs).TreeWalker return treeWalkerCache.get(treeType) def concatenateCharacterTokens(tokens): pendingCharacters = [] for token in tokens: type = token["type"] if type in ("Characters", "SpaceCharacters"): pendingCharacters.append(token["data"]) else: if pendingCharacters: yield {"type": "Characters", "data": "".join(pendingCharacters)} pendingCharacters = [] yield token if pendingCharacters: yield {"type": "Characters", "data": "".join(pendingCharacters)} def pprint(walker): """Pretty printer for tree walkers Takes a TreeWalker instance and pretty prints the output of walking the tree. :arg walker: a TreeWalker instance """ output = [] indent = 0 for token in concatenateCharacterTokens(walker): type = token["type"] if type in ("StartTag", "EmptyTag"): # tag name if token["namespace"] and token["namespace"] != constants.namespaces["html"]: if token["namespace"] in constants.prefixes: ns = constants.prefixes[token["namespace"]] else: ns = token["namespace"] name = "%s %s" % (ns, token["name"]) else: name = token["name"] output.append("%s<%s>" % (" " * indent, name)) indent += 2 # attributes (sorted for consistent ordering) attrs = token["data"] for (namespace, localname), value in sorted(attrs.items()): if namespace: if namespace in constants.prefixes: ns = constants.prefixes[namespace] else: ns = namespace name = "%s %s" % (ns, localname) else: name = localname output.append("%s%s=\"%s\"" % (" " * indent, name, value)) # self-closing if type == "EmptyTag": indent -= 2 elif type == "EndTag": indent -= 2 elif type == "Comment": output.append("%s<!-- %s -->" % (" " * indent, token["data"])) elif type == "Doctype": if token["name"]: if token["publicId"]: output.append("""%s<!DOCTYPE %s "%s" "%s">""" % (" " * indent, token["name"], token["publicId"], token["systemId"] if token["systemId"] else "")) elif token["systemId"]: output.append("""%s<!DOCTYPE %s "" "%s">""" % (" " * indent, token["name"], token["systemId"])) else: output.append("%s<!DOCTYPE %s>" % (" " * indent, token["name"])) else: output.append("%s<!DOCTYPE >" % (" " * indent,)) elif type == "Characters": output.append("%s\"%s\"" % (" " * indent, token["data"])) elif type == "SpaceCharacters": assert False, "concatenateCharacterTokens should have got rid of all Space tokens" else: raise ValueError("Unknown token type, %s" % type) return "\n".join(output)
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings