HEX

File: //usr/local/CyberCP/lib64/python3.10/site-packages/bs4/builder/__pycache__/__init__.cpython-310.pyc
o

�h�_�@sfdZddlmZddlZddlZddlZddlZddlmZm	Z	m
Z
mZmZm
Z
mZmZgd�ZdZdZdZd	Zd
ZdZGdd
�d
e�ZGdd�de�Ze�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�Zdd�Z Gdd�de!�Z"ddl#m$Z$e e$�zddl#m%Z%e e%�Wn	e&y�Ynwz
ddl#m'Z'e e'�WdSe&y�YdSw) �MIT�)�defaultdictN)�CharsetMetaAttributeValue�ContentMetaAttributeValue�RubyParenthesisString�RubyTextString�
Stylesheet�Script�TemplateString�nonwhitespace_re)�HTMLTreeBuilder�SAXTreeBuilder�TreeBuilder�TreeBuilderRegistry�fast�
permissive�strict�xml�html�html5c@seZdZdZdZdS)�XMLParsedAsHTMLWarningzWThe warning issued when an HTML parser is used to parse
    XML that is not XHTML.
    a�It looks like you're parsing an XML document using an HTML parser. If this really is an HTML document (maybe it's XHTML?), you can ignore or filter this warning. If it's XML, you should know that using an XML parser will be more reliable. To parse this document as XML, make sure you have the lxml package installed, and pass the keyword argument `features="xml"` into the BeautifulSoup constructor.N)�__name__�
__module__�__qualname__�__doc__�MESSAGE�rr�G/usr/local/CyberCP/lib/python3.10/site-packages/bs4/builder/__init__.pyr#src@s(eZdZdZdd�Zdd�Zdd�ZdS)	rzYA way of looking up TreeBuilder subclasses by their name or by desired
    features.
    cCstt�|_g|_dS�N)r�list�builders_for_feature�builders��selfrrr�__init__/s

zTreeBuilderRegistry.__init__cCs0|jD]}|j|�d|�q|j�d|�dS)z�Register a treebuilder based on its advertised features.

        :param treebuilder_class: A subclass of Treebuilder. its .features
           attribute should list its features.
        rN)�featuresr �insertr!)r#�treebuilder_class�featurerrr�register3s
zTreeBuilderRegistry.registercGs�t|j�dkr	dSt|�dkr|jdSt|�}|��d}d}t|�dkrO|��}|j�|g�}t|�dkrI|durB|}t|�}n|�t|��}t|�dks&|durUdS|D]
}||vra|SqWdS)ajLook up a TreeBuilder subclass with the desired features.

        :param features: A list of features to look for. If none are
            provided, the most recently registered TreeBuilder subclass
            will be used.
        :return: A TreeBuilder subclass, or None if there's no
            registered subclass with all the requested features.
        rN)	�lenr!r�reverse�popr �get�set�intersection)r#r%�
candidates�
candidate_setr(�we_have_the_feature�	candidaterrr�lookup=s4	

���zTreeBuilderRegistry.lookupN)rrrrr$r)r4rrrrr*s

rc@s�eZdZdZdZgZgZdZdZdZ	e
e�Ze
�ZiZe�ZdZeeeefdd�Zdd�Zd	d
�Zdd�Zd
d�Z		ddd�Zdd�Zdd�Zdd�ZdS)rz:Turn a textual document into a Beautiful Soup object tree.z[Unknown tree builder]FNcCsbd|_||jur|j}||_||jur|j}||_||jkr!|j}||_||jkr,|j}||_	dS)a�Constructor.

        :param multi_valued_attributes: If this is set to None, the
         TreeBuilder will not turn any values for attributes like
         'class' into lists. Setting this to a dictionary will
         customize this behavior; look at DEFAULT_CDATA_LIST_ATTRIBUTES
         for an example.

         Internally, these are called "CDATA list attributes", but that
         probably doesn't make sense to an end-user, so the argument name
         is `multi_valued_attributes`.

        :param preserve_whitespace_tags: A list of tags to treat
         the way <pre> tags are treated in HTML. Tags in this list
         are immune from pretty-printing; their contents will always be
         output as-is.

        :param string_containers: A dictionary mapping tag names to
        the classes that should be instantiated to contain the textual
        contents of those tags. The default is to use NavigableString
        for every tag, no matter what the name. You can override the
        default by changing DEFAULT_STRING_CONTAINERS.

        :param store_line_numbers: If the parser keeps track of the
         line numbers and positions of the original markup, that
         information will, by default, be stored in each corresponding
         `Tag` object. You can turn this off by passing
         store_line_numbers=False. If the parser you're using doesn't 
         keep track of this information, then setting store_line_numbers=True
         will do nothing.
        N)
