U
|
¡ý°d,j ã @ s d Z zddlmZ W n. ek
|
rB Z zddlmZ W 5 dZ[X Y nX ddlZddlZddlZddl m
|
Z
|
ddl m Z m Z mZ dZe d¡Ze d¡Zd d
|
Zed d d dddddddddg ZG dd deZG dd deZG dd d eZG d d d eZG d d d eZ G d!d" d"ee Z G d#d$ d$e Z G d%d& d&e Z G d'd( d(e Z G d)d* d*e Z!G d+d, d,e Z"G d-d. d.e Z#G d/d0 d0e Z$G d1d2 d2e Z%G d3d4 d4e Z&G d5d6 d6e Z'G d7d8 d8e Z(G d9d: d:e Z)G d;d< d<e Z*G d=d> d>eZ+G d?d@ d@e,Z-dS )AÚMITé )ÚCallableN©ÚCSS)Ú FormatterÚ HTMLFormatterÚ XMLFormatterzutf-8z\S+z\s+c s& t fdd}|j fdd}|S )z>Alias one attribute name to another for backward compatibilityc s
|
t | S ©N©Úgetattr©Úself©Úattr© úBd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\bs4/element.pyÚalias s z_alias.<locals>.aliasc s
|
t | S r )Úsetattrr r r r r ! s )ÚpropertyÚsetter)r r r r r Ú_alias s
|
r ÚidnaÚmbcsÚoemZpalmosÚpunycodeZraw_unicode_escapeZ undefinedZunicode_escapezraw-unicode-escapeúunicode-escapez string-escapeZ string_escapec @ s e Zd ZdZdddZdS )ÚNamespacedAttributezA namespaced string (e.g. 'xml:lang') that remembers the namespace
|
('xml') and the name ('lang') that were used to create it.
|
Nc C sV |sd }|st | |¡}n&|s,t | |¡}nt | |d | ¡}||_||_||_|S )Nú:)ÚstrÚ__new__ÚprefixÚnameÚ namespace)Úclsr r! r" Úobjr r r r I s zNamespacedAttribute.__new__)NN)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__r r r r r r D s r c @ s e Zd ZdZdS )Ú%AttributeValueWithCharsetSubstitutionz=A stand-in object for a character encoding specified in HTML.N©r% r& r' r( r r r r r) [ s r) c @ s e Zd ZdZdd Zdd ZdS )ÚCharsetMetaAttributeValuezÕA generic stand-in for the value of a meta tag's 'charset' attribute.
|
|
When Beautiful Soup parses the markup '<meta charset="utf8">', the
|
value of the 'charset' attribute will be one of these objects.
|
c C s t | |¡}||_|S r )r r Úoriginal_value)r# r, r$ r r r r e s z!CharsetMetaAttributeValue.__new__c C s |t kr dS |S )zWhen an HTML document is being encoded to a given encoding, the
|
value of a meta tag's 'charset' is the name of the encoding.
|
Ú )ÚPYTHON_SPECIFIC_ENCODINGS©r Úencodingr r r Úencodej s z CharsetMetaAttributeValue.encodeN)r% r& r' r( r r1 r r r r r+ ^ s r+ c @ s. e Zd ZdZe dej¡Zdd Zdd Z dS )ÚContentMetaAttributeValuea A generic stand-in for the value of a meta tag's 'content' attribute.
|
|
When Beautiful Soup parses the markup:
|
<meta http-equiv="content-type" content="text/html; charset=utf8">
|
|
The value of the 'content' attribute will be one of these objects.
|
z((^|;)\s*charset=)([^;]*)c C s6 | j |¡}|d kr t t|¡S t | |¡}||_|S r )Ú
|
CHARSET_REÚsearchr r r, )r# r, Úmatchr$ r r r r ~ s z!ContentMetaAttributeValue.__new__c s( t kr dS fdd}| j || j¡S )Nr- c s | d¡ S )Né )Úgroup)r5 ©r0 r r Úrewrite s z1ContentMetaAttributeValue.encode.<locals>.rewrite)r. r3 Úsubr, )r r0 r9 r r8 r r1 s z ContentMetaAttributeValue.encodeN)
|
r% r& r' r( ÚreÚcompileÚMr3 r r1 r r r r r2 s s
|
r2 c @ s` e Zd ZdZdZd\ddZdd Zdd Zed d
|
Z e
|
d Z e
|
d Z e Zd efddZedd Zdd efddZeZeeZdd ZeZdd ZeZeZdd Zd]dd Zd^d d ZeZ d d! Z d"d# Z d$d% Z d&d' Z d(d) Z!di dfd*d+Z"e"Z#di ddfd,d-Z$e$Z%di dfd.d/Z&e&Z'di ddfd0d1Z(e(Z)e(Z*di dfd2d3Z+e+Z,di ddfd4d5Z-e-Z.e-Z/di dfd6d7Z0e0Z1di ddfd8d9Z2e2Z3e2Z4di fd:d;Z5e5Z6di dfd<d=Z7e7Z8e7Z9ed>d? Z:ed@dA Z;dBdC Z<dDdE Z=edFdG Z>edHdI Z?edJdK Z@edLdM ZAedNdO ZBedPdQ ZCdRdS ZDdTdU ZEdVdW ZFdXdY ZGdZd[ ZHdS )_Ú PageElementz½Contains the navigational information for some part of the page:
|
that is, its current location in the parse tree.
|
|
NavigableString, Tag, etc. are all subclasses of PageElement.
|
Nc C s || _ || _|dk r | | j_|| _| jdk r4| | j_|| _| jdk rL| | j_|dkrr| j dk rr| j jrr| j jd }|| _|dk r| | j_dS )aJ Sets up the initial relations between this element and
|
other elements.
|
|
:param parent: The parent of this element.
|
|
:param previous_element: The element parsed immediately before
|
this one.
|
|
:param next_element: The element parsed immediately before
|
this one.
|
|
:param previous_sibling: The most recently encountered element
|
on the same level of the parse tree as this one.
|
|
:param previous_sibling: The next element to be encountered
|
on the same level of the parse tree as this one.
|
Néÿÿÿÿ)ÚparentÚprevious_elementÚ next_elementÚ next_siblingÚprevious_siblingÚcontents)r r@ rA rB rD rC r r r Úsetup s&
|
|
ÿÿ zPageElement.setupc C s. |dkr |S t |ts | |¡}| |¡}|S )z¹Format the given string using the given formatter.
|
|
:param s: A string.
|
:param formatter: A Formatter object, or a string naming one of the standard formatters.
|
N)Ú
|
isinstancer Úformatter_for_nameÚ
|
substitute)r ÚsÚ formatterÚoutputr r r Ú format_stringÅ s
|
|
|
zPageElement.format_stringc C s< t |tr|S | jrt}nt}t |tr2||dS |j| S )a| Look up or create a Formatter for the given identifier,
|
if necessary.
|
|
:param formatter: Can be a Formatter object (used as-is), a
|
function (used as the entity substitution hook for an
|
XMLFormatter or HTMLFormatter), or a string (used to look
|
up an XMLFormatter or HTMLFormatter in the appropriate
|
registry.
|
)Zentity_substitution)rG r Ú_is_xmlr r r ZREGISTRY)r rK Úcr r r rH Ò s
|
|
|
|
z PageElement.formatter_for_namec C s. | j dk r| j S | jdkr&t| ddS | jjS )a Is this element part of an XML tree or an HTML tree?
|
|
This is used in formatter_for_name, when deciding whether an
|
XMLFormatter or HTMLFormatter is more appropriate. It can be
|
inefficient, but it should be called very rarely.
|
NÚis_xmlF)Ú known_xmlr@ r rN r r r r rN æ s
|
|
|
zPageElement._is_xmlrC rD Fc C s
|
t dS )zYield all strings of certain classes, possibly stripping them.
|
|
This is implemented differently in Tag and NavigableString.
|
N)ÚNotImplementedError)r ÚstripÚtypesr r r Ú _all_strings s zPageElement._all_stringsc c s | d¡D ]
|
}|V q
|
dS )zvYield all strings in this PageElement, stripping them first.
|
|
:yield: A sequence of stripped strings.
|
TN)rU ©r Ústringr r r Ústripped_strings s z PageElement.stripped_stringsr- c C s | dd | j||dD ¡S )a Get all child strings of this PageElement, concatenated using the
|
given separator.
|
|
:param separator: Strings will be concatenated using this separator.
|
|
:param strip: If True, strings will be stripped before being
|
concatenated.
|
|
:param types: A tuple of NavigableString subclasses. Any
|
strings of a subclass not found in this list will be
|
ignored. Although there are exceptions, the default
|
behavior in most cases is to consider only NavigableString
|
and CData objects. That means no comments, processing
|
instructions, etc.
|
|
:return: A string.
|
c S s g | ]}|qS r r )Ú.0rJ r r r Ú
|
<listcomp>$ s z(PageElement.get_text.<locals>.<listcomp>)rT )ÚjoinrU )r Ú separatorrS rT r r r Úget_text s ÿzPageElement.get_textc s j dkrtdt|dkr.|d kr.dS t fdd|D rLtd j } j ¡} j|d t||d D ]\}}| ||¡ qv S )
|
zÔReplace this PageElement with one or more PageElements, keeping the
|
rest of the tree the same.
|
|
:param args: One or more PageElements.
|
:return: `self`, no longer part of the tree.
|
Nz^Cannot replace one element with another when the element to be replaced is not part of a tree.r6 r c 3 s | ]}| j kV qd S r ©r@ ©rY Úxr r r Ú <genexpr>6 s z+PageElement.replace_with.<locals>.<genexpr>z%Cannot replace a Tag with its parent.©Ú _self_index)Ústart)r@ Ú
|
ValueErrorÚlenÚanyÚindexÚextractÚ enumerateÚinsert)r ÚargsZ
|
old_parentÚmy_indexÚidxÚ replace_withr r r ro ) s
|
ÿ zPageElement.replace_withc C sX | j }| j dkrtd| j | ¡}| j|d t| jdd
D ]}| ||¡ qB| S )zjReplace this PageElement with its contents.
|
|
:return: `self`, no longer part of the tree.
|
NzSCannot replace an element with its contents when thatelement is not part of a tree.rb )r@ re rh ri ÚreversedrE rk )r Z my_parentrm Úchildr r r Úunwrap@ s
|
ÿ zPageElement.unwrapc C s | |¡}| |¡ |S )zëWrap this PageElement inside another one.
|
|
:param wrap_inside: A PageElement.
|
:return: `wrap_inside`, occupying the position in the tree that used
|
to be occupied by `self`, and with `self` inside it.
|
)ro Úappend)r Z wrap_insideÚmer r r ÚwrapR s
|
|
zPageElement.wrapc C sÎ | j dk r(|dkr | j | ¡}| j j|= | ¡ }|j}| jdk rR| j|k rR|| j_|dk rl|| jk rl| j|_d| _d|_d| _ | jdk r| j| jk r| j| j_| jdk r¾| j| jk r¾| j| j_d | _| _| S )a Destructively rips this element out of the tree.
|
|
:param _self_index: The location of this element in its parent's
|
.contents, if known. Passing this in allows for a performance
|
optimization.
|
|
:return: `self`, no longer part of the tree.
|
N)r@ rh rE Ú_last_descendantrB rA rD rC )r rc Ú
|
last_childrB r r r ri ] s2
|
|
|
ÿ
|
|
ÿ
|
|
|
ÿ
|
zPageElement.extractTc C sL |r| j dk r| j j}n | }t|tr8|jr8|jd }q |sH|| krHd}|S )zêFinds the last element beneath this object to be parsed.
|
|
:param is_initialized: Has `setup` been called on this PageElement
|
yet?
|
:param accept_self: Is `self` an acceptable answer to the question?
|
Nr? )rC rA rG ÚTagrE )r Zis_initializedZ accept_selfrw r r r rv s
|
z PageElement._last_descendantc C sê |dkrt d|| kr t dt|tr<t|ts<t|}ddlm} t||rzt|jD ]}| ||¡ |d7 }q\dS t |t
|
| j}t |drÊ|j dk rÊ|j | krÂ| |¡}||k rÂ|d8 }| ¡ | |_ d}|dkrêd|_| |_n(| j|d }||_||j_| d¡|_|jdk r&||j_| d¡}|t
|
| jkrd|_| }d} | dkr|dk r|j} |j }| dk rNqqN| dk r| |_nd|_n*| j| }
|
|
|
|_|jdk r¾||j_|
|
|_|jdk rØ||j_| j ||¡ dS ) a& Insert a new PageElement in the list of this PageElement's children.
|
|
This works the same way as `list.insert`.
|
|
:param position: The numeric position that should be occupied
|
in `self.children` by the new PageElement.
|
:param new_child: A PageElement.
|
Nz Cannot insert None into a tag.z Cannot insert a tag into itself.r )Ú BeautifulSoupr6 r@ F)re rG r ÚNavigableStringZbs4ry ÚlistrE rk Úminrf Úhasattrr@ rh ri rD rA rC rv rB ) r ÚpositionÚ new_childry ZsubchildZ current_indexZprevious_childZnew_childs_last_elementr@ Zparents_next_siblingZ
|
next_childr r r rk sj
|
ÿ
|
|
|
|
|
|
|
|
zPageElement.insertc C s | t| j|¡ dS )zgAppends the given PageElement to the contents of this one.
|
|
:param tag: A PageElement.
|
N)rk rf rE )r Útagr r r rs è s zPageElement.appendc C s: t |tr|j}t |tr"t|}|D ]}| |¡ q&dS )zñAppends the given PageElements to this one's contents.
|
|
:param tags: A list of PageElements. If a single Tag is
|
provided instead, this PageElement's contents will be extended
|
with that Tag's contents.
|
N)rG rx rE r{ rs )r Útagsr r r r Úextendï s
|
|
zPageElement.extendc sj j }|dkrtdt fdd|D r4td|D ],}t|trN| ¡ | ¡}| ||¡ q8dS )zóMakes the given element(s) the immediate predecessor of this one.
|
|
All the elements will have the same parent, and the given elements
|
will be immediately before this one.
|
|
:param args: One or more PageElements.
|
Nz2Element has no parent, so 'before' has no meaning.c 3 s | ]}| kV qd S r r r_ r r r ra s z,PageElement.insert_before.<locals>.<genexpr>z&Can't insert an element before itself.©r@ re rg rG r> ri rh rk )r rl r@ Z predecessorrh r r r Ú insert_beforeÿ s ÿ
|
|
zPageElement.insert_beforec s~ j }|dkrtdt fdd|D r4tdd}|D ]<}t|trR| ¡ | ¡}| |d | |¡ |d7 }q<dS )zìMakes the given element(s) the immediate successor of this one.
|
|
The elements will have the same parent, and the given elements
|
will be immediately after this one.
|
|
:param args: One or more PageElements.
|
Nz1Element has no parent, so 'after' has no meaning.c 3 s | ]}| kV qd S r r r_ r r r ra " s z+PageElement.insert_after.<locals>.<genexpr>z%Can't insert an element after itself.r r6 r )r rl r@ ÚoffsetÚ successorrh r r r Ú insert_after s ÿ
|
|
zPageElement.insert_afterc K s | j | j|||f|S )aU Find the first PageElement that matches the given criteria and
|
appears later in the document than this PageElement.
|
|
All find_* methods take a common set of arguments. See the online
|
documentation for detailed explanations.
|
|
:param name: A filter on tag name.
|
:param attrs: A dictionary of filters on attribute values.
|
:param string: A filter for a NavigableString with specific text.
|
:kwargs: A dictionary of filters on attribute values.
|
:return: A PageElement.
|
:rtype: bs4.element.Tag | bs4.element.NavigableString
|
)Ú _find_oneÚ find_all_next©r r! ÚattrsrW Úkwargsr r r Ú find_next/ s zPageElement.find_nextc K s0 | dd¡}| j||||| jfd|d i|S )ai Find all PageElements that match the given criteria and appear
|
later in the document than this PageElement.
|
|
All find_* methods take a common set of arguments. See the online
|
documentation for detailed explanations.
|
|
:param name: A filter on tag name.
|
:param attrs: A dictionary of filters on attribute values.
|
:param string: A filter for a NavigableString with specific text.
|
:param limit: Stop looking after finding this many results.
|
:kwargs: A dictionary of filters on attribute values.
|
:return: A ResultSet containing PageElements.
|
Ú _stacklevelé r6 )ÚpopÚ _find_allÚ next_elements©r r! r rW Úlimitr r r r r r @ s ÿÿzPageElement.find_all_nextc K s | j | j|||f|S )aQ Find the closest sibling to this PageElement that matches the
|
given criteria and appears later in the document.
|
|
All find_* methods take a common set of arguments. See the
|
online documentation for detailed explanations.
|
|
:param name: A filter on tag name.
|
:param attrs: A dictionary of filters on attribute values.
|
:param string: A filter for a NavigableString with specific text.
|
:kwargs: A dictionary of filters on attribute values.
|
:return: A PageElement.
|
:rtype: bs4.element.Tag | bs4.element.NavigableString
|
)r Úfind_next_siblingsr r r r Úfind_next_siblingT s ÿz PageElement.find_next_siblingc K s0 | dd¡}| j||||| jfd|d i|S )a Find all siblings of this PageElement that match the given criteria
|
and appear later in the document.
|
|
All find_* methods take a common set of arguments. See the online
|
documentation for detailed explanations.
|
|
:param name: A filter on tag name.
|
:param attrs: A dictionary of filters on attribute values.
|
:param string: A filter for a NavigableString with specific text.
|
:param limit: Stop looking after finding this many results.
|
:kwargs: A dictionary of filters on attribute values.
|
:return: A ResultSet of PageElements.
|
:rtype: bs4.element.ResultSet
|
r r r6 )r r Ú next_siblingsr r r r r f s þþþz PageElement.find_next_siblingsc K s | j | j|||f|S )aV Look backwards in the document from this PageElement and find the
|
first PageElement that matches the given criteria.
|
|
All find_* methods take a common set of arguments. See the online
|
documentation for detailed explanations.
|
|
:param name: A filter on tag name.
|
:param attrs: A dictionary of filters on attribute values.
|
:param string: A filter for a NavigableString with specific text.
|
:kwargs: A dictionary of filters on attribute values.
|
:return: A PageElement.
|
:rtype: bs4.element.Tag | bs4.element.NavigableString
|
)r Úfind_all_previousr r r r Ú find_previous~ s ÿÿzPageElement.find_previousc K s0 | dd¡}| j||||| jfd|d i|S )a Look backwards in the document from this PageElement and find all
|
PageElements that match the given criteria.
|
|
All find_* methods take a common set of arguments. See the online
|
documentation for detailed explanations.
|
|
:param name: A filter on tag name.
|
:param attrs: A dictionary of filters on attribute values.
|
:param string: A filter for a NavigableString with specific text.
|
:param limit: Stop looking after finding this many results.
|
:kwargs: A dictionary of filters on attribute values.
|
:return: A ResultSet of PageElements.
|
:rtype: bs4.element.ResultSet
|
r r r6 )r r Úprevious_elementsr r r r r s ÿþþz PageElement.find_all_previousc K s | j | j|||f|S )aV Returns the closest sibling to this PageElement that matches the
|
given criteria and appears earlier in the document.
|
|
All find_* methods take a common set of arguments. See the online
|
documentation for detailed explanations.
|
|
:param name: A filter on tag name.
|
:param attrs: A dictionary of filters on attribute values.
|
:param string: A filter for a NavigableString with specific text.
|
:kwargs: A dictionary of filters on attribute values.
|
:return: A PageElement.
|
:rtype: bs4.element.Tag | bs4.element.NavigableString
|
)r Úfind_previous_siblingsr r r r Úfind_previous_sibling¨ s ÿz!PageElement.find_previous_siblingc K s0 | dd¡}| j||||| jfd|d i|S )a Returns all siblings to this PageElement that match the
|
given criteria and appear earlier in the document.
|
|
All find_* methods take a common set of arguments. See the online
|
documentation for detailed explanations.
|
|
:param name: A filter on tag name.
|
:param attrs: A dictionary of filters on attribute values.
|
:param string: A filter for a NavigableString with specific text.
|
:param limit: Stop looking after finding this many results.
|
:kwargs: A dictionary of filters on attribute values.
|
:return: A ResultSet of PageElements.
|
:rtype: bs4.element.ResultSet
|
r r r6 )r r Úprevious_siblingsr r r r r º s þþþz"PageElement.find_previous_siblingsc K s. d}| j ||dfddi|}|r*|d }|S )aå Find the closest parent of this PageElement that matches the given
|
criteria.
|
|
All find_* methods take a common set of arguments. See the online
|
documentation for detailed explanations.
|
|
:param name: A filter on tag name.
|
:param attrs: A dictionary of filters on attribute values.
|
:kwargs: A dictionary of filters on attribute values.
|
|
:return: A PageElement.
|
:rtype: bs4.element.Tag | bs4.element.NavigableString
|
Nr6 r é r )Ú find_parents)r r! r r ÚrÚlr r r Ú find_parentÒ s
|
zPageElement.find_parentc K s0 | dd¡}| j||d|| jfd|d i|S )a Find all parents of this PageElement that match the given criteria.
|
|
All find_* methods take a common set of arguments. See the online
|
documentation for detailed explanations.
|
|
:param name: A filter on tag name.
|
:param attrs: A dictionary of filters on attribute values.
|
:param limit: Stop looking after finding this many results.
|
:kwargs: A dictionary of filters on attribute values.
|
|
:return: A PageElement.
|
:rtype: bs4.element.Tag | bs4.element.NavigableString
|
r r Nr6 )r r Úparents)r r! r r r r r r r r é s ÿÿzPageElement.find_parentsc C s | j S )z¥The PageElement, if any, that was parsed just after this one.
|
|
:return: A PageElement.
|
:rtype: bs4.element.Tag | bs4.element.NavigableString
|
©rB r r r r Únextý s zPageElement.nextc C s | j S )z¦The PageElement, if any, that was parsed just before this one.
|
|
:return: A PageElement.
|
:rtype: bs4.element.Tag | bs4.element.NavigableString
|
©rA r r r r Úprevious s zPageElement.previousc K s. d }||||dfddi|}|r*|d }|S )Nr6 r é r r )r Úmethodr! r rW r r r¡ r r r r s
|
zPageElement._find_onec sL | dd¡}|dkr6d|kr6| d¡}tjdt|d ttrF}nt||f|}|dkrä|sä|sä|sädkszdkrdd |D } t|| S tträ d
|
¡d kr¼ d
|
d ¡\ nd fd d |D } t|| S t|}
|
z t
|
|} W n t k
|
r Y qHY nX | rì| | ¡} | rì|
|
| ¡ |rìt|
|
|krìqHqì|
|
S ) z8Iterates over a generator looking for things that match.r r NÚtextzOThe 'text' argument to find()-type methods is deprecated. Use 'string' instead.©Ú
|
stacklevelTc s s | ]}t |tr|V qd S r )rG rx ©rY Úelementr r r ra + s
|
ÿz(PageElement._find_all.<locals>.<genexpr>r r6 c 3 sB | ]:}t |tr|jks6|j krd ks6|jkr|V qd S r )rG rx r! r r ©Z
|
local_namer! r r r ra 8 s
|
|
|
|
ú)r ÚwarningsÚwarnÚDeprecationWarningrG Ú SoupStrainerÚ ResultSetr ÚcountÚsplitr¥ Ú StopIterationr4 rs rf ) r r! r rW r Ú generatorr r ZstrainerÚresultÚresultsÚiÚfoundr r¯ r r sD
|
þ
|
|
|
|
|
|
zPageElement._find_allc c s | j }|dk r |V |j }qdS )zgAll PageElements that were parsed after this one.
|
|
:yield: A sequence of PageElements.
|
Nr¤ ©r r» r r r r R s zPageElement.next_elementsc c s | j }|dk r |V |j }qdS )zAll PageElements that are siblings of this one but were parsed
|
later.
|
|
:yield: A sequence of PageElements.
|
N)rC r½ r r r r ] s zPageElement.next_siblingsc c s | j }|dk r |V |j }qdS )zhAll PageElements that were parsed before this one.
|
|
:yield: A sequence of PageElements.
|
Nr¦ r½ r r r r i s z PageElement.previous_elementsc c s | j }|dk r |V |j }qdS )z
All PageElements that are siblings of this one but were parsed
|
earlier.
|
|
:yield: A sequence of PageElements.
|
N)rD r½ r r r r t s z PageElement.previous_siblingsc c s | j }|dk r |V |j }qdS )zlAll PageElements that are parents of this PageElement.
|
|
:yield: A sequence of PageElements.
|
Nr^ r½ r r r r£ s zPageElement.parentsc C s t | ddpdS )zOCheck whether a PageElement has been decomposed.
|
|
:rtype: bool
|
Ú _decomposedFr
|
r r r r Ú
|
decomposed s zPageElement.decomposedc C s | j S r )r r r r r Ú nextGenerator s zPageElement.nextGeneratorc C s | j S r )r r r r r ÚnextSiblingGenerator s z PageElement.nextSiblingGeneratorc C s | j S r )r r r r r ÚpreviousGenerator s z PageElement.previousGeneratorc C s | j S r )r r r r r ÚpreviousSiblingGenerator s z$PageElement.previousSiblingGeneratorc C s | j S r )r£ r r r r ÚparentGenerator¡ s zPageElement.parentGenerator)NNNNN)N)TT)Ir% r& r' r( rQ rF rM rH r rN r Z nextSiblingZpreviousSiblingÚobjectÚdefaultrU rX r] ZgetTextrª ro Ú replaceWithrr Zreplace_with_childrenZreplaceWithChildrenru ri rv Z_lastRecursiveChildrk rs r r r r ZfindNextr Z findAllNextr ZfindNextSiblingr ZfindNextSiblingsZfetchNextSiblingsr Z findPreviousr ZfindAllPreviousZ fetchPreviousr ZfindPreviousSiblingr ZfindPreviousSiblingsZfetchPreviousSiblingsr¢ Z
|
findParentr Z findParentsZ fetchParentsr¥ r§ r r r r r r r£ r¿ rÀ rÁ r rà rÄ r r r r r> s¨ ÿ
|
)
|
|
ÿ
|
|
&
|
Rÿ
|
|
|
|
:
|
|
|
|
|
|
|
|
|
r> c @ s~ e Zd ZdZdZdZdd ZdddZdd Zd
|
d Z d d Z
|
dddZ e dd Z e jdd Z dejfddZe eZdS )rz z´A Python Unicode string that is part of a parse tree.
|
|
When Beautiful Soup parses the markup <b>penguin</b>, it will
|
create a NavigableString for the string "penguin".
|
r- c C s2 t |trt | |¡}nt | |t¡}| ¡ |S )a- Create a new NavigableString.
|
|
When unpickling a NavigableString, this method is called with
|
the string in DEFAULT_OUTPUT_ENCODING. That encoding needs to be
|
passed in to the superclass's __new__ or the superclass won't know
|
how to handle non-ASCII characters.
|
)rG r r ÚDEFAULT_OUTPUT_ENCODINGrF )r# ÚvalueÚur r r r ¯ s
|
|
zNavigableString.__new__Fc C s t | | S )a> A copy of a NavigableString has the same contents and class
|
as the original, but it is not connected to the parse tree.
|
|
:param recursive: This parameter is ignored; it's only defined
|
so that NavigableString.__deepcopy__ implements the same
|
signature as Tag.__deepcopy__.
|
)Útype)r ÚmemoÚ recursiver r r Ú __deepcopy__¾ s z NavigableString.__deepcopy__c C s
|
| i ¡S )zA copy of a NavigableString can only be a deep copy, because
|
only one PageElement can occupy a given place in a parse tree.
|
©rÎ r r r r Ú__copy__È s zNavigableString.__copy__c C s
|
t | fS r )r r r r r Ú__getnewargs__Î s z NavigableString.__getnewargs__c C s$ |dkr | S t d| jj|f dS )zªtext.string gives you text. This is for backwards
|
compatibility for Navigable*String, but for CData* it lets you
|
get the string without the CData wrapper.rW ú!'%s' object has no attribute '%s'N)ÚAttributeErrorÚ __class__r% )r r r r r Ú __getattr__Ñ s ÿÿzNavigableString.__getattr__Úminimalc C s | | |¡}| j| | j S )zRun the string through the provided formatter.
|
|
:param formatter: A Formatter object, or a string naming one of the standard formatters.
|
©rM ÚPREFIXÚSUFFIX)r rK rL r r r Ú output_readyÜ s z NavigableString.output_readyc C s dS )z÷Since a NavigableString is not a Tag, it has no .name.
|
|
This property is implemented so that code like this doesn't crash
|
when run on a mixture of Tag and NavigableString objects:
|
[x.name for x in tag.children]
|
Nr r r r r r! ä s zNavigableString.namec C s t ddS )z1Prevent NavigableString.name from ever being set.z)A NavigableString cannot be given a name.N©rÓ )r r! r r r r! î s c c sj || j krtj}t| }|dk rDt|tr8||k rDdS n ||krDdS | }|rT| ¡ }t|dkrf|V dS )aï Yield all strings of certain classes, possibly stripping them.
|
|
This makes it easy for NavigableString to implement methods
|
like get_text() as conveniences, creating a consistent
|
text-extraction API across all PageElements.
|
|
:param strip: If True, all strings will be stripped before being
|
yielded.
|
|
:param types: A tuple of NavigableString subclasses. If this
|
NavigableString isn't one of those subclasses, the
|
sequence will be empty. By default, the subclasses
|
considered are NavigableString and CData objects. That
|
means no comments, processing instructions, etc.
|
|
:yield: A sequence that either contains this string, or is empty.
|
|
Nr )rÆ rx Ú DEFAULT_INTERESTING_STRING_TYPESrË rG rS rf )r rS rT Zmy_typerÉ r r r rU ó s
|
|
z NavigableString._all_stringsN)F)rÖ )r% r& r' r( rØ rÙ r rÎ rÐ rÑ rÕ rÚ r r! r r> rÆ rU Ústringsr r r r rz ¥ s
|
|
|
|
|
.rz c @ s" e Zd ZdZdZdZdddZdS )ÚPreformattedStringzÔA NavigableString not subject to the normal formatting rules.
|
|
This is an abstract class used for special kinds of strings such
|
as comments (the Comment class) and CDATA blocks (the CData
|
class).
|
r- Nc C s$ |dk r| | |¡}| j| | j S )a¿ Make this string ready for output by adding any subclass-specific
|
prefix or suffix.
|
|
:param formatter: A Formatter object, or a string naming one
|
of the standard formatters. The string will be passed into the
|
Formatter, but only to trigger any side effects: the return
|
value is ignored.
|
|
:return: The string, with any subclass-specific prefix and
|
suffix added on.
|
Nr× )r rK Úignorer r r rÚ . s z PreformattedString.output_ready)N)r% r& r' r( rØ rÙ rÚ r r r r rÞ # s rÞ c @ s e Zd ZdZdZdZdS )ÚCDatazA CDATA block.z <![CDATA[z]]>N©r% r& r' r( rØ rÙ r r r r rà > s rà c @ s e Zd ZdZdZdZdS )ÚProcessingInstructionz A SGML processing instruction.ú<?ú>Nrá r r r r râ C s râ c @ s e Zd ZdZdZdZdS )ÚXMLProcessingInstructionz An XML processing instruction.rã ú?>Nrá r r r r rå I s rå c @ s e Zd ZdZdZdZdS )ÚCommentzAn HTML or XML comment.z<!--z-->Nrá r r r r rç N s rç c @ s e Zd ZdZdZdZdS )Ú DeclarationzAn XML declaration.rã ræ Nrá r r r r rè T s rè c @ s$ e Zd ZdZedd ZdZdZdS )ÚDoctypez A document type declaration.c C sN |pd}|dk r2|d| 7 }|dk rF|d| 7 }n|dk rF|d| 7 }t |S )aÜ Generate an appropriate document type declaration for a given
|
public ID and system ID.
|
|
:param name: The name of the document's root element, e.g. 'html'.
|
:param pub_id: The Formal Public Identifier for this document type,
|
e.g. '-//W3C//DTD XHTML 1.1//EN'
|
:param system_id: The system identifier for this document type,
|
e.g. 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'
|
|
:return: A Doctype.
|
r- Nz PUBLIC "%s"z "%s"z SYSTEM "%s")ré )r# r! Zpub_idÚ system_idrÉ r r r Úfor_name_and_ids\ s zDoctype.for_name_and_idsz
|
<!DOCTYPE z>
|
N)r% r& r' r( Ú classmethodrë rØ rÙ r r r r ré Z s
|
|
ré c @ s e Zd ZdZdS )Ú
|
StylesheetzA NavigableString representing an stylesheet (probably
|
CSS).
|
|
Used to distinguish embedded stylesheets from textual content.
|
Nr* r r r r rí w s rí c @ s e Zd ZdZdS )ÚScriptzA NavigableString representing an executable script (probably
|
Javascript).
|
|
Used to distinguish executable code from textual content.
|
Nr* r r r r rî s rî c @ s e Zd ZdZdS )ÚTemplateStringz·A NavigableString representing a string found inside an HTML
|
template embedded in a larger document.
|
|
Used to distinguish such strings from the main body of the document.
|
Nr* r r r r rï s rï c @ s e Zd ZdZdS )ÚRubyTextStringzóA NavigableString representing the contents of the <rt> HTML
|
element.
|
|
https://dev.w3.org/html5/spec-LC/text-level-semantics.html#the-rt-element
|
|
Can be used to distinguish such strings from the strings they're
|
annotating.
|
Nr* r r r r rð s rð c @ s e Zd ZdZdS )ÚRubyParenthesisStringzA NavigableString representing the contents of the <rp> HTML
|
element.
|
|
https://dev.w3.org/html5/spec-LC/text-level-semantics.html#the-rp-element
|
Nr* r r r r rñ s rñ c @ sf e Zd ZdZdnddZedZdoddZd d
|
Zd d Z e
|
d d Z e Z e
|
dd Z e jdd Z eefZdejfddZe
|
eZdd ZdpddZdd Zdd Zdqd d Zdrd d Zd!d" Z d#d$ Z d%d& Z d'd( Z d)d* Z d+d, Z!d-d. Z"d/d0 Z#d1d2 Z$d3d4 Z%d5d6 Z&d7d8 Z'd9d: Z(dsd<d=Z)d>d? Z*e* Z+Z)e,dd@dAfdBdCZ-de,d@dfdDdEZ.e/ Z0e/ Z1e/ Z2e/ Z3dtdFdGZ4dHdI Z5dJdK Z6dudMdNZ7dvdOdPZ8de,d@fdQdRZ9de,d@fdSdTZ:e,ddUfdVdWZ;di ddfdXdYZ<e<Z=di dddfdZd[Z>e>Z?e>Z@e
|
d\d] ZAe
|
d^d_ ZBe
|
d`da ZCdwdbdcZDdxdddeZEe
|
dfdg ZFdhdi ZGdjdk ZHdldm ZIdS )yrx záRepresents an HTML or XML tag that is part of a parse tree, along
|
with its attributes and contents.
|
|
When Beautiful Soup parses the markup <b>penguin</b>, it will
|
create a Tag object representing the <b> tag.
|
Nc C sR |dkrd| _ n|j| _ |dkr(td|| _|| _|p:i | _|| _|rN|jrj|
|
dk s^| dk rj|
|
| _| | _ |dkrxi }n4|r¤|dk r|j
|
r| | j|¡}q¬t |}nt |}|rº|j | _n| | _|| _g | _| ||¡ d| _|dkr| | _| | _
|
|| _|| _nL| | ¡ | |¡| _|j
|
| _
|
|j| _| j|jkrF|j| j | _n| j| _dS )aM Basic constructor.
|
|
:param parser: A BeautifulSoup object.
|
:param builder: A TreeBuilder.
|
:param name: The name of the tag.
|
:param namespace: The URI of this Tag's XML namespace, if any.
|
:param prefix: The prefix for this Tag's XML namespace, if any.
|
:param attrs: A dictionary of this Tag's attribute values.
|
:param parent: The PageElement to use as this Tag's parent.
|
:param previous: The PageElement that was parsed immediately before
|
this tag.
|
:param is_xml: If True, this is an XML tag. Otherwise, this is an
|
HTML tag.
|
:param sourceline: The line number where this tag was found in its
|
source document.
|
:param sourcepos: The character position within `sourceline` where this
|
tag was found.
|
:param can_be_empty_element: If True, this tag should be
|
represented as <tag/>. If False, this tag should be represented
|
as <tag></tag>.
|
:param cdata_list_attributes: A list of attributes whose values should
|
be treated as CDATA if they ever show up on this tag.
|
:param preserve_whitespace_tags: A list of tag names whose contents
|
should have their whitespace preserved.
|
:param interesting_string_types: This is a NavigableString
|
subclass or a tuple of them. When iterating over this
|
Tag's strings in methods like Tag.strings or Tag.get_text,
|
these are the types of strings that are interesting enough
|
to be considered. The default is to consider
|
NavigableString and CData the only interesting string
|
subtypes.
|
:param namespaces: A dictionary mapping currently active
|
namespace prefixes to URIs. This can be used later to
|
construct CSS selectors.
|
Nz%No value provided for new tag's name.F)Ú parser_classrÔ re r! r" Ú _namespacesr Zstore_line_numbersÚ
|
sourcelineÚ sourceposÚcdata_list_attributesZ$_replace_cdata_list_attribute_valuesÚdictrP rQ r rE rF ÚhiddenÚcan_be_empty_elementÚpreserve_whitespace_tagsÚinteresting_string_typesZset_up_substitutionsZstring_containersrÜ )r ÚparserÚbuilderr! r" r r r@ r§ rP rô rõ rù rö rú rû Ú
|
namespacesr r r Ú__init__¯ sZ +
|
|
ÿÿ ÿ
|
|
|
|
|
z Tag.__init__rò Tc C sp | ¡ }|rl|g}| | j¡D ]L\}}|tjkr:| ¡ q |j|dd}|d |¡ |tjkr | |¡ q |S )zA deepcopy of a Tag is a new Tag, unconnected to the parse tree.
|
Its contents are a copy of the old Tag's contents.
|
F)rÍ r? ) Ú_cloneÚ _event_streamÚ descendantsrx ÚEND_ELEMENT_EVENTr rÎ rs ÚSTART_ELEMENT_EVENT)r rÌ rÍ ÚcloneÚ tag_stackÚeventr® Zdescendant_cloner r r rÎ & s
|
|
ÿ
|
zTag.__deepcopy__c C s
|
| i ¡S )zyA copy of a Tag must always be a deep copy, because a Tag's
|
children can only have one parent at a time.
|
rÏ r r r r rÐ B s z Tag.__copy__c C s^ t | d| j| j| j| j| j| j| j| j| j | j
|
| j | j d }dD ]}t ||t| | qB|S )z¥Create a new Tag just like this one, but with no
|
contents and unattached to any parse tree.
|
|
This is the first step in the deepcopy process.
|
N)rP rô rõ rù rö rú rû )rù rø )rË rý r! r" r r rN rô rõ rù rö rú rû r r )r r r r r r r H s$ ù z
|
Tag._clonec C s t | jdko| jS )a7 Is this tag an empty-element tag? (aka a self-closing tag)
|
|
A tag that has contents is never an empty-element tag.
|
|
A tag that has no contents may or may not be an empty-element
|
tag. It depends on the builder used to create the tag. If the
|
builder has a designated list of empty-element tags, then only
|
a tag whose name shows up in that list is considered an
|
empty-element tag.
|
|
If the builder has no designated list of empty-element tags,
|
then any tag with no contents is an empty-element tag.
|
r )rf rE rù r r r r Úis_empty_element[ s zTag.is_empty_elementc C s0 t | jdkrdS | jd }t|tr*|S |jS )aý Convenience property to get the single string within this
|
PageElement.
|
|
TODO It might make sense to have NavigableString.string return
|
itself.
|
|
:return: If this element has a single string child, return
|
value is that string. If this element has one child tag,
|
return value is the 'string' attribute of the child tag,
|
recursively. If this element is itself a string, has no
|
children, or has more than one child, return value is None.
|
r6 Nr )rf rE rG rz rW )r rq r r r rW m s
|
|
z
|
Tag.stringc C s | ¡ | | |¡¡ dS )z2Replace this PageElement's contents with `string`.N)Úclearrs rÔ rV r r r rW s Fc c s || j kr| j}| jD ]h}|dkr.t|ts.qt|}t|trL||k r^qn|dk r^||kr^q|rx| ¡ }t|dkrxq|V qdS )a| Yield all strings of certain classes, possibly stripping them.
|
|
:param strip: If True, all strings will be stripped before being
|
yielded.
|
|
:param types: A tuple of NavigableString subclasses. Any strings of
|
a subclass not found in this list will be ignored. By
|
default, the subclasses considered are the ones found in
|
self.interesting_string_types. If that's not specified,
|
only NavigableString and CData objects will be
|
considered. That means no comments, processing
|
instructions, etc.
|
|
:yield: A sequence of strings.
|
|
Nr )rÆ rû r rG rz rË rS rf )r rS rT Z
|
descendantZdescendant_typer r r rU s
|
|
|
zTag._all_stringsc C s: | ¡ | }|dk r6|j}|j ¡ g |_d|_|}q dS )a Recursively destroys this PageElement and its children.
|
|
This element will be removed from the tree and wiped out; so
|
will everything beneath it.
|
|
The behavior of a decomposed PageElement is undefined and you
|
should never use one for anything, but if you need to _check_
|
whether an element has been decomposed, you can use the
|
`decomposed` property.
|
NT)ri rB Ú__dict__r rE r¾ )r r» Únr r r Ú decompose¯ s
|
z Tag.decomposec C sV |r6| j dd
D ] }t|tr*| ¡ q| ¡ qn | j dd
D ] }| ¡ qDdS )zàWipe out all children of this PageElement by calling extract()
|
on them.
|
|
:param decompose: If this is True, decompose() (a more
|
destructive method) will be called instead of extract().
|
N)rE rG rx r ri )r r r® r r r r à s
|
|
z Tag.clearc C sÆ g }t | jD ]n\}}t|tr(| ¡ |t| jd kr<q| j|d }t|trt|trt|tst|ts| |¡ qt |D ]:}| j| }| j|d }|
|
¡ t|| }| |¡ qdS )zÓSmooth out this element's children by consolidating consecutive
|
strings.
|
|
This makes pretty-printed output look more natural following a
|
lot of operations that modified the tree.
|
r6 N) rj rE rG rx Úsmoothrf rz rÞ rs rp ri ro )r Zmarkedr» ÚaÚbr r r r r Ô s*
|
|
ÿþý
|
z
|
Tag.smoothc C s0 t | jD ]\}}||kr
|
| S q
|
tddS )zæFind the index of a child by identity, not value.
|
|
Avoids issues with tag.contents.index(element) getting the
|
index of equal elements.
|
|
:param element: Look for this PageElement in `self.contents`.
|
z Tag.index: element not in tagN)rj rE re )r r® r» rq r r r rh ú s
|
z Tag.indexc C s | j ||¡S )zReturns the value of the 'key' attribute for the tag, or
|
the value given for 'default' if it doesn't have that
|
attribute.)r Úget)r ÚkeyrÆ r r r r s zTag.getc C s | ||¡}t|ts |g}|S )a& The same as get(), but always returns a list.
|
|
:param key: The attribute to look for.
|
:param default: Use this value if the attribute is not present
|
on this PageElement.
|
:return: A list of values, probably containing only a single
|
value.
|
)r rG r{ )r r rÆ rÉ r r r Úget_attribute_list s
|
zTag.get_attribute_listc C s
|
|| j kS )z<Does this PageElement have an attribute with the given name?©r ©r r r r r Úhas_attr s z Tag.has_attrc C s t | ¡ S r )r Ú__hash__r r r r r s z Tag.__hash__c C s
|
| j | S )zqtag[key] returns the value of the 'key' attribute for the Tag,
|
and throws an exception if it's not there.r r r r r Ú __getitem__" s zTag.__getitem__c C s
|
t | jS )z0Iterating over a Tag iterates over its contents.©ÚiterrE r r r r Ú__iter__' s z Tag.__iter__c C s
|
t | jS )z:The length of a Tag is the length of its list of contents.)rf rE r r r r Ú__len__+ s z Tag.__len__c C s
|
|| j kS r )rE )r r` r r r Ú __contains__/ s zTag.__contains__c C s dS )z-A tag is non-None even if it has no contents.Tr r r r r Ú__bool__2 s z Tag.__bool__c C s || j |< dS )zKSetting tag[key] sets the value of the 'key' attribute for the
|
tag.Nr )r r rÉ r r r Ú __setitem__6 s zTag.__setitem__c C s | j |d¡ dS )z;Deleting tag[key] deletes all 'key' attributes for the tag.N)r r r r r r Ú __delitem__; s zTag.__delitem__c O s | j ||S )z Calling a Tag like a function is the same as calling its
|
find_all() method. Eg. tag('a') returns a list of all the A tags
|
found within this tag.©Úfind_all)r rl r r r r Ú__call__? s z Tag.__call__c C sx t |dkrF| d¡rF|dd
}tjdt|d tdd | |¡S | d ¡sb|d
|
ksb| |¡S td | j |f dS ) zACalling tag.subtag is the same as calling tag.find(name="subtag")r rx Néýÿÿÿz.%(name)sTag is deprecated, use .find("%(name)s") instead. If you really were looking for a tag called %(name)sTag, use .find("%(name)sTag"))r! r r« Ú__rE rÒ )
|
rf Úendswithr° r± r÷ r² ÚfindÚ
|
startswithrÓ rÔ )r r Ztag_namer r r rÕ E s ÿ ü
|
|
ÿzTag.__getattr__c C s | |kr dS t |drRt |drRt |drR| j|jksR| j|jksRt| t|krVdS t| jD ] \}}||j| kr` dS q`dS )zyReturns true iff this Tag has the same name, the same attributes,
|
and the same contents (recursively) as `other`.Tr! r rE F)r} r! r rf rj rE )r Úotherr» Zmy_childr r r Ú__eq__X s$
|
ÿþ
|
ý
|
üûz
|
Tag.__eq__c C s
|
| |k S )zTReturns true iff this Tag is not identical to `other`,
|
as defined in __eq__.r )r r( r r r Ú__ne__i s z
|
Tag.__ne__r c C s | ¡ S )zûRenders this PageElement as a string.
|
|
:param encoding: The encoding to use (Python 2 only).
|
TODO: This is now ignored and a warning should be issued
|
if a value is provided.
|
:return: A (Unicode) string.
|
©Údecoder/ r r r Ú__repr__n s z Tag.__repr__c C s | ¡ S )z-Renders this PageElement as a Unicode string.r+ r r r r Ú __unicode__y s zTag.__unicode__rÖ Úxmlcharrefreplacec C s | |||¡}| ||¡S )a Render a bytestring representation of this PageElement and its
|
contents.
|
|
:param encoding: The destination encoding.
|
:param indent_level: Each line of the rendering will be
|
indented this many levels. (The formatter decides what a
|
'level' means in terms of spaces or other characters
|
output.) Used internally in recursive calls while
|
pretty-printing.
|
:param formatter: A Formatter object, or a string naming one of
|
the standard formatters.
|
:param errors: An error handling strategy such as
|
'xmlcharrefreplace'. This value is passed along into
|
encode() and its value should be one of the constants
|
defined by Python.
|
:return: A bytestring.
|
|
©r, r1 )r r0 Ú indent_levelrK ÚerrorsrÊ r r r r1 s z
|
Tag.encodec C sX g }t |ts| |¡}|dkr$d}d }| |¡D ]\}}|tjtjfkr^|j||dd} n6|tjkr|j||dd} |d k r|d8 }n
|
| |¡} |r¢d }
|
} nd }
|
} |tjkrÎ|sÎ|
|
¡ sÎd}
|
d} |}n |tjkrì||krìd}
|
d} d }|d k rB|
|
s| r.t |t r| ¡ } | r.| | |||
|
| ¡} |tjkrB|d7 }| | ¡ q2d |¡S )NTr )ÚopeningFr6 r- )rG r rH r rx r ÚEMPTY_ELEMENT_EVENTÚ _format_tagr rÚ Ú_should_pretty_printrz rS Ú_indent_stringrs r[ ) r r1 Úeventual_encodingrK ÚiteratorÚpiecesZstring_literal_tagr r® ZpieceÚ indent_beforeÚ indent_afterr r r r, sn
|
|
ÿ
|
ÿ
|
|
|
|
ÿþ
|
ÿ
|
þ z
|
Tag.decodec c s¢ g }|p | j }|D ]p}|r>|j|d kr>| ¡ }tj|fV qt|trv|jr\tj|fV qtj|fV | |¡ qqtj
|
|fV q|r| ¡ }tj|fV qdS )a] Yield a sequence of events that can be used to reconstruct the DOM
|
for this element.
|
|
This lets us recreate the nested structure of this element
|
(e.g. when formatting it as a string) without using recursive
|
method calls.
|
|
This is similar in concept to the SAX API, but it's a simpler
|
interface designed for internal use. The events are different
|
from SAX and the arguments associated with the events are Tags
|
and other Beautiful Soup objects.
|
|
:param iterator: An alternate iterator to use when traversing
|
the tree.
|
r? N) Úself_and_descendantsr@ r rx r rG r r4 r rs ÚSTRING_ELEMENT_EVENT)r r9 r rO Znow_closed_tagr r r r ÷ s
|
|
|
zTag._event_streamc C s. d}|r|r|j | }d}|r"d}|| | S )a° Add indentation whitespace before and/or after a string.
|
|
:param s: The string to amend with whitespace.
|
:param indent_level: The indentation level; affects how much
|
whitespace goes before the string.
|
:param indent_before: Whether or not to add whitespace
|
before the string.
|
:param indent_after: Whether or not to add whitespace
|
(a newline) after the string.
|
r- Ú
|
)Úindent)r rJ r1 rK r; r< Z space_beforeZ space_afterr r r r7 ! s
|
zTag._indent_stringc C s d}|s d}d}| j r | j d }d}|rÞ| | ¡}g }|D ]\} }
|
|
|
d krP| } npt|
|
tsdt|
|
trpd |
|
¡}
|
n0t|
|
tst|
|
}
|
n t|
|
tr |d k r |
|
|¡}
|
| |
|
¡} t| d |
|
| ¡ } | | ¡ q:|rÞdd |¡ }d} | j rò|j pðd} d| | | j | | d S )Nr- ú/r ú ú=ú<rä )r Ú
|
attributesrG r{ Útupler[ r r) r1 Zattribute_valueZquoted_attribute_valuers r Zvoid_element_close_prefixr! )r r8 rK r3 Z closing_slashr Zattribute_stringrE r r ÚvalÚdecodedrª Zvoid_element_closing_slashr r r r5 7 sD
|
|
|
|
ÿþ
|
|
|
ÿÿ
|
zTag._format_tagr6 c C s |dk o| j p| j| j kS )zShould this tag be pretty-printed?
|
|
Most of them should, but some (such as <pre> in HTML
|
documents) should not.
|
N)rú r! )r r1 r r r r6 h s
|
üzTag._should_pretty_printc C s* |dkr| j d|dS | j|d|dS dS )a~ Pretty-print this PageElement as a string.
|
|
:param encoding: The eventual encoding of the string. If this is None,
|
a Unicode string will be returned.
|
:param formatter: A Formatter object, or a string naming one of
|
the standard formatters.
|
:return: A Unicode string (if encoding==None) or a bytestring
|
(otherwise).
|
NT)rK r0 )r r0 rK r r r Úprettifyv s
|
z Tag.prettifyc C s | j |||| jdS )a, Renders the contents of this tag as a Unicode string.
|
|
:param indent_level: Each line of the rendering will be
|
indented this many levels. (The formatter decides what a
|
'level' means in terms of spaces or other characters
|
output.) Used internally in recursive calls while
|
pretty-printing.
|
|
:param eventual_encoding: The tag is destined to be
|
encoded into this encoding. decode_contents() is _not_
|
responsible for performing that encoding. This information
|
is passed in so that it can be substituted in if the
|
document contains a <META> tag that mentions the document's
|
encoding.
|
|
:param formatter: A Formatter object, or a string naming one of
|
the standard Formatters.
|
|
)r9 )r, r )r r1 r8 rK r r r Údecode_contents
s
|
ÿzTag.decode_contentsc C s | |||¡}| |¡S )a: Renders the contents of this PageElement as a bytestring.
|
|
:param indent_level: Each line of the rendering will be
|
indented this many levels. (The formatter decides what a
|
'level' means in terms of spaces or other characters
|
output.) Used internally in recursive calls while
|
pretty-printing.
|
|
:param eventual_encoding: The bytestring will be in this encoding.
|
|
:param formatter: A Formatter object, or a string naming one of
|
the standard Formatters.
|
|
:return: A bytestring.
|
)rJ r1 )r r1 r0 rK rE r r r Úencode_contents s zTag.encode_contentsr c C s |sd}| j ||dS )z(Deprecated method for BS3 compatibility.N)r1 r0 )rK )r r0 Z prettyPrintZ indentLevelr r r ÚrenderContents´ s ÿzTag.renderContentsc K s2 d}| j ||||dfddi|}|r.|d }|S )a Look in the children of this PageElement and find the first
|
PageElement that matches the given criteria.
|
|
All find_* methods take a common set of arguments. See the online
|
documentation for detailed explanations.
|
|
:param name: A filter on tag name.
|
:param attrs: A dictionary of filters on attribute values.
|
:param recursive: If this is True, find() will perform a
|
recursive search of this PageElement's children. Otherwise,
|
only the direct children will be considered.
|
:param limit: Stop looking after finding this many results.
|
:kwargs: A dictionary of filters on attribute values.
|
:return: A PageElement.
|
:rtype: bs4.element.Tag | bs4.element.NavigableString
|
Nr6 r r r r )r r! r rÍ rW r r r¡ r r r r& ¾ s ÿzTag.findc K s> | j }|s| j}| dd¡}| j|||||fd|d i|S )aù Look in the children of this PageElement and find all
|
PageElements that match the given criteria.
|
|
All find_* methods take a common set of arguments. See the online
|
documentation for detailed explanations.
|
|
:param name: A filter on tag name.
|
:param attrs: A dictionary of filters on attribute values.
|
:param recursive: If this is True, find_all() will perform a
|
recursive search of this PageElement's children. Otherwise,
|
only the direct children will be considered.
|
:param limit: Stop looking after finding this many results.
|
:kwargs: A dictionary of filters on attribute values.
|
:return: A ResultSet of PageElements.
|
:rtype: bs4.element.ResultSet
|
r r r6 )r Úchildrenr r ) r r! r rÍ rW r r r¸ r r r r r! Ø s ÿÿz Tag.find_allc C s
|
t | jS )zkIterate over all direct children of this PageElement.
|
|
:yield: A sequence of PageElements.
|
r r r r r rM ô s z Tag.childrenc c s" | j s | V | jD ]
|
}|V qdS )zIterate over this PageElement and its children in a
|
breadth-first sequence.
|
|
:yield: A sequence of PageElements.
|
N)rø r r½ r r r r= ý s
|
zTag.self_and_descendantsc c s< t | jsdS | ¡ j}| jd }||k r8|V |j}q"dS )zIterate over all children of this PageElement in a
|
breadth-first sequence.
|
|
:yield: A sequence of PageElements.
|
Nr )rf rE rv rB )r ZstopNodeÚcurrentr r r r s
|
|
|
zTag.descendantsc K s | j j||f|S )a Perform a CSS selection operation on the current element.
|
|
:param selector: A CSS selector.
|
|
:param namespaces: A dictionary mapping namespace prefixes
|
used in the CSS selector to namespace URIs. By default,
|
Beautiful Soup will use the prefixes it encountered while
|
parsing the document.
|
|
:param kwargs: Keyword arguments to be passed into Soup Sieve's
|
soupsieve.select() method.
|
|
:return: A Tag.
|
:rtype: bs4.element.Tag
|
)ÚcssÚ
|
select_one)r Úselectorrþ r r r r rP s zTag.select_onec K s | j j|||f|S )a Perform a CSS selection operation on the current element.
|
|
This uses the SoupSieve library.
|
|
:param selector: A string containing a CSS selector.
|
|
:param namespaces: A dictionary mapping namespace prefixes
|
used in the CSS selector to namespace URIs. By default,
|
Beautiful Soup will use the prefixes it encountered while
|
parsing the document.
|
|
:param limit: After finding this number of results, stop looking.
|
|
:param kwargs: Keyword arguments to be passed into SoupSieve's
|
soupsieve.select() method.
|
|
:return: A ResultSet of Tags.
|
:rtype: bs4.element.ResultSet
|
)rO Úselect)r rQ rþ r r r r r rR + s z
|
Tag.selectc C s t | S )z,Return an interface to the CSS selector API.r r r r r rO A s zTag.cssc C s | j S ©zDeprecated generator.)rM r r r r ÚchildGeneratorG s zTag.childGeneratorc C s | j S rS )r r r r r ÚrecursiveChildGeneratorK s zTag.recursiveChildGeneratorc C s t jdtdd | |¡S )z´Deprecated method. This was kind of misleading because has_key()
|
(attributes) was different from __in__ (contents).
|
|
has_key() is gone in Python 3, anyway.
|
z1has_key is deprecated. Use has_attr(key) instead.r r« )r° r± r² r r r r r Úhas_keyO s þz Tag.has_key)NNNNNNNNNNNNNNNN)T)F)N)N)r )N)r6 )NrÖ )N)NN)Jr% r& r' r( rÿ r Z parserClassrÎ rÐ r r r Z isSelfClosingrW r rz rà rÜ r> rÆ rU rÝ r r r rh r r r r r r r r r r r r" rÕ r) r* r- r. Ú__str__rÈ r1 r, rÅ r r r4 r> r r7 r5 r6 rI rJ rK rL r& Z findChildr! ZfindAllZ findChildrenrM r= r rP rR rO rT rU rV r r r r rx § sÌ ú
|
u
|
|
|
|
$
|
&
|
|
|
þ
|
ý
|
Y
|
*1
|
|
þ
|
þ
|
ÿ
|
|
ÿ
|
|
|
|
|
|
|
rx c @ sT e Zd ZdZdi dfddZdd Zdd Zdi fd d
|
ZeZd d Z dd dZ
|
dS )r³ a& Encapsulates a number of ways of matching a markup element (tag or
|
string).
|
|
This is primarily used to underpin the find_* methods, but you can
|
create one yourself and pass it in as `parse_only` to the
|
`BeautifulSoup` constructor, to parse a subset of a large
|
document.
|
Nc K sÌ |dkr*d|kr*| d¡}tjdtdd | |¡| _t|tsL||d< d}d|krf|d |d< |d= |r|r| ¡ }| |¡ n|}i }t
|
| ¡ D ]\}}| |¡||< q|| _ | |¡| _ | j | _dS )a³ Constructor.
|
|
The SoupStrainer constructor takes the same arguments passed
|
into the find_* methods. See the online documentation for
|
detailed explanations.
|
|
:param name: A filter on tag name.
|
:param attrs: A dictionary of filters on attribute values.
|
:param string: A filter for a NavigableString with specific text.
|
:kwargs: A dictionary of filters on attribute values.
|
Nrª zXThe 'text' argument to the SoupStrainer constructor is deprecated. Use 'string' instead.r r« ÚclassÚclass_)r r° r± r² Ú_normalize_search_valuer! rG r÷ ÚcopyÚupdater{ Úitemsr rW rª )r r! r rW r Znormalized_attrsr rÉ r r r rÿ f s2
|
þ
|
zSoupStrainer.__init__c C sª t |ts0t |ts0t|ds0t |ts0|d kr4|S t |trH| d¡S t|drg }|D ]>}t|drt |tst |ts| |¡ qZ| | |¡¡ qZ|S tt|S )Nr5 Úutf8r ) rG r r r} ÚboolÚbytesr, rs rZ )r rÉ Ú new_valueÚvr r r rZ s$ ÿÿ
|
|
|
ÿ z$SoupStrainer._normalize_search_valuec C s | j r | j S d| j| jf S dS )z5A human-readable representation of this SoupStrainer.z%s|%sN)rW r! r r r r r rW ´ s zSoupStrainer.__str__c C sH d}d}t |tr|}|}t | jtr@|r@|js@| j|jkr@dS t | jtoVt |t }| jr|s|rt| || j¡s|s | || j¡r |r| ||¡}nnd}d}t| j ¡ D ]V\}} |sèt
|
|drÎ|}ni }|D ]\}
|
} | ||
|
< qÖ| |¡} | | | ¡s²d} q
|
q²|r |r |}n|}|rD| j rD| |j | j ¡sDd}|S )a¾ Check whether a Tag with the given name and attributes would
|
match this SoupStrainer.
|
|
Used prospectively to decide whether to even bother creating a Tag
|
object.
|
|
:param markup_name: A tag name as found in some markup.
|
:param markup_attrs: A dictionary of attributes as found in some markup.
|
|
:return: True if the prospective tag would match this SoupStrainer;
|
False otherwise.
|
NFTr ) rG rx r! r r r Ú_matchesr{ r r] r} r rW ) r Z markup_nameZ markup_attrsr¼ ÚmarkupZcall_function_with_tag_datar5 Zmarkup_attr_mapr Ú match_againstÚkrb Ú
|
attr_valuer r r Ú
|
search_tag» sX
|
|
þÿþ þý ý
|
|
|
zSoupStrainer.search_tagc C s² d}t |drDt|ttfsD|D ] }t|tr | |¡r |} q®q njt|trl| jr`| js`| jr®| |¡}nBt|tst|tr | js®| js®|
|
|| j¡r®|}nt d|j |S )zâFind all items in `markup` that match this SoupStrainer.
|
|
Used by the core _find_all() method, which is ultimately
|
called by all find_* methods.
|
|
:param markup: A PageElement or a list of them.
|
Nr z&I don't know how to match against a %s) r} rG rx r rz r4 rW r! r rh rc Ú ExceptionrÔ )r rd r¼ r® r r r r4 ú s(
|
ÿ
|
|
ÿÿzSoupStrainer.searchc C sz d}t |tst |trN|D ]}| ||¡r dS q | d |¡|¡rJdS dS |dkr^|d k S t |trp||S |}t |tr|j}| |¡}|d kr| S t |dr
|
t |t
|
s
|
|s¾t }|D ]B}|j rÒ|}nt |}||kræqÂqÂ| |¡ | |||¡r dS qÂdS d}|s(t |t
|
r(||k}|sDt |drD| |¡S |svt |trv|jrv| |jd |j |¡S |S )NFTrB r r4 r )rG r{ rF rc r[ r rx r! rZ r} r Úsetr ÚidÚaddr4 r ) r rd re Z already_triedr¹ ÚitemZoriginal_markupr r5 r r r rc s`
|
|
|
ÿ
|
|
ÿþ ÿzSoupStrainer._matches)N) r% r& r' r( rÿ rZ rW rh Z searchTagr4 rc r r r r r³ \ s 0 =!r³ c s* e Zd ZdZd fdd Zdd Z ZS )r´ zTA ResultSet is just a list that keeps track of the SoupStrainer
|
that created it.r c s t t| |¡ || _dS )zlConstructor.
|
|
:param source: A SoupStrainer.
|
:param result: A list of PageElements.
|
N)Úsuperr´ rÿ Úsource)r ro r¹ ©rÔ r r rÿ q s zResultSet.__init__c C s t d| dS )z7Raise a helpful exception to explain a common code fix.z¡ResultSet object has no attribute '%s'. You're probably treating a list of elements like a single element. Did you call find_all() when you meant to call find()?NrÛ r r r r rÕ z s ÿzResultSet.__getattr__)r )r% r& r' r( rÿ rÕ Ú __classcell__r r rp r r´ n s r´ ).Ú __license__Úcollections.abcr Ú ImportErrorÚeÚ collectionsr; Úsysr° Zbs4.cssr Z bs4.formatterr r r rÈ r< Znonwhitespace_reZ whitespace_rer rj r. r r r) r+ r2 rÅ r> rz rÞ rà râ rå rç rè ré rí rî rï rð rñ rx r³ r{ r´ r r r r Ú<module> s~
|
|
ô ~ <
|
