
    h(                       U d dl mZ d dlmZmZmZmZmZmZm	Z	m
Z
 d dlmZ d dlmZ e	rd dlmZ  G d de      Z G d d	e      Z G d
 de      Z eej(                        ej*                  d<    eej,                  dd      ej*                  d<    eej(                  dd      ej*                  d<    eej.                        ej*                  d<    ed      ej*                  d<    eej(                        ej*                  d<    eej.                        ej*                  d<    ed      ej*                  d<   eegef   Zded<   e
eef   Zy)    )annotations)CallableDictIterableOptionalSetTupleTYPE_CHECKINGUnion)	TypeAlias)EntitySubstitution)_AttributeValuec                      e Zd ZU dZdZded<   dZded<    e eddg      	      Z	d
ed<   ded<   ded<   ded<   ded<   ded<   ded<   	 	 	 	 	 	 	 	 ddZ
	 	 	 	 	 	 d	 	 	 	 	 	 	 	 	 	 	 ddZddZd dZ	 	 	 	 d!dZy)"	Formattera  Describes a strategy to use when outputting a parse tree to a string.

    Some parts of this strategy come from the distinction between
    HTML4, HTML5, and XML. Others are configurable by the user.

    Formatters are passed in as the `formatter` argument to methods
    like `bs4.element.Tag.encode`. Most people won't need to
    think about formatters, and most people who need to think about
    them can pass in one of these predefined strings as `formatter`
    rather than making a new Formatter object:

    For HTML documents:
     * 'html' - HTML entity substitution for generic HTML documents. (default)
     * 'html5' - HTML entity substitution for HTML5 documents, as
                 well as some optimizations in the way tags are rendered.
     * 'html5-4.12.0' - The version of the 'html5' formatter used prior to
                        Beautiful Soup 4.13.0.
     * 'minimal' - Only make the substitutions necessary to guarantee
                   valid HTML.
     * None - Do not perform any substitution. This will be faster
              but may result in invalid markup.

    For XML documents:
     * 'html' - Entity substitution for XHTML documents.
     * 'minimal' - Only make the substitutions necessary to guarantee
                   valid XML. (default)
     * None - Do not perform any substitution. This will be faster
              but may result in invalid markup.

    htmlstrHTMLxmlXMLscriptstyle)cdata_containing_tagszDict[str, Set[str]]HTML_DEFAULTSOptional[str]language%Optional[_EntitySubstitutionFunction]entity_substitutionvoid_element_close_prefixSet[str]r   indentboolempty_attributes_are_booleansc                Z    ||S || j                   k(  r
t               S | j                  |   S )N)r   setr   )selfr   valuekwargs       u/var/labsstorage/home/kalaiyarasan.offl.2004/htdocs/course/socket/myenv/lib/python3.12/site-packages/bs4/formatter.py_defaultzFormatter._defaultB   s7     Ltxx 5L !!%((    Nc                2   |xs | j                   | _        || _        || _        | j	                  | j                  |d      | _        || _        |d}t        |t              r|dk  rd}d|z  }|| _
        yt        |t              r
|}|| _
        yd}|| _
        y)a  Constructor.

        :param language: This should be `Formatter.XML` if you are formatting
           XML markup and `Formatter.HTML` if you are formatting HTML markup.

        :param entity_substitution: A function to call to replace special
           characters with XML/HTML entities. For examples, see
           bs4.dammit.EntitySubstitution.substitute_html and substitute_xml.
        :param void_element_close_prefix: By default, void elements
           are represented as <tag/> (XML rules) rather than <tag>
           (HTML rules). To get <tag>, pass in the empty string.
        :param cdata_containing_tags: The set of tags that are defined
           as containing CDATA in this dialect. For example, in HTML,
           <script> and <style> tags are defined as containing CDATA,
           and their contents should not be formatted.
        :param empty_attributes_are_booleans: If this is set to true,
          then attributes whose values are sent to the empty string
          will be treated as `HTML boolean
          attributes<https://dev.w3.org/html5/spec-LC/common-microsyntaxes.html#boolean-attributes>`_. (Attributes
          whose value is None are always rendered this way.)
        :param indent: If indent is a non-negative integer or string,
            then the contents of elements will be indented
            appropriately when pretty-printing. An indent level of 0,
            negative, or "" will only insert newlines. Using a
            positive integer indent indents that many spaces per
            level. If indent is a string (such as "\t"), that string
            is used to indent each level. The default behavior is to
            indent one space per level.

        r   Nr    )r   r   r   r   r)   r   r"   