�soup�USE_DEFAULT�DEFAULT_CDATA_LIST_ATTRIBUTES�cdata_list_attributes� DEFAULT_PRESERVE_WHITESPACE_TAGS�preserve_whitespace_tags�TRACKS_LINE_NUMBERS�store_line_numbers�DEFAULT_STRING_CONTAINERS�string_containers)r#�multi_valued_attributesr:r<r>rrrr$�s$




zTreeBuilder.__init__cCs
||_dS)z�The BeautifulSoup object has been initialized and is now
        being associated with the TreeBuilder.

        :param soup: A BeautifulSoup object.
        N)r5)r#r5rrr�initialize_soup�s
zTreeBuilder.initialize_soupcC�dS)z�Do any work necessary to reset the underlying parser
        for a new document.

        By default, this does nothing.
        Nrr"rrr�reset�szTreeBuilder.resetcCs|jdurdS||jvS)a�Might a tag with this name be an empty-element tag?

        The final markup may or may not actually present this tag as
        self-closing.

        For instance: an HTMLBuilder does not consider a <p> tag to be
        an empty-element tag (it's not in
        HTMLBuilder.empty_element_tags). This means an empty <p> tag
        will be presented as "<p></p>", not "<p/>" or "<p>".

        The default implementation has no opinion about which tags are
        empty-element tags, so a tag will be presented as an
        empty-element tag if and only if it has no children.
        "<foo></foo>" will become "<foo/>", and "<foo>bar</foo>" will
        be left alone.

        :param tag_name: The name of a markup tag.
        NT)�empty_element_tags)r#�tag_namerrr�can_be_empty_element�s

z TreeBuilder.can_be_empty_elementcC�t��)z�Run some incoming markup through some parsing process,
        populating the `BeautifulSoup` object in self.soup.

        This method is not implemented in TreeBuilder; it must be
        implemented in subclasses.

        :return: None.
        ��NotImplementedError�r#�markuprrr�feed�s	zTreeBuilder.feedccs�|dddfVdS)aRun any preliminary steps necessary to make incoming markup
        acceptable to the parser.

        :param markup: Some markup -- probably a bytestring.
        :param user_specified_encoding: The user asked to try this encoding.
        :param document_declared_encoding: The markup itself claims to be
            in this encoding. NOTE: This argument is not used by the
            calling code and can probably be removed.
        :param exclude_encodings: The user asked _not_ to try any of
            these encodings.

        :yield: A series of 4-tuples:
         (markup, encoding, declared encoding,
          has undergone character replacement)

         Each 4-tuple represents a strategy for converting the
         document to Unicode and parsing it. Each strategy will be tried 
         in turn.

         By default, the only strategy is to parse the markup
         as-is. See `LXMLTreeBuilderForXML` and
         `HTMLParserTreeBuilder` for implementations that take into
         account the quirks of particular parsers.
        NFr)r#rJ�user_specified_encoding�document_declared_encoding�exclude_encodingsrrr�prepare_markup�s�zTreeBuilder.prepare_markupcCs|S)aWrap an HTML fragment to make it look like a document.

        Different parsers do this differently. For instance, lxml
        introduces an empty <head> tag, and html5lib
        doesn't. Abstracting this away lets us write simple tests
        which run HTML fragments through the parser and compare the
        results against other HTML fragments.

        This method should not be used outside of tests.

        :param fragment: A string -- fragment of HTML.
        :return: A string -- a full HTML document.
        r)r#�fragmentrrr�test_fragment_to_documentsz%TreeBuilder.test_fragment_to_documentcCrA)a2Set up any substitutions that will need to be performed on 
        a `Tag` when it's output as a string.

        By default, this does nothing. See `HTMLTreeBuilder` for a
        case where this is used.

        :param tag: A `Tag`
        :return: Whether or not a substitution was performed.
        Fr)r#�tagrrr�set_up_substitutionss