isinstanceintr   r    )r%   r   r   r   r   r"   r    
indent_strs           r(   __init__zFormatter.__init__O   s    N !-DII#6 )B&%)]]MM02I&
" .K*>Ffc"zvJ
 !	 $J ! J r*   c                    | j                   s|S ddlm} t        ||      r0|j                  $|j                  j
                  | j                  v r|S | j                  |      S )a$  Process a string that needs to undergo entity substitution.
        This may be a string encountered in an attribute value or as
        text.

        :param ns: A string.
        :return: The same string but with certain characters replaced by named
           or numeric entities.
           )NavigableString)r   elementr3   r-   parentnamer   )r%   nsr3   s      r(   
substitutezFormatter.substitute   sY     ''I, r?+		%		$"<"<< I''++r*   c                $    | j                  |      S )zProcess the value of an attribute.

        :param ns: A string.
        :return: A string with certain characters replaced by named
           or numeric entities.
        )r8   )r%   r&   s     r(   attribute_valuezFormatter.attribute_value   s     u%%r*   c                     |j                   g S t        |j                   j                               }t         fd|D              S )a  Reorder a tag's attributes however you want.

        By default, attributes are sorted alphabetically. This makes
        behavior consistent between Python 2 and Python 3, and preserves
        backwards compatibility with older versions of Beautiful Soup.

        If `empty_attributes_are_booleans` is True, then
        attributes whose values are set to the empty string will be
        treated as boolean attributes.
        c              3  R   K   | ]  \  }}|j                   r|d k(  rdn|f   yw) N)r"   ).0kvr%   s      r(   	<genexpr>z'Formatter.attributes.<locals>.<genexpr>   s2      
1 ;;RQP
s   $')attrslistitemssorted)r%   tagrD   s   `  r(   
attributeszFormatter.attributes   sC     99I7;CIIOO<M7N 

 
 	
r*   )r   r   r&   Optional[Set[str]]r'   r   returnr   )NN/NFr2   )r   r   r   r   r   r   r   rH   r"   r!   r    Union[int, str])r7   r   rI   r   )r&   r   rI   r   )rF   zbs4.element.TagrI   z/Iterable[Tuple[str, Optional[_AttributeValue]]])__name__
__module____qualname____doc__r   __annotations__r   dictr$   r   r)   r0   r8   r:   rG    r*   r(   r   r   
   s   @ D# C *.!8W"56*M&  >>""##K $('))$6)?B)	) #'EI),48.3!"9!9! C9! $'	9!
  29! (,9! 9!v,.&
"
	8
r*   r   c                  R     e Zd ZU dZi Zded<   	 	 	 	 	 d	 	 	 	 	 	 	 	 	 d fdZ xZS )HTMLFormatterzA generic Formatter for HTML.z"Dict[Optional[str], HTMLFormatter]REGISTRYc                L    t         t        |   | j                  |||||       y N)r    )superrT   r0   r   r%   r   r   r   r"   r    	__class__s         r(   r0   zHTMLFormatter.__init__   s/     	mT+II%!) 	, 	
r*   NrJ   NFr2   
r   r   r   r   r   rH   r"   r!   r    rK   rL   rM   rN   rO   rU   rP   r0   __classcell__rZ   s   @r(   rT   rT      s^    '35H05 FJ),48.3!"
B
 $'
  2	

 (,
 
 
r*   rT   c                  R     e Zd ZU dZi Zded<   	 	 	 	 	 d	 	 	 	 	 	 	 	 	 d fdZ xZS )XMLFormatterzA generic Formatter for XML.z!Dict[Optional[str], XMLFormatter]rU   c                L    t         t        |   | j                  |||||       y rW   )rX   ra   r0   r   rY   s         r(   r0   zXMLFormatter.__init__   s/     	lD*HH%!) 	+ 	
r*   r[   r\   r]   r_   s   @r(   ra   ra      s^    &24H/4 FJ),48.3!"
B
 $'
  2	

 (,
 
 
r*   ra   )r   r   r=   T)r   r   r"   html5z
html5-4.12minimalNr   _EntitySubstitutionFunction)
__future__r   typingr   r   r   r   r   r	   r
   r   typing_extensionsr   
bs4.dammitr   bs4._typingr   r   rT   ra   substitute_htmlrU   substitute_html5substitute_xmlr   re   rP   _FormatterOrNamerR   r*   r(   <module>ro      sf   " W W W ' )+t
" t
n
I 
.
9 
0 "/*::"  v  #0*;; "&#  w 
 (5*:: "&(  | $
 %2*99%  y !  -F  t  ,*::!  f  $0*99$  i   +tD  d  *23%*)= Y = C( r*   