z TreeBuilder.set_up_substitutionscCs�|s|S|jr?|j�dg�}|j�|��d�}t|���D]!}||vs)|r>||vr>||}t|t�r8t�|�}n|}|||<q|S)a�When an attribute value is associated with a tag that can
        have multiple values for that attribute, convert the string
        value to a list of strings.

        Basically, replaces class="foo bar" with class=["foo", "bar"]

        NOTE: This method modifies its input in place.

        :param tag_name: The name of a tag.
        :param attrs: A dictionary containing the tag's attributes.
           Any appropriate attribute values will be modified in place.
        �*N)	r8r-�lowerr�keys�
isinstance�strr�findall)r#rD�attrs�	universal�tag_specific�attr�value�valuesrrr�$_replace_cdata_list_attribute_values's 
�
�z0TreeBuilder._replace_cdata_list_attribute_values)NNN)rrrr�NAME�ALTERNATE_NAMESr%�is_xml�	picklablerCrrr7r.r9r=�objectr6r;r$r@rBrErKrOrQrSr`rrrrros8
�2
�rc@sheZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�ZdS)r
z�A Beautiful Soup treebuilder that listens for SAX events.

    This is not currently used for anything, but it demonstrates
    how a simple TreeBuilder would work.
    cCrFrrGrIrrrrKTszSAXTreeBuilder.feedcC�dSrrr"rrr�closeW�zSAXTreeBuilder.closecCs,tdd�t|���D��}|j�||�dS)Ncss �|]\}}|d|fVqdS)�Nr)�.0�keyr^rrr�	<genexpr>[s�z.SAXTreeBuilder.startElement.<locals>.<genexpr>)�dictr�itemsr5�handle_starttag)r#�namerZrrr�startElementZszSAXTreeBuilder.startElementcC�|j�|�dSr)r5�
handle_endtag�r#rprrr�
endElement_�zSAXTreeBuilder.endElementcCs|�||�dSr)rq)r#�nsTuple�nodeNamerZrrr�startElementNScrvzSAXTreeBuilder.startElementNScCs|�|�dSr)ru)r#rwrxrrr�endElementNSgszSAXTreeBuilder.endElementNScCrfrr)r#�prefix�	nodeValuerrr�startPrefixMappinglsz!SAXTreeBuilder.startPrefixMappingcCrfrr)r#r{rrr�endPrefixMappingpszSAXTreeBuilder.endPrefixMappingcCrrr)r5�handle_data)r#�contentrrr�
charactersuszSAXTreeBuilder.characterscCrfrrr"rrr�
startDocumentxrhzSAXTreeBuilder.startDocumentcCrfrrr"rrr�endDocument{rhzSAXTreeBuilder.endDocumentN)rrrrrKrgrqruryrzr}r~r�r�r�rrrrr
Msr
c
@s�eZdZdZegd��Zegd��Zeee	e
ed�Zgd�ddgddgdgdgdgd	gd
gdgdgdgd
gd�Z
eddg�Zdd�ZdS)rz]This TreeBuilder knows facts about HTML.

    Such as which tags are empty-element tags.
    )�area�base�br�col�embed�hr�img�input�keygen�link�menuitem�meta�param�source�track�wbr�basefont�bgsound�command�frame�image�isindex�nextid�spacer)#�address�article�aside�
blockquote�canvas�dd�div�dl�dt�fieldset�
figcaption�figure�footer�form�h1�h2�h3�h4�h5�h6�headerr��li�main�nav�noscript�ol�output�p�pre�section�table�tfoot�ul�video)�rt�rp�style�script�template)�class�	accesskey�dropzone�rel�rev�headerszaccept-charset�archive�sizes�sandbox�for)rT�ar��td�thr�r�rer��icon�iframer�r��textareacCs�|jdkrdS|�d�}|�d�}|�d�}d}|dur(|}t|�|d<|duS|dur<|dur<|��dkr<t|�|d<|duS)a�Replace the declared encoding in a <meta> tag with a placeholder,
        to be substituted when the tag is output to a string.

        An HTML document may come in to Beautiful Soup as one
        encoding, but exit in a different encoding, and the <meta> tag
        needs to be changed to reflect this.

        :param tag: A `Tag`
        :return: Whether or not a substitution was performed.
        r�Fz
http-equivr��charsetNzcontent-type)rpr-rrUr)r#rR�
http_equivr�r��
meta_encodingrrrrS�s



�z$HTMLTreeBuilder.set_up_substitutionsN)rrrrr.rC�block_elementsrrrr	r
r=r7r9rSrrrrrs2��rc@sheZdZdZe�dej�Ze�dej�ZdZ	dZ
eddd��Zedd
d��Z
dd
�Zdd�Zdd�ZdS)�DetectsXMLParsedAsHTMLaA mixin class for any class (a TreeBuilder, or some class used by a
    TreeBuilder) that's in a position to detect whether an XML
    document is being incorrectly parsed as HTML, and issue an
    appropriate warning.

    This requires being able to observe an incoming processing
    instruction that might be an XML declaration, and also able to
    observe tags as they're opened. If you can't do that for a given
    TreeBuilder, there's a less reliable implementation based on
    examining the raw markup.
    z
<[^ +]htmls
<[^ +]htmlz<?xmls<?xml�cCs`t|t�r|j}|j}n|j}|j}|dur.|�|�r.|�|dd��s.|j|dd�dSdS)a�Perform a check on some markup to see if it looks like XML
        that's not XHTML. If so, issue a warning.

        This is much less reliable than doing the check while parsing,
        but some of the tree builders can't do that.

        :param stacklevel: The stacklevel of the code calling this
        function.

        :return: True if the markup looks like non-XHTML XML, False
        otherwise.

        Ni����
stacklevelTF)	rW�bytes�XML_PREFIX_B�LOOKS_LIKE_HTML_B�
XML_PREFIX�LOOKS_LIKE_HTML�
startswith�search�_warn)�clsrJr�r{�looks_like_htmlrrr�warn_if_markup_looks_like_xmls
��z4DetectsXMLParsedAsHTML.warn_if_markup_looks_like_xml�cCstjtjt|d�dS)z/Issue a warning about XML being parsed as HTML.r�N)�warnings�warnrr)r�r�rrrr�"s
�zDetectsXMLParsedAsHTML._warncCsd|_d|_dS)z+Call this method before parsing a document.N��_first_processing_instruction�	_root_tagr"rrr�_initialize_xml_detector*s
z/DetectsXMLParsedAsHTML._initialize_xml_detectorcCs"|jdus
|jdurdS||_dS)z�Call this method when encountering an XML declaration, or a
        "processing instruction" that might be an XML declaration.
        Nr�)r#�processing_instructionrrr�_document_might_be_xml/s


z-DetectsXMLParsedAsHTML._document_might_be_xmlcCsN|jdurdS||_|dkr!|jdur#|j���d�r%|��dSdSdSdS)z�Call this when you encounter the document's root tag.

        This is where we actually check whether an XML document is
        being incorrectly parsed as HTML, and issue the warning.
        Nrzxml )r�r�rUr�r�rtrrr�_root_tag_encountered>s
��z,DetectsXMLParsedAsHTML._root_tag_encounteredN)r�)r�)rrrr�re�compile�Ir�r�r�r��classmethodr�r�r�r�r�rrrrr��s
r�cCsRtjt}|jD]}t||�}t|t�r&t|||�|j�|�|j	�
|�qdS)z9Copy TreeBuilders from the given module into this module.N)�sys�modulesr�__all__�getattr�
issubclassr�setattr�append�builder_registryr))�module�this_modulerp�objrrr�register_treebuilders_fromRs



��rcs eZdZdZ�fdd�Z�ZS)�ParserRejectedMarkupzgAn Exception to be raised when the underlying parser simply
    refuses to parse the given markup.
    cs6t|t�r|}d|jjt|�f}tt|��|�dS)zzExplain why the parser rejected the given markup, either
        with a textual explanation or another exception.
        z%s: %sN)rW�	Exception�	__class__rrX�superrr$)r#�message_or_exception�e�rrrr$bs
zParserRejectedMarkup.__init__)rrrrr$�
__classcell__rrrrr^srri)�_htmlparser)�	_html5lib)�_lxml)(�__license__�collectionsr�	itertoolsr�r�r��bs4.elementrrrrrr	r
rr��FAST�
PERMISSIVE�STRICT�XML�HTML�HTML_5�UserWarningrrerr�rr
rr�rrr�r	r
�ImportErrorrrrrr�<module>sL(C_2qb��