File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/bs4.zip
Back
PK z�ZMa �I I tests/test_element.pynu �[��� """Tests of classes in element.py. The really big classes -- Tag, PageElement, and NavigableString -- are tested in separate files. """ from bs4.element import ( CharsetMetaAttributeValue, ContentMetaAttributeValue, NamespacedAttribute, ) from . import SoupTest class TestNamedspacedAttribute(object): def test_name_may_be_none_or_missing(self): a = NamespacedAttribute("xmlns", None) assert a == "xmlns" a = NamespacedAttribute("xmlns", "") assert a == "xmlns" a = NamespacedAttribute("xmlns") assert a == "xmlns" def test_namespace_may_be_none_or_missing(self): a = NamespacedAttribute(None, "tag") assert a == "tag" a = NamespacedAttribute("", "tag") assert a == "tag" def test_attribute_is_equivalent_to_colon_separated_string(self): a = NamespacedAttribute("a", "b") assert "a:b" == a def test_attributes_are_equivalent_if_prefix_and_name_identical(self): a = NamespacedAttribute("a", "b", "c") b = NamespacedAttribute("a", "b", "c") assert a == b # The actual namespace is not considered. c = NamespacedAttribute("a", "b", None) assert a == c # But name and prefix are important. d = NamespacedAttribute("a", "z", "c") assert a != d e = NamespacedAttribute("z", "b", "c") assert a != e class TestAttributeValueWithCharsetSubstitution(object): """Certain attributes are designed to have the charset of the final document substituted into their value. """ def test_content_meta_attribute_value(self): # The value of a CharsetMetaAttributeValue is whatever # encoding the string is in. value = CharsetMetaAttributeValue("euc-jp") assert "euc-jp" == value assert "euc-jp" == value.original_value assert "utf8" == value.encode("utf8") assert "ascii" == value.encode("ascii") def test_content_meta_attribute_value(self): value = ContentMetaAttributeValue("text/html; charset=euc-jp") assert "text/html; charset=euc-jp" == value assert "text/html; charset=euc-jp" == value.original_value assert "text/html; charset=utf8" == value.encode("utf8") assert "text/html; charset=ascii" == value.encode("ascii") PK z�Z��w�g g tests/test_docs.pynu �[��� "Test harness for doctests." # TODO: Pretty sure this isn't used and should be deleted. # pylint: disable-msg=E0611,W0142 __metaclass__ = type __all__ = [ 'additional_tests', ] import atexit import doctest import os #from pkg_resources import ( # resource_filename, resource_exists, resource_listdir, cleanup_resources) import unittest DOCTEST_FLAGS = ( doctest.ELLIPSIS | doctest.NORMALIZE_WHITESPACE | doctest.REPORT_NDIFF) # def additional_tests(): # "Run the doc tests (README.txt and docs/*, if any exist)" # doctest_files = [ # os.path.abspath(resource_filename('bs4', 'README.txt'))] # if resource_exists('bs4', 'docs'): # for name in resource_listdir('bs4', 'docs'): # if name.endswith('.txt'): # doctest_files.append( # os.path.abspath( # resource_filename('bs4', 'docs/%s' % name))) # kwargs = dict(module_relative=False, optionflags=DOCTEST_FLAGS) # atexit.register(cleanup_resources) # return unittest.TestSuite(( # doctest.DocFileSuite(*doctest_files, **kwargs))) PK z�Z��U~< < tests/test_fuzz.pynu �[��� """This file contains test cases reported by third parties using fuzzing tools, primarily from Google's oss-fuzz project. Some of these represent real problems with Beautiful Soup, but many are problems in libraries that Beautiful Soup depends on, and many of the test cases represent different ways of triggering the same problem. Grouping these test cases together makes it easy to see which test cases represent the same problem, and puts the test cases in close proximity to code that can trigger the problems. """ import os import pytest from bs4 import ( BeautifulSoup, ParserRejectedMarkup, ) try: from soupsieve.util import SelectorSyntaxError import lxml import html5lib fully_fuzzable = True except ImportError: fully_fuzzable = False @pytest.mark.skipif(not fully_fuzzable, reason="Prerequisites for fuzz tests are not installed.") class TestFuzz(object): # Test case markup files from fuzzers are given this extension so # they can be included in builds. TESTCASE_SUFFIX = ".testcase" # Copied 20230512 from # https://github.com/google/oss-fuzz/blob/4ac6a645a197a695fe76532251feb5067076b3f3/projects/bs4/bs4_fuzzer.py # # Copying the code lets us precisely duplicate the behavior of # oss-fuzz. The downside is that this code changes over time, so # multiple copies of the code must be kept around to run against # older tests. I'm not sure what to do about this, but I may # retire old tests after a time. def fuzz_test_with_css(self, filename): data = self.__markup(filename) parsers = ['lxml-xml', 'html5lib', 'html.parser', 'lxml'] try: idx = int(data[0]) % len(parsers) except ValueError: return css_selector, data = data[1:10], data[10:] try: soup = BeautifulSoup(data[1:], features=parsers[idx]) except ParserRejectedMarkup: return except ValueError: return list(soup.find_all(True)) try: soup.css.select(css_selector.decode('utf-8', 'replace')) except SelectorSyntaxError: return soup.prettify() # This class of error has been fixed by catching a less helpful # exception from html.parser and raising ParserRejectedMarkup # instead. @pytest.mark.parametrize( "filename", [ "clusterfuzz-testcase-minimized-bs4_fuzzer-5703933063462912", "crash-ffbdfa8a2b26f13537b68d3794b0478a4090ee4a", ] ) def test_rejected_markup(self, filename): markup = self.__markup(filename) with pytest.raises(ParserRejectedMarkup): BeautifulSoup(markup, 'html.parser') # This class of error has to do with very deeply nested documents # which overflow the Python call stack when the tree is converted # to a string. This is an issue with Beautiful Soup which was fixed # as part of [bug=1471755]. # # These test cases are in the older format that doesn't specify # which parser to use or give a CSS selector. @pytest.mark.parametrize( "filename", [ "clusterfuzz-testcase-minimized-bs4_fuzzer-5984173902397440", "clusterfuzz-testcase-minimized-bs4_fuzzer-5167584867909632", "clusterfuzz-testcase-minimized-bs4_fuzzer-6124268085182464", "clusterfuzz-testcase-minimized-bs4_fuzzer-6450958476902400", ] ) def test_deeply_nested_document_without_css(self, filename): # Parsing the document and encoding it back to a string is # sufficient to demonstrate that the overflow problem has # been fixed. markup = self.__markup(filename) BeautifulSoup(markup, 'html.parser').encode() # This class of error has to do with very deeply nested documents # which overflow the Python call stack when the tree is converted # to a string. This is an issue with Beautiful Soup which was fixed # as part of [bug=1471755]. @pytest.mark.parametrize( "filename", [ "clusterfuzz-testcase-minimized-bs4_fuzzer-5000587759190016", "clusterfuzz-testcase-minimized-bs4_fuzzer-5375146639360000", "clusterfuzz-testcase-minimized-bs4_fuzzer-5492400320282624", ] ) def test_deeply_nested_document(self, filename): self.fuzz_test_with_css(filename) @pytest.mark.parametrize( "filename", [ "clusterfuzz-testcase-minimized-bs4_fuzzer-4670634698080256", "clusterfuzz-testcase-minimized-bs4_fuzzer-5270998950477824", ] ) def test_soupsieve_errors(self, filename): self.fuzz_test_with_css(filename) # This class of error represents problems with html5lib's parser, # not Beautiful Soup. I use # https://github.com/html5lib/html5lib-python/issues/568 to notify # the html5lib developers of these issues. # # These test cases are in the older format that doesn't specify # which parser to use or give a CSS selector. @pytest.mark.skip(reason="html5lib-specific problems") @pytest.mark.parametrize( "filename", [ # b"""ÿ<!DOCTyPEV PUBLIC'''Ð'""" "clusterfuzz-testcase-minimized-bs4_fuzzer-4818336571064320", # b')<a><math><TR><a><mI><a><p><a>' "clusterfuzz-testcase-minimized-bs4_fuzzer-4999465949331456", # b'-<math><sElect><mi><sElect><sElect>' "clusterfuzz-testcase-minimized-bs4_fuzzer-5843991618256896", # b'ñ<table><svg><html>' "clusterfuzz-testcase-minimized-bs4_fuzzer-6241471367348224", # <TABLE>, some ^@ characters, some <math> tags. "clusterfuzz-testcase-minimized-bs4_fuzzer-6600557255327744", # Nested table "crash-0d306a50c8ed8bcd0785b67000fcd5dea1d33f08" ] ) def test_html5lib_parse_errors_without_css(self, filename): markup = self.__markup(filename) print(BeautifulSoup(markup, 'html5lib').encode()) # This class of error represents problems with html5lib's parser, # not Beautiful Soup. I use # https://github.com/html5lib/html5lib-python/issues/568 to notify # the html5lib developers of these issues. @pytest.mark.skip(reason="html5lib-specific problems") @pytest.mark.parametrize( "filename", [ # b'- \xff\xff <math>\x10<select><mi><select><select>t' "clusterfuzz-testcase-minimized-bs4_fuzzer-6306874195312640", ] ) def test_html5lib_parse_errors(self, filename): self.fuzz_test_with_css(filename) def __markup(self, filename): if not filename.endswith(self.TESTCASE_SUFFIX): filename += self.TESTCASE_SUFFIX this_dir = os.path.split(__file__)[0] path = os.path.join(this_dir, 'fuzz', filename) return open(path, 'rb').read() PK z�Z��_9 9 6 tests/__pycache__/test_navigablestring.cpython-310.pycnu �[��� o �h� � @ sh d dl Z d dlmZmZmZmZmZmZmZm Z m Z m Z ddl m Z G dd� de �ZG dd� de �ZdS ) � N) �CData�Comment� Declaration�Doctype�NavigableString�RubyParenthesisString�RubyTextString�Script� Stylesheet�TemplateString� )�SoupTestc @ s e Zd Zdd� Zdd� ZdS )�TestNavigableStringc C sV t d�}td�}td�}d|�� ksJ �d|jdd�ks J �dgt|j�ks(J �dgt|j�ks2J �dgt|�� �ks=J �d|�� ksEJ �d|jdd�ksOJ �dgt|j�ksYJ �dgt|j�kscJ �dgt|�� �ksnJ �d|�� ksvJ �g t|j�ksJ �g t|j�ks�J �g t|�� �ks�J �d |jdtd �ks�J �d|jtt fd �ks�J �d S ) Nzfee zfie zfoe �feeT��strip�fie� �foe�r �types�r )r r r �get_text�list�strings�stripped_strings� _all_strings)�self�s�cdata�comment� r! �Q/usr/local/CyberCP/lib/python3.10/site-packages/bs4/tests/test_navigablestring.py� test_text_acquisition_methods s& z1TestNavigableString.test_text_acquisition_methodsc C sP | � d�j}d |jks J �t�t�� d|_W d � d S 1 s!w Y d S )Nr �foo)�soup�string�name�pytest�raises�AttributeError)r r& r! r! r" �'test_string_has_immutable_name_property3 s "�z;TestNavigableString.test_string_has_immutable_name_propertyN)�__name__� __module__� __qualname__r# r+ r! r! r! r" r s r c @ s< e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd S )� TestNavigableStringSubclassesc C sX | � d�}td�}|�d|� t|�dksJ �|jdd�dks!J �|jd dks*J �d S )Nr r$ r z<![CDATA[foo]]>�r& r )r% r �insert�str�find�contents)r r% r r! r! r" � test_cdata< s z(TestNavigableStringSubclasses.test_cdatac sV d� _ � fdd�}� �d�}td�}|�d|� d|j|d�ks"J �d� j ks)J �d S ) zkText inside a CData object is passed into the formatter. But the return value is ignored. r c s � j d7 _ dS )Nr zBITTER FAILURE)�count)�args�r r! r" � incrementM s zNTestNavigableStringSubclasses.test_cdata_is_never_formatted.<locals>.incrementr z<><><>r s <![CDATA[<><><>]]>)� formatterN)r6 r% r r1 �encode)r r9 r% r r! r8 r" � test_cdata_is_never_formattedF s z;TestNavigableStringSubclasses.test_cdata_is_never_formattedc C s2 t d�}| �d�}|�d|� |�� dksJ �d S )Nr$ r r s <!DOCTYPE foo> )r r% r1 r; )r �doctyper% r! r! r" � test_doctype_ends_in_newlineW s z:TestNavigableStringSubclasses.test_doctype_ends_in_newlinec C s t d�}d|�� ks J �d S )Nr$ z<?foo?>)r � output_ready)r �dr! r! r" �test_declaration_ s z.TestNavigableStringSubclasses.test_declarationc C s� | � d�}tttgdd� |jdd�D �ksJ �| � d�}tdd� |jjd d �D ��s,J �|jj}t |t�s7J �t |t �r>J �d }| � |�}||j� d �ksOJ �d S ) Nz7<div>text</div><script>text</script><style>text</style>c S s g | ]}|j �qS r! )� __class__��.0�xr! r! r" � <listcomp>i s �zPTestNavigableStringSubclasses.test_default_string_containers.<locals>.<listcomp>Tr0 z><template>Some text<p>In a tag</p></template>Some text outsidec s s � | ]}t |t�V qd S )N)� isinstancer rC r! r! r" � <genexpr>s s � � �zOTestNavigableStringSubclasses.test_default_string_containers.<locals>.<genexpr>r sB <template>Some text<p>In a tag</p><!--with a comment--></template>�utf8) r% r r r �find_all�all�templater � next_siblingrG r r; )r r% �outside�markupr! r! r" � test_default_string_containersc s$ � �� � z<TestNavigableStringSubclasses.test_default_string_containersc C sf d}| � |�}t|jjt�sJ �t|jjt�sJ �d|jdd�ks#J �d|jdtttfd�ks1J �d S )NuU <ruby>漢 <rp>(</rp><rt>kan</rt><rp>)</rp> 字 <rp>(</rp><rt>ji</rt><rp>)</rp></ruby>u 漢字Tr u 漢(kan)字(ji)r ) r% rG �rpr& r �rtr r r )r rO r% r! r! r" �test_ruby_strings� s �z/TestNavigableStringSubclasses.test_ruby_stringsN) r, r- r. r5 r< r> rA rP rS r! r! r! r" r/ : s "r/ )r( � bs4.elementr r r r r r r r r r r r r r/ r! r! r! r" �<module> s 0 (PK z�Z �8N N * tests/__pycache__/test_css.cpython-310.pycnu �[��� o �hC � @ sv d dl Z d dlZd dlmZ d dlmZmZmZ ddlm Z m Z e r(d dl m Z e j je dd�G d d � d e ��ZdS ) � N)� MagicMock)�CSS� BeautifulSoup� ResultSet� )�SoupTest�SOUP_SIEVE_PRESENT)�SelectorSyntaxErrorzSoup Sieve not installed)�reasonc @ s e Zd ZdZdZdd� Zdd� ZeZdd� Zd d � Z d d � Z d d� Z dd� Z dd� Z dd� Zdd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Z d1d2� Z d3d4� Z d5d6� Z d7d8� Z d9d:� Z!d;d<� Z"d=d>� Z#d?d@� Z$dAdB� Z%dCdD� Z&dEdF� Z'dGdH� Z(dIdJ� Z)dKdL� Z*dMdN� Z+dOdP� Z,dQdR� Z-dSdT� Z.dUdV� Z/dWdX� Z0dYdZ� Z1d[d\� Z2d]d^� Z3d_d`� Z4dadb� Z5dcdd� Z6dedf� Z7dgdh� Z8didj� Z9dkdl� Z:dmdn� Z;dodp� Z<dqdr� Z=dsdt� Z>dudv� Z?dwdx� Z@dydz� ZAd{d|� ZBd}d~� ZCdd�� ZDd�S )��TestCSSSelectorsz�Test basic CSS selector functionality. This functionality is implemented in soupsieve, which has a much more comprehensive test suite, so this is basically an extra check that soupsieve works as expected. a� <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <html> <head> <title>The title</title> <link rel="stylesheet" href="blah.css" type="text/css" id="l1"> </head> <body> <custom-dashed-tag class="dashed" id="dash1">Hello there.</custom-dashed-tag> <div id="main" class="fancy"> <div id="inner"> <h1 id="header1">An H1</h1> <p>Some text</p> <p class="onep" id="p1">Some more text</p> <h2 id="header2">An H2</h2> <p class="class1 class2 class3" id="pmulti">Another</p> <a href="http://bob.example.org/" rel="friend met" id="bob">Bob</a> <h2 id="header3">Another H2</h2> <a id="me" href="http://simonwillison.net/" rel="me">me</a> <span class="s1"> <a href="#" id="s1a1">span1a1</a> <a href="#" id="s1a2">span1a2 <span id="s1a2s1">test</span></a> <span class="span2"> <a href="#" id="s2a1">span2a1</a> </span> <span class="span3"></span> <custom-dashed-tag class="dashed" id="dash2"/> <div data-tag="dashedvalue" id="data1"/> </span> </div> <x id="xid"> <z id="zida"/> <z id="zidab"/> <z id="zidac"/> </x> <y id="yid"> <z id="zidb"/> </y> <p lang="en" id="lang-en">English</p> <p lang="en-gb" id="lang-en-gb">English UK</p> <p lang="en-us" id="lang-en-us">English US</p> <p lang="fr" id="lang-fr">French</p> </div> <div id="footer"> </div> c C s t | jd�| _d S )N� html.parser)r �HTML�soup��self� r �E/usr/local/CyberCP/lib/python3.10/site-packages/bs4/tests/test_css.py� setup_methodN � z TestCSSSelectors.setup_methodc K sj | j j|fi |��}t|t�sJ �dd� |D �}|�� |�� ||ks3J d|d�|�d�|�f ��d S )Nc S s g | ]}|d �qS ��idr )�.0�elr r r � <listcomp>T s z3TestCSSSelectors.assert_selects.<locals>.<listcomp>z$Selector %s, expected [%s], got [%s]z, )r �select� isinstancer �sort�join)r �selector� expected_ids�kwargs�results�el_idsr r r �assert_selectsQ s �z TestCSSSelectors.assert_selectsc G s |D ] \}}| � ||� qd S )N�r# )r �testsr r r r r �assert_select_multiple] s �z'TestCSSSelectors.assert_select_multiplec C sb | j j�d�}| j �|�}t|�dksJ �|D ] }|jdks J �q| j �|�}d|d ks/J �d S �N�div� �mainr )r �css�compiler �len�name� select_one)r �sel�elsr( r r r r �test_precompileda s z!TestCSSSelectors.test_precompiledc C sF | j �d�}t|�dksJ �|d jdksJ �|d jdgks!J �d S )N�titler r z The title)r r r- r. �contents�r r1 r r r �test_one_tag_onel s z!TestCSSSelectors.test_one_tag_onec C sT | j �d�}t|�dksJ �|D ] }|jdksJ �q| j �d�}d|d ks(J �d S r' )r r r- r. r/ )r r1 r( r r r r �test_one_tag_manyr s z"TestCSSSelectors.test_one_tag_manyc C s | j �d�}d |ks J �d S )N�nonexistenttag)r r/ )r �matchr r r �(test_select_one_returns_none_if_no_match{ s z9TestCSSSelectors.test_select_one_returns_none_if_no_matchc C s | j �d�}| �dddg� d S )Nzdiv div�inner�data1)r r r# r5 r r r �test_tag_in_tag_one� � z$TestCSSSelectors.test_tag_in_tag_onec C s dD ] }| � |g d�� qd S )N)�html div� html body div�body div�r< r* r; �footerr$ �r r r r r �test_tag_in_tag_many� s �z%TestCSSSelectors.test_tag_in_tag_manyc C s> | j ddgdd� | j dddgdd� | j dg d �d d� d S ) Nr? r* r )�limitr@ r; � rA rB � r$ r r r r � test_limit� s �zTestCSSSelectors.test_limitc C s t | j�d��dks J �d S )N�delr �r- r r r r r r �test_tag_no_match� s z"TestCSSSelectors.test_tag_no_matchc C �< t �t�� | j�d� W d � d S 1 sw Y d S )Nztag%t��pytest�raisesr r r r r r r �test_invalid_tag� � "�z!TestCSSSelectors.test_invalid_tagc C � | � dddg� d S )N�custom-dashed-tag�dash1�dash2r$ r r r r �test_select_dashed_tag_ids� � z+TestCSSSelectors.test_select_dashed_tag_idsc C s6 | j �d�}|d jdksJ �|d d dksJ �d S )Nz custom-dashed-tag[id="dash2"]r rT r rV )r r r. )r �dashedr r r �test_select_dashed_by_id� s z)TestCSSSelectors.test_select_dashed_by_idc C s | j �d�d jdks J �d S )Nzbody > custom-dashed-tagr z Hello there.)r r �textr r r r �test_dashed_tag_text� s z%TestCSSSelectors.test_dashed_tag_textc C s | j �d�| j �d�ksJ �d S )NrT )r r �find_allr r r r �#test_select_dashed_matches_find_all� s z4TestCSSSelectors.test_select_dashed_matches_find_allc C s | � ddgfdddgf� d S )N�h1�header1�h2�header2�header3�r& r r r r �test_header_tags� s �z!TestCSSSelectors.test_header_tagsc C sR dD ]$}| j �|�}t|�dksJ �|d jdksJ �|d d dgks&J �qd S )N)z.onepzp.onepz html p.onepr r �p�class�onep)r r r- r. )r r r1 r r r �test_class_one� s �z TestCSSSelectors.test_class_onec C � | j �d�}t|�dksJ �d S )Nzdiv.onepr �r r r- r5 r r r �test_class_mismatched_tag� r> z*TestCSSSelectors.test_class_mismatched_tagc C � dD ] }| � |dg� qd S )N)z div#innerz#innerz div div#innerr; r$ rD r r r � test_one_id� s �z TestCSSSelectors.test_one_idc C rj )Nz #doesnotexistr rk r5 r r r � test_bad_id� r> z TestCSSSelectors.test_bad_idc C s` | j �d�}t|�dksJ �|D ] }|jdksJ �q|d d dgks%J �|d �d�r.J �d S )Nz div#inner p� rf r rg rh r )r r r- r. �has_attr)r r1 r r r r �test_items_in_id� s z!TestCSSSelectors.test_items_in_idc C s& dD ]}t | j�|��dksJ �qd S )N)z div#main delzdiv#main div.oopsz div div#mainr rK rD r r r �test_a_bunch_of_emptys� s �z'TestCSSSelectors.test_a_bunch_of_emptysc C rm )N)z.class1zp.class1z.class2zp.class2z.class3zp.class3z html p.class2zdiv#inner .class2�pmultir$ rD r r r �test_multi_class_support� � �z)TestCSSSelectors.test_multi_class_supportc C rm )N)z.class1.class3z.class3.class2z.class1.class2.class3rt r$ rD r r r �test_multi_class_selection� rv z+TestCSSSelectors.test_multi_class_selectionc C s" | � dddg� | � ddg� d S )Nz.s1 > a�s1a1�s1a2z .s1 > a span�s1a2s1r$ r r r r �test_child_selector� s z$TestCSSSelectors.test_child_selectorc C � | � ddg� d S )Nz.s1 > a#s1a2 spanrz r$ r r r r �test_child_selector_id� r z'TestCSSSelectors.test_child_selector_idc C st | � ddgfddgfddgfddgfddgfddgfd dgfd g fd dgfd dgfd dgfdg fdg fdg f� d S )Nzp[class="onep"]�p1z p[id="p1"]z[class="onep"]z [id="p1"]zlink[rel="stylesheet"]�l1zlink[type="text/css"]zlink[href="blah.css"]zlink[href="no-blah.css"]z[rel="stylesheet"]z[type="text/css"]z[href="blah.css"]z[href="no-blah.css"]zp[href="no-blah.css"]rd r r r r �test_attribute_equals� s �z&TestCSSSelectors.test_attribute_equalsc C s\ | � ddgfddgfddgfddgfddgfddgfdd gfd d gfd d gfd d gf� d S ) Nzp[class~="class1"]rt zp[class~="class2"]zp[class~="class3"]z[class~="class1"]z[class~="class2"]z[class~="class3"]za[rel~="friend"]�bobz a[rel~="met"]z[rel~="friend"]z [rel~="met"]rd r r r r �test_attribute_tilde� s �z%TestCSSSelectors.test_attribute_tildec C sv | � ddgfddgfdg fdg fdg fddgfdd d gfd d d gfd d dgfdd dgfddgfdd gfddgf� d S )Nz[rel^="style"]r zlink[rel^="style"]znotlink[rel^="notstyle"]z[rel^="notstyle"]zlink[rel^="notstyle"]zlink[href^="bla"]za[href^="http://"]r� �mez[href^="http://"]z [id^="p"]rt r~ z [id^="m"]r* z div[id^="m"]z a[id^="m"]zdiv[data-tag^="dashed"]r< rd r r r r �test_attribute_startswith� s �z*TestCSSSelectors.test_attribute_startswithc C s< | � ddgfddgfddgfdg d�fddgfd g f� d S ) Nz[href$=".css"]r zlink[href$=".css"]z link[id$="1"]z [id$="1"])r< r r~ r` rx �s2a1rz rU z div[id$="1"]r< z[id$="noending"]rd r r r r �test_attribute_endswith s �z(TestCSSSelectors.test_attribute_endswithc C s� | � ddgfddgfdg fdg fdg fddgfdd d gfd d d gfddgfdd gfddgfddgfddgfdg d�fddgfdg fdg d�fdd d gfd dgfd dd gfd d gfd dgf� d S )!Nz[rel*="style"]r zlink[rel*="style"]znotlink[rel*="notstyle"]z[rel*="notstyle"]zlink[rel*="notstyle"]zlink[href*="bla"]z[href*="http://"]r� r� z [id*="p"]rt r~ z div[id*="m"]r* z a[id*="m"]z[href*=".css"]zlink[href*=".css"]z link[id*="1"]z [id*="1"]) r< r r~ r` rx ry r� rz rU z div[id*="1"]r< z[id*="noending"]z [href*="."])r� r� r z a[href*="."]zlink[href*="."]z div[id*="n"]r; z div[id*="nn"]zdiv[data-tag*="edval"]rd r r r r �test_attribute_contains s0 �z(TestCSSSelectors.test_attribute_containsc C s. | � dg d�fdg d�fddgfdg f� d S )Nz p[lang|="en"])�lang-en� lang-en-gb� lang-en-usz [lang|="en"]z p[lang|="fr"]�lang-frz p[lang|="gb"]rd r r r r � test_attribute_exact_or_hypen2 s �z.TestCSSSelectors.test_attribute_exact_or_hypenc C sP | � dg d�fddgfdddgfdg d �fd d d gfd g fdg fddgf� d S )Nz[rel])r r� r� z link[rel]r za[rel]r� r� z[lang])r� r� r� r� zp[class]r~ rt z[blah]zp[blah]z div[data-tag]r< rd r r r r �test_attribute_exists: s �z&TestCSSSelectors.test_attribute_existsc C s, d}t |d�}|�d�\}d|jksJ �d S )Nz]<div style="display: wrong">nope</div> <div style="display: right">yes</div> r zdiv[style="display: right"]�yes)r r �string)r �htmlr �chosenr r r �"test_quoted_space_in_selector_nameF s z3TestCSSSelectors.test_quoted_space_in_selector_namec C sr t �t�� | j�d� W d � n1 sw Y t �t�� | j�d� W d � d S 1 s2w Y d S )Nza:no-such-pseudoclassza:nth-of-type(a))rO rP �NotImplementedErrorr r r r r r r � test_unsupported_pseudoclassN s � "�z-TestCSSSelectors.test_unsupported_pseudoclassc C s� | j �d�}t|�dksJ �|d jdksJ �| j �d�}t|�dks%J �|d jdks.J �| j �d�}t|�dks<J �| j �d�}t|�dksJJ �d S ) Nzdiv#inner p:nth-of-type(1)r r � Some textzdiv#inner p:nth-of-type(3)�Anotherzdiv#inner p:nth-of-type(4)zdiv p:nth-of-type(0)�r r r- r� r5 r r r �test_nth_of_typeU s z!TestCSSSelectors.test_nth_of_typec C s2 | j �d�}t|�dksJ �|d jdksJ �d S )Nz div#inner > p:nth-of-type(1)r r r� r� r5 r r r �"test_nth_of_type_direct_descendanth s z3TestCSSSelectors.test_nth_of_type_direct_descendantc C r| )Nz#inner > p:nth-of-type(2)r~ r$ r r r r �"test_id_child_selector_nth_of_typem r z3TestCSSSelectors.test_id_child_selector_nth_of_typec C s. | j jddd�}|�d�}| �|ddg� d S )Nr( r* r r; r< )r �findr �assert_selects_ids)r r; �selectedr r r �test_select_on_elementp s z'TestCSSSelectors.test_select_on_elementc C s | � ddg� | � dg � d S )Nz .fancy #innerr; z.normal #innerr$ r r r r �test_overspecified_child_idy s z,TestCSSSelectors.test_overspecified_child_idc C sB | � ddg� | � ddg� | � ddg� g | j�d�ks J �d S )Nz#p1 + h2rb z #p1 + h2 + prt z#p1 + #header2 + .class1z#p1 + p�r# r r r r r r � test_adjacent_sibling_selector} s z/TestCSSSelectors.test_adjacent_sibling_selectorc C sR | � dddg� | � ddg� | � ddg� | � ddg� g | j�d�ks'J �d S ) Nz#p1 ~ h2rb rc z#p1 ~ #header2z #p1 ~ h2 + ar� z#p1 ~ h2 + [rel="me"]z #inner ~ h2r� r r r r � test_general_sibling_selector� s z.TestCSSSelectors.test_general_sibling_selectorc C rM )Nzh1 >rN r r r r �test_dangling_combinator� rR z)TestCSSSelectors.test_dangling_combinatorc C � | � dg d�� d S )Nz p[lang] ~ p)r� r� r� r$ r r r r �2test_sibling_combinator_wont_select_same_tag_twice� rX zCTestCSSSelectors.test_sibling_combinator_wont_select_same_tag_twicec C rS )Nzx, y�xid�yidr$ r r r r �test_multiple_select� rX z%TestCSSSelectors.test_multiple_selectc C rS )Nzx,yr� r� r$ r r r r �"test_multiple_select_with_no_space� rX z3TestCSSSelectors.test_multiple_select_with_no_spacec C rS )Nzx, yr� r� r$ r r r r �$test_multiple_select_with_more_space� rX z5TestCSSSelectors.test_multiple_select_with_more_spacec C r| )Nzx, xr� r$ r r r r � test_multiple_select_duplicated� r z0TestCSSSelectors.test_multiple_select_duplicatedc C rS )Nzx, y ~ p[lang=fr]r� r� r$ r r r r � test_multiple_select_sibling� rX z-TestCSSSelectors.test_multiple_select_siblingc C rS )Nzx, y > zr� �zidbr$ r r r r �.test_multiple_select_tag_and_direct_descendant� rX z?TestCSSSelectors.test_multiple_select_tag_and_direct_descendantc C r� )Nz div > x, y, z�r� r� �zidar� �zidab�zidacr$ r r r r �/test_multiple_select_direct_descendant_and_tags� rX z@TestCSSSelectors.test_multiple_select_direct_descendant_and_tagsc C r� )Nz div x,y, zr� r$ r r r r �(test_multiple_select_indirect_descendant� rX z9TestCSSSelectors.test_multiple_select_indirect_descendantc C sr t �t�� | j�d� W d � n1 sw Y t �t�� | j�d� W d � d S 1 s2w Y d S )Nz,x, yzx,,yrN r r r r � test_invalid_multiple_select� s � "�z-TestCSSSelectors.test_invalid_multiple_selectc C rS )Nzp[lang=en], p[lang=en-gb]r� r� r$ r r r r �test_multiple_select_attrs� rX z+TestCSSSelectors.test_multiple_select_attrsc C r� )Nz*x, y > z[id=zida], z[id=zidab], z[id=zidb])r� r� r� r$ r r r r �test_multiple_select_ids� rX z)TestCSSSelectors.test_multiple_select_idsc C rS )Nzbody > div > x, y > zr� r� r$ r r r r �test_multiple_select_nested� rX z,TestCSSSelectors.test_multiple_select_nestedc C sN d}t |d�}|�d�}dt|�ksJ �|jddgd�D ]}||v s$J �q d S )Nz3<div class="c1"/><div class="c2"/><div class="c1"/>r z.c1, .c2rp �c1�c2)�class_)r r r- r] )r �markupr r� �elementr r r � test_select_duplicate_elements� s �z/TestCSSSelectors.test_select_duplicate_elementsc C s8 | j jddd�}|j�d�}|| j jddd�ksJ �d S )Nr( r; r � div[id=main]r* )r r� r+ �closest)r r; r� r r r � test_closest� s z TestCSSSelectors.test_closestc C sL | j jddd�}| j jddd�}|j�d�dksJ �|j�d�dks$J �d S )Nr( r; r r* r� FT)r r� r+ r9 )r r; r* r r r � test_match� s zTestCSSSelectors.test_matchc C sJ | j j�d�}t|tj�sJ �|\}}|d dksJ �|d dks#J �d S )Nra r rb rc )r r+ �iselectr �types� GeneratorType)r �genrb rc r r r � test_iselect� s z TestCSSSelectors.test_iselectc C sh | j jddd�}|j�d�}t|j�d��dksJ �|j�d�}t|t�s'J �|\}|d dks2J �d S ) Nr( r; r ra rG zh2[id=header3]r rc )r r� r+ �filterr- r r )r r; r! �resultr r r � test_filter� s z TestCSSSelectors.test_filterc C sH | j jj}|d�dks J �|d�dksJ �|d�| j j�d�ks"J �d S )Nz.foo#barz \.foo\#barz()[]{}z \(\)\[\]\{\}z.foo)r r+ �escape)r �mr r r � test_escape� s z TestCSSSelectors.test_escapeN)E�__name__� __module__� __qualname__�__doc__r r r# � assertSelectr& r2 r6 r7 r: r= rE rI rL rQ rW rZ r\ r^ re ri rl rn ro rr rs ru rw r{ r} r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r s� 1 r )rO r� � unittest.mockr �bs4r r r � r r � soupsiever �mark�skipifr r r r r �<module> s PK z�Z*D�8�" �" * tests/__pycache__/test_tag.cpython-310.pycnu �[��� o �h�% � @ sH d dl Z d dlmZmZ ddlmZ G dd� de�ZG dd� de�ZdS ) � N)�Comment�NavigableString� )�SoupTestc @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd S )!�TestTagz]Test various methods of Tag which aren't so complicated they need their own classes. c C st | � d��d�}d |_d|�d�ksJ �dg|_d|�d�ks!J �d|�d �ks*J �ddg|_d|�d�ks8J �d S )N� �a_tagTr �some_other_tagr F)�soup�new_tag�_preserve_whitespace_tags�_should_pretty_print�preserve_whitespace_tags)�self�tag� r �E/usr/local/CyberCP/lib/python3.10/site-packages/bs4/tests/test_tag.py�test__should_pretty_print s z!TestTag.test__should_pretty_printc C sV | � d�}t|j�dksJ �t|�dksJ �t|j�dks J �t|jj�dks)J �dS )z.The length of a Tag is its number of children.z<top>1<b>2</b>3</top>r � N)r �len�contents�top�r r r r r �test_len s zTestTag.test_lenc C sL | � d�}|j|�d�ksJ �|jj|�d��d�ks J �|jdks$J �dS )z2Accessing a Python member .foo invokes find('foo')�<b><i></i></b>�b�iN)r r �findr �ar r r r � test_member_access_invokes_find. s z'TestTag.test_member_access_invokes_findc C sd | � d�}tjdd�� }|j}W d � n1 sw Y |j|ks%J �dt|d j�ks0J �d S )Nr T)�recordzp.bTag is deprecated, use .find("b") instead. If you really were looking for a tag called bTag, use .find("bTag")r )r �warnings�catch_warnings�bTagr �str�message)r r �wr r r r � test_deprecated_member_access5 s �z%TestTag.test_deprecated_member_accessc C s. | � d�}|j�d�s J �|j�d�rJ �dS )z�has_attr() checks for the presence of an attribute. Please note note: has_attr() is different from __in__. has_attr() checks the tag's attributes and __in__ checks the tag's chidlren. z<foo attr='bar'>�attr�attr2N)r �foo�has_attrr r r r � test_has_attr< s zTestTag.test_has_attrc C s d}| � |d� d S )Nz%<b a="1" z="5" m="3" f="2" y="4"></b>z%<b a="1" f="2" m="3" y="4" z="5"></b>)�assertSoupEquals)r �markupr r r �.test_attributes_come_out_in_alphabetical_orderG s z6TestTag.test_attributes_come_out_in_alphabetical_orderc C s | � d�}|jjdks J �d S )Nz <b>foo</b>r* �r r �stringr r r r � test_stringK s zTestTag.test_stringc C s | � d�}|jjd ks J �d S )N�<b></b>r0 r r r r � test_empty_tag_has_no_stringQ s z$TestTag.test_empty_tag_has_no_stringc C s` | � d�}|jjd ks J �| � d�}|jjd ksJ �| � d�}|j�dd� |jjd ks.J �d S )Nz<a>foo<b></b><b></b></b>z<a>foo<b></b>bar</b>z <a>foo</b>r �bar)r r r1 r �insertr r r r �-test_tag_with_multiple_children_has_no_stringV s z5TestTag.test_tag_with_multiple_children_has_no_stringc C s, | � d�}|jjdks J �|jdksJ �d S )Nz<a><b>foo</b></a>r* )r r r1 r r r r �)test_tag_with_recursive_string_has_stringd s z1TestTag.test_tag_with_recursive_string_has_stringc C s8 | � d�}|jjdu s J �| � d�}|jjdu sJ �dS )z7Only a Tag containing a single text node has a .string.z<b>f<i>e</i>o</b>Nr3 r0 r r r r �test_lack_of_stringk s zTestTag.test_lack_of_stringc C s` | � d�}|jjdks J �|jjdd�dksJ �|j�d�dks"J �|jjddd�dks.J �d S ) zBTag.text and Tag.get_text(sep=u"") -> all child text, concatenatedz <a>a<b>r</b> <r> t </r></a>zar t T)�strip�art�,z a,r, , t za,r,tN)r r �text�get_textr r r r � test_all_texts s zTestTag.test_all_textc C sd | � d�}|�� dks J �|jttfd�dksJ �|jd d�dks#J �| � d�}|�� dks0J �d S )N�foo<!--IGNORE-->bar�foobar)�types� fooIGNOREbar�3foo<style>CSS</style><script>Javascript</script>bar)r r> r r r r r r �/test_get_text_ignores_special_string_containers{ s z7TestTag.test_get_text_ignores_special_string_containersc C sD | � d�}ddgt|j�ksJ �| � d�}ddgt|j�ks J �d S )Nr@ r* r5 rD )r �list�stringsr r r r �2test_all_strings_ignores_special_string_containers� s z:TestTag.test_all_strings_ignores_special_string_containersc C s | � d�}| � d�}| � d�}|j�� dksJ �t|jj�dgks#J �|jj�� dks-J �t|jjj�dgks9J �|j�� dksBJ �t|jj�dgksMJ �|jj�� dksWJ �t|jjj�g d�ksdJ �|j�� dksmJ �t|jj�dgksxJ �|jj�� dks�J �t|jjj�dgks�J �d S ) Nz#<div>a<style>Some CSS</style></div>zT<div>a<template><p>Templated <b>text</b>.</p><!--With a comment.--></template></div>z6<div>a<script><!--a comment-->Some text</script></div>r zSome CSSzTemplated text.)z Templated r= �.z<!--a comment-->Some text)r �divr> rF rG �style�template�script)r rK rL rM r r r �8test_string_methods_inside_special_string_container_tags� s z@TestTag.test_string_methods_inside_special_string_container_tagsN)�__name__� __module__� __qualname__�__doc__r r r r' r, r/ r2 r4 r7 r8 r9 r? rE rH rN r r r r r s" r c @ sX e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dS )�TestMultiValuedAttributesz�Test the behavior of multi-valued attributes like 'class'. The values of such attributes are always presented as lists. c C s" | � d�}dg|jd ksJ �d S )Nz<a class='foo'>r* �class�r r r r r r � test_single_value_becomes_list� s z8TestMultiValuedAttributes.test_single_value_becomes_listc C �$ | � d�}ddg|jd ksJ �d S )Nz<a class='foo bar'>r* r5 rT rU r r r r �!test_multiple_values_becomes_list� � z;TestMultiValuedAttributes.test_multiple_values_becomes_listc C s$ | � d�}g d�|jd ksJ �d S )Nz<a class='foo bar baz'>)r* r5 �bazrT rU r r r r �2test_multiple_values_separated_by_weird_whitespace� rY zLTestMultiValuedAttributes.test_multiple_values_separated_by_weird_whitespacec C s | � d�}d|j�� ksJ �d S )Nz<a class='foo bar'>s <a class="foo bar"></a>)r r �encoder r r r �,test_attributes_joined_into_string_on_output� s zFTestMultiValuedAttributes.test_attributes_joined_into_string_on_outputc C s$ | � d�}dg|j�d�ksJ �d S )Nz<a id='abc def'>zabc def�id)r r �get_attribute_listr r r r �test_get_attribute_list� rY z1TestMultiValuedAttributes.test_get_attribute_listc C rW )Nz(<form accept-charset="ISO-8859-1 UTF-8">z ISO-8859-1zUTF-8�accept-charset)r �formr r r r �test_accept_charset� rY z-TestMultiValuedAttributes.test_accept_charsetc C s$ d}| � |�}d|jd ksJ �d S )Nz)<a accept-charset="ISO-8859-1 UTF-8"></a>zISO-8859-1 UTF-8ra rU )r �datar r r r �-test_cdata_attribute_applying_only_to_one_tag� s zGTestMultiValuedAttributes.test_cdata_attribute_applying_only_to_one_tagc C s< | j dddid�}|jd dksJ �|jd dgks J �d S )Nz<a class="foo" id="bar">�*r^ )�multi_valued_attributesrT r* r5 rU r r r r �test_customization� s �z,TestMultiValuedAttributes.test_customizationc C s( | � d�}d|j_dt|j�ksJ �d S )Nz.<div id="1"><span id="2">a string</span></div>Tz<div id="1">a string</div>)r �span�hiddenr$ rJ r r r r � test_hidden_tag_is_invisible� s z6TestMultiValuedAttributes.test_hidden_tag_is_invisibleN) rO rP rQ rR rV rX r[ r] r` rc re rh rk r r r r rS � s rS )r! � bs4.elementr r r r r rS r r r r �<module> s %PK z�Z|� �6 6 2 tests/__pycache__/test_pageelement.cpython-310.pycnu �[��� o �h�7 � @ s� d Z ddlZddlZddlZddlZddlmZ ddlmZm Z m Z ddl m Z G dd� de �Z G d d � d e �ZG d d � d e �ZdS ) z*Tests of the bs4.element.PageElement class� N)� BeautifulSoup)�Comment� ResultSet� SoupStrainer� )�SoupTestc @ sX e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dS )� TestEncodingz0Test the ability to encode objects into strings.c C s. d}| � |�}|jj�d�d�d�ksJ �d S )N� <b>☃</b>�utf-8� ☃)�soup�b�string�encode��self�htmlr � r �M/usr/local/CyberCP/lib/python3.10/site-packages/bs4/tests/test_pageelement.py�"test_unicode_string_can_be_encoded s z/TestEncoding.test_unicode_string_can_be_encodedc C s, d}| � |�}|j�d�|�d�ksJ �d S )Nr r �r r r r r r r �1test_tag_containing_unicode_string_can_be_encoded s z>TestEncoding.test_tag_containing_unicode_string_can_be_encodedc C s& d}| � |�}|j�d�dksJ �d S )Nr �asciis <b>☃</b>r r r r r �<test_encoding_substitutes_unrecognized_characters_by_default s zITestEncoding.test_encoding_substitutes_unrecognized_characters_by_defaultc C sL d}| � |�}t�t�� |jddd� W d � d S 1 s w Y d S )Nr r �strict)�errors)r �pytest�raises�UnicodeEncodeErrorr r r r r � test_encoding_can_be_made_strict# s "�z-TestEncoding.test_encoding_can_be_made_strictc C s$ d}| � |�}d|j�� ksJ �d S )Nr r )r r �decode_contentsr r r r �test_decode_contents) s z!TestEncoding.test_decode_contentsc C s. d}| � |�}d�d�|jjdd�ksJ �d S )Nr r �utf8)�encoding)r r r �encode_contentsr r r r �test_encode_contents. s �z!TestEncoding.test_encode_contentsc C s< t �� d }d| }| �|�}|�� }||�d�ks J �d S )Nr �<span>s <span>)�sys�getrecursionlimitr r �count)r �limit�markupr �encodedr r r �"test_encode_deeply_nested_document5 s z/TestEncoding.test_encode_deeply_nested_documentc C s2 d}| � |�}|�� d�d�|j�� ksJ �d S )Nr r r" )r �renderContentsr r r r r r � test_deprecated_renderContents? s z+TestEncoding.test_deprecated_renderContentsc C s" d}| � |�}|t|�ksJ �d S �Nr )r �reprr r r r � test_reprE s zTestEncoding.test_reprN) �__name__� __module__� __qualname__�__doc__r r r r r! r% r- r/ r2 r r r r r s r c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$S )%�TestFormatterszrTest the formatting feature, used by methods like decode() and prettify(), and the formatters themselves. c C �0 d}| � |�}|jdd�}|| �d�ksJ �d S �N�# <b><<Sacré bleu!>></b>�minimal�� formatter�r �decode� document_for�r r+ r �decodedr r r �!test_default_formatter_is_minimalP � �z0TestFormatters.test_default_formatter_is_minimalc C �0 d}| � |�}|jdd�}|| �d�ksJ �d S )N�' <br><b><<Sacré bleu!>></b>r r< z.<br/><b><<Sacré bleu!>></b>r> rA r r r �test_formatter_htmlY � �z"TestFormatters.test_formatter_htmlc C rE )NrF �html5r< z-<br><b><<Sacré bleu!>></b>r> rA r r r �test_formatter_html5a rH z#TestFormatters.test_formatter_html5c C r8 r9 r> rA r r r �test_formatter_minimali rD z%TestFormatters.test_formatter_minimalc C s0 d}| � |�}|jd d�}|| �d�ksJ �d S )Nr: r< u <b><<Sacré bleu!>></b>r> rA r r r �test_formatter_nullr s �z"TestFormatters.test_formatter_nullc C s4 d}| � |�}|jdd� d�}|| �d�ksJ �d S )Nz!<b><foo></b><b>bar</b><br/>c S � | � � S �N��upper��xr r r �<lambda> � z6TestFormatters.test_formatter_custom.<locals>.<lambda>r< z<b><FOO></b><b>BAR</b><br/>r> rA r r r �test_formatter_custom| s z$TestFormatters.test_formatter_customc C s� d}| � |�}|j}d}||�� ksJ �||jdd�ks J �d}||jdd�ks*J �||jd d�ks4J �d}||jdd � d�ksBJ �d S ) Nu% <a href="http://a.com?a=b&c=é">e</a>u) <a href="http://a.com?a=b&c=é">e</a>r; r< z/<a href="http://a.com?a=b&c=é">e</a>r u% <a href="HTTP://A.COM?A=B&C=É">E</a>c S rM rN rO rQ r r r rS � rT zJTestFormatters.test_formatter_is_run_on_attribute_values.<locals>.<lambda>)r �ar? )r r+ r rV �expect_minimal� expect_html� expect_upperr r r �)test_formatter_is_run_on_attribute_values� s z8TestFormatters.test_formatter_is_run_on_attribute_valuesc C �" d}t |d��� }d|v sJ �d S )NzO <script type="text/javascript"> console.log("< < hey > > "); </script> � html.parser� < < hey > >�r r �r �docr, r r r �2test_formatter_skips_script_tag_for_html_documents� � zATestFormatters.test_formatter_skips_script_tag_for_html_documentsc C r[ )NzF <style type="text/css"> console.log("< < hey > > "); </style> r\ r] r^ r_ r r r �1test_formatter_skips_style_tag_for_html_documents� rb z@TestFormatters.test_formatter_skips_style_tag_for_html_documentsc C s | � d�}d|j�� ksJ �d S )NzN<div> foo <pre> bar </pre> baz <textarea> eee fff </textarea></div>zP<div> foo <pre> bar </pre> baz <textarea> eee fff </textarea> </div> �r �div�prettify�r r r r r �,test_prettify_leaves_preformatted_text_alone� s z;TestFormatters.test_prettify_leaves_preformatted_text_alonec C s( d}d}| � |�}||j�� ksJ �d S )NzR<div><pre><code>some <script><pre>code</pre></script> for you </code></pre></div>zV<div> <pre><code>some <script><pre>code</pre></script> for you </code></pre> </div> rd )r r+ �expectr r r r �0test_prettify_handles_nested_string_literal_tags� s z?TestFormatters.test_prettify_handles_nested_string_literal_tagsc C s* t dd�}|jdd� d�}d|v sJ �d S )Nz <html><body>foo</body></html>r\ c S rM rN rO rQ r r r rS � rT zITestFormatters.test_prettify_accepts_formatter_function.<locals>.<lambda>r< �FOO)r rf )r r �prettyr r r �(test_prettify_accepts_formatter_function� s z7TestFormatters.test_prettify_accepts_formatter_functionc C s" | � d�}tt|�� �ksJ �d S )N�<a></a>)r �str�typerf rg r r r �(test_prettify_outputs_unicode_by_default� s z7TestFormatters.test_prettify_outputs_unicode_by_defaultc C s$ | � d�}tt|�d��ksJ �d S )Nrn r )r �bytesrp rf rg r r r � test_prettify_can_encode_data� s z,TestFormatters.test_prettify_can_encode_datac C s0 d}| � |�}|j�d�}||�d�ksJ �d S )Nu <b>Sacré bleu!</b>r r )r r+ r r, r r r �,test_html_entity_substitution_off_by_default� s z;TestFormatters.test_html_entity_substitution_off_by_defaultc C s� d}| � |�}|jd dksJ �|�d�}d|v sJ �|�d�}d|v s&J �|�d�}d |v s1J �|�d ��d �}d |v s?J �d S ) NzE<meta content="text/html; charset=x-sjis" http-equiv="Content-type"/>�contentztext/html; charset=x-sjisr s charset=utf-8�euc_jps charset=euc_jpz shift-jiss charset=shift-jiszutf-16zcharset=utf-16)r �metar r? )r �meta_tagr �utf_8rv � shift_jis�utf_16_ur r r �test_encoding_substitution� s z)TestFormatters.test_encoding_substitutionc C s2 d}t d�}| j||d�}|jd jdksJ �d S )Nz`<head><meta content="text/html; charset=x-sjis" http-equiv="Content-type"/></head><pre>foo</pre>�pre)� parse_onlyr )r r �contents�name)r r+ �strainerr r r r �;test_encoding_substitution_doesnt_happen_if_tag_is_strained� s zJTestFormatters.test_encoding_substitution_doesnt_happen_if_tag_is_strainedN)r3 r4 r5 r6 rC rG rJ rK rL rU rZ ra rc rh rj rm rq rs rt r| r� r r r r r7 K s& r7 c @ sh e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� ZdS )�TestPersistencez*Testing features like pickle and deepcopy.c C s d| _ | �| j �| _d S )Nay <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/transitional.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> <title>Beautiful Soup: We called him Tortoise because he taught us.</title> <link rev="made" href="mailto:leonardr@segfault.org"> <meta name="Description" content="Beautiful Soup: an HTML parser optimized for screen-scraping."> <meta name="generator" content="Markov Approximation 1.4 (module: leonardr)"> <meta name="author" content="Leonard Richardson"> </head> <body> <a href="foo">foo</a> <a href="foo"><b>bar</b></a> </body> </html>)�pager �tree)r r r r � setup_method� s z TestPersistence.setup_methodc C s@ t �| jd�}t �|�}|jtksJ �|�� | j�� ks J �d S )N� )�pickle�dumpsr� �loads� __class__r r? )r �dumped�loadedr r r �!test_pickle_and_unpickle_identity s z1TestPersistence.test_pickle_and_unpickle_identityc C s& t �| j�}|�� | j�� ksJ �d S rN )�copy�deepcopyr� r? )r �copiedr r r �test_deepcopy_identity s z&TestPersistence.test_deepcopy_identityc C s6 t �� d }d| }| �|�}t�|�}t�|�}d S )Nr r& )r' r( r r� r� )r r* r+ r r� r r r � test_copy_deeply_nested_document s z0TestPersistence.test_copy_deeply_nested_documentc C s: t dd�}|j}|�� }dt|�ksJ �||jksJ �d S )Ns <p> </p>r\ u <p> </p>)r �original_encoding�__copy__ro )r r r# r� r r r � test_copy_preserves_encoding+ s z,TestPersistence.test_copy_preserves_encodingc C s� | � d�j}d|_d|_|�� }|j|jksJ �|j|jks J �|j|jks(J �|j|jks0J �|j|jks8J �|j|jks@J �d S )Nz<p></p>� �! ) r �p� sourceline� sourceposr� �can_be_empty_element�cdata_list_attributes�preserve_whitespace_tags�interesting_string_types)r �tagr� r r r �'test_copy_preserves_builder_information2 s z7TestPersistence.test_copy_preserves_builder_informationc C s> d}| � |�}t�|tj�}t�|�}|�� |�� ks J �d S r0 )r r� r� �HIGHEST_PROTOCOLr� r? )r r r r� r� r r r �test_unicode_pickleE s z#TestPersistence.test_unicode_picklec C sz d}| � |�}|jdd�}t�|�}||ksJ �d |jks J �d |jks&J �d |jks-J �d |jks4J �d |jks;J �d S )Nz<b>Foo<a></a></b><b>Bar</b>�Foo�r )r �findr� �parent� next_element� next_sibling�previous_element�r r r �s1�s2r r r �1test_copy_navigablestring_is_not_attached_to_treeM s zATestPersistence.test_copy_navigablestring_is_not_attached_to_treec C s< d}| � |�}|j}t�|�}||ksJ �t|t�s J �d S )Nz<b><!--Foo--></b>)r r r� � isinstancer r� r r r �0test_copy_navigablestring_subclass_has_same_typeY s z@TestPersistence.test_copy_navigablestring_subclass_has_same_typec C s( d}| � |�}t�|�}||ksJ �d S )N�)<div><b>Foo<a></a></b><b>Bar</b></div>end)r r� )r r r � soup_copyr r r �test_copy_entire_soupa s z%TestPersistence.test_copy_entire_soupc C s� d}| � |�}|j}t�|�}t|�t|�ksJ �||ks J �||us%J �d |jks,J �d |jks3J �d |jdd�jks>J �d |jdd�jksIJ �d S )Nr� �Barr� )r re r� ro r� r� r� r� )r r r re �div_copyr r r � test_copy_tag_copies_contentsg s z-TestPersistence.test_copy_tag_copies_contentsN)r3 r4 r5 r6 r� r� r� r� r� r� r� r� r� r� r� r r r r r� � s r� )r6 r� r� r r' �bs4r � bs4.elementr r r � r r r7 r� r r r r �<module> s : 2PK z�Z�ޯв в * tests/__pycache__/__init__.cpython-310.pycnu �[��� o �h� � @ s` d Z dZddlZddlZddlZddlZddlZddlmZ ddl m Z m Z m Z m Z mZmZmZmZmZ ddlmZmZmZ eZz ddlmZ dZW n eyU d ZY nw zddl Z dZ W n eyi d Z Y nw z ddl Z dZ e j!j"Z"W n ey� d Z d Z"Y nw d Z#G d d � d e$�Z%G dd� de$�Z&G dd� de&�Z'G dd� de&�Z(G dd� de'�Z)dS )zHelper classes for tests.�MIT� N)� BeautifulSoup) �CharsetMetaAttributeValue�Comment�ContentMetaAttributeValue�Doctype�PYTHON_SPECIFIC_ENCODINGS� SoupStrainer�Script� Stylesheet�Tag)�DetectsXMLParsedAsHTML�HTMLParserTreeBuilder�XMLParsedAsHTMLWarning)�SelectorSyntaxErrorTF)r u- A bare string <!DOCTYPE xsl:stylesheet SYSTEM "htmlent.dtd"> <!DOCTYPE xsl:stylesheet PUBLIC "htmlent.dtd"> <div><![CDATA[A CDATA section where it doesn't belong]]></div> <div><svg><![CDATA[HTML5 does allow CDATA sections in SVG]]></svg></div> <div>A <meta> tag</div> <div>A <br> tag that supposedly has contents.</br></div> <div>AT&T</div> <div><textarea>Within a textarea, markup like <b> tags and <&<& should be treated as literal</textarea></div> <div><script>if (i < 2) { alert("<b>Markup within script tags should be treated as literal.</b>"); }</script></div> <div>This numeric entity is missing the final semicolon: <x t="piñata"></div> <div><a href="http://example.com/</a> that attribute value never got closed</div> <div><a href="foo</a>, </a><a href="bar">that attribute value was closed by the subsequent tag</a></div> <! This document starts with a bogus declaration ><div>a</div> <div>This document contains <!an incomplete declaration <div>(do you see it?)</div> <div>This document ends with <!an incomplete declaration <div><a style={height:21px;}>That attribute value was bogus</a></div> <! DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN">The doctype is invalid because it contains extra whitespace <div><table><td nowrap>That boolean attribute had no value</td></table></div> <div>Here's a nonexistent entity: &#foo; (do you see it?)</div> <div>This document ends before the entity finishes: > <div><p>Paragraphs shouldn't contain block display elements, but this one does: <dl><dt>you see?</dt></p> <b b="20" a="1" b="10" a="2" a="3" a="4">Multiple values for the same attribute.</b> <div><table><tr><td>Here's a table</td></tr></table></div> <div><table id="1"><tr><td>Here's a nested table:<table id="2"><tr><td>foo</td></tr></table></td></div> <div>This tag contains nothing but whitespace: <b> </b></div> <div><blockquote><p><b>This p tag is cut off by</blockquote></p>the end of the blockquote tag</div> <div><table><div>This table contains bare markup</div></table></div> <div><div id="1"> <a href="link1">This link is never closed. </div> <div id="2"> <div id="3"> <a href="link2">This link is closed.</a> </div> </div></div> <div>This document contains a <!DOCTYPE surprise>surprise doctype</div> <div><a><B><Cd><EFG>Mixed case tags are folded to lowercase</efg></CD></b></A></div> <div><our☃>Tag name contains Unicode characters</our☃></div> <div><a ☃="snowman">Attribute name contains Unicode characters</a></div> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> c @ sX e Zd Zedd� �Zdd� Zdd� Zddd �ZeZd d � Z dd d�Z dd� Z dd� Z dS )�SoupTestc C s t S �N)�default_builder��self� r �E/usr/local/CyberCP/lib/python3.10/site-packages/bs4/tests/__init__.pyr ^ s zSoupTest.default_builderc K s" |� d| j�}t|fd|i|��S )z*Build a Beautiful Soup object from markup.�builder)�popr r )r �markup�kwargsr r r r �soupb s z SoupTest.soupc K s | j di |���|�S )z[Turn an HTML fragment into a document. The details depend on the builder. Nr )r �test_fragment_to_document)r r r r r r � document_forg s zSoupTest.document_forNc C st | j }t||d�}|du r|}|�� | �|�ksJ �tdd� t|j�� �D ��s*J �|jgdd� |j D �ks8J �dS )ziParse some markup using Beautiful Soup and verify that the output markup is as expected. )r Nc s s � | ]}|d kV qdS )r Nr )�.0�vr r r � <genexpr> s � z'SoupTest.assert_soup.<locals>.<genexpr>c S � g | ]}|j �qS r )�name)r �xr r r � <listcomp>� � z(SoupTest.assert_soup.<locals>.<listcomp>) r r �decoder �all�list�open_tag_counter�values� ROOT_TAG_NAME�tagStack)r �to_parse�compare_parsed_tor �objr r r � assert_soupn s zSoupTest.assert_soupc C s8 d}|j D ]}|r||jksJ �||jksJ �|}qdS )zyEnsure that next_element and previous_element are properly set for all descendants of the given element. N)� descendants� next_element�previous_element)r �element�earlier�er r r �assertConnectedness� s �z SoupTest.assertConnectednessFc C s� d}|j du r4|jdu sJ d�||jd���|jdu s%J d�||jd���|jdu s4J d�||jd���d}d}d}t|j�d }|jD ]�}d}|dkr|j dur~|j|u s`J d�||j|���|j|u soJ d�||j|���|jdu s~J d�||jd���n\|j|j|d u s�J d �||j|j|d ���|j|d j|u s�J d �|j|d |j|d j|���|dur�|j|u s�J d �||j||j j���|j|u s�J d �||j|���t|t �r�|jr�| � |d �}|jdu s�J d �||jd���|dur�|}n|}||k�r|jdu �sJ d �||jd���|d7 }qD|du�r"|n|}|du �r+|}|�sn|du�rn|} |du �rN|jdu �sKJ d �||jd��� dS |jdu�ri|j|ju �sfJ d �||j|j��� dS |j }�q6|S )z.Ensure proper linkage throughout the document.Nz3Bad previous_element NODE: {} PREV: {} EXPECTED: {}z3Bad previous_sibling NODE: {} PREV: {} EXPECTED: {}z/Bad next_sibling NODE: {} NEXT: {} EXPECTED: {}r � z/Bad next_element NODE: {} NEXT: {} EXPECTED: {}z2Bad previous_sibling NODE: {} PREV {} EXPECTED: {}z1Bad previous_sibling NODE: {} PREV {} EXPECTED {}z-Bad next_sibling NODE: {} NEXT {} EXPECTED {}z=Bad previous_element NODE: {} PREV {} EXPECTED {} CONTENTS {}z-Bad next_element NODE: {} NEXT {} EXPECTED {}T) �parentr4 �format�previous_sibling� next_sibling�len�contentsr3 � isinstancer �linkage_validator) r �el�_recursive_call� descendant�idx�child� last_child�last_idx�targetr r r rA � s� �� �� �� �� �� ����� �� �� �� �� �� �� � ����zSoupTest.linkage_validatorc C � dd� |D �|ks J �dS )z�Make sure that the given tags have the correct text. This is used in tests that define a bunch of tags, each containing a single string, and then select certain strings by some mechanism. c S r" r ��string�r �tagr r r r% r& z+SoupTest.assert_selects.<locals>.<listcomp>Nr �r �tags� should_matchr r r �assert_selects � zSoupTest.assert_selectsc C rJ )z�Make sure that the given tags have the correct IDs. This is used in tests that define a bunch of tags, each containing a single string, and then select certain strings by some mechanism. c S s g | ]}|d �qS ��idr rM r r r r% s z/SoupTest.assert_selects_ids.<locals>.<listcomp>Nr rO r r r �assert_selects_ids rS zSoupTest.assert_selects_idsr )F) �__name__� __module__� __qualname__�propertyr r r r1 �assertSoupEqualsr8 rA rR rV r r r r r \ s r r c @ sh e Zd Zej�ddi edgd�ddgig�dd� �Zej�dedgd �ddgig�d d � �Zd d � Z dS )�TreeBuilderSmokeTest�multi_valued_attributesN�class)�b�*�notclassc C s( d}| j ||d�}|jd dksJ �d S )NzC<html xmlns="http://www.w3.org/1999/xhtml"><a class="a b c"></html>�r] r^ za b c�r �a�r r] r r r r r � test_attribute_not_multi_valued s z4TreeBuilderSmokeTest.test_attribute_not_multi_valued)rd c C s, d}| j ||d�}|jd g d�ksJ �d S )Nz<a class="a b c">rb r^ )rd r_ �crc re r r r �test_attribute_multi_valued# s �z0TreeBuilderSmokeTest.test_attribute_multi_valuedc C s d}d}| � |�}d S )Nz <![if word]>content<![endif]>z<!DOCTYPE html]ff>)r �r r r r r r �test_invalid_doctype- s z)TreeBuilderSmokeTest.test_invalid_doctype) rW rX rY �pytest�mark� parametrize�dictrf rh rj r r r r r\ s � � r\ c @ s e Zd ZdZdd� Zdd� Zdd� Zdd � Zd�d d �Zd d� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� Z d5d6� Z d7d8� Z d9d:� Z d;d<� Z d=d>� Z!d?d@� Z"dAdB� Z#dCdD� Z$dEdF� Z%dGdH� Z&dIdJ� Z'dKdL� Z(dMdN� Z)dOdP� Z*dQd� ZdRdS� Z+dTdU� Z,dVdW� Z-dXdY� Z.dZd[� Z/d\d]� Z0d^d_� Z1d`da� Z2dbdc� Z3ddde� Z4dfdg� Z5dhdi� Z6djdk� Z7dldm� Z8dndo� Z9dpdq� Z:drds� Z;dtdu� Z<dvdw� Z=dxdy� Z>dzd{� Z?d|d}� Z@d~d� ZAd�d�� ZBd�S )��HTMLTreeBuilderSmokeTestaC A basic test of a treebuilder's competence. Any HTML treebuilder, present or future, should be able to pass these tests. With invalid markup, there's room for interpretation, and different parsers can handle it differently. But with the markup in these tests, there's not much room for interpretation. c C s0 dD ]}| � d�}|�|�}|jdksJ �qdS )zmVerify that all HTML4 and HTML5 empty element (aka void element) tags are handled correctly. )�area�base�br�col�embed�hr�img�input�keygen�link�menuitem�meta�param�source�track�wbr�spacer�frame� TN)r �new_tag�is_empty_element)r r# r r� r r r �test_empty_element_tags< s �z0HTMLTreeBuilderSmokeTest.test_empty_element_tagsc C sp | � d�}t|jjt�sJ �t|jjt�sJ �| � d�}t|jjt�s%J �|jjdks-J �t|jjt�s6J �d S )Nz7<style>Some CSS</style><script>Some Javascript</script>z <style><!--Some CSS--></style>z<!--Some CSS-->)r r@ �stylerL r �scriptr �r r r r r � test_special_string_containersH s ��z7HTMLTreeBuilderSmokeTest.test_special_string_containersc C �F | � d�}t�|d�}t�|�}|jtksJ �|�� |�� ks!J �d S �Nz <a><b>foo</a>� �r �pickle�dumps�loads� __class__r r' �r �tree�dumped�loadedr r r �!test_pickle_and_unpickle_identityX � z:HTMLTreeBuilderSmokeTest.test_pickle_and_unpickle_identityc C sh | � |�\}}|jd }|jtksJ �||ksJ �|�d�dt|�� |ks(J �|jjd dks2J �dS )z8Assert that a given doctype string is handled correctly.r �utf8N�foo��_document_with_doctyper? r� r �encoder> �p�r �doctype_fragment� doctype_strr �doctyper r r �assertDoctypeHandleda s z-HTMLTreeBuilderSmokeTest.assertDoctypeHandled�DOCTYPEc C s, d||f }|d }| � |�}|�d�|fS )z5Generate and parse a document with the given doctype.z<!%s %s>z <p>foo</p>r� �r r� )r r� �doctype_stringr� r r r r r r� o s z/HTMLTreeBuilderSmokeTest._document_with_doctypec C s | � d� | � d� dS )z?Make sure normal, everyday HTML doctypes are handled correctly.�htmlz4html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"N�r� r r r r �test_normal_doctypesv s �z-HTMLTreeBuilderSmokeTest.test_normal_doctypesc C s( | � d�}|jd }d|�� ksJ �d S )Nz <!DOCTYPE>r r� )r r? �strip)r r r� r r r �test_empty_doctype| s z+HTMLTreeBuilderSmokeTest.test_empty_doctypec C st dD ]5}| � d|�\}}|jd }|jtksJ �|dks J �|�d�d t|�� dks-J �|jjd dks7J �qd S )N)r� �DocTyper� r r� s <!DOCTYPE html>r� r� r� r r r �test_mixed_case_doctype� s � �z0HTMLTreeBuilderSmokeTest.test_mixed_case_doctypec C � d}| � |� d S )Nznhtml PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"r� )r r� r r r � test_public_doctype_with_url� � z5HTMLTreeBuilderSmokeTest.test_public_doctype_with_urlc C � | � d� d S )Nz$foo SYSTEM "http://www.example.com/"r� r r r r �test_system_doctype� � z,HTMLTreeBuilderSmokeTest.test_system_doctypec C r� )Nz#xsl:stylesheet SYSTEM "htmlent.dtd"r� r r r r � test_namespaced_system_doctype� � z7HTMLTreeBuilderSmokeTest.test_namespaced_system_doctypec C r� )Nz#xsl:stylesheet PUBLIC "htmlent.dtd"r� r r r r � test_namespaced_public_doctype� r� z7HTMLTreeBuilderSmokeTest.test_namespaced_public_doctypec C sl d}t jdd�� }| �|�}W d � n1 sw Y |�d��dd�|�dd�ks.J �|g ks4J �dS )zJA real XHTML document should come out more or less the same as it went in.�� <?xml version="1.0" encoding="utf-8"?> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"> <html xmlns="http://www.w3.org/1999/xhtml"> <head><title>Hello.</title></head> <body>Goodbye.</body> </html>T��recordN�utf-8� � )�warnings�catch_warningsr r� �replace�r r �wr r r r �test_real_xhtml_document� s �"z1HTMLTreeBuilderSmokeTest.test_real_xhtml_documentc C s` d}t jdd�� }| �|�}W d � n1 sw Y dt|�d��ks(J �g |ks.J �d S )Ns. <ns1:foo>content</ns1:foo><ns1:foo/><ns2:foo/>Tr� r� zns1:foo)r� r� r r> �find_allr� r r r �test_namespaced_html� s �z-HTMLTreeBuilderSmokeTest.test_namespaced_htmlc C sx d}t jdd��}| �|�}|jjdksJ �W d � n1 s w Y |\}t|jt�s0J �t|j�tj ks:J �d S )Ns7 <?xml version="1.0" encoding="utf-8"?><tag>string</tag>Tr� rL ) r� r� r rN rL r@ �messager �str�MESSAGE)r r r� r �warningr r r � test_detect_xml_parsed_as_html� s �z7HTMLTreeBuilderSmokeTest.test_detect_xml_parsed_as_htmlc C sB d}| � |�}||�� ksJ �d}| � |�}||�d�ks J �d S )Nz<?PITarget PIContent?>s <?PITarget PIContent?>r� )r r' r� ri r r r �test_processing_instruction� s z4HTMLTreeBuilderSmokeTest.test_processing_instructionc C s t �| j� dS )z�Make sure you can copy the tree builder. This is important because the builder is part of a BeautifulSoup object, and we want to be able to copy that. N)�copy�deepcopyr r r r r � test_deepcopy� s z&HTMLTreeBuilderSmokeTest.test_deepcopyc C s, | � d�}|jjr J �t|j�dksJ �dS )z�A <p> tag is never designated as an empty-element tag. Even if the markup shows it as an empty-element tag, it shouldn't be presented that way. �<p/>�<p></p>N)r r� r� r� r� r r r �!test_p_tag_is_never_empty_element� � z:HTMLTreeBuilderSmokeTest.test_p_tag_is_never_empty_elementc C s( | � dd� | � dd� | � dd� dS )z�A tag that's not closed by the end of the document should be closed. This applies to all tags except empty-element tags. �<p>r� z<b>z<b></b>z<br>�<br/>N�r1 r r r r � test_unclosed_tags_get_closed� s z6HTMLTreeBuilderSmokeTest.test_unclosed_tags_get_closedc C s, | � d�}|jjs J �t|j�dksJ �dS )z�A <br> tag is designated as an empty-element tag. Some parsers treat <br></br> as one <br/> tag, some parsers as two tags, but it should always be an empty-element tag. z <br></br>r� N)r rr r� r� r� r r r �#test_br_is_always_empty_element_tag� r� z<HTMLTreeBuilderSmokeTest.test_br_is_always_empty_element_tagc C r� )Nz<em><em></em></em>r� r r r r � test_nested_formatting_elements r� z8HTMLTreeBuilderSmokeTest.test_nested_formatting_elementsc C s( d}| � |�}d|�d�d ksJ �d S )Nz�<!DOCTYPE html> <html> <head> <title>Ordinary HEAD element test</title> </head> <script type="text/javascript"> alert("Help!"); </script> <body> Hello, world! </body> </html> ztext/javascriptr� �type)r �find)r r� r r r r �test_double_head s z)HTMLTreeBuilderSmokeTest.test_double_headc C sj d}| � |� | �|�}|jdd�}|jtksJ �|jdd�}||jks&J �|jdd�}||jks3J �d S )Nz<p>foo<!--foobar-->baz</p>�foobarrK r� �baz)r1 r r� r� r r3 r4 )r r r �commentr� r� r r r � test_comment s z%HTMLTreeBuilderSmokeTest.test_commentc C st d}d}| � |� | � |� | �|�}|j�� |ks J �| �|�}|j�� |ks*J �| �d�}|j�� dks8J �dS )zWhitespace must be preserved in <pre> and <textarea> tags, even if that would mean not prettifying the markup. z<pre>a z</pre> z <textarea> woo woo </textarea> z<textarea></textarea>z<textarea></textarea> N)r1 r �pre�prettify�textarea)r � pre_markup�textarea_markupr r r r �-test_preserved_whitespace_in_pre_and_textarea& s zFHTMLTreeBuilderSmokeTest.test_preserved_whitespace_in_pre_and_textareac C s. d}| � |� d}| � |� d}| � |� dS )z+Inline elements can be nested indefinitely.z<b>Inside a B tag</b>z!<p>A <i>nested <b>tag</b></i></p>z/<p>A <a>doubly <i>nested <b>tag</b></i></a></p>Nr� )r �b_tag� nested_b_tag�double_nested_b_tagr r r �test_nested_inline_elements8 s z4HTMLTreeBuilderSmokeTest.test_nested_inline_elementsc C s6 | � d�}|j}|jjjdksJ �|jjdksJ �dS )z Block elements can be nested.z*<blockquote><p><b>Foo</b></p></blockquote>�FooN)r � blockquoter� r_ rL )r r r� r r r � test_nested_block_level_elementsC s z9HTMLTreeBuilderSmokeTest.test_nested_block_level_elementsc C s d}| � |d� | � d� dS )z$One table can go inside another one.z[<table id="1"><tr><td>Here's another table:<table id="2"><tr><td>foo</td></tr></table></td>zh<table id="1"><tr><td>Here's another table:<table id="2"><tr><td>foo</td></tr></table></td></tr></table>z{<table><thead><tr><td>Foo</td></tr></thead><tbody><tr><td>Bar</td></tr></tbody><tfoot><tr><td>Baz</td></tr></tfoot></table>Nr� )r r r r r � test_correctly_nested_tablesJ s ��z5HTMLTreeBuilderSmokeTest.test_correctly_nested_tablesc C s@ d}| � |�}ddg|jd ksJ �|j|jddd�ks J �d S )Nz <div class=" foo bar "></a>r� �barr^ �divzfoo bar)�class_)r r� r� ri r r r �*test_multivalued_attribute_with_whitespace^ s zCHTMLTreeBuilderSmokeTest.test_multivalued_attribute_with_whitespacec C s( d}| � |�}dg|jjd ksJ �d S )Nz1<table><div><div class="css"></div></div></table>�cssr^ )r r� ri r r r �(test_deeply_nested_multivalued_attributej � zAHTMLTreeBuilderSmokeTest.test_deeply_nested_multivalued_attributec C �( d}| � |�}ddg|jd ksJ �d S )Nz<html class="a b"></html>rd r_ r^ )r r� ri r r r �"test_multivalued_attribute_on_htmlr r� z;HTMLTreeBuilderSmokeTest.test_multivalued_attribute_on_htmlc C � | � dd� d S )Nz<a b="<a>"></a>z<a b="<a>"></a>r� r r r r �3test_angle_brackets_in_attribute_values_are_escapedz s zLHTMLTreeBuilderSmokeTest.test_angle_brackets_in_attribute_values_are_escapedc C r� )Nz$<p>• AT&T is in the s&p 500</p>u) <p>• AT&T is in the s&p 500</p>r� r r r r �3test_strings_resembling_character_entity_references} s �zLHTMLTreeBuilderSmokeTest.test_strings_resembling_character_entity_referencesc C r� )Nz<p>Bob's Bar</p>z<p>Bob's Bar</p>r� r r r r �test_apos_entity� s �z)HTMLTreeBuilderSmokeTest.test_apos_entityc C �" d}| � |�}d|jjksJ �d S )Nz%<p>“Hello” -☃</p>u “Hello” -☃�r r� rL ri r r r �*test_entities_in_foreign_document_encoding� s zCHTMLTreeBuilderSmokeTest.test_entities_in_foreign_document_encodingc C �8 d}| � d|� | � d|� | � d|� | � d|� d S )Nu <p id="piñata"></p>z<p id="piñata"></p>z<p id="piñata"></p>z<p id="piñata"></p>z<p id="piñata"></p>r� �r �expectr r r �0test_entities_in_attributes_converted_to_unicode� � zIHTMLTreeBuilderSmokeTest.test_entities_in_attributes_converted_to_unicodec C r� )Nu <p>piñata</p>z<p>piñata</p>z<p>piñata</p>z<p>piñata</p>z<p>piñata</p>r� r� r r r �*test_entities_in_text_converted_to_unicode� r zCHTMLTreeBuilderSmokeTest.test_entities_in_text_converted_to_unicodec C r� )Nz#<p>I said "good day!"</p>z<p>I said "good day!"</p>r� r r r r �,test_quot_entity_converted_to_quotation_mark� � �zEHTMLTreeBuilderSmokeTest.test_quot_entity_converted_to_quotation_markc C s, d}| � d|� | � d|� | � d|� d S )Nu �z�z�z �r� r� r r r �test_out_of_range_entity� s z1HTMLTreeBuilderSmokeTest.test_out_of_range_entityc C s< | � d�}d|jjjjksJ �d|jjksJ �| �|� dS )zDMostly to prevent a recurrence of a bug in the html5lib treebuilder.z!<html><h2> foo</h2><p></p></html>r� N)r �h2rL r3 r# r� r8 r� r r r �test_multipart_strings� s z/HTMLTreeBuilderSmokeTest.test_multipart_stringsc C s | � dd� | � dd� dS )zqVerify consistent handling of empty-element tags, no matter how they come in through the markup. z<br/><br/><br/>z<br /><br /><br />Nr� r r r r r� � s c C s, d}| � |�}|jjdusJ �| �|� dS )�8Prevent recurrence of a bug in the html5lib treebuilder.z?<html><head></head> <link></link> <body>foo</body> </html> N)r r� �bodyr8 �r �contentr r r r �#test_head_tag_between_head_and_body� s z<HTMLTreeBuilderSmokeTest.test_head_tag_between_head_and_bodyc C s d}| � |�}| �|j� dS )r z�<!DOCTYPE html> <html> <body> <article id="a" > <div><a href="1"></div> <footer> <a href="2"></a> </footer> </article> </body> </html> N)r r8 �articler r r r � test_multiple_copies_of_a_tag� s z6HTMLTreeBuilderSmokeTest.test_multiple_copies_of_a_tagc C s^ d}| � |�}||�� ksJ �|j}d|jd ksJ �d|jd ks$J �d|jd ks-J �dS ) z�Parsers don't need to *understand* namespaces, but at the very least they should not choke on namespaces or lose data.s� <html xmlns="http://www.w3.org/1999/xhtml" xmlns:mathml="http://www.w3.org/1998/Math/MathML" xmlns:svg="http://www.w3.org/2000/svg"><head></head><body><mathml:msqrt>4</mathml:msqrt><b svg:fill="red"></b></body></html>� http://www.w3.org/1999/xhtml�xmlns�"http://www.w3.org/1998/Math/MathMLz xmlns:mathml�http://www.w3.org/2000/svgz xmlns:svgN)r r� r� )r r r r� r r r �test_basic_namespaces� s z.HTMLTreeBuilderSmokeTest.test_basic_namespacesc C r� )Ns <a class="foo bar">r� r� r^ rc ri r r r �-test_multivalued_attribute_value_becomes_list� s zFHTMLTreeBuilderSmokeTest.test_multivalued_attribute_value_becomes_listc C r� )NuD <html><head><meta encoding="euc-jp"></head><body>Sacré bleu!</body>� Sacré bleu!)r r rL ri r r r � test_can_parse_unicode_document� s z8HTMLTreeBuilderSmokeTest.test_can_parse_unicode_documentc C s* t d�}| jd|d�}|�� dksJ �dS )z2Parsers should be able to work with SoupStrainers.r_ z&A <b>bold</b> <meta/> <i>statement</i>)� parse_onlyz <b>bold</b>N)r r r' )r �strainerr r r r �test_soupstrainer� s �z*HTMLTreeBuilderSmokeTest.test_soupstrainerc C r� )Nz<foo attr='bar'></foo>z<foo attr="bar"></foo>r� r r r r �7test_single_quote_attribute_values_become_double_quotes r zPHTMLTreeBuilderSmokeTest.test_single_quote_attribute_values_become_double_quotesc C r� )N�'<foo attr='bar "brawls" happen'>a</foo>r� )r �textr r r �7test_attribute_values_with_nested_quotes_are_left_alone r� zPHTMLTreeBuilderSmokeTest.test_attribute_values_with_nested_quotes_are_left_alonec C s. d}| � |�}d|jd< | �|j�� d� d S )Nr z Brawls happen at "Bob's Bar"�attrz:<foo attr="Brawls happen at "Bob's Bar"">a</foo>)r r� r1 r' )r r r r r r �:test_attribute_values_with_double_nested_quotes_get_quoted s �zSHTMLTreeBuilderSmokeTest.test_attribute_values_with_double_nested_quotes_get_quotedc C s | � dd� | � dd� d S )Nz+<this is="really messed up & stuff"></this>z/<this is="really messed up & stuff"></this>z.<a href="http://example.org?a=1&b=2;3">foo</a>z2<a href="http://example.org?a=1&b=2;3">foo</a>r� r r r r �.test_ampersand_in_attribute_value_gets_escaped s ��zGHTMLTreeBuilderSmokeTest.test_ampersand_in_attribute_value_gets_escapedc C r� )Nz/<a href="http://example.org?a=1&b=2;3"></a>r� r r r r �7test_escaped_ampersand_in_attribute_value_is_left_alone r� zPHTMLTreeBuilderSmokeTest.test_escaped_ampersand_in_attribute_value_is_left_alonec C s d}d}| � ||� d S )N�-<p><<sacré bleu!>></p>�# <p><<sacré bleu!>></p>r� )r r �expectedr r r �1test_entities_in_strings_converted_during_parsing s zJHTMLTreeBuilderSmokeTest.test_entities_in_strings_converted_during_parsingc C s" d}| � |�}|jjdksJ �d S )Ns <p>�Foo�</p>u ‘Foo’r� )r �quoter r r r �)test_smart_quotes_converted_on_the_way_in# s zBHTMLTreeBuilderSmokeTest.test_smart_quotes_converted_on_the_way_inc C s | � d�}|jjdks J �d S )Nz<a> </a>u )r rd rL r� r r r �0test_non_breaking_spaces_converted_on_the_way_in* � zIHTMLTreeBuilderSmokeTest.test_non_breaking_spaces_converted_on_the_way_inc C s0 d}d� d�}| �|�}|j� d�|ksJ �d S )Nr! r" r� )r� r r� )r r r# r r r r �&test_entities_converted_on_the_way_out. s z?HTMLTreeBuilderSmokeTest.test_entities_converted_on_the_way_outc C sH d}|� d�}| �|�}|� d�}|�dd�}|� d�}||ks"J �d S )Nu� <html><head><meta content="text/html; charset=ISO-8859-1" http-equiv="Content-type"/></head><body><p>Sacré bleu!</p></body></html>z iso-8859-1r� z ISO-8859-1)r� r r� )r � unicode_html�iso_latin_htmlr �resultr# r r r �test_real_iso_8859_document4 s z4HTMLTreeBuilderSmokeTest.test_real_iso_8859_documentc C sL d}|� d�}| �|�}|�d�|�d�ksJ �|�d�|�d�ks$J �d S )Nsk <html><head></head><body><pre>�����Shift-JIS�ŃR�[�f�B���O���ꂽ���{��̃t�@�C���ł��B</pre></body></html>z shift-jisr� �euc_jp)r' r r� )r �shift_jis_htmlr* r r r r � test_real_shift_jis_documentP s � z5HTMLTreeBuilderSmokeTest.test_real_shift_jis_documentc C sB d}| j |dd�}|jdv sJ �|�d�|�d��d�ks J �d S )Ns� <html><head><title>Hebrew (ISO 8859-8) in Visual Directionality</title></head><body><h1>Hebrew (ISO 8859-8) in Visual Directionality</h1>���</body></html>� iso8859-8)� from_encoding)r1 z iso-8859-8r� )r �original_encodingr� r' )r �hebrew_documentr r r r �test_real_hebrew_documenta s � �z2HTMLTreeBuilderSmokeTest.test_real_hebrew_documentc C s^ d}d| }| � |�}|�dddi�}|d }d|ks J �t|t�s$J �d|�d �ks-J �d S ) NzE<meta content="text/html; charset=x-sjis" http-equiv="Content-type"/>�j<html><head> %s <meta http-equiv="Content-language" content="ja"/></head><body>Shift-JIS markup goes here.r{ z http-equivz Content-typer ztext/html; charset=x-sjisztext/html; charset=utf8r� )r r� r@ r r� )r �meta_tagr/ r � parsed_metar r r r �'test_meta_tag_reflects_current_encodingn s � z@HTMLTreeBuilderSmokeTest.test_meta_tag_reflects_current_encodingc C s\ d}d| }| � |�}|jddd�}|d }d|ks J �t|t�s#J �d|�d�ks,J �d S ) Nz'<meta id="encoding" charset="x-sjis" />r6 r{ �encodingrT �charsetzx-sjisr� )r r� r@ r r� )r r7 r/ r r8 r; r r r �3test_html5_style_meta_tag_reflects_current_encoding� s � zLHTMLTreeBuilderSmokeTest.test_html5_style_meta_tag_reflects_current_encodingc C sT dD ]%}| � |�}tD ]}|dv rq |�|�}d|v s J �|�d�|vs&J �q qd S )N)sB <meta charset="utf8"></head><meta id="encoding" charset="utf-8" />��idna�mbcs�oem� undefined� string_escapez string-escapes meta charset=""�ascii�r r r� �r r r r: �encodedr r r �2test_python_specific_encodings_not_used_in_charset� s ��zKHTMLTreeBuilderSmokeTest.test_python_specific_encodings_not_used_in_charsetc C s* | � d�}d|jd< d|j�� ksJ �d S )Nz <a>text</a>r� r� z<a foo="bar">text</a>)r rd r' )r �datar r r �5test_tag_with_no_attributes_can_have_attributes_added� s zNHTMLTreeBuilderSmokeTest.test_tag_with_no_attributes_can_have_attributes_addedc C s | � d�}d|j�� ksJ �d S )Nz0<body><div><p>text1</p></span>text2</div></body>z)<body><div><p>text1</p>text2</div></body>)r r r' r� r r r �$test_closing_tag_with_no_opening_tag� s z=HTMLTreeBuilderSmokeTest.test_closing_tag_with_no_opening_tagc C � | � t�}| �|� dS �z3Test the worst case (currently) for linking issues.N�r � BAD_DOCUMENTrA r� r r r �test_worst_case� � z(HTMLTreeBuilderSmokeTest.test_worst_caseN)r� )CrW rX rY �__doc__r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r r r r r r r r r r r r$ r& r' r) r- r0 r5 r9 r< rG rI rJ rO r r r r ro 2 s� ro c @ s� e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+S ),�XMLTreeBuilderSmokeTestc C r� r� r� r� r r r r� � r� z9XMLTreeBuilderSmokeTest.test_pickle_and_unpickle_identityc C s | � d�}|�� dks J �d S )N�<root/>s. <?xml version="1.0" encoding="utf-8"?> <root/>r� r� r r r �test_docstring_generated� r( z0XMLTreeBuilderSmokeTest.test_docstring_generatedc C �$ d}| � |�}||�d�ksJ �d S )Ns, <?xml version="1.0" encoding="utf8"?> <foo/>r� r� ri r r r �test_xml_declaration� � z,XMLTreeBuilderSmokeTest.test_xml_declarationc C sN d}| � |�}tD ]}|dv rq |�|�}d|v sJ �|�d�|vs$J �q d S )Ns <?xml version="1.0"?> <foo/>r= s <?xml version="1.0"?>rC rD rE r r r �:test_python_specific_encodings_not_used_in_xml_declaration� s �zRXMLTreeBuilderSmokeTest.test_python_specific_encodings_not_used_in_xml_declarationc C rU )Ns< <?xml version="1.0" encoding="utf8"?> <?PITarget PIContent?>r� r� ri r r r r� � rW z3XMLTreeBuilderSmokeTest.test_processing_instructionc C �$ d}| � |�}|�d�|ksJ �dS )zGA real XHTML document should come out *exactly* the same as it went in.r� r� Nr� ri r r r r� � s z0XMLTreeBuilderSmokeTest.test_real_xhtml_documentc C s" d}| � |�}||�� ksJ �d S )Ns <?xml version="1.0" encoding="utf-8"?> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"> <parent xmlns="http://ns1/"> <child xmlns="http://ns2/" xmlns:ns3="http://ns3/"> <grandchild ns3:attr="value" xmlns="http://ns4/"/> </child> </parent>r� �r �docr r r r �test_nested_namespaces s z.XMLTreeBuilderSmokeTest.test_nested_namespacesc C s. d}t |d�}d|j_|�� }d|v sJ �d S )Nz/ <script type="text/javascript"> </script> zlxml-xmlz console.log("< < hey > > ");s < < hey > >)r r� rL r� )r r[ r rF r r r �5test_formatter_processes_script_tag_for_xml_documents s zMXMLTreeBuilderSmokeTest.test_formatter_processes_script_tag_for_xml_documentsc C r� )Nu? <?xml version="1.0" encoding="euc-jp"><root>Sacré bleu!</root>r �r �rootrL ri r r r r � z7XMLTreeBuilderSmokeTest.test_can_parse_unicode_documentc C r� )NuB <?xml version="1.0" encoding="euc-jp"><root>Sacré bleu!</root>r r^ ri r r r �1test_can_parse_unicode_document_begining_with_bom r` zIXMLTreeBuilderSmokeTest.test_can_parse_unicode_document_begining_with_bomc C �$ d}| � |�}t|j�|ksJ �d S )Nz�<rss xmlns:dc="foo"><dc:creator>b</dc:creator><dc:date>2012-07-02T20:33:42Z</dc:date><dc:rights>c</dc:rights><image>d</image></rss>)r r� �rssri r r r �test_popping_namespaced_tag% rW z3XMLTreeBuilderSmokeTest.test_popping_namespaced_tagc C s | � d�}|�d�dksJ �d S )NrS �latin1s/ <?xml version="1.0" encoding="latin1"?> <root/>r� r� r r r �(test_docstring_includes_correct_encoding* s z@XMLTreeBuilderSmokeTest.test_docstring_includes_correct_encodingc C rY )z<A large XML document should come out the same as it went in.s4 <?xml version="1.0" encoding="utf-8"?> <root>0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000</root>r� Nr� ri r r r �test_large_xml_document. s z/XMLTreeBuilderSmokeTest.test_large_xml_documentc C s | � dd� | � d� d S )Nr� r� z <p>foo</p>r� r r r r �9test_tags_are_empty_element_if_and_only_if_they_are_empty6 s zQXMLTreeBuilderSmokeTest.test_tags_are_empty_element_if_and_only_if_they_are_emptyc C s8 d}| � |�}|j}d|d ksJ �d|d ksJ �d S )Nz�<root xmlns:a="http://example.com/" xmlns:b="http://example.net/"><a:foo>This tag is in the a namespace</a:foo><b:foo>This tag is in the b namespace</b:foo></root>zhttp://example.com/zxmlns:azhttp://example.net/zxmlns:b)r r_ )r r r r_ r r r � test_namespaces_are_preserved: s z5XMLTreeBuilderSmokeTest.test_namespaces_are_preservedc C rb )NzN<p xmlns:dc="http://purl.org/dc/elements/1.1/"><dc:date>20010504</dc:date></p>)r r� r� ri r r r �test_closing_namespaced_tagA rW z3XMLTreeBuilderSmokeTest.test_closing_namespaced_tagc C rb )Nzs<foo xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><bar xsi:schemaLocation="http://www.example.com"/></foo>�r r� r� ri r r r �test_namespaced_attributesF rW z2XMLTreeBuilderSmokeTest.test_namespaced_attributesc C rb )Nz <foo xml:lang="fr">bar</foo>rk ri r r r �(test_namespaced_attributes_xml_namespaceK rW z@XMLTreeBuilderSmokeTest.test_namespaced_attributes_xml_namespacec C sV d}| � |�}dt|�d��ksJ �dt|�d��ks J �dt|�d��ks(J � d S )Na <?xml version="1.0" encoding="utf-8"?> <Document xmlns="http://example.com/ns0" xmlns:ns1="http://example.com/ns1" xmlns:ns2="http://example.com/ns2"> <ns1:tag>foo</ns1:tag> <ns1:tag>bar</ns1:tag> <ns2:tag key="value">baz</ns2:tag> </Document> � rN r� zns1:tagr9 zns2:tag)r r> r� rZ r r r �test_find_by_prefixed_nameP s z2XMLTreeBuilderSmokeTest.test_find_by_prefixed_namec C s2 d}| � |�}|j}t�|�}|j|jksJ �d S )Nzf<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <w:document xmlns:w="http://example.com/ns0"/>)r �documentr� �prefix)r �xmlr rN � duplicater r r �!test_copy_tag_preserves_namespacef s z9XMLTreeBuilderSmokeTest.test_copy_tag_preserves_namespacec C rK rL rM r� r r r rO q rP z'XMLTreeBuilderSmokeTest.test_worst_caseN)rW rX rY r� rT rV rX r� r� r\ r] r ra rd rf rg rh ri rj rl rm ro rt rO r r r r rR � s, rR c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �HTML5TreeBuilderSmokeTestz2Smoke test for a tree builder that supports HTML5.c C s d S r r r r r r r� { s z2HTML5TreeBuilderSmokeTest.test_real_xhtml_documentc C r� )Nz<a>r )r rd � namespaceri r r r � test_html_tags_have_namespace� r` z7HTML5TreeBuilderSmokeTest.test_html_tags_have_namespacec C �6 d}| � |�}d}||jjksJ �||jjksJ �d S )Nz<svg><circle/></svg>r )r �svgrv �circle�r r r rv r r r � test_svg_tags_have_namespace� � z6HTML5TreeBuilderSmokeTest.test_svg_tags_have_namespacec C rx )Nz <math><msqrt>5</msqrt></math>r )r �mathrv �msqrtr{ r r r � test_mathml_tags_have_namespace� r} z9HTML5TreeBuilderSmokeTest.test_mathml_tags_have_namespacec C sN d}| � |�}t|jd t�sJ �|jd dksJ �d|jd jjks%J �d S )Nz3<?xml version="1.0" encoding="utf-8"?><html></html>r z$?xml version="1.0" encoding="utf-8"?r� )r r@ r? r r3 r# ri r r r �$test_xml_declaration_becomes_comment� s z>HTML5TreeBuilderSmokeTest.test_xml_declaration_becomes_commentN) rW rX rY rQ r� rw r| r� r� r r r r ru x s ru )*rQ � __license__r� r� � functoolsr� rk �bs4r � bs4.elementr r r r r r r r r � bs4.builderr r r r � soupsiever �SOUP_SIEVE_PRESENT� ImportError�html5lib�HTML5LIB_PRESENT� lxml.etree�lxml� LXML_PRESENT�etree� LXML_VERSIONrN �objectr r\ ro rR ru r r r r �<module> sX , � � �% < ,PK z�ZK M� � 0 tests/__pycache__/test_formatter.cpython-310.pycnu �[��� o �h4 � @ sH d dl Z d dlmZ d dlmZmZmZ ddlmZ G dd� de�Z dS )� N)�Tag)� Formatter� HTMLFormatter� XMLFormatter� )�SoupTestc @ s\ e Zd Zdd� Zdd� Zdd� Zej�ddd d d d d dde � dfdg �dd� �Z dd� Z dS )� TestFormatterc C s` t � }tdd�}d|d< d|d< ddg|�|�ksJ �d |_g |�|�ks'J �d |jks.J �d S ) N�tag)�namer �b� �a)r r )r r � )r r � attributes�attrs�indent)�self� formatterr � r �K/usr/local/CyberCP/lib/python3.10/site-packages/bs4/tests/test_formatter.py�test_default_attributes s z%TestFormatter.test_default_attributesc C sL G dd� dt �}| �d�}|� }|j|d�}|j|jks J �d|ks$J �d S )Nc @ s e Zd Zdd� ZdS )z=TestFormatter.test_sort_attributes.<locals>.UnsortedFormatterc s s8 � || _ t|j�� �D ]\}}|dkrq ||fV q d S )N�ignore)� called_with�sortedr �items)r r �k�vr r r r $ s � �zHTestFormatter.test_sort_attributes.<locals>.UnsortedFormatter.attributesN)�__name__� __module__� __qualname__r r r r r �UnsortedFormatter# s r z*<p cval="1" aval="2" ignore="ignored"></p>�r z<p aval="2" cval="1"></p>)r �soup�decoder �p)r r r" r �decodedr r r �test_sort_attributes s z"TestFormatter.test_sort_attributesc C s� dD ]}t j| }d|jksJ �qtjd }d|jks J �t jd }d|jks)J �tdd�}d|jks5J �dD ]"}| �|�}dD ]}d|jjd d �ksMJ �d |jjdd �ksXJ �q@q7d S ) N)�html�minimalNF�html5T)� empty_attributes_are_booleans)z<option selected></option>z <option selected=""></option>)r' r( �xmlNs <option selected=""></option>r' r! s <option selected></option>)r �REGISTRYr* r r r" �option�encode)r r r �markupr" r r r �"test_empty_attributes_are_booleans4 s ��z0TestFormatter.test_empty_attributes_are_booleansz indent,expect)N�<a> <b> text </b> </a> )���r1 )r r1 )� r1 )r �<a> <b> text </b> </a> )r z <a> <b> text </b> </a> )� z<a> <b> text </b> </a> )�abcz#<a> abc<b> abcabctext abc</b> </a> r4 )s bytesr4 c C s@ | � d�}t|d�}|j|d�|ksJ �|j|d�|ks J �d S )Nz<a><b>text</b></a>)r r! )r" r �prettifyr. )r r �expectr" r r r r � test_indentP s zTestFormatter.test_indentc C s t � }|jdks J �d S )Nr )r r )r r r r r �test_default_indent_valuen s z'TestFormatter.test_default_indent_valueN) r r r r r& r0 �pytest�mark� parametrize�objectr9 r: r r r r r s( �� r ) r; � bs4.elementr � bs4.formatterr r r r3 r r r r r r �<module> s PK z�Z@S�(8 8 7 tests/__pycache__/test_builder_registry.cpython-310.pycnu �[��� o �h� � @ s� d Z ddlZddlZddlmZ ddlmZmZm Z ddl m Z m Z e r*ddlm Z e r4ddlmZmZ G d d � d e�ZG d d � d e�ZdS ) z Tests of the builder registry.� N)� BeautifulSoup)�builder_registry�HTMLParserTreeBuilder�TreeBuilderRegistry� )�HTML5LIB_PRESENT� LXML_PRESENT)�HTML5TreeBuilder)�LXMLTreeBuilderForXML�LXMLTreeBuilderc @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �TestBuiltInRegistryz@Test the built-in registry with the default builders registered.c C s` t �dd�tks J �tr t �dd�tksJ �t �dd�tks J �tr,t �dd�tks.J �d S d S )N�strict�html�fast� permissive�xml�html5lib)�registry�lookupr r r r r r ��self� r �R/usr/local/CyberCP/lib/python3.10/site-packages/bs4/tests/test_builder_registry.py�test_combination! s �z$TestBuiltInRegistry.test_combinationc C sn t rt�d�tks J �t�d�tksJ �d S t�d�d ks J �tr,t�d�tks*J �d S t�d�tks5J �d S )Nr r )r r r r r r r r r r r r �test_lookup_by_markup_type) s z.TestBuiltInRegistry.test_lookup_by_markup_typec C sX t rt�dd�tks J �t�dd�tksJ �tr!t�d�tks!J �t�d�tks*J �d S )N�lxmlr r r z html.parser)r r r r r r r r r r r r �test_named_library4 s z&TestBuiltInRegistry.test_named_libraryc C s� t jdd��}tddd� tdddgd� W d � n1 s w Y t�t�� tddd� W d � d S 1 s;w Y d S )NT)�record� r )�featuresr zno-such-feature)�warnings�catch_warningsr �pytest�raises� ValueError)r �wr r r �*test_beautifulsoup_constructor_does_lookup= s � "�z>TestBuiltInRegistry.test_beautifulsoup_constructor_does_lookupN)�__name__� __module__� __qualname__�__doc__r r r r& r r r r r s r c @ sX e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dS )� TestRegistryz.Test the TreeBuilderRegistry class in general.c C s t � | _d S �N)r r r r r r � setup_methodQ s zTestRegistry.setup_methodc G s, t dd�|� tfd|i�}| j�|� |S )N�Builder_�_r )�type�join�objectr �register)r � feature_list�clsr r r �builder_for_featuresT s � z!TestRegistry.builder_for_featuresc C s2 | � � }| j�d�d u sJ �| j�� |ksJ �d S )N�foo�r6 r r �r �builderr r r � test_register_with_no_features[ s z+TestRegistry.test_register_with_no_featuresc C s8 | � dd�}| j�d�|u sJ �| j�d�|u sJ �d S �Nr7 �barr8 r9 r r r �0test_register_with_features_makes_lookup_succeedf s z=TestRegistry.test_register_with_features_makes_lookup_succeedc C s$ | � dd�}| j�d�d u sJ �d S �Nr7 r= �bazr8 r9 r r r �4test_lookup_fails_when_no_builder_implements_featurek s zATestRegistry.test_lookup_fails_when_no_builder_implements_featurec C s* | � d�}| � d�}| j�� |ksJ �d S r< r8 �r �builder1�builder2r r r �Ctest_lookup_gets_most_recent_registration_when_no_feature_specifiedo s zPTestRegistry.test_lookup_gets_most_recent_registration_when_no_feature_specifiedc C s | j �� d u s J �d S r, )r r r r r r �2test_lookup_fails_when_no_tree_builders_registeredt s z?TestRegistry.test_lookup_fails_when_no_tree_builders_registeredc C sv | � d�}| � d�}| � ddd�}| � ddd�}| � d�}| � d�}| j�dd�|ks-J �| j�ddd�|ks9J �d S )Nr7 r= r@ �quuxr8 )r �has_one� has_the_other�has_both_early� has_both_late� lacks_oner r r �<test_lookup_gets_most_recent_builder_supporting_all_featuresw s zITestRegistry.test_lookup_gets_most_recent_builder_supporting_all_featuresc C s2 | � dd�}| � dd�}| j�dd�d u sJ �d S r? r8 rB r r r �:test_lookup_fails_when_cannot_reconcile_requested_features� s zGTestRegistry.test_lookup_fails_when_cannot_reconcile_requested_featuresN) r' r( r) r* r- r6 r; r> rA rE rF rM rN r r r r r+ N s r+ )r* r" r �bs4r � bs4.builderr r r r r r r r r r r2 r r+ r r r r �<module> s 0PK z�Z��Q� � 1 tests/__pycache__/test_htmlparser.cpython-310.pycnu �[��� o �hp � @ sn d Z ddlmZ ddlZddlZddlZddlmZmZm Z ddl m Z ddl m Z mZ G dd � d e e�ZdS ) zGTests to ensure that the html.parser tree builder generates good trees.� )� set_traceN)�HTMLParserTreeBuilder�ParserRejectedMarkup�XMLParsedAsHTMLWarning)�BeautifulSoupHTMLParser� )�SoupTest�HTMLTreeBuilderSmokeTestc @ sX e Zd ZeZdd� Zdd� Zdd� Zdd� Zd d � Z d d � Z d d� Z dd� Z dd� Z dS )�TestHTMLParserTreeBuilderc C sJ g d�}|D ] }t �t�� | �|�}W d � n1 s w Y qd S )N)s <![���� s <![n s <![UNKNOWN[]]>)�pytest�raisesr �soup)�self� bad_markup�markupr � r �L/usr/local/CyberCP/lib/python3.10/site-packages/bs4/tests/test_htmlparser.py�test_rejected_input s ���z-TestHTMLParserTreeBuilder.test_rejected_inputc C � d S �Nr �r r r r � test_namespaced_system_doctype* � z8TestHTMLParserTreeBuilder.test_namespaced_system_doctypec C r r r r r r r � test_namespaced_public_doctype. r z8TestHTMLParserTreeBuilder.test_namespaced_public_doctypec C s: | � d�}t�|d�}t�|�}t|jt|j��sJ �dS )zfUnlike most tree builders, HTMLParserTreeBuilder and will be restored after pickling. z <a><b>foo</a>� N)r �pickle�dumps�loads� isinstance�builder�type)r �tree�dumped�loadedr r r �test_builder_is_pickled2 s z1TestHTMLParserTreeBuilder.test_builder_is_pickledc C s | � dd� | � dd� d S )Nz<br></br><br></br><br></br>z<br/><br/><br/>z</br></br></br>� �� assert_soupr r r r �)test_redundant_empty_element_closing_tags; s zCTestHTMLParserTreeBuilder.test_redundant_empty_element_closing_tagsc C s | � dd� d S )Nz foo &# barzfoo &# barr& r r r r �test_empty_element? s z,TestHTMLParserTreeBuilder.test_empty_elementc C sz d}| � |�}d|jjksJ �d|jjksJ �d|j�d�jks"J �| j |dd�}d|jjjks2J �d|jjjks;J �d S )Nz= <p> <sourceline> <b>text</b></sourceline><sourcepos></p>r � � sourcelineF)�store_line_numbers� sourcepos)r �pr+ r- �find�name)r r r r r r �test_tracking_line_numbersD s z4TestHTMLParserTreeBuilder.test_tracking_line_numbersc s� d� �� � �}d|jd ksJ �dg|jd ksJ �d|jd ks#J �� �fdd�}|d d� |tjd� |tjd � d d � }||g d �� d S ) Nz;<a class="cls" href="url1" href="url2" href="url3" id="id">�url3�href�cls�class�idc sJ �j � | d�}||jd ksJ �dg|jd ksJ �d|jd ks#J �d S )N)�on_duplicate_attributer3 r4 r5 r6 )r �a)r7 �expectedr �r r r r �assert_attribute` s �zOTestHTMLParserTreeBuilder.test_on_duplicate_attribute.<locals>.assert_attribute�url1c S s. t | | t�s| | g| |< | | �|� d S r )r �list�append)�attrs�key�valuer r r � accumulatep s zITestHTMLParserTreeBuilder.test_on_duplicate_attribute.<locals>.accumulate)r< �url2r2 )r r8 r �REPLACE�IGNORE)r r r; rB r r: r �test_on_duplicate_attributeR s z5TestHTMLParserTreeBuilder.test_on_duplicate_attributec C sj dD ]0\}}}d| }| � |�j}|�� }d|�d� }||ks"J �|jdd�}d| }||ks2J �qd S )N))z⇄u ⇄s ⇄)z⊧u ⊧s ⊧)z𝔑u 𝔑s 𝔑)z≧̸u ≧̸s ≧̸)z¬� ¬s ¬)z⫬u ⫬s ⫬)z"�"� ")z∴� ∴� ∴)z ∴rJ rK )z ∴rJ rK )zfj�fjs fj)z⊔u ⊔s ⊔)z⊔︀u ⊔︀s ⊔︀)z'�'� ')z|�|� |z <div>%s</div>s <div>%s</div>�utf8�html)� formatter)r �div�encode) r � input_element�output_unicode�output_elementr rT �without_element�expect� with_elementr r r �test_html5_attributesv s �z/TestHTMLParserTreeBuilder.test_html5_attributesN)�__name__� __module__� __qualname__r �default_builderr r r r$ r( r) r1 rF r\ r r r r r s $r )�__doc__�pdbr r r �warnings� bs4.builderr r r �bs4.builder._htmlparserr r% r r r r r r r �<module> s PK z�Zz����� �� + tests/__pycache__/test_tree.cpython-310.pycnu �[��� o �h� � @ s� d Z ddlmZ ddlZddlZddlZddlmZ ddlm Z m Z ddl m Z m Z mZmZmZmZmZmZmZmZmZ ddlmZ G d d � d e�ZG d d � d e�ZG d d� de�ZG dd� de�Z G dd� de�Z G dd� de�Z G dd� de�Z G dd� de�Z G dd� de�Z!G dd � 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'd(� d(e�Z(dS ))a8 Tests for Beautiful Soup's tree traversal methods. The tree traversal methods are the main advantage of using Beautiful Soup over just using a parser. Different parsers will build different Beautiful Soup trees given the same markup, but all Beautiful Soup trees can be traversed with the methods tested here. � )� set_traceN)� BeautifulSoup)�builder_registry�HTMLParserTreeBuilder) �CData�Comment� Declaration�Doctype� Formatter�NavigableString�Script� SoupStrainer� Stylesheet�Tag�TemplateString� )�SoupTestc @ �8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �TestFindz�Basic tests of the find() method. find() just calls find_all() with limit=1, so it's not tested all that thouroughly here. c C s" | � d�}|�d�jdksJ �d S )Nz <a>1</a><b>2</b><a>3</a><b>4</b>�b�2)�soup�find�string��selfr � r �F/usr/local/CyberCP/lib/python3.10/site-packages/bs4/tests/test_tree.py� test_find_tag- � zTestFind.test_find_tagc C s" | � d�}|jdd�dksJ �d S )Nu <h1>Räksmörgås</h1>� Räksmörgås�r )r r r r r r �test_unicode_text_find1 r z TestFind.test_unicode_text_findc C s, | � d�}t|� d|jdd�jksJ �d S )Nu& <h1 id="Räksmörgås">here it is</h1>z here it isr ��id)r �strr �textr r r r �test_unicode_attribute_find5 s z$TestFind.test_unicode_attribute_findc C s" | � d�}dt|�� �ksJ �dS )z)Test an optimization that finds all tags.�<a>foo</a><b>bar</b>� N�r �len�find_allr r r r �test_find_everything; s z TestFind.test_find_everythingc C s$ | � d�}dt|�d��ksJ �dS )z;Test an optimization that finds all tags with a given name.z <a>foo</a><b>bar</b><a>baz</a>r) �aNr* r r r r � test_find_everything_with_name@ s z'TestFind.test_find_everything_with_nameN) �__name__� __module__� __qualname__�__doc__r r" r' r- r/ r r r r r & s r c @ r ) � TestFindAllz%Basic tests of the find_all() method.c C sv | � d�}|jdd�dgksJ �|jddgd�ddgks J �|jt�d�d�g d�ks-J �|jdd�g d�ks9J �dS ) z'You can search the tree for text nodes.u <html>Foo<b>bar</b>»</html>�barr! �Fooz.*)r6 r5 � »TN)r r, �re�compiler r r r �test_find_all_text_nodesH s z$TestFindAll.test_find_all_text_nodesc C st | � d�}| �|jddd�g d�� | �|jddd�dg� | �|jddd�g d �� | �|jdd d�g d �� d S ) z7You can limit the number of items returned by find_all.z(<a>1</a><a>2</a><a>3</a><a>4</a><a>5</a>r. � ��limit)�1r �3r r> � )r> r r? �4�5r N�r �assert_selectsr, r r r r �test_find_all_limitV s ��z TestFindAll.test_find_all_limitc C s: | � d�}| �|ddd�dg� | �|jdd�dg� d S ) Nz!<a>1</a><b>2<a id='foo'>3</a></b>r. r r< r> �foor# r? )r rD r r r r r �%test_calling_a_tag_is_calling_findallb s z1TestFindAll.test_calling_a_tag_is_calling_findallc C s. | � d�}g }|�|� g |�|�ksJ �d S )N�<a></a>)r �appendr, )r r �lr r r �Ttest_find_all_with_self_referential_data_structure_does_not_cause_infinite_recursiong s z`TestFindAll.test_find_all_with_self_referential_data_structure_does_not_cause_infinite_recursionc C sX | � d�}|�d�}t|d�sJ �|�d�}t|d�s J �|jdd�}t|d�s*J �dS )z%All find_all calls return a ResultSetrH r. �sourceTrF r! N)r r, �hasattr)r r �resultr r r �test_find_all_resultsetq s z#TestFindAll.test_find_all_resultsetN) r0 r1 r2 r3 r: rE rG rK rO r r r r r4 E s r4 c @ � e Zd Zdd� ZdS )�TestFindAllBasicNamespacesc C s< | � d�}d|�d�jksJ �d|jddid�jks J �d S )Nz0<mathml:msqrt>4</mathml:msqrt><a svg:fill="red">rA z mathml:msqrtr. zsvg:fill�red��attrs)r r r �namer r r r � test_find_by_namespaced_name� s z7TestFindAllBasicNamespaces.test_find_by_namespaced_nameN)r0 r1 r2 rV r r r r rQ ~ � rQ c @ sh e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� ZdS )�TestFindAllByNamez&Test ways of finding tags by tag name.c C � | � d�| _d S )Nz�<a>First tag.</a> <b>Second tag.</b> <c>Third <a>Nested tag.</a> tag.</c>�r �tree�r r r r � setup_method� � z TestFindAllByName.setup_methodc C s | � | j�d�ddg� d S �Nr. � First tag.� Nested tag.�rD r[ r, r\ r r r �test_find_all_by_tag_name� s �z+TestFindAllByName.test_find_all_by_tag_namec C s\ | � | jjddd�dg� | � | jjddd�ddg� | � | jjdt�d�d�ddg� d S )Nr. r` r! Tra �tag�rD r[ r, r8 r9 r\ r r r � test_find_all_by_name_and_text� s ���z0TestFindAllByName.test_find_all_by_name_and_textc C s | � | jj�d�dg� d S )Nr. ra )rD r[ �cr, r\ r r r �!test_find_all_on_non_root_element� s z3TestFindAllByName.test_find_all_on_non_root_elementc C s | � | �d�ddg� d S r_ )rD r[ r\ r r r �%test_calling_element_invokes_find_all� s z7TestFindAllByName.test_calling_element_invokes_find_allc C s | � | j�td��ddg� d S r_ )rD r[ r, r r\ r r r � test_find_all_by_tag_strainer� � �z/TestFindAllByName.test_find_all_by_tag_strainerc C s | � | j�ddg�g d�� d S )Nr. r �r` z Second tag.ra rb r\ r r r �test_find_all_by_tag_names� rk z,TestFindAllByName.test_find_all_by_tag_namesc C s" | � | j�ddd��g d�� d S )NT)r. r rl rb r\ r r r �test_find_all_by_tag_dict� � �z+TestFindAllByName.test_find_all_by_tag_dictc C s" | � | j�t�d��g d�� d S )Nz^[ab]$rl re r\ r r r �test_find_all_by_tag_re� ro z)TestFindAllByName.test_find_all_by_tag_rec C s, dd� }| � d�}| �|�|�ddg� d S )Nc S s | j | �d�kS �Nr$ )rU �get�rd r r r �id_matches_name� r^ zRTestFindAllByName.test_find_all_with_tags_matching_method.<locals>.id_matches_namez�<a id="a">Match 1.</a> <a id="1">Does not match.</a> <b id="b">Match 2.</a>zMatch 1.zMatch 2.rC )r rt r[ r r r �'test_find_all_with_tags_matching_method� s �z9TestFindAllByName.test_find_all_with_tags_matching_methodc C sx | � d�}|�dd�}|�dt�d��}|�dddg�\}}d|jks%J �d|jks,J �d|jks3J �d|jks:J �d S )NzH<div class='a b'>1</div><div class='a c'>2</div><div class='a d'>3</div>�divza dza br? r> )r r r8 r9 r, r )r r �r1�r2�r3�r4r r r �%test_find_with_multi_valued_attribute� s � z7TestFindAllByName.test_find_with_multi_valued_attributeN)r0 r1 r2 r3 r] rc rf rh ri rj rm rn rp ru r{ r r r r rX � s rX c @ s� e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd � Zd d � Zd d � Zd!S )"�TestFindAllByAttributec C �& | � d�}| �|jdd�ddg� d S )Nz� <a id="first">Matching a.</a> <a id="second"> Non-matching <b id="first">Matching b.</b>a. </a>�firstr# z Matching a.z Matching b.rC �r r[ r r r � test_find_all_by_attribute_name� s �z6TestFindAllByAttribute.test_find_all_by_attribute_namec C st d� d�}d� d�}| �|�}|jg|j|d�ksJ �|jg|j|�d�d�ks*J �|jgs8J |j|dgd���d S )Nu םולש�utf8u <a title="םולש"></a>)�titlezsomething else)�encoder r. r, �decode)r �peace�datar r r r �%test_find_all_by_utf8_attribute_value� s z<TestFindAllByAttribute.test_find_all_by_utf8_attribute_valuec C sX | � d�}| �|jdd�dg� | �|jddid�dg� | �|jdd id�d g� d S ) Na0 <a name="name1" class="class1">Name match.</a> <a name="name2" class="class2">Class match.</a> <a name="name3" class="class3">Non-match.</a> <name1>A tag called 'name1'.</name1> �name1�rU zA tag called 'name1'.rU rS z Name match.�class�class2z Class match.rC r r r r � test_find_all_by_attribute_dict� s ���z6TestFindAllByAttribute.test_find_all_by_attribute_dictc C s� | � d�}| �|jddd�dg� | �|jddd�dg� | �|jdd d�dg� | �|�dd�dg� | �|jdd �ddg� | �|�dd�dg� | �|�dd �dg� d S ) Nz� <a class="1">Class 1.</a> <a class="2">Class 2.</a> <b class="1">Class 1.</b> <c class="3 4">Class 3 and 4.</c> r. r> ��class_zClass 1.rg r? zClass 3 and 4.rA rS rC r r r r �test_find_all_by_class� s z-TestFindAllByAttribute.test_find_all_by_classc C st | � d�}|jdt�d�d�}| �|dg� |jdt�d�d�}| �|dg� |jdt�d�d�}| �|dg� d S )Nz#<gar class='foo bar'>Found it</gar>�gar�or� �Found itr. zo b)r r, r8 r9 rD )r r[ �fr r r �0test_find_by_class_when_multiple_classes_present s zGTestFindAllByAttribute.test_find_by_class_when_multiple_classes_presentc C sd | � d�}| �|�dt�d��dg� dd� }| �|�d|�g � dd� }| �|�d|�dg� d S ) Nz<a class='bar'>Found it</a>r. �bar� c S s t | �dkS �Nr; �r+ ��valuer r r �big_attribute_value% � znTestFindAllByAttribute.test_find_all_with_non_dictionary_for_attrs_finds_by_class.<locals>.big_attribute_valuec S s t | �dkS r� r� r� r r r �small_attribute_value* r� zpTestFindAllByAttribute.test_find_all_with_non_dictionary_for_attrs_finds_by_class.<locals>.small_attribute_value�r rD r, r8 r9 )r r r� r� r r r �:test_find_all_with_non_dictionary_for_attrs_finds_by_class s �zQTestFindAllByAttribute.test_find_all_with_non_dictionary_for_attrs_finds_by_classc C s� | � d�}|�d�\}}||gsJ |�dd���|gs#J |�dd���|g|jddd�ks/J �|g|�dd�ks:J �g |�dd�ksDJ �d S )Nz*<a class="foo bar"></a><a class="foo"></a>r. rF r5 zfoo barr� zbar foo�r r, )r r r. �a2r r r �:test_find_all_with_string_for_attrs_finds_multiple_classes0 s zQTestFindAllByAttribute.test_find_all_with_string_for_attrs_finds_multiple_classesc C s0 | � d�}tddid�}| �|�|�dg� d S )Nzi <a id="first">Match.</a> <a id="second">Non-match.</a>r$ r~ rS zMatch.)r r rD r, )r r[ �strainerr r r �'test_find_all_by_attribute_soupstrainer< s z>TestFindAllByAttribute.test_find_all_by_attribute_soupstrainerc C s& | � d�}| �|jdd d�dg� d S )N��<a id="1">ID present.</a> <a>No ID present.</a> <a id="">ID is empty.</a>r. r# zNo ID present.rC r r r r �$test_find_all_with_missing_attributeD s z;TestFindAllByAttribute.test_find_all_with_missing_attributec C r} )Nr� Tr# z ID present.z ID is empty.rC r r r r �$test_find_all_with_defined_attributeL s �z;TestFindAllByAttribute.test_find_all_with_defined_attributec C s> | � d�}ddg}| �|jdd�|� | �|jdd�|� d S )Nz[<a id=1>Unquoted attribute.</a> <a id="1">Quoted attribute.</a>zUnquoted attribute.zQuoted attribute.r r# r> rC )r r[ �expectedr r r �$test_find_all_with_numeric_attributeU s z;TestFindAllByAttribute.test_find_all_with_numeric_attributec C s* | � d�}| �|jg d�d�ddg� d S )Nz�<a id="1">1</a> <a id="2">2</a> <a id="3">3</a> <a>No ID.</a>)r> r? rA r# r> r? rC r r r r �(test_find_all_with_list_attribute_values^ s �z?TestFindAllByAttribute.test_find_all_with_list_attribute_valuesc C s, | � d�}| �|jt�d�d�ddg� d S )Nz�<a id="a">One a.</a> <a id="aa">Two as.</a> <a id="ab">Mixed as and bs.</a> <a id="b">One b.</a> <a>No ID.</a>z^a+$r# zOne a.zTwo as.r� r r r r �5test_find_all_with_regular_expression_attribute_valueh s �zLTestFindAllByAttribute.test_find_all_with_regular_expression_attribute_valuec C sB | � d�}|j}|g|jddd�ksJ �g |jddd�ks J �d S )Nz <b>foo</b><b>bar</b><a>foo</a>r. rF r! r5 �r r. r, �r r r. r r r �'test_find_by_name_and_containing_stringu � z>TestFindAllByAttribute.test_find_by_name_and_containing_stringc C s* | � d�}|�d�|jddd�ksJ �d S )Nz"<a>foo</a><a><b><c>foo</c></b></a>r. rF r! r� r r r r �=test_find_by_name_and_containing_string_when_string_is_buried| s zTTestFindAllByAttribute.test_find_by_name_and_containing_string_when_string_is_buriedc C sB | � d�}|j}|g|jddd�ksJ �g |jddd�ks J �d S )Nz"<b id="1">foo</b><a id="2">foo</a>r) rF )r$ r r r5 r� r� r r r �,test_find_by_attribute_and_containing_string� r� zCTestFindAllByAttribute.test_find_by_attribute_and_containing_stringN)r0 r1 r2 r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r| � s" r| c @ � e Zd ZdZdd� ZdS )� TestSmoothzTest Tag.smooth.c C s | � d�}|j}|�d� |�d� |�td�� |�td�� |�d� | �� }t||d�}|�d� |�d � |�|� d |jjksFJ �d t|j �ksOJ �|� � d t|j �ks\J �d |j d kseJ �d|jjksmJ �d|j d ksvJ �d|j d ksJ �d S )Nz <div>a</div>r rg z Comment 1z Comment 2�d�spanr> r � � �abcr �12r r) ) r rv rI r �default_builderr r� r r+ �contents�smooth)r r rv �builderr� r r r � test_smooth� s( zTestSmooth.test_smoothN)r0 r1 r2 r3 r� r r r r r� � s r� c @ r� )� TestIndexzTest Tag.indexc C sp | � d�}|j}t|j�D ] \}}||�|�ksJ �q t�t�� |�d� W d � d S 1 s1w Y d S )Nah <div> <a>Identical</a> <b>Not identical</b> <a>Identical</a> <c><d>Identical with child</d></c> <b>Also not identical</b> <c><d>Identical with child</d></c> </div>r )r rv � enumerater� �index�pytest�raises� ValueError)r r[ rv �i�elementr r r � test_index� s "�zTestIndex.test_indexN)r0 r1 r2 r3 r� r r r r r� � s r� c @ sX e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dS )�TestParentOperationsz;Test navigation and searching through an element's parents.c C s | � d�| _| jj| _d S )Na1 <ul id="empty"></ul> <ul id="top"> <ul id="middle"> <ul id="bottom"> <b>Start here</b> </ul> </ul>)r r[ r �startr\ r r r r] � s z!TestParentOperations.setup_methodc C sF | j jd dks J �| j jjd dksJ �| j jjjd dks!J �d S )Nr$ �bottom�middle�top)r� �parentr\ r r r � test_parent� s z TestParentOperations.test_parentc C s | j jd }|j| j ksJ �d S )Nr )r[ r� r� )r �top_tagr r r �%test_parent_of_top_tag_is_soup_object� s z:TestParentOperations.test_parent_of_top_tag_is_soup_objectc C s d | j jksJ �d S �N)r[ r� r\ r r r � test_soup_object_has_no_parent� � z3TestParentOperations.test_soup_object_has_no_parentc C s6 | � | j�d�g d�� | � | jjddd�dg� d S )N�ul)r� r� r� r� r# )�assert_selects_idsr� � find_parentsr\ r r r �test_find_parents� s ��z&TestParentOperations.test_find_parentsc C s8 | j �d�d dks J �| j jddd�d dksJ �d S )Nr� r$ r� r� r# )r� � find_parentr\ r r r �test_find_parent� s z%TestParentOperations.test_find_parentc C s" | j jdd�}|jjdksJ �d S )N� Start herer! r )r[ r r� rU �r r& r r r �test_parent_of_text_element� � z0TestParentOperations.test_parent_of_text_elementc C s( | j jdd�}|�d�d dksJ �d S )Nr� r! r� r$ r� )r[ r r� r� r r r � test_text_element_find_parent� s z2TestParentOperations.test_text_element_find_parentc C s* dd� | j jD �}|sJ dddkg��d S )Nc S s& g | ]}|d urd|j v r|d �qS rq rS )�.0r� r r r � <listcomp>� s �z>TestParentOperations.test_parent_generator.<locals>.<listcomp>r� r� r� )r� �parents)r r� r r r �test_parent_generator� s z*TestParentOperations.test_parent_generatorN) r0 r1 r2 r3 r] r� r� r� r� r� r� r� r� r r r r r� � s r� c @ rP )� ProximityTestc C rY )Nzg<html id="start"><head></head><body><b id="1">One</b><b id="2">Two</b><b id="3">Three</b></body></html>rZ r\ r r r r] � s �zProximityTest.setup_methodN�r0 r1 r2 r] r r r r r� � rW r� c �T e Zd Z� fdd�Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z � Z S )�TestNextOperationsc s t t| ��� | jj| _d S r� )�superr� r] r[ r r� r\ �� __class__r r r] s z TestNextOperations.setup_methodc C s* | j jdksJ �| j jjd dksJ �d S )N�Oner$ r )r� � next_elementr\ r r r � test_next s z TestNextOperations.test_nextc C s | j jdd�}|jd ksJ �d S �N�Threer! )r[ r r� )r �lastr r r � test_next_of_last_item_is_none s z1TestNextOperations.test_next_of_last_item_is_nonec C � | j jd ksJ �d S r� )r[ r� r\ r r r �test_next_of_root_is_none � z,TestNextOperations.test_next_of_root_is_nonec C sB | � | j�d�ddg� | jjdd� | � | jjdd�dg� d S )Nr �Twor� r; r# )rD r� � find_all_nextr\ r r r �test_find_all_next s z%TestNextOperations.test_find_all_nextc C �2 | j �d�d dks J �| j jdd�dksJ �d S )Nr r$ r r� r! )r� � find_nextr\ r r r �test_find_next � z!TestNextOperations.test_find_nextc C s< | j jdd�}|�d�jdksJ �| �|�d�ddg� d S )Nr� r! r r� r� )r[ r r� r rD r� r� r r r � test_find_next_for_text_element s z2TestNextOperations.test_find_next_for_text_elementc C sF | j jdd�}dd� |jD �}|\}}|d dksJ �|dks!J �d S )Nr� r! c S � g | ]}|�qS r r �r� �noder r r r� " � z:TestNextOperations.test_next_generator.<locals>.<listcomp>r$ r? r� )r[ r � next_elements)r r� � successorsrd r� r r r �test_next_generator s z&TestNextOperations.test_next_generator) r0 r1 r2 r] r� r� r� r� r� r� r � __classcell__r r r� r r� s r� c r� )�TestPreviousOperationsc �" t t| ��� | jjdd�| _d S r� )r� r r] r[ r �endr\ r� r r r] * r� z#TestPreviousOperations.setup_methodc C s* | j jd dks J �| j jjdksJ �d S )Nr$ r? r� )r �previous_elementr\ r r r � test_previous. s z$TestPreviousOperations.test_previousc C s | j �d�}|jd ks J �d S )N�html)r[ r r )r r~ r r r �#test_previous_of_first_item_is_none2 s z:TestPreviousOperations.test_previous_of_first_item_is_nonec C r� r� )r[ r r\ r r r � test_previous_of_root_is_none6 r� z4TestPreviousOperations.test_previous_of_root_is_nonec C s4 | � | j�d�g d�� | � | jjdd�dg� d S )Nr �r� r� r� r r# r� )rD r �find_all_previousr\ r r r �test_find_all_previous: s � z-TestPreviousOperations.test_find_all_previousc C r� )Nr r$ r? r� r! )r � find_previousr\ r r r �test_find_previousB r� z)TestPreviousOperations.test_find_previousc C s< | j jdd�}|�d�jdksJ �| �|�d�g d�� d S )Nr� r! r r )r[ r r r rD r r� r r r �#test_find_previous_for_text_elementF s �z:TestPreviousOperations.test_find_previous_for_text_elementc C sh | j jdd�}dd� |jD �}|\}}}}|d dks J �|jdks$J �|jdks+J �|jd ks2J �d S ) Nr� r! c S r� r r r� r r r r� N r� zBTestPreviousOperations.test_previous_generator.<locals>.<listcomp>r$ r> �body�headr )r[ r �previous_elementsrU )r r� � predecessorsr r r r r r r �test_previous_generatorL s z.TestPreviousOperations.test_previous_generator) r0 r1 r2 r] r r r r r r r r r r r� r r ( s r c @ rP )� SiblingTestc C s& d}t �d��d|�}| �|�| _d S )Na� <html> <span id="1"> <span id="1.1"></span> </span> <span id="2"> <span id="2.1"></span> </span> <span id="3"> <span id="3.1"></span> </span> <span id="4"></span> </html>z\n\s*� )r8 r9 �subr r[ )r �markupr r r r] [ s zSiblingTest.setup_methodNr� r r r r r Y rW r c �L e Zd Z� fdd�Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z � Z S )�TestNextSiblingc r )Nr> r# )r� r r] r[ r r� r\ r� r r r] p r� z TestNextSibling.setup_methodc C r� r� )r[ � next_siblingr\ r r r �!test_next_sibling_of_root_is_nonet r� z1TestNextSibling.test_next_sibling_of_root_is_nonec C �B | j jd dks J �| j jjd dksJ �| j jd dks J �d S )Nr$ r r? �1.1)r� r r� r\ r r r �test_next_siblingw � z!TestNextSibling.test_next_siblingc C �N | j jjd ks J �| j jdd�}|jd ksJ �| j jdd�}|jd ks%J �d S )Nr r# rA )r[ r r r )r � nested_span� last_spanr r r � test_next_sibling_may_not_exist~ � z/TestNextSibling.test_next_sibling_may_not_existc C � | j �d�d dks J �d S )Nr� r$ r )r� �find_next_siblingr\ r r r �test_find_next_sibling� � z&TestNextSibling.test_find_next_siblingc C �4 | � | j�d�g d�� | � | jjdd�dg� d S )Nr� )r r? rA r? r# )r� r� �find_next_siblingsr\ r r r �test_next_siblings� � � z"TestNextSibling.test_next_siblingsc C �v | � d�}|jdd�}|jjdksJ �|jjdksJ �| �|�d�dg� |jdd�dks/J �|jdd�d ks9J �d S )N�Foo<b>bar</b>bazr6 r! r �bazr5 �nonesuch)r r r rU rD r, r( �r r r� r r r �"test_next_sibling_for_text_element� � z2TestNextSibling.test_next_sibling_for_text_element) r0 r1 r2 r] r r r% r) r- r4 r r r r� r r n � r c r )�TestPreviousSiblingc r )NrA r# )r� r7 r] r[ r r r\ r� r r r] � r� z TestPreviousSibling.setup_methodc C r� r� )r[ �previous_siblingr\ r r r �%test_previous_sibling_of_root_is_none� r� z9TestPreviousSibling.test_previous_sibling_of_root_is_nonec C r )Nr$ r? r z3.1)r r8 r r\ r r r �test_previous_sibling� r! z)TestPreviousSibling.test_previous_siblingc C r" )Nr r# r> )r[ r r8 r )r r# � first_spanr r r �#test_previous_sibling_may_not_exist� r& z7TestPreviousSibling.test_previous_sibling_may_not_existc C r' )Nr� r$ r? )r �find_previous_siblingr\ r r r �test_find_previous_sibling� r* z.TestPreviousSibling.test_find_previous_siblingc C r+ )Nr� )r? r r> r> r# )r� r �find_previous_siblingsr\ r r r �test_previous_siblings� r. z*TestPreviousSibling.test_previous_siblingsc C r/ )Nr0 r1 r! r r6 r5 r2 )r r r8 rU rD r? r= r3 r r r �&test_previous_sibling_for_text_element� r5 z:TestPreviousSibling.test_previous_sibling_for_text_element) r0 r1 r2 r] r9 r: r< r> r@ rA r r r r� r r7 � r6 r7 c @ s� e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zej�d#d$d%� d&d%� g�d'd(� �Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Z d3d4� Z d5d6� Z d7d8� Z d9d:� Z d;d<� Z!d=d>� Z"d?d@� Z#dAdB� Z$dCdD� Z%dEdF� Z&dGdH� Z'dIdJ� Z(dKdL� Z)dMdN� Z*dOdP� Z+dQdR� Z,dSdT� Z-dUdV� Z.dWdX� Z/dYdZ� Z0d[d\� Z1d]d^� Z2d_S )`�TestTreeModificationc C sl | � d�}d|jd< |�� | �d�ksJ �|jd= |�� | �d�ks$J �d|jd< |�� | �d�ks4J �d S ) Nz<a id="1"></a>r) r$ z<a id="2"></a>rH rF �id2z<a id2="foo"></a>)r r. r� � document_forr r r r �test_attribute_modification� s z0TestTreeModification.test_attribute_modificationc C sl t �d�� }| jd|d�}t||d�}t||d�}d|d< |j�d|� |j�d |� |j�� d ks4J �d S ) Nr z <body></body>�r� r. �olzhttp://foo.com/�hrefr r s4 <body><a href="http://foo.com/"></a><ol></ol></body>)r �lookupr r r �insertr� )r r� r r. rG r r r �test_new_tag_creation� s z*TestTreeModification.test_new_tag_creationc C s\ d}| � |�}|jdd�}|j}|jdd��|j� |j|ks!J �|�� | �d�ks,J �d S )NzT<p id="1">Don't leave me <b>here</b>.</p> <p id="2">Don't leave!</p>r r# zD<p id="1">Don't leave me .</p> <p id="2">Don't leave!<b>here</b></p>)r r r rI r� r� rD )r �docr � second_para�boldr r r �!test_append_to_contents_moves_tag� s �z6TestTreeModification.test_append_to_contents_moves_tagc C s0 d}| � |�}|j}|�|j�}||ksJ �d S )Nz<a></a><b><c></c></b>)r r. � replace_withrg �r r& r r. �new_ar r r �1test_replace_with_returns_thing_that_was_replaced� s zFTestTreeModification.test_replace_with_returns_thing_that_was_replacedc C s, d}| � |�}|j}|�� }||ksJ �d S )N�<a><b></b><c></c></a>)r r. �unwraprQ r r r �+test_unwrap_returns_thing_that_was_replaced� s z@TestTreeModification.test_unwrap_returns_thing_that_was_replacedc C s� | � d�}|j}|�� d |jksJ �t�t�� |�� W d � n1 s'w Y t�t�� |�|j � W d � d S 1 sCw Y d S )Nz<a><b>Foo</b></a><c>Bar</c>) r r. �extractr� r� r� r� rU rP rg r� r r r �Itest_replace_with_and_unwrap_give_useful_exception_when_tag_has_no_parent� s � "�z^TestTreeModification.test_replace_with_and_unwrap_give_useful_exception_when_tag_has_no_parentc C s: d}| � |�}|j}|j�|� |�� | �|�ksJ �d S )Nz-<a><b></b><c>Foo<d></d></c></a><a><e></e></a>)r rg rP r� rD )r r& r rg r r r � test_replace_tag_with_itself s z1TestTreeModification.test_replace_tag_with_itselfc C sL d}| � |�}t�t�� |j�|j� W d � d S 1 s w Y d S �N�<a><b></b></a>)r r� r� r� r rP r. �r r& r r r r �1test_replace_tag_with_its_parent_raises_exception s "�zFTestTreeModification.test_replace_tag_with_its_parent_raises_exceptionc C sN d}| � |�}t�t�� |j�d|j� W d � d S 1 s w Y d S )Nr[ r )r r� r� r� r. rJ r\ r r r �,test_insert_tag_into_itself_raises_exception s "�zATestTreeModification.test_insert_tag_into_itself_raises_exceptionc C s� | � d�}d}| � |�}|�d|� |jD ] }t|t�r J �qt|j�\}}}}d|jks/J �d|jks6J �d|jks=J �d|jksDJ �dS ) z�Inserting one BeautifulSoup object into another actually inserts all of its children -- you'll never combine BeautifulSoup objects. z-<p>And now, a word:</p><p>And we're back.</p>z<p>p2</p><p>p3</p>r zAnd now, a word:�p2�p3zAnd we're back.N)r rJ � descendants� isinstancer �list�childrenr ) r r r& � to_insertr� �p1r_ r` �p4r r r �1test_insert_beautifulsoup_object_inserts_children s zFTestTreeModification.test_insert_beautifulsoup_object_inserts_childrenc C sX | � d�}|j}|jd }|�dd� |j\}}|�d� |�d� d|jjks*J �d S )Nz <p><a>one</a><b>three</b></p>r r �twor �three)r r. r� rJ � replaceWithr r )r r r. r �left�rightr r r �3test_replace_with_maintains_next_element_throughout. s zHTestTreeModification.test_replace_with_maintains_next_element_throughoutc C sl | � d�}|jdd��d� |jdd�}|j}|j|ks J �|j|ks%J �|jj|ks-J �|jd ks4J �d S )Nz <b>Argh!</b>�Argh!r! �Hooray!)r r rP r r r� r� )r r �new_textr r r r �test_replace_final_node= s z,TestTreeModification.test_replace_final_nodec C s� | � d�}|j�dd� |�� | �d�ksJ �|jdd�}|jdks$J �|jj|ks,J �|jdks3J �|jj |ks;J �|j d ksBJ �|j|j ksJJ �d S )Nz<a><b>Argh!</b><c></c></a>r rp z!<a><b>Argh!Hooray!</b><c></c></a>r! ro ) r r rJ r� rD r r r� r8 r rg )r r rq r r r �test_consecutive_text_nodesG s � z0TestTreeModification.test_consecutive_text_nodesc C sT | � d�}|j�dd� |j�dd� ddg|jjks J �|jjd jdks(J �d S )NrH r r5 rF )r r. rJ r� r� r r r r �test_insert_string\ s z'TestTreeModification.test_insert_stringc C s� | � � }| jd|d�}t||d�}|�dd� |j�d|� |�� | �d�ks)J �|j}|j|ks3J �|j |ks:J �|j dd �}|j |ksGJ �|j |ksNJ �|j }|j|ksXJ �|j |ks_J �|j dd �}|j|kslJ �|j |kssJ �|j |kszJ �d S ) Nz%<a><b>Find</b><c>lady!</c><d></d></a>rF �magictagr �ther z=<a><b>Find</b><magictag>the</magictag><c>lady!</c><d></d></a>�Findr! )r� r r rJ r. r� rD r r r8 r r� r rg r� )r r� r � magic_tag�b_tagr �c_tagrv r r r �test_insert_tage s. � � z$TestTreeModification.test_insert_tagc C s0 d}| � |�}|j�|j� ||�� ksJ �d S rZ )r r. rI r r� �r r� r r r r �*test_append_child_thats_already_at_the_end� � z?TestTreeModification.test_append_child_thats_already_at_the_endc C sJ d}| � |�}|j|j|j|j|j|jg}|j�|� d|� � ks#J �d S )Nz1<a><b><c><d><e><f><g></g></f></e></d></c></b></a>z1<a><g></g><f></f><e></e><d></d><c></c><b></b></a>) r �gr� �er� rg r r. �extendr� )r r� r rJ r r r � test_extend� s z TestTreeModification.test_extend�get_tagsc C s | S r� r rs r r r �<lambda>� s z TestTreeModification.<lambda>c C s | j S r� )r� rs r r r r� � s c C s` d}| � |�}|jddd�}|jddd�}||�}|�|� d|�� ks&J �d|�� ks.J �d S )NzS<body><div id="d1"><a>1</a><a>2</a><a>3</a><a>4</a></div><div id="d2"></div></body>rv �d1r# �d2z<div id="d1"></div>z3<div id="d2"><a>1</a><a>2</a><a>3</a><a>4</a></div>)r r r� r� )r r� r� r r� r� �tagsr r r �&test_extend_with_another_tags_contents� s z;TestTreeModification.test_extend_with_another_tags_contentsc C s2 d}| � |�}|j�d|j� d|�� ksJ �d S )Nz <a><b></b><c></c><d></d></a>r z <a><d></d><b></b><c></c></a>)r r. rJ r� r� r| r r r �$test_move_tag_to_beginning_of_parent� s z9TestTreeModification.test_move_tag_to_beginning_of_parentc C s. | � d�}|j�dd� t|j�dksJ �d S )Nz<br/>r �Contentsz<br>Contents</br>)r �brrJ r% r r r r �&test_insert_works_on_empty_element_tag� s z;TestTreeModification.test_insert_works_on_empty_element_tagc C s� | � d�}|j�d� |j�d� |�� | �d�ks J �|j�|j� |�� | �d�ks.J �|j}t�t�� |�|� W d � n1 sFw Y |� � t�t�� |�d� W d � n1 sdw Y | � d�}|j�|� d�� d S ) Nr( �BAZ�QUUXzQUUX<a>foo</a>BAZ<b>bar</b>�QUUX<b>bar</b><a>foo</a>BAZ�nope�<a>r. ) r r � insert_beforer. r� rD r� r� r� rW �new_tag�r r r r r r �test_insert_before� s$ � � � z'TestTreeModification.test_insert_beforec C sj | � d�}|j�ddd� |j�ddd� |�� | �d�ks J �|j�|jd� |�� | �d�ks3J �d S )Nr( r� � r� z$QUUX BAZ<a>foo</a>BAZ QUUX<b>bar</b>�FOOz'QUUX BAZ<b>bar</b>FOO<a>foo</a>BAZ QUUX)r r r� r. r� rD r r r r �test_insert_multiple_before� s � �z0TestTreeModification.test_insert_multiple_beforec C s� | � d�}|j�d� |j�d� |�� | �d�ks J �|j�|j� |�� | �d�ks.J �|j}t�t�� |�|� W d � n1 sFw Y |� � t�t�� |�d� W d � n1 sdw Y | � d�}|j� |� d�� d S ) Nr( r� r� z<a>foo</a>QUUX<b>bar</b>BAZr� r� r� r. ) r r � insert_afterr. r� rD r� r� r� rW r� r� r� r r r �test_insert_after� s$ � � � z&TestTreeModification.test_insert_afterc C sj | � d�}|j�ddd� |j�ddd� |�� | �d�ks J �|j�|jd� |�� | �d�ks3J �d S )Nr( r� r� r� z$<a>foo</a>QUUX BAZ<b>bar</b>BAZ QUUXzFOO z(QUUX BAZ<b>bar</b><a>foo</a>FOO BAZ QUUX)r r r� r. r� rD r r r r �test_insert_multiple_after� s � �z/TestTreeModification.test_insert_multiple_afterc C � | � d�}|�d�}|�d�}t�t�� |�|� W d � n1 s$w Y t�t�� |�|� W d � n1 s>w Y t�t�� |�|� W d � d S 1 sYw Y d S �Nr r. )r r� � new_stringr� r� r� r� �NotImplementedError�r r rd r r r r �:test_insert_after_raises_exception_if_after_has_no_meaning� � � � "�zOTestTreeModification.test_insert_after_raises_exception_if_after_has_no_meaningc C r� r� )r r� r� r� r� r� r� r� r� r r r �Ftest_insert_before_raises_notimplementederror_if_before_has_no_meaning r� z[TestTreeModification.test_insert_before_raises_notimplementederror_if_before_has_no_meaningc C sv | � d�}|�d�\}}|�|� |�� | �d�ks J �|jd ks#J �|j|jks+J �|jdks2J �|jdks9J �d S )Nz;<p>There's <b>no</b> business like <b>show</b> business</p>r z0<p>There's business like <b>no</b> business</p>�noz business) r r, rP r� rD r� �pr� r )r r r� �showr r r �test_replace_with s � �z&TestTreeModification.test_replace_withc C s� t dd�}t�t�� |�d� W d � n1 sw Y | �d�j}t�t�� |j�|� W d � n1 s;w Y t�t�� |j�d|d� W d � d S 1 sYw Y d S )Nr. r� z won't workr[ �string1�string2)r r� r� r� rP r r. r )r �a_tagr r r �test_replace_with_errors s � � "�z-TestTreeModification.test_replace_with_errorsc C s� d}| � |�}|�d�}d|_|�d�}|�d�}d}|j�||||� |�� dks,J �|jj|ks4J �|jj|ks<J �|jj|ksDJ �|jj|ksLJ �d S )NrT r� z Text In D Tagr� r� z Random Textz;<a><b></b><d>Text In D Tag</d><e></e>Random Text<f></f></a>)r r� r rg rP r� r r� )r r� r �d_tag�e_tag�f_tag�a_stringr r r �test_replace_with_multiple- s z/TestTreeModification.test_replace_with_multiplec C �0 d}| � |�}|j�|j� d|�� ksJ �d S )NrT z<a><c></c></a>)r r rP rg r� r| r r r �test_replace_first_child< r~ z-TestTreeModification.test_replace_first_childc C r� )NrT r[ )r rg rP r r� r| r r r �test_replace_last_childB r~ z,TestTreeModification.test_replace_last_childc C s | � d�}|j}|j}|�|� |�� | �d�ksJ �|jd ks"J �|jdd�jd ks-J �|j d ks4J �|j d ks;J �|j d ksBJ �|j|j ksJJ �|j dksQJ �|jj|j ksZJ �|j d ksaJ �|jdd�}|j}|j|ksqJ �|j |ksxJ �|j |ksJ �|j |ks�J �d S )NzQ<a>We<b>reserve<c>the</c><d>right</d></b></a><e>to<f>refuse</f><g>service</g></e>z-<a>We<f>refuse</f></a><e>to<g>service</g></e>rm r! �We�to)r r r� rP r� rD r� r r� r r r8 r. r� r )r r � remove_tag�move_tag�to_text�g_tagr r r � test_nested_tag_replace_withH s0 � � z1TestTreeModification.test_nested_tag_replace_withc C s6 | � d�}|j�� |jd ksJ �|jjdksJ �d S )NzI <p>Unneeded <em>formatting</em> is unneeded</p> z Unneeded formatting is unneeded)r �emrU r� r& r r r r � test_unwrapl s z TestTreeModification.test_unwrapc C sF | � d�}|j�|�d��}|�� dksJ �|�� | �d�ks!J �d S )NzI wish I was bold.r �<b>I wish I was bold.</b>)r r �wrapr� r� rD )r r r� r r r � test_wrapt s z TestTreeModification.test_wrapc C s4 | � d�}|jj�|j� |�� | �d�ksJ �d S )Nz<b></b>I wish I was bold.r� )r r r r� r� rD r r r r �%test_wrap_extracts_tag_from_elsewherez s z:TestTreeModification.test_wrap_extracts_tag_from_elsewherec C sH | � d�}|jj�|j� dt|jj�ksJ �|�� | �d�ks"J �d S )Nz+<b>I like being bold.</b>I wish I was bold.r) z+<b>I like being bold.I wish I was bold.</b>)r r r r� r+ r� r� rD r r r r �&test_wrap_puts_new_contents_at_the_end s �z;TestTreeModification.test_wrap_puts_new_contents_at_the_endc C s� | � d�}t|jj�dksJ �|jdd��� }|�� dks J �|�� dks'J �t|jj�dks1J �|jd ks8J �|jd ks?J �|j j d ksGJ �|jdd �}|jd d �}|j |ksZJ �|j |ksaJ �|j|kshJ �|j |ksoJ �d S ) NzR<html><body>Some content. <div id="nav">Nav crap</div> More content.</body></html>r; �navr# z6<html><body>Some content. More content.</body></html>z <div id="nav">Nav crap</div>r) zSome content. r! z More content.) r r+ r r� r rW r� r� r r� r r8 )r r � extracted� content_1� content_2r r r � test_extract� s" � z!TestTreeModification.test_extractc C sz | � d�}|jj}|jj}|�d�}|�d�}|j�|� |j�|� |�� |�� ||jjks3J �||jjks;J �d S )Nr( rF r5 )r r. r r r� rI rW )r r �foo_1�bar_1�foo_2�bar_2r r r �4test_extract_distinguishes_between_identical_strings� s zITestTreeModification.test_extract_distinguishes_between_identical_stringsc s8 | � d�� � fdd�� �d�D � dt� j�ksJ �d S )Nzv <html> <head> <script>foo</script> </head> <body> <script>bar</script> <a></a> </body> <script>baz</script> </html>c s g | ]}� j �� �qS r )�scriptrW )r� r� �r r r r� � s zKTestTreeModification.test_extract_multiples_of_same_tag.<locals>.<listcomp>r� z<body> <a></a> </body>)r r, r% r r\ r r� r �"test_extract_multiples_of_same_tag� s z7TestTreeModification.test_extract_multiples_of_same_tagc C s. | � d�}|�d��� d |�d�ksJ �d S )Nz <html> <body>hi</body> </html>r )r r rW r r r r �Btest_extract_works_when_element_is_surrounded_by_identical_strings� s �zWTestTreeModification.test_extract_works_when_element_is_surrounded_by_identical_stringsc C sd | � d�}|j}|j�� t|jj�dksJ �t|d�s J �|j}|jdd� dt|j�ks0J �dS )z Tag.clear()z4<p><a>String <em>Italicized</em></a> and another</p>r r� T)� decomposeN)r r. r� �clearr+ r� rM r� )r r r. r� r r r � test_clear� s z TestTreeModification.test_clearc C s~ | � d�}|�d�\}}|j}|jj}||||fD ] }d|jks"J �q|�� |||fD ] }d|jks5J �q,d|jks=J �d S )Nz;<p><a>String <em>Italicized</em></a></p><p>Another para</p>r� FT)r r, r. r� r � decomposedr� )r r rf r_ r. r& r� r r r �test_decompose� s z#TestTreeModification.test_decomposec C sB | � d�}d|j_|jjdgksJ �d|j_|jjdgks J �dS )zTag.string = 'string'z<a></a> <b><c></c></b>rF r5 N)r r. r r� r r r r r �test_string_set� s z$TestTreeModification.test_string_setc C s, | � d�}|jj|j_|j�� dksJ �d S )Nz<a><b>foo</b><c>bar</c>s <a><b>bar</b><c>bar</c></a>)r rg r r r. r� r r r r �/test_string_set_does_not_affect_original_string� s zDTestTreeModification.test_string_set_does_not_affect_original_stringc C s0 | � d�}td�}||j_t|jjt�sJ �d S )NrH rF )r r r. r rb )r r �cdatar r r �)test_set_string_preserves_class_of_string� s z>TestTreeModification.test_set_string_preserves_class_of_stringN)3r0 r1 r2 rE rK rO rS rV rX rY r] r^ rh rn rr rs rt r{ r} r� r� �mark� parametrizer� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r rB � sb � $ rB c @ s. e Zd Zej�dg d��dd� �Zdd� ZdS )�TestDeprecatedArguments� method_name) r r, r� r� r� r� r r r( r, r= r? c C s| | � d�}t|j|�}tjdd��#}|dd� |\}|jtks!J �t|j�}|dks,J �W d � d S 1 s7w Y d S )Nz<a>some</a><b>markup</b>T��recordr �r& zOThe 'text' argument to find()-type methods is deprecated. Use 'string' instead.) r �getattrr �warnings�catch_warnings�filename�__file__r% �message)r r� r �method�w�warning�msgr r r � test_find_type_method_string� s "�z4TestDeprecatedArguments.test_find_type_method_stringc C st t jdd��*}tdd�}|jdksJ �|\}t|j�}|jtks"J �|dks(J �W d � d S 1 s3w Y d S )NTr� r& r� zXThe 'text' argument to the SoupStrainer constructor is deprecated. Use 'string' instead.)r� r� r r& r% r� r� r� )r r� r� r� r� r r r �$test_soupstrainer_constructor_string s "�z<TestDeprecatedArguments.test_soupstrainer_constructor_stringN)r0 r1 r2 r� r� r� r� r� r r r r r� � s � r� ))r3 �pdbr r� r8 r� �bs4r � bs4.builderr r � bs4.elementr r r r r r r r r r r r r r r4 rQ rX r| r� r� r� r� r� r r r r7 rB r� r r r r �<module> s< 4 9N 5,2(1-- 8PK z�Z�9��� � / tests/__pycache__/test_html5lib.cpython-310.pycnu �[��� o �h� � @ sh d Z ddlZddlZddlmZ ddlmZ ddlmZm Z m Z ej j e dd�G d d � d e e ��Z dS ) zDTests to ensure that the html5lib tree builder generates good trees.� N)� BeautifulSoup)� SoupStrainer� )�HTML5LIB_PRESENT�HTML5TreeBuilderSmokeTest�SoupTestz?html5lib seems not to be present, not testing its tree builder.)�reasonc @ s� e Zd ZdZedd� �Zdd� Zdd� Zdd � Zd d � Z d d � Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"S )#�TestHTML5LibBuilderz"See ``HTML5TreeBuilderSmokeTest``.c C s ddl m} |S )Nr )�HTML5TreeBuilder)� bs4.builderr )�selfr � r �J/usr/local/CyberCP/lib/python3.10/site-packages/bs4/tests/test_html5lib.py�default_builder s z#TestHTML5LibBuilder.default_builderc C s� t d�}d}tjdd��}t|d|d�}W d � n1 s w Y |�� | �|�ks.J �|\}|jtks8J �dt|j �v sAJ �d S )N�bz <p>A <b>bold</b> statement.</p>T)�record�html5lib)� parse_onlyz4the html5lib tree builder doesn't support parse_only) r �warnings�catch_warningsr �decode� document_for�filename�__file__�str�message)r �strainer�markup�w�soup�warningr r r �test_soupstrainer s �z%TestHTML5LibBuilder.test_soupstrainerc C s d}| � |d� | � d� dS )z8html5lib inserts <tbody> tags where other parsers don't.z[<table id="1"><tr><td>Here's another table:<table id="2"><tr><td>foo</td></tr></table></td>z�<table id="1"><tbody><tr><td>Here's another table:<table id="2"><tbody><tr><td>foo</td></tr></tbody></table></td></tr></tbody></table>z{<table><thead><tr><td>Foo</td></tr></thead><tbody><tr><td>Bar</td></tr></tbody><tfoot><tr><td>Baz</td></tr></tfoot></table>N)� assert_soup)r r r r r � test_correctly_nested_tables& s ��z0TestHTML5LibBuilder.test_correctly_nested_tablesc C �$ d}| � |�}d|j�� ksJ �d S )Nzy<?xml version="1.0" encoding="utf-8"?> <!DOCTYPE html> <html> <head> </head> <body> <p>foo</p> </body> </html>s <p>foo</p>)r �p�encode�r r r r r r �(test_xml_declaration_followed_by_doctype: s z<TestHTML5LibBuilder.test_xml_declaration_followed_by_doctypec C �: d}| � |�}d|j�� ksJ �dt|�d��ksJ �d S )Nz%<p><em>foo</p> <p>bar<a></a></em></p>zD<body><p><em>foo</em></p><em> </em><p><em>bar<a></a></em></p></body>� r% �r �bodyr �len�find_allr' r r r �test_reparented_markupH � z*TestHTML5LibBuilder.test_reparented_markupc C r) )Nz&<p><em>foo</p> <p>bar<a></a></em></p> zE<body><p><em>foo</em></p><em> </em><p><em>bar<a></a></em></p> </body>r* r% r+ r' r r r �+test_reparented_markup_ends_with_whitespaceO r0 z?TestHTML5LibBuilder.test_reparented_markup_ends_with_whitespacec C sL d}| � |�}|jdd�\}}|�d�\}}|j|u s J �|j|u s$J �dS )z�Verify that we keep the two whitespace nodes in this document distinct when reparenting the adjacent <tbody> tags. z,<table> <tbody><tbody><ims></tbody> </table>� ��string�tbodyN)r r. � next_element)r r r �space1�space2�tbody1�tbody2r r r �<test_reparented_markup_containing_identical_whitespace_nodesU s zPTestHTML5LibBuilder.test_reparented_markup_containing_identical_whitespace_nodesc C s^ d}| � |�}|j}d|jksJ �|jdd�}|jdd�d }||jks&J �||jks-J �d S )NzF<div><a>aftermath<p><noscript>target</noscript>aftermath</a></p></div>�targetr3 � aftermath���)r �noscriptr6 �findr. �previous_element)r r r r? r< �final_aftermathr r r �*test_reparented_markup_containing_children` s z>TestHTML5LibBuilder.test_reparented_markup_containing_childrenc C s$ d}| � |�}t|��d�sJ �dS )z(Processing instructions become comments.s <?PITarget PIContent?>z<!--?PITarget PIContent?-->N)r r � startswithr' r r r �test_processing_instructionp s z/TestHTML5LibBuilder.test_processing_instructionc C s8 d}| � |�}|�d�\}}||ksJ �||usJ �d S )Ns <a class="my_class"><p></a>�a)r r. )r r r �a1�a2r r r �test_cloned_multivalue_nodev s z/TestHTML5LibBuilder.test_cloned_multivalue_nodec C r$ )Ns <table><td></tbody>Az><body>A<table><tbody><tr><td></td></tr></tbody></table></body>)r r, r r' r r r �test_foster_parenting} s z)TestHTML5LibBuilder.test_foster_parentingc C sL d}| � |�}dd� |d�D � dd� |d�D � t|�d��dks$J �d S ) z� Test that extraction does not destroy the tree. https://bugs.launchpad.net/beautifulsoup/+bug/1782928 zW <html><head></head> <style> </style><script></script><body><p>hello</p></body></html> c S � g | ]}|� � �qS r ��extract��.0�sr r r � <listcomp>� � z7TestHTML5LibBuilder.test_extraction.<locals>.<listcomp>�scriptc S rK r rL rN r r r rQ � rR �styler% r N)r r- r. r' r r r �test_extraction� s z#TestHTML5LibBuilder.test_extractionc C sF d}| � |�}g }|�d�D ] }|�|�d�� qt|�dks!J �dS )z� Test that empty comment does not break structure. https://bugs.launchpad.net/beautifulsoup/+bug/1806598 zI <html> <body> <form> <!----><input type="text"> </form> </body> </html> �form�inputr N)r r. �extendr- )r r r �inputsrV r r r �test_empty_comment� s z&TestHTML5LibBuilder.test_empty_commentc C sz d}| � |�}d|jjksJ �d|jjksJ �d|j�d�jks"J �| j |dd�}d|jjjks2J �d|jjjks;J �d S )Nz= <p> <sourceline> <b>text</b></sourceline><sourcepos></p>r* � � sourcelineF)�store_line_numbers� sourcepos)r r% r\ r^ r@ �namer' r r r �test_tracking_line_numbers� s z.TestHTML5LibBuilder.test_tracking_line_numbersc C s d S )Nr )r r r r � test_special_string_containers� s z2TestHTML5LibBuilder.test_special_string_containersc C sj dD ]0\}}}d| }| � |�j}|�� }d|�d� }||ks"J �|jdd�}d| }||ks2J �qd S )N))z⇄u ⇄s ⇄)z⊧u ⊧s ⊧)z𝔑u 𝔑s 𝔑)z≧̸u ≧̸s ≧̸)z¬� ¬s ¬)z⫬u ⫬s ⫬)z"�"� ")z∴� ∴� ∴)z ∴re rf )z ∴re rf )zfj�fjs fj)z⊔u ⊔s ⊔)z⊔︀u ⊔︀s ⊔︀)z'�'� ')z|�|� |z <div>%s</div>s <div>%s</div>�utf8�html)� formatter)r �divr& ) r � input_element�output_unicode�output_elementr ro �without_element�expect� with_elementr r r �test_html5_attributes� s �z)TestHTML5LibBuilder.test_html5_attributesN)�__name__� __module__� __qualname__�__doc__�propertyr r! r# r( r/ r1 r; rC rE rI rJ rU rZ r` ra rv r r r r r s& r )rz �pytestr �bs4r � bs4.elementr � r r r �mark�skipifr r r r r �<module> s �PK z�Z}U�u� � + tests/__pycache__/test_docs.cpython-310.pycnu �[��� o �hg � @ sD d Z eZdgZddlZddlZddlZddlZejej B ej B Z dS )zTest harness for doctests.�additional_tests� N) �__doc__�type� __metaclass__�__all__�atexit�doctest�os�unittest�ELLIPSIS�NORMALIZE_WHITESPACE� REPORT_NDIFF� DOCTEST_FLAGS� r r �F/usr/local/CyberCP/lib/python3.10/site-packages/bs4/tests/test_docs.py�<module> s ����PK z�Z+ef�@ @ + tests/__pycache__/test_fuzz.cpython-310.pycnu �[��� o �h< � @ s� d Z ddlZddlZddlmZmZ zddlmZ ddlZddl Z dZ W n e y/ dZ Y nw ej j e dd�G d d � d e��ZdS ) a This file contains test cases reported by third parties using fuzzing tools, primarily from Google's oss-fuzz project. Some of these represent real problems with Beautiful Soup, but many are problems in libraries that Beautiful Soup depends on, and many of the test cases represent different ways of triggering the same problem. Grouping these test cases together makes it easy to see which test cases represent the same problem, and puts the test cases in close proximity to code that can trigger the problems. � N)� BeautifulSoup�ParserRejectedMarkup)�SelectorSyntaxErrorTFz/Prerequisites for fuzz tests are not installed.��reasonc @ s� e Zd ZdZdd� Zej�dddg�dd� �Zej�dg d ��d d � �Z ej�dg d ��d d� �Z ej�dddg�dd� �Z ejj dd�ej�dg d��dd� ��Z ejj dd�ej�ddg�dd� ��Zdd � Zd S ) �TestFuzzz .testcasec C s� | � |�}g d�}z t|d �t|� }W n ty Y d S w |dd� |dd � }}zt|dd � || d�}W n tyE Y d S tyN Y d S w t|�d�� z |j� |� dd�� W n t yl Y d S w |� � d S ) N)zlxml-xml�html5lib� html.parser�lxmlr � � )�featuresTzutf-8�replace) �_TestFuzz__markup�int�len� ValueErrorr r �list�find_all�css�select�decoder �prettify)�self�filename�data�parsers�idx� css_selector�soup� r �F/usr/local/CyberCP/lib/python3.10/site-packages/bs4/tests/test_fuzz.py�fuzz_test_with_css) s, � � � zTestFuzz.fuzz_test_with_cssr z:clusterfuzz-testcase-minimized-bs4_fuzzer-5703933063462912z.crash-ffbdfa8a2b26f13537b68d3794b0478a4090ee4ac C sD | � |�}t�t�� t|d� W d � d S 1 sw Y d S �Nr )r �pytest�raisesr r �r r �markupr r r! �test_rejected_markupD s "�z TestFuzz.test_rejected_markup)z:clusterfuzz-testcase-minimized-bs4_fuzzer-5984173902397440z:clusterfuzz-testcase-minimized-bs4_fuzzer-5167584867909632z:clusterfuzz-testcase-minimized-bs4_fuzzer-6124268085182464z:clusterfuzz-testcase-minimized-bs4_fuzzer-6450958476902400c C s | � |�}t|d��� d S r# )r r �encoder& r r r! �'test_deeply_nested_document_without_cssV s z0TestFuzz.test_deeply_nested_document_without_css)z:clusterfuzz-testcase-minimized-bs4_fuzzer-5000587759190016z:clusterfuzz-testcase-minimized-bs4_fuzzer-5375146639360000z:clusterfuzz-testcase-minimized-bs4_fuzzer-5492400320282624c C � | � |� d S �N�r" �r r r r r! �test_deeply_nested_documenti � z$TestFuzz.test_deeply_nested_documentz:clusterfuzz-testcase-minimized-bs4_fuzzer-4670634698080256z:clusterfuzz-testcase-minimized-bs4_fuzzer-5270998950477824c C r+ r, r- r. r r r! �test_soupsieve_errorss s z TestFuzz.test_soupsieve_errorszhtml5lib-specific problemsr )z:clusterfuzz-testcase-minimized-bs4_fuzzer-4818336571064320z:clusterfuzz-testcase-minimized-bs4_fuzzer-4999465949331456z:clusterfuzz-testcase-minimized-bs4_fuzzer-5843991618256896z:clusterfuzz-testcase-minimized-bs4_fuzzer-6241471367348224z:clusterfuzz-testcase-minimized-bs4_fuzzer-6600557255327744z.crash-0d306a50c8ed8bcd0785b67000fcd5dea1d33f08c C s | � |�}tt|d��� � d S )Nr )r �printr r) r& r r r! �&test_html5lib_parse_errors_without_css� s z/TestFuzz.test_html5lib_parse_errors_without_cssz:clusterfuzz-testcase-minimized-bs4_fuzzer-6306874195312640c C r+ r, r- r. r r r! �test_html5lib_parse_errors� r0 z#TestFuzz.test_html5lib_parse_errorsc C sD |� | j�s || j7 }tj�t�d }tj�|d|�}t|d��� S )Nr �fuzz�rb) �endswith�TESTCASE_SUFFIX�os�path�split�__file__�join�open�read)r r �this_dirr: r r r! �__markup� s zTestFuzz.__markupN)�__name__� __module__� __qualname__r8 r" r$ �mark� parametrizer( r* r/ r1 �skipr3 r4 r r r r r! r sL �� � � �� � �� r )�__doc__r9 r$ �bs4r r �soupsieve.utilr r r �fully_fuzzable� ImportErrorrE �skipif�objectr r r r r! �<module> s �PK z�Zi*uQ� � . tests/__pycache__/test_element.cpython-310.pycnu �[��� o �hI � @ sH d Z ddlmZmZmZ ddlmZ G dd� de�ZG dd� de�Z d S ) z�Tests of classes in element.py. The really big classes -- Tag, PageElement, and NavigableString -- are tested in separate files. � )�CharsetMetaAttributeValue�ContentMetaAttributeValue�NamespacedAttribute� )�SoupTestc @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) �TestNamedspacedAttributec C sD t dd �}|dks J �t dd�}|dksJ �t d�}|dks J �d S )N�xmlns� �r ��self�a� r �I/usr/local/CyberCP/lib/python3.10/site-packages/bs4/tests/test_element.py� test_name_may_be_none_or_missing s z9TestNamedspacedAttribute.test_name_may_be_none_or_missingc C s0 t d d�}|dks J �t dd�}|dksJ �d S )N�tagr r r r r r �%test_namespace_may_be_none_or_missing s z>TestNamedspacedAttribute.test_namespace_may_be_none_or_missingc C s t dd�}d|ks J �d S )Nr �bza:br r r r r �6test_attribute_is_equivalent_to_colon_separated_string" s zOTestNamedspacedAttribute.test_attribute_is_equivalent_to_colon_separated_stringc C sp t ddd�}t ddd�}||ksJ �t ddd �}||ks J �t ddd�}||ks*J �t ddd�}||ks6J �d S )Nr r �c�zr )r r r r �d�er r r �;test_attributes_are_equivalent_if_prefix_and_name_identical& s zTTestNamedspacedAttribute.test_attributes_are_equivalent_if_prefix_and_name_identicalN)�__name__� __module__� __qualname__r r r r r r r r r s r c @ s e Zd ZdZdd� Zdd� ZdS )�)TestAttributeValueWithCharsetSubstitutionzpCertain attributes are designed to have the charset of the final document substituted into their value. c C sJ t d�}d|ks J �d|jksJ �d|�d�ksJ �d|�d�ks#J �d S )Nzeuc-jp�utf8�ascii)r �original_value�encode�r �valuer r r �!test_content_meta_attribute_value< s zKTestAttributeValueWithCharsetSubstitution.test_content_meta_attribute_valuec C sJ t d�}d|ks J �d|jksJ �d|�d�ksJ �d|�d�ks#J �d S )Nztext/html; charset=euc-jpztext/html; charset=utf8r ztext/html; charset=asciir )r r r! r" r r r r$ E s N)r r r �__doc__r$ r r r r r 7 s r N) r% � bs4.elementr r r r r �objectr r r r r r �<module> s (PK z�ZAp���0 �0 - tests/__pycache__/test_dammit.cpython-310.pycnu �[��� o �h[< � @ sl d dl Z d dlZd dlZd dlmZ d dlmZmZmZ G dd� de�Z G dd� de�Z G dd � d e�Z dS ) � N)� BeautifulSoup)�EntitySubstitution�EncodingDetector� UnicodeDammitc @ sb e Zd ZdZdd� Zej�dg d��dd� �Zdd � Z d d � Z d d � Z dd� Z dd� Z dd� ZdS )�TestUnicodeDammitz"Standalone tests of UnicodeDammit.c C s d}t |�}|j|ks J �d S )Nu I'm already Unicode! ☃)r �unicode_markup)�self�markup�dammit� r �H/usr/local/CyberCP/lib/python3.10/site-packages/bs4/tests/test_dammit.py�test_unicode_input s z$TestUnicodeDammit.test_unicode_inputz smart_quotes_to,expect_converted))Nu ‘’“”)�xmlz ‘’“”)�htmlz ‘’“”)�asciiz''""c C s, d}t |dg|d�j}|d�|�ksJ �dS )zbVerify the functionality of the smart_quotes_to argument to the UnicodeDammit constructor.s <foo>����</foo>� windows-1252)�known_definite_encodings�smart_quotes_toz <foo>{}</foo>N)r r �format)r r �expect_convertedr � convertedr r r �test_smart_quotes_to s ��z&TestUnicodeDammit.test_smart_quotes_toc C s0 d}t |�}|j�� dksJ �|jdksJ �d S )Ns Sacré bleu! ☃�utf-8u Sacré bleu! ☃�r �original_encoding�lowerr )r �utf8r r r r �test_detect_utf8& s z"TestUnicodeDammit.test_detect_utf8c C s4 d}t |dg�}|j�� dksJ �|jdksJ �d S )N� ��� iso-8859-8u םולשr �r �hebrewr r r r �test_convert_hebrew, s z%TestUnicodeDammit.test_convert_hebrewc C s6 d}t |�}|j�� dksJ �|j�d�|ksJ �d S )Ns ケータイ Watchr )r r r r �encode)r �utf_8r r r r �/test_dont_see_smart_quotes_where_there_are_none2 s zATestUnicodeDammit.test_dont_see_smart_quotes_where_there_are_nonec C s, d� d�}t|dg�}|j�� dksJ �d S )N� Räksmörgåsr r �r# r r r �r � utf8_datar r r r � test_ignore_inappropriate_codecs8 s z2TestUnicodeDammit.test_ignore_inappropriate_codecsc C s6 d� d�}dD ]}t||g�}|j�� dksJ �qd S )Nr& r )z.utf8z...z utF---16.!r' )r r) � bad_encodingr r r r �test_ignore_invalid_codecs= s �z,TestUnicodeDammit.test_ignore_invalid_codecsc C sL d� d�}t|dgd�}|j�� dksJ �t|ddgd�}|jd ks$J �d S )Nr& r )�exclude_encodingsr r' r( r r r �test_exclude_encodingsC s �z(TestUnicodeDammit.test_exclude_encodingsN)�__name__� __module__� __qualname__�__doc__r �pytest�mark� parametrizer r r" r% r* r, r. r r r r r s � r c @ sT e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dS )�TestEncodingDetectorc C s" t d�}t|j�}d|v sJ �d S )Ns' <?xml version="1.0" encoding="UTF-�" ?>u utf-�)r �list� encodings)r �detectedr8 r r r �Ptest_encoding_detector_replaces_junk_in_encoding_name_with_replacement_characterS s � zeTestEncodingDetector.test_encoding_detector_replaces_junk_in_encoding_name_with_replacement_characterc C s( dD ]}t |dd�}d|jksJ �qd S )N)s& <html><meta charset="euc-jp" /></html>s& <html><meta charset='euc-jp' /></html>s$ <html><meta charset=euc-jp /></html>s# <html><meta charset=euc-jp/></html>T��is_htmlzeuc-jp)r r �r �datar r r r � test_detect_html5_style_meta_tagY s �z5TestEncodingDetector.test_detect_html5_style_meta_tagc C s� d}t jj}t�tj� z1dd� }|t j_t|�}d|jks J �d|jv s'J �t |d�}|js1J �W t�tj � |t j_d S t�tj � |t j_w )NsT <?xml version="1.0" encoding="UTF-8"?> <html><b>بتر</b> <i>��ѐ����</i></html>c S s d S �Nr )�strr r r �noopy s zETestEncodingDetector.test_last_ditch_entity_replacement.<locals>.noopTu �z html.parser) �bs4r �chardet_dammit�logging�disable�WARNINGr � contains_replacement_charactersr r �NOTSET)r �doc�chardetrB r �soupr r r �"test_last_ditch_entity_replacementc s � z7TestEncodingDetector.test_last_ditch_entity_replacementc C s, d}t |�}d|jks J �d|jksJ �d S )N� ��< a > � � < / a > u <a>áé</a>�utf-16le)r r r r= r r r � test_byte_order_mark_removed� s z1TestEncodingDetector.test_byte_order_mark_removedc C s� d}t |�}t |dgd�}d|jksJ �t |dgd�}d|jks"J �dgdd� |jD �ks/J �d }t |dgd gd �}d |jksAJ �dd gd d� |jD �ksOJ �d S ) NrN zutf-16)r r )�user_encodingsrO c S � g | ]}|d �qS �r r ��.0�xr r r � <listcomp>� � zRTestEncodingDetector.test_known_definite_versus_user_encodings.<locals>.<listcomp>r r )r rQ c S rR rS r rT r r r rW � rX �r r �tried_encodings)r r> r �before�afterr! r r r �)test_known_definite_versus_user_encodings� s � z>TestEncodingDetector.test_known_definite_versus_user_encodingsc C sH d}t |dgdgdgd�}d|jksJ �g d�dd� |jD �ks"J �d S ) Nr � shift-jisr r )r �override_encodingsrQ )r^ r r c S rR rS r rT r r r rW � rX zKTestEncodingDetector.test_deprecated_override_encodings.<locals>.<listcomp>rY r r r r �"test_deprecated_override_encodings� s � �z7TestEncodingDetector.test_deprecated_override_encodingsc C st d� d�}d� d�}|| | }t�t�� |�d� W d � n1 s%w Y t�|�}d|�d�ks8J �d S )Nu ☃☃☃r u “Hi, I like Windows!”� windows_1252u+ ☃☃☃“Hi, I like Windows!”☃☃☃)r# r3 �raises�UnicodeDecodeError�decoder � detwingle)r r ra rJ �fixedr r r �test_detwingle� s � � z#TestEncodingDetector.test_detwinglec C s< dD ]}|� d�}|�d�sJ �t�|�}||ksJ �qd S )N)u œu ₓu ðr � �)r# �endswithr re )r �tricky_unicode_char�input�outputr r r �+test_detwingle_ignores_multibyte_characters� s �z@TestEncodingDetector.test_detwingle_ignores_multibyte_charactersc C s d}|� d�}d}|� d�}tj}||dd�d u sJ �d||dd�ks%J �d||dd�ks/J �d||�ks7J �d||�ks?J �d d }||| �d u sMJ �||| �d u sWJ �||| ddd �dksdJ �||dd �dksnJ �|d | dd �dkszJ �|d | dd �d u s�J �d S )Nz0<html><head><meta charset="utf-8"></head></html>r z,<?xml version="1.0" encoding="ISO-8859-1" ?>Fr; r Tz iso-8859-1� i� )r< �search_entire_document)ro � a)r# r �find_declared_encoding)r � html_unicode� html_bytes� xml_unicode� xml_bytes�m�spacerr r r �test_find_declared_encoding� s& � z0TestEncodingDetector.test_find_declared_encodingN) r/ r0 r1 r: r? rM rP r] r` rg rm rx r r r r r6 Q s # r6 c @ s� e Zd ZdZdd� Zej�dddg�dd� �Zd d � Z d d � Z d d� Z dd� Z dd� Z dd� Zdd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!S )"�TestEntitySubstitutionz1Standalone tests of the EntitySubstitution class.c C s t | _d S r@ )r �sub�r r r r � setup_method s z#TestEntitySubstitution.setup_methodzoriginal,substituted)u foo∀☃õbaru foo∀☃õbar)u ‘’foo“”z ‘’foo“”c C s | j �|�|ks J �d S r@ �rz �substitute_html)r �original� substitutedr r r �test_substitute_html s z+TestEntitySubstitution.test_substitute_htmlc C s: dD ]\}}d}|| }|| }| j �|�|ksJ �qd S )N) )z⊧u ⊧)z𝔑u 𝔑)z≧̸u ≧̸)z¬� ¬)z⫬u ⫬z||)�fjr� )z>�>)z<�<)z&�&z3 %s 4r} )r �entity�u�template�raw� with_entitiesr r r �test_html5_entity% s �z(TestEntitySubstitution.test_html5_entityc C s< d}d}| j �|�|ksJ �d}d}| j �|�|ks J �d S )Nu fjords ⊔ penguinszfjords ⊔ penguinsu fjords ⊔︀ penguinszfjords ⊔︀ penguinsr} )r r> r r r r �)test_html5_entity_with_variation_selectorC s z@TestEntitySubstitution.test_html5_entity_with_variation_selectorc C s d}| j �|d�|ks J �d S )N�Welcome to "my bar"F�rz �substitute_xml�r �sr r r �Itest_xml_converstion_includes_no_quotes_if_make_quoted_attribute_is_falseO � z`TestEntitySubstitution.test_xml_converstion_includes_no_quotes_if_make_quoted_attribute_is_falsec C s0 | j �dd�dks J �| j �dd�dksJ �d S )N�WelcomeTz "Welcome"z Bob's Barz "Bob's Bar"r� r{ r r r �6test_xml_attribute_quoting_normally_uses_double_quotesS s zMTestEntitySubstitution.test_xml_attribute_quoting_normally_uses_double_quotesc C � d}| j �|d�dks J �d S )Nr� Tz'Welcome to "my bar"'r� r� r r r �Otest_xml_attribute_quoting_uses_single_quotes_when_value_contains_double_quotesW r� zfTestEntitySubstitution.test_xml_attribute_quoting_uses_single_quotes_when_value_contains_double_quotesc C r� )N�Welcome to "Bob's Bar"Tz""Welcome to "Bob's Bar""r� r� r r r �btest_xml_attribute_quoting_escapes_single_quotes_when_value_contains_both_single_and_double_quotes[ r� zyTestEntitySubstitution.test_xml_attribute_quoting_escapes_single_quotes_when_value_contains_both_single_and_double_quotesc C s d}| j �|�|ks J �d S )Nr� r� )r �quotedr r r �<test_xml_quotes_arent_escaped_when_value_is_not_being_quoted_ s zSTestEntitySubstitution.test_xml_quotes_arent_escaped_when_value_is_not_being_quotedc C � | j �d�dks J �d S )Nzfoo<bar>zfoo<bar>r� r{ r r r �'test_xml_quoting_handles_angle_bracketsc � z>TestEntitySubstitution.test_xml_quoting_handles_angle_bracketsc C r� )NzAT&TzAT&Tr� r{ r r r �#test_xml_quoting_handles_ampersandsf r� z:TestEntitySubstitution.test_xml_quoting_handles_ampersandsc C r� )N� ÁT&Tz&Aacute;T&Tr� r{ r r r �Etest_xml_quoting_including_ampersands_when_they_are_part_of_an_entityi r� z\TestEntitySubstitution.test_xml_quoting_including_ampersands_when_they_are_part_of_an_entityc C r� )Nr� zÁT&T)rz �"substitute_xml_containing_entitiesr{ r r r �Dtest_xml_quoting_ignoring_ampersands_when_they_are_part_of_an_entityl r� z[TestEntitySubstitution.test_xml_quoting_ignoring_ampersands_when_they_are_part_of_an_entityc C s d}| j �|�|ks J �dS )z:There's no need to do this except inside attribute values.z Bob's "bar"Nr} )r �textr r r � test_quotes_not_html_substitutedo s z7TestEntitySubstitution.test_quotes_not_html_substitutedN)r/ r0 r1 r2 r| r3 r4 r5 r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r ry s, �� ry ) r3 rE rC r � bs4.dammitr r r �objectr r6 ry r r r r �<module> s E ?PK z�Z}% A� � + tests/__pycache__/test_lxml.cpython-310.pycnu �[��� o �h� � @ s� d Z ddlZddlZddlZddlZddlmZmZ er$ddlm Z m Z ddl m Z m Z ddlmZmZmZ ddlmZmZmZmZ ejje d d �G d d � d ee��Zejje d d �G dd� dee��ZdS )z@Tests to ensure that the lxml tree builder generates good trees.� N� )� LXML_PRESENT� LXML_VERSION)�LXMLTreeBuilder�LXMLTreeBuilderForXML)� BeautifulSoup�BeautifulStoneSoup)�Comment�Doctype� SoupStrainer)�HTMLTreeBuilderSmokeTest�XMLTreeBuilderSmokeTest�SOUP_SIEVE_PRESENT�SoupTestz;lxml seems not to be present, not testing its tree builder.��reasonc @ s^ e Zd ZdZedd� �Zdd� Zdd� Zej j e p e dk d d �d d � �Z d d� Zdd� ZdS )�TestLXMLTreeBuilder�!See ``HTMLTreeBuilderSmokeTest``.c C � t S �N)r ��self� r �F/usr/local/CyberCP/lib/python3.10/site-packages/bs4/tests/test_lxml.py�default_builder � z#TestLXMLTreeBuilder.default_builderc C s( | � dd� | � dd� | � dd� d S )Nz <p>foo�bar</p>z <p>foobar</p>z <p>foo�bar</p>z<p>foo�bar</p>)� assert_soupr r r r �test_out_of_range_entity# s ���z,TestLXMLTreeBuilder.test_out_of_range_entityc C s d S r r r r r r �*test_entities_in_foreign_document_encoding+ s z>TestLXMLTreeBuilder.test_entities_in_foreign_document_encoding)� � � r z@Skipping doctype test for old version of lxml to avoid segfault.r c C s( | � d�}|jd }d|�� ksJ �d S )Nz <!DOCTYPE>r � )�soup�contents�strip)r r# �doctyper r r �test_empty_doctype4 s z&TestLXMLTreeBuilder.test_empty_doctypec C sp t jdd�� }td�}W d � n1 sw Y dt|j�ks#J �|\}|jtks-J �dt|j�v s6J �d S )NT)�recordz<b />z<b/>z&BeautifulStoneSoup class is deprecated)�warnings�catch_warningsr �str�b�filename�__file__�message)r �wr# �warningr r r �%test_beautifulstonesoup_is_xml_parser= s �z9TestLXMLTreeBuilder.test_beautifulstonesoup_is_xml_parserc C s6 | j ddd�}d|jjjksJ �d|jjjksJ �d S )Nz= <p> <sourceline> <b>text</b></sourceline><sourcepos></p>T)�store_line_numbers� sourceline� sourcepos)r# �pr4 �namer5 �r r# r r r �test_tracking_line_numbersG s �z.TestLXMLTreeBuilder.test_tracking_line_numbersN)�__name__� __module__� __qualname__�__doc__�propertyr r r �pytest�mark�skipifr r r' r2 r9 r r r r r s � r z?lxml seems not to be present, not testing its XML tree builder.c @ sF e Zd ZdZedd� �Zdd� Zejj e dd�dd � �Z d d � Z d S ) �TestLXMLXMLTreeBuilderr c C r r )r r r r r r ] r z&TestLXMLXMLTreeBuilder.default_builderc C sz | � d�}|jdddd�ksJ �|jjddiksJ �|jjddd�ks%J �|jjddd�ks0J �|jjddd�ks;J �d S ) Nam <?xml version="1.1"?> <root><tag xmlns="http://unprefixed-namespace.com">content</tag><prefix:tag2 xmlns:prefix="http://prefixed-namespace.com">content</prefix:tag2><prefix2:tag3 xmlns:prefix2="http://another-namespace.com"><subtag xmlns="http://another-unprefixed-namespace.com"><subsubtag xmlns="http://yet-another-unprefixed-namespace.com"></prefix2:tag3></root>z$http://www.w3.org/XML/1998/namespacez http://prefixed-namespace.comz http://another-namespace.com)�xml�prefix�prefix2rC )rD rC )rE rC )r# � _namespaces�tag�tag2�subtag� subsubtagr8 r r r �test_namespace_indexinga s. � � � � ��z.TestLXMLXMLTreeBuilder.test_namespace_indexingzSoup Sieve not installedr c C s� | � d�}|�d�jdksJ �|�d�jdksJ �|�d�d u s"J �|jd|jjd�jdks0J �|j�d�jdks;J �|�d�jdksEJ �|�d�jdksOJ �|�d �jdksYJ �|j�d �jdksdJ �d S ) Nz�<?xml version="1.1"?> <root><tag xmlns="http://unprefixed-namespace.com">content</tag><prefix:tag2 xmlns:prefix="http://prefixed-namespace.com">content</tag><subtag xmlns:prefix="http://another-namespace-same-prefix.com"><prefix:tag3></subtag></root>rG z prefix|tag2rH z prefix|tag3)� namespaces�tag3z prefix:tag2z prefix:tag3)r# � select_oner7 rI rF �findr8 r r r �/test_namespace_interaction_with_select_and_find� s � ��zFTestLXMLXMLTreeBuilder.test_namespace_interaction_with_select_and_findc C sf | � d�}t|j| j�sJ �t�|�}t�|�}d|jjks J �|j|jks(J �t|j| j�s1J �d S )Nz<a>some markup</a>z some markup) r# � isinstance�builderr �pickle�dumps�loads�a�string)r r# �pickled� unpickledr r r � test_pickle_restores_builder� s z3TestLXMLXMLTreeBuilder.test_pickle_restores_builderN) r: r; r< r= r> r rK r? r@ rA r rP rZ r r r r rB V s 5� 'rB )r= rS r? �rer) r" r r � bs4.builderr r �bs4r r � bs4.elementr r r r r r r r@ rA r rB r r r r �<module> s* �:�PK z�Z����� � . tests/__pycache__/test_builder.cpython-310.pycnu �[��� o �h[ � @ s4 d dl Z d dlmZ d dlmZ G dd� de�ZdS )� N)�patch)�DetectsXMLParsedAsHTMLc @ s& e Zd Zej�dg d��dd� �ZdS )�TestDetectsXMLParsedAsHTMLzmarkup,looks_like_xml))zNo xml declarationF)z<html>obviously HTML</htmlF)z"<?xml ><html>Actually XHTML</html>F)z/<?xml> < html>Tricky XHTML</html>F)z<?xml ><no-html-tag>Tc C sz t d��/}||�d�fD ] }t�|�}||ksJ �|r!|js J �n|jr&J �|�� q W d � d S 1 s6w Y d S )Nz(bs4.builder.DetectsXMLParsedAsHTML._warn�utf8)r �encoder � warn_if_markup_looks_like_xml�called� reset_mock)�self�markup�looks_like_xml�mock�data�result� r �I/usr/local/CyberCP/lib/python3.10/site-packages/bs4/tests/test_builder.py�"test_warn_if_markup_looks_like_xml s � �"�z=TestDetectsXMLParsedAsHTML.test_warn_if_markup_looks_like_xmlN)�__name__� __module__� __qualname__�pytest�mark� parametrizer r r r r r s � r )r � unittest.mockr � bs4.builderr �objectr r r r r �<module> s PK z�Z v|�K �K + tests/__pycache__/test_soup.cpython-310.pycnu �[��� o �h�M � @ s, d Z ddlmZ ddlZddlZddlZddlZddlZddlZddl m Z m Z m Z m Z mZ ddlmZmZmZ ddlmZmZmZmZmZ ddlmZmZm Z ddl Z G d d � d e �Z G d d � d e �Z G d d� de �Z G dd� de �Z!G dd� de �Z"G dd� de �Z#G dd� de �Z$G dd� de �Z%dS )z#Tests of Beautiful Soup as a whole.� )� set_traceN)� BeautifulSoup�BeautifulStoneSoup�GuessedAtParserWarning� MarkupResemblesLocatorWarning�dammit)�builder_registry� TreeBuilder�ParserRejectedMarkup)�Comment� SoupStrainer�PYTHON_SPECIFIC_ENCODINGS�Tag�NavigableString� )�default_builder� LXML_PRESENT�SoupTestc @ sL e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dS )�TestConstructorc C �" d}| � |�}d|jjksJ �d S )Nu <h1>éé</h1>u éé��soup�h1�string��self�datar � r �F/usr/local/CyberCP/lib/python3.10/site-packages/bs4/tests/test_soup.py�test_short_unicode_input) � z(TestConstructor.test_short_unicode_inputc C r )Nz<h1>foo bar</h1>zfoo barr r r r r �test_embedded_null. r z"TestConstructor.test_embedded_nullc C s, d� d�}| j|dgd�}d|jksJ �d S )Nu Räksmörgås�utf-8)�exclude_encodingsz windows-1252)�encoder �original_encoding)r � utf8_datar r r r �test_exclude_encodings3 s z&TestConstructor.test_exclude_encodingsc C s G dd� dt �}tddd�}tjdd�� tdd|i|��}W d � n1 s(w Y t|j|�s5J �tdd �|jjks@J �d |jjksHJ �|di |��}tjdd��}td|dd �}W d � n1 sgw Y t |d j �}|� d �szJ �||jks�J �||jks�J �d S )Nc @ sD e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Ze ZZ d d � Z d S )z7TestConstructor.test_custom_builder_class.<locals>.Mockc [ s( || _ d| _d| _g | _g | _i | _d S )NTF)� called_with�is_xml�store_line_numbers�cdata_list_attributes�preserve_whitespace_tags�string_containers)r �kwargsr r r �__init__< s z@TestConstructor.test_custom_builder_class.<locals>.Mock.__init__c S � d S �Nr �r r r r r �initialize_soupC � zGTestConstructor.test_custom_builder_class.<locals>.Mock.initialize_soupc S s || _ d S r1 )�fed)r �markupr r r �feedE s z<TestConstructor.test_custom_builder_class.<locals>.Mock.feedc S r0 r1 r �r r r r �resetG r4 z=TestConstructor.test_custom_builder_class.<locals>.Mock.resetc S r0 r1 r )r �ignorer r r r: I r4 z>TestConstructor.test_custom_builder_class.<locals>.Mock.ignorec s � dV d S )N)�prepared markupzoriginal encodingzdeclared encodingz contains replacement charactersr �r �argsr. r r r �prepare_markupL s � zFTestConstructor.test_custom_builder_class.<locals>.Mock.prepare_markupN) �__name__� __module__� __qualname__r/ r3 r7 r9 r: �set_up_substitutions�can_be_empty_elementr> r r r r �Mock; s rD �valueT)�var�convertEntities��record� �builder)rF r; )rK � ignored_valuer zCKeyword arguments to the BeautifulSoup constructor will be ignored.)rJ r ) �object�dict�warnings�catch_warningsr � isinstancerK r( r5 �str�message� startswith)r rD r. r rK �w�msgr r r �test_custom_builder_class8 s* � �� �z)TestConstructor.test_custom_builder_classc C sl G dd� dt �}dd� }dd l}t�t��}td|d� W d � n1 s&w Y dt|j�v s4J �d S ) Nc @ � e Zd Zdd� ZdS )z:TestConstructor.test_parser_markup_rejection.<locals>.Mockc _ s t d��)NzNope.)r r< r r r r7 l s z?TestConstructor.test_parser_markup_rejection.<locals>.Mock.feedN)r? r@ rA r7 r r r r rD k s rD c s" � t d d dfV t d d dfV d S )NF)r6 r< r r r r> o s �zDTestConstructor.test_parser_markup_rejection.<locals>.prepare_markupr rJ )rK zoThe markup you provided was rejected by the parser. Trying a different parser or a different encoding may help.)r �re�pytest�raisesr r rR rE )r rD r> rY �exc_infor r r � test_parser_markup_rejectionh s �z,TestConstructor.test_parser_markup_rejectionc C s� d}| � |�}|j}d|d ksJ �ddg|d ks J �| j |td d�}d|jd ks-J �ddiddifD ]5}tjd d ��}| j |d |d�}W d � n1 sPw Y |j}d dg|d ksbJ �d|d ksjJ �q5d S ) Nz&<a id=" an id " class=" a class "></a>z an id �id�a�class)rK �multi_valued_attributesz a class �*TrH �an)r r_ r rO rP )r r6 r r_ � switcheroorU r r r �test_cdata_list_attributes{ s ��z*TestConstructor.test_cdata_list_attributesc sp G dd� dt ��G dd� dt��G dd� dt�� | jdt �t�t� id�}t� ��fd d �|�� D ��s6J �d S ) Nc @ � e Zd ZdS )z9TestConstructor.test_replacement_classes.<locals>.TagPlusN�r? r@ rA r r r r �TagPlus� � rh c @ rf )z<TestConstructor.test_replacement_classes.<locals>.StringPlusNrg r r r r � StringPlus� ri rj c @ rf )z=TestConstructor.test_replacement_classes.<locals>.CommentPlusNrg r r r r � CommentPlus� ri rk z <a><b>foo</b>bar</a><!--whee-->)�element_classesc 3 s � | ] }t |��� f�V qd S r1 )rQ ��.0�x�rk rj rh r r � <genexpr>� s � � �z;TestConstructor.test_replacement_classes.<locals>.<genexpr>)r r r r �all�recursiveChildGeneratorr2 r rp r �test_replacement_classes� s �� �z(TestConstructor.test_replacement_classesc C s� G dd� dt �}G dd� dt �}| jd||d�d�}t|jjd t �s%J �t|jjd |�s0J �|jjD ] }t||�s=J �q4g |jksEJ �d S ) Nc @ rf )zATestConstructor.test_alternate_string_containers.<locals>.PStringNrg r r r r �PString� ri ru c @ rf )zATestConstructor.test_alternate_string_containers.<locals>.BStringNrg r r r r �BString� ri rv z4<div>Hello.<p>Here is <b>some <i>bolded</i></b> text)�b�p)r- r ) r r rQ �div�contentsrx rw �strings�string_container_stack)r ru rv r �sr r r � test_alternate_string_containers� s �� z0TestConstructor.test_alternate_string_containersN) r? r@ rA r r! r' rW r] re rt r~ r r r r r ' s 0 r c @ sT e Zd Zej�dddg�dd� �Zej�ddd� eD �d g �d d � �Zd d � Z d S )� TestOutputz!eventual_encoding,actual_encoding)r" r" )�utf-16r� c C s0 | � d�}d|_d|� d�|j|d�ksJ �d S )N� <tag></tag>Tz <?xml version="1.0" encoding="z"?> <tag></tag>��eventual_encoding)r r) �decode)r r� �actual_encodingr r r r �test_decode_xml_declaration� s �z&TestOutput.test_decode_xml_declarationr� c C s g | ]}|�qS r r rm r r r � <listcomp>� s zTestOutput.<listcomp>Nc C s( t dd�}d|_d|j|d�ksJ �d S )Nr� � html.parserTz!<?xml version="1.0"?> <tag></tag>r� )r r) r� )r r� r r r r �Mtest_decode_xml_declaration_with_missing_or_python_internal_eventual_encoding� s �zXTestOutput.test_decode_xml_declaration_with_missing_or_python_internal_eventual_encodingc C sV | � d�}d|jdd�ksJ �d|jdd�ksJ �d|�� ks!J �d|�� ks)J �d S )Nr� s <tag></tag>r" )�encodingz <tag> </tag> )r r$ �encode_contents�decode_contents�prettifyr2 r r r �test� s zTestOutput.test) r? r@ rA rZ �mark� parametrizer� r r� r� r r r r r � s �� � r c @ s� e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z e j � dg d��dd� �Ze j � dg d��dd� �Zdd� Zdd� Zd d � Zd d � Zd S )!� TestWarningsc C s< |D ]}t |j|�r|jtksJ �| S qtd||f ��)Nz%s warning not found in %r)rQ rS �filename�__file__� Exception)r rO �clsrU r r r �_assert_warning s �z TestWarnings._assert_warningc C s2 | � |t�}t|j�}|�tjd d� �sJ �d S )N�< )r� r rR rS rT r �NO_PARSER_SPECIFIED_WARNING)r rU �warningrS r r r �_assert_no_parser_specified s z(TestWarnings._assert_no_parser_specifiedc C sB t jdd�� }td�}W d � n1 sw Y | �|� d S �NTrH �<a><b></b></a>�rO rP r r� �r rU r r r r �#test_warning_if_no_parser_specified s �z0TestWarnings.test_warning_if_no_parser_specifiedc C sD t jdd�� }tdd�}W d � n1 sw Y | �|� d S )NTrH r� �htmlr� r� r r r �*test_warning_if_parser_specified_too_vague s �z7TestWarnings.test_warning_if_parser_specified_too_vaguec C sF t jdd�� }| �d�}W d � n1 sw Y g |ks!J �d S r� �rO rP r r� r r r �,test_no_warning_if_explicit_parser_specified s �z9TestWarnings.test_no_warning_if_explicit_parser_specifiedc C s� t jdd��}tddtd�d�}W d � n1 sw Y | �|t�}t|j�}d|v s0J �d|v s6J �d |�� ks>J �d S ) NTrH r� r� rw )�parseOnlyTheser� � parse_onlys <b></b>) rO rP r r r� �DeprecationWarningrR rS r$ )r rU r r� rV r r r �)test_parseOnlyThese_renamed_to_parse_only" s � � z6TestWarnings.test_parseOnlyThese_renamed_to_parse_onlyc C s~ t jdd��}d}t|ddd�}W d � n1 sw Y | �|t�}t|j�}d|v s0J �d|v s6J �d|jks=J �d S ) NTrH s ér� �utf8)� fromEncodingr� � from_encoding)rO rP r r� r� rR rS r% )r rU r� r r� rV r r r �*test_fromEncoding_renamed_to_from_encoding. s � � z7TestWarnings.test_fromEncoding_renamed_to_from_encodingc C s> t �t�� | jddd� W d � d S 1 sw Y d S )Nz<a>T)�no_such_argument)rZ r[ � TypeErrorr r8 r r r �"test_unrecognized_keyword_argument: s "�z/TestWarnings.test_unrecognized_keyword_argument� extension)z markup.htmlz markup.htmz markup.HTMLz markup.txtz markup.xhtmlz markup.xmlz/home/user/filez c:\user ilec C s^ t jdd�� }td| d�}| �|t�}dt|j�v s J �W d � d S 1 s(w Y d S )NTrH r6 r� zlooks more like a filename�rO rP r r� r rR rS )r r� rU r r� r r r � test_resembles_filename_warning> s "�z,TestWarnings.test_resembles_filename_warning)� markuphtmlz markup.comrJ z markup.jsc C sJ t jdd��}| �d| �}W d � n1 sw Y g |ks#J �d S )NTrH r6 r� )r r� rU r r r r �"test_resembles_filename_no_warningK s �z/TestWarnings.test_resembles_filename_no_warningc C st d}t jdd�� }t|d�}W d � n1 sw Y | �|t�}dt|j�v s,J �|t|j��d�vs8J �d S )Ns http://www.crummybytes.com/TrH r� �looks more like a URLr� )rO rP r r� r rR rS r$ �r �url� warning_listr r� r r r � test_url_warning_with_bytes_urlW s �� z,TestWarnings.test_url_warning_with_bytes_urlc C sn d}t jdd�� }t|d�}W d � n1 sw Y | �|t�}dt|j�v s,J �|t|j�vs5J �d S )Nz http://www.crummyunicode.com/TrH r� r� r� r� r r r �!test_url_warning_with_unicode_urla s ��z.TestWarnings.test_url_warning_with_unicode_urlc C �P t jdd�� }| �d�}W d � n1 sw Y tdd� |D ��r&J �d S )NTrH s$ http://www.crummybytes.com/ is greatc s � � | ] }d t |j�v V qdS �r� N�rR rS �rn rU r r r rq r � � �zETestWarnings.test_url_warning_with_bytes_and_space.<locals>.<genexpr>�rO rP r �any�r r� r r r r �%test_url_warning_with_bytes_and_spacem s ��z2TestWarnings.test_url_warning_with_bytes_and_spacec C r� )NTrH z&http://www.crummyunicode.com/ is greatc s r� r� r� r� r r r rq x r� zGTestWarnings.test_url_warning_with_unicode_and_space.<locals>.<genexpr>r� r� r r r �'test_url_warning_with_unicode_and_spaceu s ��z4TestWarnings.test_url_warning_with_unicode_and_spaceN)r? r@ rA r� r� r� r� r� r� r� r� rZ r� r� r� r� r� r� r� r� r r r r r� � s. � � r� c @ rX )�TestSelectiveParsingc C s. d}t d�}| j||d�}|�� dksJ �d S )Nz&No<b>Yes</b><a>No<b>Yes <c>Yes</c></b>rw )r� s <b>Yes</b><b>Yes <c>Yes</c></b>)r r r$ )r r6 �strainerr r r r � test_parse_with_soupstrainer~ s z1TestSelectiveParsing.test_parse_with_soupstrainerN)r? r@ rA r� r r r r r� | s r� c @ s: e Zd ZdZdd� Zejje dd�dd� �Z dd � Z d S ) � TestNewTagz(Test the BeautifulSoup.new_tag() method.c C sb | � d�}|jddddid�}t|t�sJ �d|jks J �tddd�|jks(J �d |jks/J �d S )NrJ �foo�baz�nameza name)�bar�attrs)r� r� )r �new_tagrQ r r� rN r� �parent)r r r� r r r � test_new_tag� s zTestNewTag.test_new_tagz-lxml not installed, cannot parse XML document)�reasonc C �B t dd�}|�d�}|�d�}d|�� ksJ �d|�� ks J �d S )NrJ �xml�brrx � <br/>s <p/>�r r� r$ )r �xml_soup�xml_br�xml_pr r r �5test_xml_tag_inherits_self_closing_rules_from_builder� s z@TestNewTag.test_xml_tag_inherits_self_closing_rules_from_builderc C r� )NrJ r� r� rx r� s <p></p>r� )r � html_soup�html_br�html_pr r r �1test_tag_inherits_self_closing_rules_from_builder� s z<TestNewTag.test_tag_inherits_self_closing_rules_from_builderN) r? r@ rA �__doc__r� rZ r� �skipifr r� r� r r r r r� � s � r� c @ s e Zd ZdZdd� Zdd� ZdS )� TestNewStringz+Test the BeautifulSoup.new_string() method.c C s2 | � d�}|�d�}d|ksJ �t|t�sJ �d S �NrJ r� )r � new_stringrQ r �r r r} r r r �'test_new_string_creates_navigablestring� s z5TestNewString.test_new_string_creates_navigablestringc C s4 | � d�}|�dt�}d|ksJ �t|t�sJ �d S r� )r r� r rQ r� r r r �3test_new_string_can_create_navigablestring_subclass� s zATestNewString.test_new_string_can_create_navigablestring_subclassN)r? r@ rA r� r� r� r r r r r� � s r� c @ s e Zd Zdd� Zdd� ZdS )� TestPicklec C s2 | � d�}t�|�}t�|�}d|jjksJ �d S )Nz<a>some markup</a>� some markup)r �pickle�dumps�loadsr_ r �r r �pickled� unpickledr r r �test_normal_pickle� s z TestPickle.test_normal_picklec C s6 | � d�}d |_t�|�}t�|�}d|jksJ �d S )Nr� )r rK r� r� r� r r� r r r �test_pickle_with_no_builder� s z&TestPickle.test_pickle_with_no_builderN)r? r@ rA r� r� r r r r r� � s r� c @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd S ) �TestEncodingConversionc C s& d| _ | j �d�| _| jdksJ �d S )NuU <html><head><meta charset="utf-8"/></head><body><foo>Sacré bleu!</foo></body></html>r" sU <html><head><meta charset="utf-8"/></head><body><foo>Sacré bleu!</foo></body></html>)� unicode_datar$ r& r8 r r r � setup_method� s z#TestEncodingConversion.setup_methodc C s� t j}t�tj� z9dd� }|t _d}| �|�}|�� }t|t�s#J �|| � |�� �ks.J �|j � � dks7J �W t�tj � |t _d S t�tj � |t _w )Nc S r0 r1 r )rR r r r �noop� r4 z>TestEncodingConversion.test_ascii_in_unicode_out.<locals>.noops <foo>a</foo>r" ) r �chardet_dammit�logging�disable�WARNINGr r� rQ rR � document_forr% �lower�NOTSET)r �chardetr� �ascii�soup_from_ascii�unicode_outputr r r �test_ascii_in_unicode_out� s �z0TestEncodingConversion.test_ascii_in_unicode_outc C s@ | � | j�}|�� | jksJ �|jjdksJ �|jd ks J �d S �Nu Sacré bleu!)r r� r� r� r r% �r �soup_from_unicoder r r �test_unicode_in_unicode_out� s z2TestEncodingConversion.test_unicode_in_unicode_outc C s2 | � | j�}|�� | jksJ �|jjdksJ �d S r )r r& r� r� r� r )r �soup_from_utf8r r r �test_utf8_in_unicode_out� s z/TestEncodingConversion.test_utf8_in_unicode_outc C s$ | � | j�}|�d�| jksJ �d S )Nr" )r r� r$ r& r r r r � test_utf8_out� s z$TestEncodingConversion.test_utf8_outN)r? r@ rA r� r r r r r r r r r� � s r� )&r� �pdbr r� �osr� rZ �sys�tempfile�bs4r r r r r � bs4.builderr r r � bs4.elementr r r r r rJ r r r rO r r r� r� r� r� r� r� r r r r �<module> s, 0)} "PK z�Z�a� �M �M tests/test_soup.pynu �[��� # -*- coding: utf-8 -*- """Tests of Beautiful Soup as a whole.""" from pdb import set_trace import logging import os import pickle import pytest import sys import tempfile from bs4 import ( BeautifulSoup, BeautifulStoneSoup, GuessedAtParserWarning, MarkupResemblesLocatorWarning, dammit, ) from bs4.builder import ( builder_registry, TreeBuilder, ParserRejectedMarkup, ) from bs4.element import ( Comment, SoupStrainer, PYTHON_SPECIFIC_ENCODINGS, Tag, NavigableString, ) from . import ( default_builder, LXML_PRESENT, SoupTest, ) import warnings class TestConstructor(SoupTest): def test_short_unicode_input(self): data = "<h1>éé</h1>" soup = self.soup(data) assert "éé" == soup.h1.string def test_embedded_null(self): data = "<h1>foo\0bar</h1>" soup = self.soup(data) assert "foo\0bar" == soup.h1.string def test_exclude_encodings(self): utf8_data = "Räksmörgås".encode("utf-8") soup = self.soup(utf8_data, exclude_encodings=["utf-8"]) assert "windows-1252" == soup.original_encoding def test_custom_builder_class(self): # Verify that you can pass in a custom Builder class and # it'll be instantiated with the appropriate keyword arguments. class Mock(object): def __init__(self, **kwargs): self.called_with = kwargs self.is_xml = True self.store_line_numbers = False self.cdata_list_attributes = [] self.preserve_whitespace_tags = [] self.string_containers = {} def initialize_soup(self, soup): pass def feed(self, markup): self.fed = markup def reset(self): pass def ignore(self, ignore): pass set_up_substitutions = can_be_empty_element = ignore def prepare_markup(self, *args, **kwargs): yield "prepared markup", "original encoding", "declared encoding", "contains replacement characters" kwargs = dict( var="value", # This is a deprecated BS3-era keyword argument, which # will be stripped out. convertEntities=True, ) with warnings.catch_warnings(record=True): soup = BeautifulSoup('', builder=Mock, **kwargs) assert isinstance(soup.builder, Mock) assert dict(var="value") == soup.builder.called_with assert "prepared markup" == soup.builder.fed # You can also instantiate the TreeBuilder yourself. In this # case, that specific object is used and any keyword arguments # to the BeautifulSoup constructor are ignored. builder = Mock(**kwargs) with warnings.catch_warnings(record=True) as w: soup = BeautifulSoup( '', builder=builder, ignored_value=True, ) msg = str(w[0].message) assert msg.startswith("Keyword arguments to the BeautifulSoup constructor will be ignored.") assert builder == soup.builder assert kwargs == builder.called_with def test_parser_markup_rejection(self): # If markup is completely rejected by the parser, an # explanatory ParserRejectedMarkup exception is raised. class Mock(TreeBuilder): def feed(self, *args, **kwargs): raise ParserRejectedMarkup("Nope.") def prepare_markup(self, *args, **kwargs): # We're going to try two different ways of preparing this markup, # but feed() will reject both of them. yield markup, None, None, False yield markup, None, None, False import re with pytest.raises(ParserRejectedMarkup) as exc_info: BeautifulSoup('', builder=Mock) assert "The markup you provided was rejected by the parser. Trying a different parser or a different encoding may help." in str(exc_info.value) def test_cdata_list_attributes(self): # Most attribute values are represented as scalars, but the # HTML standard says that some attributes, like 'class' have # space-separated lists as values. markup = '<a id=" an id " class=" a class "></a>' soup = self.soup(markup) # Note that the spaces are stripped for 'class' but not for 'id'. a = soup.a assert " an id " == a['id'] assert ["a", "class"] == a['class'] # TreeBuilder takes an argument called 'multi_valued_attributes' which lets # you customize or disable this. As always, you can customize the TreeBuilder # by passing in a keyword argument to the BeautifulSoup constructor. soup = self.soup(markup, builder=default_builder, multi_valued_attributes=None) assert " a class " == soup.a['class'] # Here are two ways of saying that `id` is a multi-valued # attribute in this context, but 'class' is not. for switcheroo in ({'*': 'id'}, {'a': 'id'}): with warnings.catch_warnings(record=True) as w: # This will create a warning about not explicitly # specifying a parser, but we'll ignore it. soup = self.soup(markup, builder=None, multi_valued_attributes=switcheroo) a = soup.a assert ["an", "id"] == a['id'] assert " a class " == a['class'] def test_replacement_classes(self): # Test the ability to pass in replacements for element classes # which will be used when building the tree. class TagPlus(Tag): pass class StringPlus(NavigableString): pass class CommentPlus(Comment): pass soup = self.soup( "<a><b>foo</b>bar</a><!--whee-->", element_classes = { Tag: TagPlus, NavigableString: StringPlus, Comment: CommentPlus, } ) # The tree was built with TagPlus, StringPlus, and CommentPlus objects, # rather than Tag, String, and Comment objects. assert all( isinstance(x, (TagPlus, StringPlus, CommentPlus)) for x in soup.recursiveChildGenerator() ) def test_alternate_string_containers(self): # Test the ability to customize the string containers for # different types of tags. class PString(NavigableString): pass class BString(NavigableString): pass soup = self.soup( "<div>Hello.<p>Here is <b>some <i>bolded</i></b> text", string_containers = { 'b': BString, 'p': PString, } ) # The string before the <p> tag is a regular NavigableString. assert isinstance(soup.div.contents[0], NavigableString) # The string inside the <p> tag, but not inside the <i> tag, # is a PString. assert isinstance(soup.p.contents[0], PString) # Every string inside the <b> tag is a BString, even the one that # was also inside an <i> tag. for s in soup.b.strings: assert isinstance(s, BString) # Now that parsing was complete, the string_container_stack # (where this information was kept) has been cleared out. assert [] == soup.string_container_stack class TestOutput(SoupTest): @pytest.mark.parametrize( "eventual_encoding,actual_encoding", [ ("utf-8", "utf-8"), ("utf-16", "utf-16"), ] ) def test_decode_xml_declaration(self, eventual_encoding, actual_encoding): # Most of the time, calling decode() on an XML document will # give you a document declaration that mentions the encoding # you intend to use when encoding the document as a # bytestring. soup = self.soup("<tag></tag>") soup.is_xml = True assert (f'<?xml version="1.0" encoding="{actual_encoding}"?>\n<tag></tag>' == soup.decode(eventual_encoding=eventual_encoding)) @pytest.mark.parametrize( "eventual_encoding", [x for x in PYTHON_SPECIFIC_ENCODINGS] + [None] ) def test_decode_xml_declaration_with_missing_or_python_internal_eventual_encoding(self, eventual_encoding): # But if you pass a Python internal encoding into decode(), or # omit the eventual_encoding altogether, the document # declaration won't mention any particular encoding. soup = BeautifulSoup("<tag></tag>", "html.parser") soup.is_xml = True assert (f'<?xml version="1.0"?>\n<tag></tag>' == soup.decode(eventual_encoding=eventual_encoding)) def test(self): # BeautifulSoup subclasses Tag and extends the decode() method. # Make sure the other Tag methods which call decode() call # it correctly. soup = self.soup("<tag></tag>") assert b"<tag></tag>" == soup.encode(encoding="utf-8") assert b"<tag></tag>" == soup.encode_contents(encoding="utf-8") assert "<tag></tag>" == soup.decode_contents() assert "<tag>\n</tag>\n" == soup.prettify() class TestWarnings(SoupTest): # Note that some of the tests in this class create BeautifulSoup # objects directly rather than using self.soup(). That's # because SoupTest.soup is defined in a different file, # which will throw off the assertion in _assert_warning # that the code that triggered the warning is in the same # file as the test. def _assert_warning(self, warnings, cls): for w in warnings: if isinstance(w.message, cls): assert w.filename == __file__ return w raise Exception("%s warning not found in %r" % (cls, warnings)) def _assert_no_parser_specified(self, w): warning = self._assert_warning(w, GuessedAtParserWarning) message = str(warning.message) assert message.startswith(BeautifulSoup.NO_PARSER_SPECIFIED_WARNING[:60]) def test_warning_if_no_parser_specified(self): with warnings.catch_warnings(record=True) as w: soup = BeautifulSoup("<a><b></b></a>") self._assert_no_parser_specified(w) def test_warning_if_parser_specified_too_vague(self): with warnings.catch_warnings(record=True) as w: soup = BeautifulSoup("<a><b></b></a>", "html") self._assert_no_parser_specified(w) def test_no_warning_if_explicit_parser_specified(self): with warnings.catch_warnings(record=True) as w: soup = self.soup("<a><b></b></a>") assert [] == w def test_parseOnlyThese_renamed_to_parse_only(self): with warnings.catch_warnings(record=True) as w: soup = BeautifulSoup( "<a><b></b></a>", "html.parser", parseOnlyThese=SoupStrainer("b"), ) warning = self._assert_warning(w, DeprecationWarning) msg = str(warning.message) assert "parseOnlyThese" in msg assert "parse_only" in msg assert b"<b></b>" == soup.encode() def test_fromEncoding_renamed_to_from_encoding(self): with warnings.catch_warnings(record=True) as w: utf8 = b"\xc3\xa9" soup = BeautifulSoup( utf8, "html.parser", fromEncoding="utf8" ) warning = self._assert_warning(w, DeprecationWarning) msg = str(warning.message) assert "fromEncoding" in msg assert "from_encoding" in msg assert "utf8" == soup.original_encoding def test_unrecognized_keyword_argument(self): with pytest.raises(TypeError): self.soup("<a>", no_such_argument=True) @pytest.mark.parametrize( "extension", ['markup.html', 'markup.htm', 'markup.HTML', 'markup.txt', 'markup.xhtml', 'markup.xml', "/home/user/file", "c:\\user\file"] ) def test_resembles_filename_warning(self, extension): # A warning is issued if the "markup" looks like the name of # an HTML or text file, or a full path to a file on disk. with warnings.catch_warnings(record=True) as w: soup = BeautifulSoup("markup" + extension, "html.parser") warning = self._assert_warning(w, MarkupResemblesLocatorWarning) assert "looks more like a filename" in str(warning.message) @pytest.mark.parametrize( "extension", ['markuphtml', 'markup.com', '', 'markup.js'] ) def test_resembles_filename_no_warning(self, extension): # The 'looks more like a filename' warning is not issued if # the markup looks like a bare string, a domain name, or a # file that's not an HTML file. with warnings.catch_warnings(record=True) as w: soup = self.soup("markup" + extension) assert [] == w def test_url_warning_with_bytes_url(self): url = b"http://www.crummybytes.com/" with warnings.catch_warnings(record=True) as warning_list: soup = BeautifulSoup(url, "html.parser") warning = self._assert_warning( warning_list, MarkupResemblesLocatorWarning ) assert "looks more like a URL" in str(warning.message) assert url not in str(warning.message).encode("utf8") def test_url_warning_with_unicode_url(self): url = "http://www.crummyunicode.com/" with warnings.catch_warnings(record=True) as warning_list: # note - this url must differ from the bytes one otherwise # python's warnings system swallows the second warning soup = BeautifulSoup(url, "html.parser") warning = self._assert_warning( warning_list, MarkupResemblesLocatorWarning ) assert "looks more like a URL" in str(warning.message) assert url not in str(warning.message) def test_url_warning_with_bytes_and_space(self): # Here the markup contains something besides a URL, so no warning # is issued. with warnings.catch_warnings(record=True) as warning_list: soup = self.soup(b"http://www.crummybytes.com/ is great") assert not any("looks more like a URL" in str(w.message) for w in warning_list) def test_url_warning_with_unicode_and_space(self): with warnings.catch_warnings(record=True) as warning_list: soup = self.soup("http://www.crummyunicode.com/ is great") assert not any("looks more like a URL" in str(w.message) for w in warning_list) class TestSelectiveParsing(SoupTest): def test_parse_with_soupstrainer(self): markup = "No<b>Yes</b><a>No<b>Yes <c>Yes</c></b>" strainer = SoupStrainer("b") soup = self.soup(markup, parse_only=strainer) assert soup.encode() == b"<b>Yes</b><b>Yes <c>Yes</c></b>" class TestNewTag(SoupTest): """Test the BeautifulSoup.new_tag() method.""" def test_new_tag(self): soup = self.soup("") new_tag = soup.new_tag("foo", bar="baz", attrs={"name": "a name"}) assert isinstance(new_tag, Tag) assert "foo" == new_tag.name assert dict(bar="baz", name="a name") == new_tag.attrs assert None == new_tag.parent @pytest.mark.skipif( not LXML_PRESENT, reason="lxml not installed, cannot parse XML document" ) def test_xml_tag_inherits_self_closing_rules_from_builder(self): xml_soup = BeautifulSoup("", "xml") xml_br = xml_soup.new_tag("br") xml_p = xml_soup.new_tag("p") # Both the <br> and <p> tag are empty-element, just because # they have no contents. assert b"<br/>" == xml_br.encode() assert b"<p/>" == xml_p.encode() def test_tag_inherits_self_closing_rules_from_builder(self): html_soup = BeautifulSoup("", "html.parser") html_br = html_soup.new_tag("br") html_p = html_soup.new_tag("p") # The HTML builder users HTML's rules about which tags are # empty-element tags, and the new tags reflect these rules. assert b"<br/>" == html_br.encode() assert b"<p></p>" == html_p.encode() class TestNewString(SoupTest): """Test the BeautifulSoup.new_string() method.""" def test_new_string_creates_navigablestring(self): soup = self.soup("") s = soup.new_string("foo") assert "foo" == s assert isinstance(s, NavigableString) def test_new_string_can_create_navigablestring_subclass(self): soup = self.soup("") s = soup.new_string("foo", Comment) assert "foo" == s assert isinstance(s, Comment) class TestPickle(SoupTest): # Test our ability to pickle the BeautifulSoup object itself. def test_normal_pickle(self): soup = self.soup("<a>some markup</a>") pickled = pickle.dumps(soup) unpickled = pickle.loads(pickled) assert "some markup" == unpickled.a.string def test_pickle_with_no_builder(self): # We had a bug that prevented pickling from working if # the builder wasn't set. soup = self.soup("some markup") soup.builder = None pickled = pickle.dumps(soup) unpickled = pickle.loads(pickled) assert "some markup" == unpickled.string class TestEncodingConversion(SoupTest): # Test Beautiful Soup's ability to decode and encode from various # encodings. def setup_method(self): self.unicode_data = '<html><head><meta charset="utf-8"/></head><body><foo>Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!</foo></body></html>' self.utf8_data = self.unicode_data.encode("utf-8") # Just so you know what it looks like. assert self.utf8_data == b'<html><head><meta charset="utf-8"/></head><body><foo>Sacr\xc3\xa9 bleu!</foo></body></html>' def test_ascii_in_unicode_out(self): # ASCII input is converted to Unicode. The original_encoding # attribute is set to 'utf-8', a superset of ASCII. chardet = dammit.chardet_dammit logging.disable(logging.WARNING) try: def noop(str): return None # Disable chardet, which will realize that the ASCII is ASCII. dammit.chardet_dammit = noop ascii = b"<foo>a</foo>" soup_from_ascii = self.soup(ascii) unicode_output = soup_from_ascii.decode() assert isinstance(unicode_output, str) assert unicode_output == self.document_for(ascii.decode()) assert soup_from_ascii.original_encoding.lower() == "utf-8" finally: logging.disable(logging.NOTSET) dammit.chardet_dammit = chardet def test_unicode_in_unicode_out(self): # Unicode input is left alone. The original_encoding attribute # is not set. soup_from_unicode = self.soup(self.unicode_data) assert soup_from_unicode.decode() == self.unicode_data assert soup_from_unicode.foo.string == 'Sacr\xe9 bleu!' assert soup_from_unicode.original_encoding == None def test_utf8_in_unicode_out(self): # UTF-8 input is converted to Unicode. The original_encoding # attribute is set. soup_from_utf8 = self.soup(self.utf8_data) assert soup_from_utf8.decode() == self.unicode_data assert soup_from_utf8.foo.string == 'Sacr\xe9 bleu!' def test_utf8_out(self): # The internal data structures can be encoded as UTF-8. soup_from_unicode = self.soup(self.unicode_data) assert soup_from_unicode.encode('utf-8') == self.utf8_data PK z�Z�jT�� � tests/test_tree.pynu �[��� # -*- coding: utf-8 -*- """Tests for Beautiful Soup's tree traversal methods. The tree traversal methods are the main advantage of using Beautiful Soup over just using a parser. Different parsers will build different Beautiful Soup trees given the same markup, but all Beautiful Soup trees can be traversed with the methods tested here. """ from pdb import set_trace import pytest import re import warnings from bs4 import BeautifulSoup from bs4.builder import ( builder_registry, HTMLParserTreeBuilder, ) from bs4.element import ( CData, Comment, Declaration, Doctype, Formatter, NavigableString, Script, SoupStrainer, Stylesheet, Tag, TemplateString, ) from . import ( SoupTest, ) class TestFind(SoupTest): """Basic tests of the find() method. find() just calls find_all() with limit=1, so it's not tested all that thouroughly here. """ def test_find_tag(self): soup = self.soup("<a>1</a><b>2</b><a>3</a><b>4</b>") assert soup.find("b").string == "2" def test_unicode_text_find(self): soup = self.soup('<h1>Räksmörgås</h1>') assert soup.find(string='Räksmörgås') == 'Räksmörgås' def test_unicode_attribute_find(self): soup = self.soup('<h1 id="Räksmörgås">here it is</h1>') str(soup) assert "here it is" == soup.find(id='Räksmörgås').text def test_find_everything(self): """Test an optimization that finds all tags.""" soup = self.soup("<a>foo</a><b>bar</b>") assert 2 == len(soup.find_all()) def test_find_everything_with_name(self): """Test an optimization that finds all tags with a given name.""" soup = self.soup("<a>foo</a><b>bar</b><a>baz</a>") assert 2 == len(soup.find_all('a')) class TestFindAll(SoupTest): """Basic tests of the find_all() method.""" def test_find_all_text_nodes(self): """You can search the tree for text nodes.""" soup = self.soup("<html>Foo<b>bar</b>\xbb</html>") # Exact match. assert soup.find_all(string="bar") == ["bar"] # Match any of a number of strings. assert soup.find_all(string=["Foo", "bar"]) == ["Foo", "bar"] # Match a regular expression. assert soup.find_all(string=re.compile('.*')) == ["Foo", "bar", '\xbb'] # Match anything. assert soup.find_all(string=True) == ["Foo", "bar", '\xbb'] def test_find_all_limit(self): """You can limit the number of items returned by find_all.""" soup = self.soup("<a>1</a><a>2</a><a>3</a><a>4</a><a>5</a>") self.assert_selects(soup.find_all('a', limit=3), ["1", "2", "3"]) self.assert_selects(soup.find_all('a', limit=1), ["1"]) self.assert_selects( soup.find_all('a', limit=10), ["1", "2", "3", "4", "5"]) # A limit of 0 means no limit. self.assert_selects( soup.find_all('a', limit=0), ["1", "2", "3", "4", "5"]) def test_calling_a_tag_is_calling_findall(self): soup = self.soup("<a>1</a><b>2<a id='foo'>3</a></b>") self.assert_selects(soup('a', limit=1), ["1"]) self.assert_selects(soup.b(id="foo"), ["3"]) def test_find_all_with_self_referential_data_structure_does_not_cause_infinite_recursion(self): soup = self.soup("<a></a>") # Create a self-referential list. l = [] l.append(l) # Without special code in _normalize_search_value, this would cause infinite # recursion. assert [] == soup.find_all(l) def test_find_all_resultset(self): """All find_all calls return a ResultSet""" soup = self.soup("<a></a>") result = soup.find_all("a") assert hasattr(result, "source") result = soup.find_all(True) assert hasattr(result, "source") result = soup.find_all(string="foo") assert hasattr(result, "source") class TestFindAllBasicNamespaces(SoupTest): def test_find_by_namespaced_name(self): soup = self.soup('<mathml:msqrt>4</mathml:msqrt><a svg:fill="red">') assert "4" == soup.find("mathml:msqrt").string assert "a" == soup.find(attrs= { "svg:fill" : "red" }).name class TestFindAllByName(SoupTest): """Test ways of finding tags by tag name.""" def setup_method(self): self.tree = self.soup("""<a>First tag.</a> <b>Second tag.</b> <c>Third <a>Nested tag.</a> tag.</c>""") def test_find_all_by_tag_name(self): # Find all the <a> tags. self.assert_selects( self.tree.find_all('a'), ['First tag.', 'Nested tag.']) def test_find_all_by_name_and_text(self): self.assert_selects( self.tree.find_all('a', string='First tag.'), ['First tag.']) self.assert_selects( self.tree.find_all('a', string=True), ['First tag.', 'Nested tag.']) self.assert_selects( self.tree.find_all('a', string=re.compile("tag")), ['First tag.', 'Nested tag.']) def test_find_all_on_non_root_element(self): # You can call find_all on any node, not just the root. self.assert_selects(self.tree.c.find_all('a'), ['Nested tag.']) def test_calling_element_invokes_find_all(self): self.assert_selects(self.tree('a'), ['First tag.', 'Nested tag.']) def test_find_all_by_tag_strainer(self): self.assert_selects( self.tree.find_all(SoupStrainer('a')), ['First tag.', 'Nested tag.']) def test_find_all_by_tag_names(self): self.assert_selects( self.tree.find_all(['a', 'b']), ['First tag.', 'Second tag.', 'Nested tag.']) def test_find_all_by_tag_dict(self): self.assert_selects( self.tree.find_all({'a' : True, 'b' : True}), ['First tag.', 'Second tag.', 'Nested tag.']) def test_find_all_by_tag_re(self): self.assert_selects( self.tree.find_all(re.compile('^[ab]$')), ['First tag.', 'Second tag.', 'Nested tag.']) def test_find_all_with_tags_matching_method(self): # You can define an oracle method that determines whether # a tag matches the search. def id_matches_name(tag): return tag.name == tag.get('id') tree = self.soup("""<a id="a">Match 1.</a> <a id="1">Does not match.</a> <b id="b">Match 2.</a>""") self.assert_selects( tree.find_all(id_matches_name), ["Match 1.", "Match 2."]) def test_find_with_multi_valued_attribute(self): soup = self.soup( "<div class='a b'>1</div><div class='a c'>2</div><div class='a d'>3</div>" ) r1 = soup.find('div', 'a d'); r2 = soup.find('div', re.compile(r'a d')); r3, r4 = soup.find_all('div', ['a b', 'a d']); assert '3' == r1.string assert '3' == r2.string assert '1' == r3.string assert '3' == r4.string class TestFindAllByAttribute(SoupTest): def test_find_all_by_attribute_name(self): # You can pass in keyword arguments to find_all to search by # attribute. tree = self.soup(""" <a id="first">Matching a.</a> <a id="second"> Non-matching <b id="first">Matching b.</b>a. </a>""") self.assert_selects(tree.find_all(id='first'), ["Matching a.", "Matching b."]) def test_find_all_by_utf8_attribute_value(self): peace = "םולש".encode("utf8") data = '<a title="םולש"></a>'.encode("utf8") soup = self.soup(data) assert [soup.a] == soup.find_all(title=peace) assert [soup.a] == soup.find_all(title=peace.decode("utf8")) assert [soup.a], soup.find_all(title=[peace, "something else"]) def test_find_all_by_attribute_dict(self): # You can pass in a dictionary as the argument 'attrs'. This # lets you search for attributes like 'name' (a fixed argument # to find_all) and 'class' (a reserved word in Python.) tree = self.soup(""" <a name="name1" class="class1">Name match.</a> <a name="name2" class="class2">Class match.</a> <a name="name3" class="class3">Non-match.</a> <name1>A tag called 'name1'.</name1> """) # This doesn't do what you want. self.assert_selects(tree.find_all(name='name1'), ["A tag called 'name1'."]) # This does what you want. self.assert_selects(tree.find_all(attrs={'name' : 'name1'}), ["Name match."]) self.assert_selects(tree.find_all(attrs={'class' : 'class2'}), ["Class match."]) def test_find_all_by_class(self): tree = self.soup(""" <a class="1">Class 1.</a> <a class="2">Class 2.</a> <b class="1">Class 1.</b> <c class="3 4">Class 3 and 4.</c> """) # Passing in the class_ keyword argument will search against # the 'class' attribute. self.assert_selects(tree.find_all('a', class_='1'), ['Class 1.']) self.assert_selects(tree.find_all('c', class_='3'), ['Class 3 and 4.']) self.assert_selects(tree.find_all('c', class_='4'), ['Class 3 and 4.']) # Passing in a string to 'attrs' will also search the CSS class. self.assert_selects(tree.find_all('a', '1'), ['Class 1.']) self.assert_selects(tree.find_all(attrs='1'), ['Class 1.', 'Class 1.']) self.assert_selects(tree.find_all('c', '3'), ['Class 3 and 4.']) self.assert_selects(tree.find_all('c', '4'), ['Class 3 and 4.']) def test_find_by_class_when_multiple_classes_present(self): tree = self.soup("<gar class='foo bar'>Found it</gar>") f = tree.find_all("gar", class_=re.compile("o")) self.assert_selects(f, ["Found it"]) f = tree.find_all("gar", class_=re.compile("a")) self.assert_selects(f, ["Found it"]) # If the search fails to match the individual strings "foo" and "bar", # it will be tried against the combined string "foo bar". f = tree.find_all("gar", class_=re.compile("o b")) self.assert_selects(f, ["Found it"]) def test_find_all_with_non_dictionary_for_attrs_finds_by_class(self): soup = self.soup("<a class='bar'>Found it</a>") self.assert_selects(soup.find_all("a", re.compile("ba")), ["Found it"]) def big_attribute_value(value): return len(value) > 3 self.assert_selects(soup.find_all("a", big_attribute_value), []) def small_attribute_value(value): return len(value) <= 3 self.assert_selects( soup.find_all("a", small_attribute_value), ["Found it"]) def test_find_all_with_string_for_attrs_finds_multiple_classes(self): soup = self.soup('<a class="foo bar"></a><a class="foo"></a>') a, a2 = soup.find_all("a") assert [a, a2], soup.find_all("a", "foo") assert [a], soup.find_all("a", "bar") # If you specify the class as a string that contains a # space, only that specific value will be found. assert [a] == soup.find_all("a", class_="foo bar") assert [a] == soup.find_all("a", "foo bar") assert [] == soup.find_all("a", "bar foo") def test_find_all_by_attribute_soupstrainer(self): tree = self.soup(""" <a id="first">Match.</a> <a id="second">Non-match.</a>""") strainer = SoupStrainer(attrs={'id' : 'first'}) self.assert_selects(tree.find_all(strainer), ['Match.']) def test_find_all_with_missing_attribute(self): # You can pass in None as the value of an attribute to find_all. # This will match tags that do not have that attribute set. tree = self.soup("""<a id="1">ID present.</a> <a>No ID present.</a> <a id="">ID is empty.</a>""") self.assert_selects(tree.find_all('a', id=None), ["No ID present."]) def test_find_all_with_defined_attribute(self): # You can pass in None as the value of an attribute to find_all. # This will match tags that have that attribute set to any value. tree = self.soup("""<a id="1">ID present.</a> <a>No ID present.</a> <a id="">ID is empty.</a>""") self.assert_selects( tree.find_all(id=True), ["ID present.", "ID is empty."]) def test_find_all_with_numeric_attribute(self): # If you search for a number, it's treated as a string. tree = self.soup("""<a id=1>Unquoted attribute.</a> <a id="1">Quoted attribute.</a>""") expected = ["Unquoted attribute.", "Quoted attribute."] self.assert_selects(tree.find_all(id=1), expected) self.assert_selects(tree.find_all(id="1"), expected) def test_find_all_with_list_attribute_values(self): # You can pass a list of attribute values instead of just one, # and you'll get tags that match any of the values. tree = self.soup("""<a id="1">1</a> <a id="2">2</a> <a id="3">3</a> <a>No ID.</a>""") self.assert_selects(tree.find_all(id=["1", "3", "4"]), ["1", "3"]) def test_find_all_with_regular_expression_attribute_value(self): # You can pass a regular expression as an attribute value, and # you'll get tags whose values for that attribute match the # regular expression. tree = self.soup("""<a id="a">One a.</a> <a id="aa">Two as.</a> <a id="ab">Mixed as and bs.</a> <a id="b">One b.</a> <a>No ID.</a>""") self.assert_selects(tree.find_all(id=re.compile("^a+$")), ["One a.", "Two as."]) def test_find_by_name_and_containing_string(self): soup = self.soup("<b>foo</b><b>bar</b><a>foo</a>") a = soup.a assert [a] == soup.find_all("a", string="foo") assert [] == soup.find_all("a", string="bar") def test_find_by_name_and_containing_string_when_string_is_buried(self): soup = self.soup("<a>foo</a><a><b><c>foo</c></b></a>") assert soup.find_all("a") == soup.find_all("a", string="foo") def test_find_by_attribute_and_containing_string(self): soup = self.soup('<b id="1">foo</b><a id="2">foo</a>') a = soup.a assert [a] == soup.find_all(id=2, string="foo") assert [] == soup.find_all(id=1, string="bar") class TestSmooth(SoupTest): """Test Tag.smooth.""" def test_smooth(self): soup = self.soup("<div>a</div>") div = soup.div div.append("b") div.append("c") div.append(Comment("Comment 1")) div.append(Comment("Comment 2")) div.append("d") builder = self.default_builder() span = Tag(soup, builder, 'span') span.append('1') span.append('2') div.append(span) # At this point the tree has a bunch of adjacent # NavigableStrings. This is normal, but it has no meaning in # terms of HTML, so we may want to smooth things out for # output. # Since the <span> tag has two children, its .string is None. assert None == div.span.string assert 7 == len(div.contents) div.smooth() assert 5 == len(div.contents) # The three strings at the beginning of div.contents have been # merged into on string. # assert 'abc' == div.contents[0] # The call is recursive -- the <span> tag was also smoothed. assert '12' == div.span.string # The two comments have _not_ been merged, even though # comments are strings. Merging comments would change the # meaning of the HTML. assert 'Comment 1' == div.contents[1] assert 'Comment 2' == div.contents[2] class TestIndex(SoupTest): """Test Tag.index""" def test_index(self): tree = self.soup("""<div> <a>Identical</a> <b>Not identical</b> <a>Identical</a> <c><d>Identical with child</d></c> <b>Also not identical</b> <c><d>Identical with child</d></c> </div>""") div = tree.div for i, element in enumerate(div.contents): assert i == div.index(element) with pytest.raises(ValueError): tree.index(1) class TestParentOperations(SoupTest): """Test navigation and searching through an element's parents.""" def setup_method(self): self.tree = self.soup('''<ul id="empty"></ul> <ul id="top"> <ul id="middle"> <ul id="bottom"> <b>Start here</b> </ul> </ul>''') self.start = self.tree.b def test_parent(self): assert self.start.parent['id'] == 'bottom' assert self.start.parent.parent['id'] == 'middle' assert self.start.parent.parent.parent['id'] == 'top' def test_parent_of_top_tag_is_soup_object(self): top_tag = self.tree.contents[0] assert top_tag.parent == self.tree def test_soup_object_has_no_parent(self): assert None == self.tree.parent def test_find_parents(self): self.assert_selects_ids( self.start.find_parents('ul'), ['bottom', 'middle', 'top']) self.assert_selects_ids( self.start.find_parents('ul', id="middle"), ['middle']) def test_find_parent(self): assert self.start.find_parent('ul')['id'] == 'bottom' assert self.start.find_parent('ul', id='top')['id'] == 'top' def test_parent_of_text_element(self): text = self.tree.find(string="Start here") assert text.parent.name == 'b' def test_text_element_find_parent(self): text = self.tree.find(string="Start here") assert text.find_parent('ul')['id'] == 'bottom' def test_parent_generator(self): parents = [parent['id'] for parent in self.start.parents if parent is not None and 'id' in parent.attrs] assert parents, ['bottom', 'middle' == 'top'] class ProximityTest(SoupTest): def setup_method(self): self.tree = self.soup( '<html id="start"><head></head><body><b id="1">One</b><b id="2">Two</b><b id="3">Three</b></body></html>') class TestNextOperations(ProximityTest): def setup_method(self): super(TestNextOperations, self).setup_method() self.start = self.tree.b def test_next(self): assert self.start.next_element == "One" assert self.start.next_element.next_element['id'] == "2" def test_next_of_last_item_is_none(self): last = self.tree.find(string="Three") assert last.next_element == None def test_next_of_root_is_none(self): # The document root is outside the next/previous chain. assert self.tree.next_element == None def test_find_all_next(self): self.assert_selects(self.start.find_all_next('b'), ["Two", "Three"]) self.start.find_all_next(id=3) self.assert_selects(self.start.find_all_next(id=3), ["Three"]) def test_find_next(self): assert self.start.find_next('b')['id'] == '2' assert self.start.find_next(string="Three") == "Three" def test_find_next_for_text_element(self): text = self.tree.find(string="One") assert text.find_next("b").string == "Two" self.assert_selects(text.find_all_next("b"), ["Two", "Three"]) def test_next_generator(self): start = self.tree.find(string="Two") successors = [node for node in start.next_elements] # There are two successors: the final <b> tag and its text contents. tag, contents = successors assert tag['id'] == '3' assert contents == "Three" class TestPreviousOperations(ProximityTest): def setup_method(self): super(TestPreviousOperations, self).setup_method() self.end = self.tree.find(string="Three") def test_previous(self): assert self.end.previous_element['id'] == "3" assert self.end.previous_element.previous_element == "Two" def test_previous_of_first_item_is_none(self): first = self.tree.find('html') assert first.previous_element == None def test_previous_of_root_is_none(self): # The document root is outside the next/previous chain. assert self.tree.previous_element == None def test_find_all_previous(self): # The <b> tag containing the "Three" node is the predecessor # of the "Three" node itself, which is why "Three" shows up # here. self.assert_selects( self.end.find_all_previous('b'), ["Three", "Two", "One"]) self.assert_selects(self.end.find_all_previous(id=1), ["One"]) def test_find_previous(self): assert self.end.find_previous('b')['id'] == '3' assert self.end.find_previous(string="One") == "One" def test_find_previous_for_text_element(self): text = self.tree.find(string="Three") assert text.find_previous("b").string == "Three" self.assert_selects( text.find_all_previous("b"), ["Three", "Two", "One"]) def test_previous_generator(self): start = self.tree.find(string="One") predecessors = [node for node in start.previous_elements] # There are four predecessors: the <b> tag containing "One" # the <body> tag, the <head> tag, and the <html> tag. b, body, head, html = predecessors assert b['id'] == '1' assert body.name == "body" assert head.name == "head" assert html.name == "html" class SiblingTest(SoupTest): def setup_method(self): markup = '''<html> <span id="1"> <span id="1.1"></span> </span> <span id="2"> <span id="2.1"></span> </span> <span id="3"> <span id="3.1"></span> </span> <span id="4"></span> </html>''' # All that whitespace looks good but makes the tests more # difficult. Get rid of it. markup = re.compile(r"\n\s*").sub("", markup) self.tree = self.soup(markup) class TestNextSibling(SiblingTest): def setup_method(self): super(TestNextSibling, self).setup_method() self.start = self.tree.find(id="1") def test_next_sibling_of_root_is_none(self): assert self.tree.next_sibling == None def test_next_sibling(self): assert self.start.next_sibling['id'] == '2' assert self.start.next_sibling.next_sibling['id'] == '3' # Note the difference between next_sibling and next_element. assert self.start.next_element['id'] == '1.1' def test_next_sibling_may_not_exist(self): assert self.tree.html.next_sibling == None nested_span = self.tree.find(id="1.1") assert nested_span.next_sibling == None last_span = self.tree.find(id="4") assert last_span.next_sibling == None def test_find_next_sibling(self): assert self.start.find_next_sibling('span')['id'] == '2' def test_next_siblings(self): self.assert_selects_ids(self.start.find_next_siblings("span"), ['2', '3', '4']) self.assert_selects_ids(self.start.find_next_siblings(id='3'), ['3']) def test_next_sibling_for_text_element(self): soup = self.soup("Foo<b>bar</b>baz") start = soup.find(string="Foo") assert start.next_sibling.name == 'b' assert start.next_sibling.next_sibling == 'baz' self.assert_selects(start.find_next_siblings('b'), ['bar']) assert start.find_next_sibling(string="baz") == "baz" assert start.find_next_sibling(string="nonesuch") == None class TestPreviousSibling(SiblingTest): def setup_method(self): super(TestPreviousSibling, self).setup_method() self.end = self.tree.find(id="4") def test_previous_sibling_of_root_is_none(self): assert self.tree.previous_sibling == None def test_previous_sibling(self): assert self.end.previous_sibling['id'] == '3' assert self.end.previous_sibling.previous_sibling['id'] == '2' # Note the difference between previous_sibling and previous_element. assert self.end.previous_element['id'] == '3.1' def test_previous_sibling_may_not_exist(self): assert self.tree.html.previous_sibling == None nested_span = self.tree.find(id="1.1") assert nested_span.previous_sibling == None first_span = self.tree.find(id="1") assert first_span.previous_sibling == None def test_find_previous_sibling(self): assert self.end.find_previous_sibling('span')['id'] == '3' def test_previous_siblings(self): self.assert_selects_ids(self.end.find_previous_siblings("span"), ['3', '2', '1']) self.assert_selects_ids(self.end.find_previous_siblings(id='1'), ['1']) def test_previous_sibling_for_text_element(self): soup = self.soup("Foo<b>bar</b>baz") start = soup.find(string="baz") assert start.previous_sibling.name == 'b' assert start.previous_sibling.previous_sibling == 'Foo' self.assert_selects(start.find_previous_siblings('b'), ['bar']) assert start.find_previous_sibling(string="Foo") == "Foo" assert start.find_previous_sibling(string="nonesuch") == None class TestTreeModification(SoupTest): def test_attribute_modification(self): soup = self.soup('<a id="1"></a>') soup.a['id'] = 2 assert soup.decode() == self.document_for('<a id="2"></a>') del(soup.a['id']) assert soup.decode() == self.document_for('<a></a>') soup.a['id2'] = 'foo' assert soup.decode() == self.document_for('<a id2="foo"></a>') def test_new_tag_creation(self): builder = builder_registry.lookup('html')() soup = self.soup("<body></body>", builder=builder) a = Tag(soup, builder, 'a') ol = Tag(soup, builder, 'ol') a['href'] = 'http://foo.com/' soup.body.insert(0, a) soup.body.insert(1, ol) assert soup.body.encode() == b'<body><a href="http://foo.com/"></a><ol></ol></body>' def test_append_to_contents_moves_tag(self): doc = """<p id="1">Don't leave me <b>here</b>.</p> <p id="2">Don\'t leave!</p>""" soup = self.soup(doc) second_para = soup.find(id='2') bold = soup.b # Move the <b> tag to the end of the second paragraph. soup.find(id='2').append(soup.b) # The <b> tag is now a child of the second paragraph. assert bold.parent == second_para assert soup.decode() == self.document_for( '<p id="1">Don\'t leave me .</p>\n' '<p id="2">Don\'t leave!<b>here</b></p>' ) def test_replace_with_returns_thing_that_was_replaced(self): text = "<a></a><b><c></c></b>" soup = self.soup(text) a = soup.a new_a = a.replace_with(soup.c) assert a == new_a def test_unwrap_returns_thing_that_was_replaced(self): text = "<a><b></b><c></c></a>" soup = self.soup(text) a = soup.a new_a = a.unwrap() assert a == new_a def test_replace_with_and_unwrap_give_useful_exception_when_tag_has_no_parent(self): soup = self.soup("<a><b>Foo</b></a><c>Bar</c>") a = soup.a a.extract() assert None == a.parent with pytest.raises(ValueError): a.unwrap() with pytest.raises(ValueError): a.replace_with(soup.c) def test_replace_tag_with_itself(self): text = "<a><b></b><c>Foo<d></d></c></a><a><e></e></a>" soup = self.soup(text) c = soup.c soup.c.replace_with(c) assert soup.decode() == self.document_for(text) def test_replace_tag_with_its_parent_raises_exception(self): text = "<a><b></b></a>" soup = self.soup(text) with pytest.raises(ValueError): soup.b.replace_with(soup.a) def test_insert_tag_into_itself_raises_exception(self): text = "<a><b></b></a>" soup = self.soup(text) with pytest.raises(ValueError): soup.a.insert(0, soup.a) def test_insert_beautifulsoup_object_inserts_children(self): """Inserting one BeautifulSoup object into another actually inserts all of its children -- you'll never combine BeautifulSoup objects. """ soup = self.soup("<p>And now, a word:</p><p>And we're back.</p>") text = "<p>p2</p><p>p3</p>" to_insert = self.soup(text) soup.insert(1, to_insert) for i in soup.descendants: assert not isinstance(i, BeautifulSoup) p1, p2, p3, p4 = list(soup.children) assert "And now, a word:" == p1.string assert "p2" == p2.string assert "p3" == p3.string assert "And we're back." == p4.string def test_replace_with_maintains_next_element_throughout(self): soup = self.soup('<p><a>one</a><b>three</b></p>') a = soup.a b = a.contents[0] # Make it so the <a> tag has two text children. a.insert(1, "two") # Now replace each one with the empty string. left, right = a.contents left.replaceWith('') right.replaceWith('') # The <b> tag is still connected to the tree. assert "three" == soup.b.string def test_replace_final_node(self): soup = self.soup("<b>Argh!</b>") soup.find(string="Argh!").replace_with("Hooray!") new_text = soup.find(string="Hooray!") b = soup.b assert new_text.previous_element == b assert new_text.parent == b assert new_text.previous_element.next_element == new_text assert new_text.next_element == None def test_consecutive_text_nodes(self): # A builder should never create two consecutive text nodes, # but if you insert one next to another, Beautiful Soup will # handle it correctly. soup = self.soup("<a><b>Argh!</b><c></c></a>") soup.b.insert(1, "Hooray!") assert soup.decode() == self.document_for( "<a><b>Argh!Hooray!</b><c></c></a>" ) new_text = soup.find(string="Hooray!") assert new_text.previous_element == "Argh!" assert new_text.previous_element.next_element == new_text assert new_text.previous_sibling == "Argh!" assert new_text.previous_sibling.next_sibling == new_text assert new_text.next_sibling == None assert new_text.next_element == soup.c def test_insert_string(self): soup = self.soup("<a></a>") soup.a.insert(0, "bar") soup.a.insert(0, "foo") # The string were added to the tag. assert ["foo", "bar"] == soup.a.contents # And they were converted to NavigableStrings. assert soup.a.contents[0].next_element == "bar" def test_insert_tag(self): builder = self.default_builder() soup = self.soup( "<a><b>Find</b><c>lady!</c><d></d></a>", builder=builder) magic_tag = Tag(soup, builder, 'magictag') magic_tag.insert(0, "the") soup.a.insert(1, magic_tag) assert soup.decode() == self.document_for( "<a><b>Find</b><magictag>the</magictag><c>lady!</c><d></d></a>" ) # Make sure all the relationships are hooked up correctly. b_tag = soup.b assert b_tag.next_sibling == magic_tag assert magic_tag.previous_sibling == b_tag find = b_tag.find(string="Find") assert find.next_element == magic_tag assert magic_tag.previous_element == find c_tag = soup.c assert magic_tag.next_sibling == c_tag assert c_tag.previous_sibling == magic_tag the = magic_tag.find(string="the") assert the.parent == magic_tag assert the.next_element == c_tag assert c_tag.previous_element == the def test_append_child_thats_already_at_the_end(self): data = "<a><b></b></a>" soup = self.soup(data) soup.a.append(soup.b) assert data == soup.decode() def test_extend(self): data = "<a><b><c><d><e><f><g></g></f></e></d></c></b></a>" soup = self.soup(data) l = [soup.g, soup.f, soup.e, soup.d, soup.c, soup.b] soup.a.extend(l) assert "<a><g></g><f></f><e></e><d></d><c></c><b></b></a>" == soup.decode() @pytest.mark.parametrize( "get_tags", [lambda tag: tag, lambda tag: tag.contents] ) def test_extend_with_another_tags_contents(self, get_tags): data = '<body><div id="d1"><a>1</a><a>2</a><a>3</a><a>4</a></div><div id="d2"></div></body>' soup = self.soup(data) d1 = soup.find('div', id='d1') d2 = soup.find('div', id='d2') tags = get_tags(d1) d2.extend(tags) assert '<div id="d1"></div>' == d1.decode() assert '<div id="d2"><a>1</a><a>2</a><a>3</a><a>4</a></div>' == d2.decode() def test_move_tag_to_beginning_of_parent(self): data = "<a><b></b><c></c><d></d></a>" soup = self.soup(data) soup.a.insert(0, soup.d) assert "<a><d></d><b></b><c></c></a>" == soup.decode() def test_insert_works_on_empty_element_tag(self): # This is a little strange, since most HTML parsers don't allow # markup like this to come through. But in general, we don't # know what the parser would or wouldn't have allowed, so # I'm letting this succeed for now. soup = self.soup("<br/>") soup.br.insert(1, "Contents") assert str(soup.br) == "<br>Contents</br>" def test_insert_before(self): soup = self.soup("<a>foo</a><b>bar</b>") soup.b.insert_before("BAZ") soup.a.insert_before("QUUX") assert soup.decode() == self.document_for( "QUUX<a>foo</a>BAZ<b>bar</b>" ) soup.a.insert_before(soup.b) assert soup.decode() == self.document_for("QUUX<b>bar</b><a>foo</a>BAZ") # Can't insert an element before itself. b = soup.b with pytest.raises(ValueError): b.insert_before(b) # Can't insert before if an element has no parent. b.extract() with pytest.raises(ValueError): b.insert_before("nope") # Can insert an identical element soup = self.soup("<a>") soup.a.insert_before(soup.new_tag("a")) # TODO: OK but what happens? def test_insert_multiple_before(self): soup = self.soup("<a>foo</a><b>bar</b>") soup.b.insert_before("BAZ", " ", "QUUX") soup.a.insert_before("QUUX", " ", "BAZ") assert soup.decode() == self.document_for( "QUUX BAZ<a>foo</a>BAZ QUUX<b>bar</b>" ) soup.a.insert_before(soup.b, "FOO") assert soup.decode() == self.document_for( "QUUX BAZ<b>bar</b>FOO<a>foo</a>BAZ QUUX" ) def test_insert_after(self): soup = self.soup("<a>foo</a><b>bar</b>") soup.b.insert_after("BAZ") soup.a.insert_after("QUUX") assert soup.decode() == self.document_for( "<a>foo</a>QUUX<b>bar</b>BAZ" ) soup.b.insert_after(soup.a) assert soup.decode() == self.document_for("QUUX<b>bar</b><a>foo</a>BAZ") # Can't insert an element after itself. b = soup.b with pytest.raises(ValueError): b.insert_after(b) # Can't insert after if an element has no parent. b.extract() with pytest.raises(ValueError): b.insert_after("nope") # Can insert an identical element soup = self.soup("<a>") soup.a.insert_before(soup.new_tag("a")) # TODO: OK but what does it look like? def test_insert_multiple_after(self): soup = self.soup("<a>foo</a><b>bar</b>") soup.b.insert_after("BAZ", " ", "QUUX") soup.a.insert_after("QUUX", " ", "BAZ") assert soup.decode() == self.document_for( "<a>foo</a>QUUX BAZ<b>bar</b>BAZ QUUX" ) soup.b.insert_after(soup.a, "FOO ") assert soup.decode() == self.document_for( "QUUX BAZ<b>bar</b><a>foo</a>FOO BAZ QUUX" ) def test_insert_after_raises_exception_if_after_has_no_meaning(self): soup = self.soup("") tag = soup.new_tag("a") string = soup.new_string("") with pytest.raises(ValueError): string.insert_after(tag) with pytest.raises(NotImplementedError): soup.insert_after(tag) with pytest.raises(ValueError): tag.insert_after(tag) def test_insert_before_raises_notimplementederror_if_before_has_no_meaning(self): soup = self.soup("") tag = soup.new_tag("a") string = soup.new_string("") with pytest.raises(ValueError): string.insert_before(tag) with pytest.raises(NotImplementedError): soup.insert_before(tag) with pytest.raises(ValueError): tag.insert_before(tag) def test_replace_with(self): soup = self.soup( "<p>There's <b>no</b> business like <b>show</b> business</p>") no, show = soup.find_all('b') show.replace_with(no) assert soup.decode() == self.document_for( "<p>There's business like <b>no</b> business</p>" ) assert show.parent == None assert no.parent == soup.p assert no.next_element == "no" assert no.next_sibling == " business" def test_replace_with_errors(self): # Can't replace a tag that's not part of a tree. a_tag = Tag(name="a") with pytest.raises(ValueError): a_tag.replace_with("won't work") # Can't replace a tag with its parent. a_tag = self.soup("<a><b></b></a>").a with pytest.raises(ValueError): a_tag.b.replace_with(a_tag) # Or with a list that includes its parent. with pytest.raises(ValueError): a_tag.b.replace_with("string1", a_tag, "string2") def test_replace_with_multiple(self): data = "<a><b></b><c></c></a>" soup = self.soup(data) d_tag = soup.new_tag("d") d_tag.string = "Text In D Tag" e_tag = soup.new_tag("e") f_tag = soup.new_tag("f") a_string = "Random Text" soup.c.replace_with(d_tag, e_tag, a_string, f_tag) assert soup.decode() == "<a><b></b><d>Text In D Tag</d><e></e>Random Text<f></f></a>" assert soup.b.next_element == d_tag assert d_tag.string.next_element==e_tag assert e_tag.next_element.string == a_string assert e_tag.next_element.next_element == f_tag def test_replace_first_child(self): data = "<a><b></b><c></c></a>" soup = self.soup(data) soup.b.replace_with(soup.c) assert "<a><c></c></a>" == soup.decode() def test_replace_last_child(self): data = "<a><b></b><c></c></a>" soup = self.soup(data) soup.c.replace_with(soup.b) assert "<a><b></b></a>" == soup.decode() def test_nested_tag_replace_with(self): soup = self.soup( """<a>We<b>reserve<c>the</c><d>right</d></b></a><e>to<f>refuse</f><g>service</g></e>""") # Replace the entire <b> tag and its contents ("reserve the # right") with the <f> tag ("refuse"). remove_tag = soup.b move_tag = soup.f remove_tag.replace_with(move_tag) assert soup.decode() == self.document_for( "<a>We<f>refuse</f></a><e>to<g>service</g></e>" ) # The <b> tag is now an orphan. assert remove_tag.parent == None assert remove_tag.find(string="right").next_element == None assert remove_tag.previous_element == None assert remove_tag.next_sibling == None assert remove_tag.previous_sibling == None # The <f> tag is now connected to the <a> tag. assert move_tag.parent == soup.a assert move_tag.previous_element == "We" assert move_tag.next_element.next_element == soup.e assert move_tag.next_sibling == None # The gap where the <f> tag used to be has been mended, and # the word "to" is now connected to the <g> tag. to_text = soup.find(string="to") g_tag = soup.g assert to_text.next_element == g_tag assert to_text.next_sibling == g_tag assert g_tag.previous_element == to_text assert g_tag.previous_sibling == to_text def test_unwrap(self): tree = self.soup(""" <p>Unneeded <em>formatting</em> is unneeded</p> """) tree.em.unwrap() assert tree.em == None assert tree.p.text == "Unneeded formatting is unneeded" def test_wrap(self): soup = self.soup("I wish I was bold.") value = soup.string.wrap(soup.new_tag("b")) assert value.decode() == "<b>I wish I was bold.</b>" assert soup.decode() == self.document_for("<b>I wish I was bold.</b>") def test_wrap_extracts_tag_from_elsewhere(self): soup = self.soup("<b></b>I wish I was bold.") soup.b.next_sibling.wrap(soup.b) assert soup.decode() == self.document_for("<b>I wish I was bold.</b>") def test_wrap_puts_new_contents_at_the_end(self): soup = self.soup("<b>I like being bold.</b>I wish I was bold.") soup.b.next_sibling.wrap(soup.b) assert 2 == len(soup.b.contents) assert soup.decode() == self.document_for( "<b>I like being bold.I wish I was bold.</b>" ) def test_extract(self): soup = self.soup( '<html><body>Some content. <div id="nav">Nav crap</div> More content.</body></html>') assert len(soup.body.contents) == 3 extracted = soup.find(id="nav").extract() assert soup.decode() == "<html><body>Some content. More content.</body></html>" assert extracted.decode() == '<div id="nav">Nav crap</div>' # The extracted tag is now an orphan. assert len(soup.body.contents) == 2 assert extracted.parent == None assert extracted.previous_element == None assert extracted.next_element.next_element == None # The gap where the extracted tag used to be has been mended. content_1 = soup.find(string="Some content. ") content_2 = soup.find(string=" More content.") assert content_1.next_element == content_2 assert content_1.next_sibling == content_2 assert content_2.previous_element == content_1 assert content_2.previous_sibling == content_1 def test_extract_distinguishes_between_identical_strings(self): soup = self.soup("<a>foo</a><b>bar</b>") foo_1 = soup.a.string bar_1 = soup.b.string foo_2 = soup.new_string("foo") bar_2 = soup.new_string("bar") soup.a.append(foo_2) soup.b.append(bar_2) # Now there are two identical strings in the <a> tag, and two # in the <b> tag. Let's remove the first "foo" and the second # "bar". foo_1.extract() bar_2.extract() assert foo_2 == soup.a.string assert bar_2 == soup.b.string def test_extract_multiples_of_same_tag(self): soup = self.soup(""" <html> <head> <script>foo</script> </head> <body> <script>bar</script> <a></a> </body> <script>baz</script> </html>""") [soup.script.extract() for i in soup.find_all("script")] assert "<body>\n\n<a></a>\n</body>" == str(soup.body) def test_extract_works_when_element_is_surrounded_by_identical_strings(self): soup = self.soup( '<html>\n' '<body>hi</body>\n' '</html>') soup.find('body').extract() assert None == soup.find('body') def test_clear(self): """Tag.clear()""" soup = self.soup("<p><a>String <em>Italicized</em></a> and another</p>") # clear using extract() a = soup.a soup.p.clear() assert len(soup.p.contents) == 0 assert hasattr(a, "contents") # clear using decompose() em = a.em a.clear(decompose=True) assert 0 == len(em.contents) def test_decompose(self): # Test PageElement.decompose() and PageElement.decomposed soup = self.soup("<p><a>String <em>Italicized</em></a></p><p>Another para</p>") p1, p2 = soup.find_all('p') a = p1.a text = p1.em.string for i in [p1, p2, a, text]: assert False == i.decomposed # This sets p1 and everything beneath it to decomposed. p1.decompose() for i in [p1, a, text]: assert True == i.decomposed # p2 is unaffected. assert False == p2.decomposed def test_string_set(self): """Tag.string = 'string'""" soup = self.soup("<a></a> <b><c></c></b>") soup.a.string = "foo" assert soup.a.contents == ["foo"] soup.b.string = "bar" assert soup.b.contents == ["bar"] def test_string_set_does_not_affect_original_string(self): soup = self.soup("<a><b>foo</b><c>bar</c>") soup.b.string = soup.c.string assert soup.a.encode() == b"<a><b>bar</b><c>bar</c></a>" def test_set_string_preserves_class_of_string(self): soup = self.soup("<a></a>") cdata = CData("foo") soup.a.string = cdata assert isinstance(soup.a.string, CData) class TestDeprecatedArguments(SoupTest): @pytest.mark.parametrize( "method_name", [ "find", "find_all", "find_parent", "find_parents", "find_next", "find_all_next", "find_previous", "find_all_previous", "find_next_sibling", "find_next_siblings", "find_previous_sibling", "find_previous_siblings", ] ) def test_find_type_method_string(self, method_name): soup = self.soup("<a>some</a><b>markup</b>") method = getattr(soup.b, method_name) with warnings.catch_warnings(record=True) as w: method(text='markup') [warning] = w assert warning.filename == __file__ msg = str(warning.message) assert msg == "The 'text' argument to find()-type methods is deprecated. Use 'string' instead." def test_soupstrainer_constructor_string(self): with warnings.catch_warnings(record=True) as w: strainer = SoupStrainer(text="text") assert strainer.text == 'text' [warning] = w msg = str(warning.message) assert warning.filename == __file__ assert msg == "The 'text' argument to the SoupStrainer constructor is deprecated. Use 'string' instead." PK z�Z �Tf�7 �7 tests/test_pageelement.pynu �[��� """Tests of the bs4.element.PageElement class""" import copy import pickle import pytest import sys from bs4 import BeautifulSoup from bs4.element import ( Comment, ResultSet, SoupStrainer, ) from . import ( SoupTest, ) class TestEncoding(SoupTest): """Test the ability to encode objects into strings.""" def test_unicode_string_can_be_encoded(self): html = "<b>\N{SNOWMAN}</b>" soup = self.soup(html) assert soup.b.string.encode("utf-8") == "\N{SNOWMAN}".encode("utf-8") def test_tag_containing_unicode_string_can_be_encoded(self): html = "<b>\N{SNOWMAN}</b>" soup = self.soup(html) assert soup.b.encode("utf-8") == html.encode("utf-8") def test_encoding_substitutes_unrecognized_characters_by_default(self): html = "<b>\N{SNOWMAN}</b>" soup = self.soup(html) assert soup.b.encode("ascii") == b"<b>☃</b>" def test_encoding_can_be_made_strict(self): html = "<b>\N{SNOWMAN}</b>" soup = self.soup(html) with pytest.raises(UnicodeEncodeError): soup.encode("ascii", errors="strict") def test_decode_contents(self): html = "<b>\N{SNOWMAN}</b>" soup = self.soup(html) assert "\N{SNOWMAN}" == soup.b.decode_contents() def test_encode_contents(self): html = "<b>\N{SNOWMAN}</b>" soup = self.soup(html) assert "\N{SNOWMAN}".encode("utf8") == soup.b.encode_contents( encoding="utf8" ) def test_encode_deeply_nested_document(self): # This test verifies that encoding a string doesn't involve # any recursive function calls. If it did, this test would # overflow the Python interpreter stack. limit = sys.getrecursionlimit() + 1 markup = "<span>" * limit soup = self.soup(markup) encoded = soup.encode() assert limit == encoded.count(b"<span>") def test_deprecated_renderContents(self): html = "<b>\N{SNOWMAN}</b>" soup = self.soup(html) soup.renderContents() assert "\N{SNOWMAN}".encode("utf8") == soup.b.renderContents() def test_repr(self): html = "<b>\N{SNOWMAN}</b>" soup = self.soup(html) assert html == repr(soup) class TestFormatters(SoupTest): """Test the formatting feature, used by methods like decode() and prettify(), and the formatters themselves. """ def test_default_formatter_is_minimal(self): markup = "<b><<Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!>></b>" soup = self.soup(markup) decoded = soup.decode(formatter="minimal") # The < is converted back into < but the e-with-acute is left alone. assert decoded == self.document_for( "<b><<Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!>></b>" ) def test_formatter_html(self): markup = "<br><b><<Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!>></b>" soup = self.soup(markup) decoded = soup.decode(formatter="html") assert decoded == self.document_for( "<br/><b><<Sacré bleu!>></b>" ) def test_formatter_html5(self): markup = "<br><b><<Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!>></b>" soup = self.soup(markup) decoded = soup.decode(formatter="html5") assert decoded == self.document_for( "<br><b><<Sacré bleu!>></b>" ) def test_formatter_minimal(self): markup = "<b><<Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!>></b>" soup = self.soup(markup) decoded = soup.decode(formatter="minimal") # The < is converted back into < but the e-with-acute is left alone. assert decoded == self.document_for( "<b><<Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!>></b>" ) def test_formatter_null(self): markup = "<b><<Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!>></b>" soup = self.soup(markup) decoded = soup.decode(formatter=None) # Neither the angle brackets nor the e-with-acute are converted. # This is not valid HTML, but it's what the user wanted. assert decoded == self.document_for( "<b><<Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!>></b>" ) def test_formatter_custom(self): markup = "<b><foo></b><b>bar</b><br/>" soup = self.soup(markup) decoded = soup.decode(formatter = lambda x: x.upper()) # Instead of normal entity conversion code, the custom # callable is called on every string. assert decoded == self.document_for("<b><FOO></b><b>BAR</b><br/>") def test_formatter_is_run_on_attribute_values(self): markup = '<a href="http://a.com?a=b&c=é">e</a>' soup = self.soup(markup) a = soup.a expect_minimal = '<a href="http://a.com?a=b&c=é">e</a>' assert expect_minimal == a.decode() assert expect_minimal == a.decode(formatter="minimal") expect_html = '<a href="http://a.com?a=b&c=é">e</a>' assert expect_html == a.decode(formatter="html") assert markup == a.decode(formatter=None) expect_upper = '<a href="HTTP://A.COM?A=B&C=É">E</a>' assert expect_upper == a.decode(formatter=lambda x: x.upper()) def test_formatter_skips_script_tag_for_html_documents(self): doc = """ <script type="text/javascript"> console.log("< < hey > > "); </script> """ encoded = BeautifulSoup(doc, 'html.parser').encode() assert b"< < hey > >" in encoded def test_formatter_skips_style_tag_for_html_documents(self): doc = """ <style type="text/css"> console.log("< < hey > > "); </style> """ encoded = BeautifulSoup(doc, 'html.parser').encode() assert b"< < hey > >" in encoded def test_prettify_leaves_preformatted_text_alone(self): soup = self.soup("<div> foo <pre> \tbar\n \n </pre> baz <textarea> eee\nfff\t</textarea></div>") # Everything outside the <pre> tag is reformatted, but everything # inside is left alone. assert '<div>\n foo\n <pre> \tbar\n \n </pre>\n baz\n <textarea> eee\nfff\t</textarea>\n</div>\n' == soup.div.prettify() def test_prettify_handles_nested_string_literal_tags(self): # Most of this markup is inside a <pre> tag, so prettify() # only does three things to it: # 1. Add a newline and a space between the <div> and the <pre> # 2. Add a newline after the </pre> # 3. Add a newline at the end. # # The contents of the <pre> tag are left completely alone. In # particular, we don't start adding whitespace again once we # encounter the first </pre> tag, because we know it's not # the one that put us into string literal mode. markup = """<div><pre><code>some <script><pre>code</pre></script> for you </code></pre></div>""" expect = """<div> <pre><code>some <script><pre>code</pre></script> for you </code></pre> </div> """ soup = self.soup(markup) assert expect == soup.div.prettify() def test_prettify_accepts_formatter_function(self): soup = BeautifulSoup("<html><body>foo</body></html>", 'html.parser') pretty = soup.prettify(formatter = lambda x: x.upper()) assert "FOO" in pretty def test_prettify_outputs_unicode_by_default(self): soup = self.soup("<a></a>") assert str == type(soup.prettify()) def test_prettify_can_encode_data(self): soup = self.soup("<a></a>") assert bytes == type(soup.prettify("utf-8")) def test_html_entity_substitution_off_by_default(self): markup = "<b>Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!</b>" soup = self.soup(markup) encoded = soup.b.encode("utf-8") assert encoded == markup.encode('utf-8') def test_encoding_substitution(self): # Here's the <meta> tag saying that a document is # encoded in Shift-JIS. meta_tag = ('<meta content="text/html; charset=x-sjis" ' 'http-equiv="Content-type"/>') soup = self.soup(meta_tag) # Parse the document, and the charset apprears unchanged. assert soup.meta['content'] == 'text/html; charset=x-sjis' # Encode the document into some encoding, and the encoding is # substituted into the meta tag. utf_8 = soup.encode("utf-8") assert b"charset=utf-8" in utf_8 euc_jp = soup.encode("euc_jp") assert b"charset=euc_jp" in euc_jp shift_jis = soup.encode("shift-jis") assert b"charset=shift-jis" in shift_jis utf_16_u = soup.encode("utf-16").decode("utf-16") assert "charset=utf-16" in utf_16_u def test_encoding_substitution_doesnt_happen_if_tag_is_strained(self): markup = ('<head><meta content="text/html; charset=x-sjis" ' 'http-equiv="Content-type"/></head><pre>foo</pre>') # Beautiful Soup used to try to rewrite the meta tag even if the # meta tag got filtered out by the strainer. This test makes # sure that doesn't happen. strainer = SoupStrainer('pre') soup = self.soup(markup, parse_only=strainer) assert soup.contents[0].name == 'pre' class TestPersistence(SoupTest): "Testing features like pickle and deepcopy." def setup_method(self): self.page = """<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/transitional.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> <title>Beautiful Soup: We called him Tortoise because he taught us.</title> <link rev="made" href="mailto:leonardr@segfault.org"> <meta name="Description" content="Beautiful Soup: an HTML parser optimized for screen-scraping."> <meta name="generator" content="Markov Approximation 1.4 (module: leonardr)"> <meta name="author" content="Leonard Richardson"> </head> <body> <a href="foo">foo</a> <a href="foo"><b>bar</b></a> </body> </html>""" self.tree = self.soup(self.page) def test_pickle_and_unpickle_identity(self): # Pickling a tree, then unpickling it, yields a tree identical # to the original. dumped = pickle.dumps(self.tree, 2) loaded = pickle.loads(dumped) assert loaded.__class__ == BeautifulSoup assert loaded.decode() == self.tree.decode() def test_deepcopy_identity(self): # Making a deepcopy of a tree yields an identical tree. copied = copy.deepcopy(self.tree) assert copied.decode() == self.tree.decode() def test_copy_deeply_nested_document(self): # This test verifies that copy and deepcopy don't involve any # recursive function calls. If they did, this test would # overflow the Python interpreter stack. limit = sys.getrecursionlimit() + 1 markup = "<span>" * limit soup = self.soup(markup) copied = copy.copy(soup) copied = copy.deepcopy(soup) def test_copy_preserves_encoding(self): soup = BeautifulSoup(b'<p> </p>', 'html.parser') encoding = soup.original_encoding copy = soup.__copy__() assert "<p> </p>" == str(copy) assert encoding == copy.original_encoding def test_copy_preserves_builder_information(self): tag = self.soup('<p></p>').p # Simulate a tag obtained from a source file. tag.sourceline = 10 tag.sourcepos = 33 copied = tag.__copy__() # The TreeBuilder object is no longer availble, but information # obtained from it gets copied over to the new Tag object. assert tag.sourceline == copied.sourceline assert tag.sourcepos == copied.sourcepos assert tag.can_be_empty_element == copied.can_be_empty_element assert tag.cdata_list_attributes == copied.cdata_list_attributes assert tag.preserve_whitespace_tags == copied.preserve_whitespace_tags assert tag.interesting_string_types == copied.interesting_string_types def test_unicode_pickle(self): # A tree containing Unicode characters can be pickled. html = "<b>\N{SNOWMAN}</b>" soup = self.soup(html) dumped = pickle.dumps(soup, pickle.HIGHEST_PROTOCOL) loaded = pickle.loads(dumped) assert loaded.decode() == soup.decode() def test_copy_navigablestring_is_not_attached_to_tree(self): html = "<b>Foo<a></a></b><b>Bar</b>" soup = self.soup(html) s1 = soup.find(string="Foo") s2 = copy.copy(s1) assert s1 == s2 assert None == s2.parent assert None == s2.next_element assert None != s1.next_sibling assert None == s2.next_sibling assert None == s2.previous_element def test_copy_navigablestring_subclass_has_same_type(self): html = "<b><!--Foo--></b>" soup = self.soup(html) s1 = soup.string s2 = copy.copy(s1) assert s1 == s2 assert isinstance(s2, Comment) def test_copy_entire_soup(self): html = "<div><b>Foo<a></a></b><b>Bar</b></div>end" soup = self.soup(html) soup_copy = copy.copy(soup) assert soup == soup_copy def test_copy_tag_copies_contents(self): html = "<div><b>Foo<a></a></b><b>Bar</b></div>end" soup = self.soup(html) div = soup.div div_copy = copy.copy(div) # The two tags look the same, and evaluate to equal. assert str(div) == str(div_copy) assert div == div_copy # But they're not the same object. assert div is not div_copy # And they don't have the same relation to the parse tree. The # copy is not associated with a parse tree at all. assert None == div_copy.parent assert None == div_copy.previous_element assert None == div_copy.find(string='Bar').next_element assert None != div.find(string='Bar').next_element PK z�Zl�:[ [ tests/test_builder.pynu �[��� import pytest from unittest.mock import patch from bs4.builder import DetectsXMLParsedAsHTML class TestDetectsXMLParsedAsHTML(object): @pytest.mark.parametrize( "markup,looks_like_xml", [("No xml declaration", False), ("<html>obviously HTML</html", False), ("<?xml ><html>Actually XHTML</html>", False), ("<?xml> < html>Tricky XHTML</html>", False), ("<?xml ><no-html-tag>", True), ] ) def test_warn_if_markup_looks_like_xml(self, markup, looks_like_xml): # Test of our ability to guess at whether markup looks XML-ish # _and_ not HTML-ish. with patch('bs4.builder.DetectsXMLParsedAsHTML._warn') as mock: for data in markup, markup.encode('utf8'): result = DetectsXMLParsedAsHTML.warn_if_markup_looks_like_xml( data ) assert result == looks_like_xml if looks_like_xml: assert mock.called else: assert not mock.called mock.reset_mock() PK z�ZJ"O� � tests/test_navigablestring.pynu �[��� import pytest from bs4.element import ( CData, Comment, Declaration, Doctype, NavigableString, RubyParenthesisString, RubyTextString, Script, Stylesheet, TemplateString, ) from . import SoupTest class TestNavigableString(SoupTest): def test_text_acquisition_methods(self): # These methods are intended for use against Tag, but they # work on NavigableString as well, s = NavigableString("fee ") cdata = CData("fie ") comment = Comment("foe ") assert "fee " == s.get_text() assert "fee" == s.get_text(strip=True) assert ["fee "] == list(s.strings) assert ["fee"] == list(s.stripped_strings) assert ["fee "] == list(s._all_strings()) assert "fie " == cdata.get_text() assert "fie" == cdata.get_text(strip=True) assert ["fie "] == list(cdata.strings) assert ["fie"] == list(cdata.stripped_strings) assert ["fie "] == list(cdata._all_strings()) # Since a Comment isn't normally considered 'text', # these methods generally do nothing. assert "" == comment.get_text() assert [] == list(comment.strings) assert [] == list(comment.stripped_strings) assert [] == list(comment._all_strings()) # Unless you specifically say that comments are okay. assert "foe" == comment.get_text(strip=True, types=Comment) assert "foe " == comment.get_text(types=(Comment, NavigableString)) def test_string_has_immutable_name_property(self): # string.name is defined as None and can't be modified string = self.soup("s").string assert None == string.name with pytest.raises(AttributeError): string.name = 'foo' class TestNavigableStringSubclasses(SoupTest): def test_cdata(self): # None of the current builders turn CDATA sections into CData # objects, but you can create them manually. soup = self.soup("") cdata = CData("foo") soup.insert(1, cdata) assert str(soup) == "<![CDATA[foo]]>" assert soup.find(string="foo") == "foo" assert soup.contents[0] == "foo" def test_cdata_is_never_formatted(self): """Text inside a CData object is passed into the formatter. But the return value is ignored. """ self.count = 0 def increment(*args): self.count += 1 return "BITTER FAILURE" soup = self.soup("") cdata = CData("<><><>") soup.insert(1, cdata) assert b"<![CDATA[<><><>]]>" == soup.encode(formatter=increment) assert 1 == self.count def test_doctype_ends_in_newline(self): # Unlike other NavigableString subclasses, a DOCTYPE always ends # in a newline. doctype = Doctype("foo") soup = self.soup("") soup.insert(1, doctype) assert soup.encode() == b"<!DOCTYPE foo>\n" def test_declaration(self): d = Declaration("foo") assert "<?foo?>" == d.output_ready() def test_default_string_containers(self): # In some cases, we use different NavigableString subclasses for # the same text in different tags. soup = self.soup( "<div>text</div><script>text</script><style>text</style>" ) assert [NavigableString, Script, Stylesheet] == [ x.__class__ for x in soup.find_all(string=True) ] # The TemplateString is a little unusual because it's generally found # _inside_ children of a <template> element, not a direct child of the # <template> element. soup = self.soup( "<template>Some text<p>In a tag</p></template>Some text outside" ) assert all( isinstance(x, TemplateString) for x in soup.template._all_strings(types=None) ) # Once the <template> tag closed, we went back to using # NavigableString. outside = soup.template.next_sibling assert isinstance(outside, NavigableString) assert not isinstance(outside, TemplateString) # The TemplateString is also unusual because it can contain # NavigableString subclasses of _other_ types, such as # Comment. markup = b"<template>Some text<p>In a tag</p><!--with a comment--></template>" soup = self.soup(markup) assert markup == soup.template.encode("utf8") def test_ruby_strings(self): markup = "<ruby>漢 <rp>(</rp><rt>kan</rt><rp>)</rp> 字 <rp>(</rp><rt>ji</rt><rp>)</rp></ruby>" soup = self.soup(markup) assert isinstance(soup.rp.string, RubyParenthesisString) assert isinstance(soup.rt.string, RubyTextString) # Just as a demo, here's what this means for get_text usage. assert "漢字" == soup.get_text(strip=True) assert "漢(kan)字(ji)" == soup.get_text( strip=True, types=(NavigableString, RubyTextString, RubyParenthesisString) ) PK z�Z% �m N tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-5703933063462912.testcasenu �[��� <![ PK z�Zx�� � N tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-5375146639360000.testcasenu �[��� � ><applet></applet><applet></applet><apple|><applet><applet><appl��><applet><applet></applet></applet></applet></applet><applet></applet><apple>t<applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet>et><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><azplet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><plet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet><applet></applet></applet></applet></applet></appt></applet></applet></applet></applet></applet></applet></applet></applet></applet></applet></applet></applet></applet></applet></applet></applet></applet></applet><<meta charset=utf-8>PK z�Z�O )| | N tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-6600557255327744.testcasenu �[��� <TABLE><<!>;<!><<!>.<lec><th>i><a><mat <mi a><math>><th><mI>chardeta����<><th><mI><||||||||A<select><>qu?�math><th><mie>quPK z�Z ϥ�g g B tests/fuzz/crash-ffbdfa8a2b26f13537b68d3794b0478a4090ee4a.testcasenu �[��� Z� � ����<h <!doc2t}pe � � ����<h <![oc2t}pe � �. � `�<ml .<xml �. � `�<ml .<xml .PK z�Z�A� N tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-4818336571064320.testcasenu �[��� �<!DOCTyPEV PUBLIC'''�'PK z�Z���J N tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-6241471367348224.testcasenu �[��� �<table><svg><html>PK z�Z�XD#'� '� N tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-5984173902397440.testcasenu �[��� :fontipt><!--</script><scri�pt><������������pt><script<>!--</script6<�<head/�Xpe" charse/� ript><s��cript><!-pt><script<>!--</script6<�<head/�Xpe" charse/� ript><s��cript><!--</scrixt><s�<!--</script>2&1#i<?xmlITLE></TITLE E><Ty<table><col></c> math>< ath><math><math>7 � ������� �<m hwitype><META cenn http-equiv=content-ty�e><�� � y<table><col></c> y></body></body></body><bod~><b M math>< ath><math><math>3 � ������� �<m hwitype><META cenn http-equ �<meta cha y<frameset></frameset#> $ ��� -<math><math><math><m(th><ul><math><l>u<math><math><math><math><ma5*><math><math><math>3M q<���������������������������ath><ul><math><math>< � q<������������������������������� y<table><col></c> math>< ath><math><math>7 � ������� �<m hwitype><META cenn http-equiv=content-ty�e><�� � y<table><col></c> y></body></body></body><bod~><b M math>< ath><math><math>3 � ������� �<m hwitype><META cenn http-equiv=content-ty�e><�� q<���������������������������ath><ul><math><math>< � q<�� a <table><col></c> ><math> q<����������������������������u>>�></body><d %ta c</y>� �<m hwitype><META cenn http-equiv=content-ty�e><�� � y<table><col></c> - ���� q<���������������������������ath><ul><math><math>< � �<a><l><ul><u><p><a> q<���tent-ty�e><�� � y<table><col></c> = @ a <table><col></c> !<P � " �������� T >E<L></TITLE E><TIT &u><P><</body></body></body></body></body><bod~><b M math>< ath><math><math>3 � ������� �<m hwitype><META cenn http-equiv=content-ty�e><�� ����������������ath><ul><math><math>< � q<������������������������������� y<table><col></c> <math><ma0h><math><math><math>3 � q<������������� ������������������������������������������������������������������������ath><math><math> q<����������������������������u>>�></body><d %ta c</y>� �<m hwitype><META cenn http-equiv=content-ty�e><�� � y<table><col></c> - ���� q<���������������������������ath><ul><math><math>< � �<a><l><ul><u><p><a> q<���tent-ty�e><�� ���������u>>�></body><d %ta c</y>� �<m hwitype><META cenn http-equiv=content-ty�e><�� � y<table><col></c> - ���� q<���������������������������ath><ul><math><math>< � �<a><l><ul><u><p><a> q<���tent-ty�e><�� � y<table><col></c> = @ a <table><col></c> !<P � " �������� T >E<L></TITLE E><TIT &u><P><</body></body></body></body></body><bod~><b M math>< ath><math><math>3 � ������� �<m hwitype><META cenn http-equiv=content-ty�e><�� ����������������ath><ul><math><math>< � q<������������������������������� y<table><col></c> <math><ma0h><math><math><math>3 � q<������������� ������������������������������������������������������������������������ath><math><math> q<����������������������������u>>�></body><d %ta c</y>� �<m hwitype><META cenn http-equiv=content-ty�e><�� � y<table><col></c> - ���� q<���������������������������ath><ul><math><math>< � �<a><l><ul><u><p><a> q<���tent-ty�e><�� � y<table><col></c> = @ a <table><col></c> !<P � " �������� T >E<L></TITLE E><TIT �������� � �<meta cha $ -<math><math><math><m(th><ul><math><l>u<math><math><math><math><ma5*><math><math><math>3M q<���������������������������ath><ul><math><math>< � q<������������������������������� y<table><col></c> �������� � �<meta cha y<frameset></frameset#> $ ��� -<math><math><math><m(th><ul><math><l>u<math><math><math><math><ma5*><math><math><math>3M q<���������������������������ath><ul><math><math>< � q<������������������������������� y<table><col></c> math>< ath><math><math>7 � ������� �<m hwitype><META cenn http-equiv=content-ty�e><�� � y<table><col></c> y></body></body></body><bod~><b M math>< ath><math><math>3 � ������� �<m hwitype><META cenn http-equiv=content-ty�e><�� q<���������������������������ath><ul><math><math>< � q<������������������������������� y<table><col></c> q<������������������������� �<'/<L=�=L/3 �<meta cha M y<frameset></frameset#> $ 0<e & ASLI -<math><math><math><math><math><math><ul><math><mha>t<math><math><ma0h><math><math><math>3 � q<������������� ������������������������������������������������������������������������ath><math><math> q<����������������������������u>>�></body><d %ta c</y>� �<m hwitype><META cenn http-equiv=content-ty�e><�� � y<table><col></c> - ���� q<���������������������������ath><ul><math><math>< � �<a><l><ul><u><p><a> q<���tent-ty�e><�� � y<table><col></c> = @ a <table><col></c> !<P � " �������� T >E<L></TITLE E><TIT &u><P><</body></body></body></body></body><bod~><b M math>< ath><math><math>3 � ������� �<m hwitype><META cenn http-equiv=content-ty�e><�� ����������������ath><ul><math><math>< � q<������������������������������� y<table><col></c> <math><ma0h><math><math><math>3 � q<������������� ������������������������������������������������������������������������ath><math><math> q<����������������������������u>>�></body><d %ta c</y>� �<m hwitype><META cenn http-equiv=content-ty�e><�� � y<table><col></c> - ���� q<���������������������������ath><ul><math><math>< � �<a><l><ul><u><p><a> q<���tent-ty�e><�� ���������u>>�></body><d %ta c</y>� �<m hwitype><META cenn http-equiv=content-ty�e><�� � y<table><col></c> - ���� q<���������������������������ath><ul><math><math>< � �<a><l><ul><u><p><a> q<���tent-ty�e><�� � y<table><col></c> = @ a <table><col></c> !<P � " �������� T >E<L></TITLE E><TIT &u><P><</body></body></body></body></body><bod~><b M math>< ath><math><math>3 � ������� �<m hwitype><META cenn http-equiv=content-ty�e><�� ����������������ath><ul><math><math>< � q<������������������������������� y<table><col></c> <math><ma0h><math><math><math>3 � q<������������� ������������������������������������������������������������������������ath><math><math> q<����������������������������u>>�></body><d %ta c</y>� �<m hwitype><META cenn http-equiv=content-ty�e><�� � y<table><col></c> - ���� q<���������������������������ath><ul><math><math>< � �<a><l><ul><u><p><a> q<���tent-ty�e><�� � y<table><col></c> = @ a <table><col></c> !<P � " �������� T >E<L></TITLE E><TIT �������� � �<meta cha $ -<math><math><math><m(th><ul><math><l>u<math><math><math><math><ma5*><math><math><math>3M q<���������������������������ath><ul><math><math>< � q<������������������������������� y<table><col></c> �������� � �<meta cha y<frameset></frameset#> $ ��� -<math><math><math><m(th><ul><math><l>u<math><math><math><math><ma5*><math><math><math>3M q<���������������������������ath><ul><math><math>< � q<������������������������������� y<table><col></c> math>< ath><math><math>7 � ������� �<m hwitype><META cenn http-equiv=content-ty�e><�� � y<table><col></c> y></body></body></body><bod~><b M math>< ath><math><math>3 � ������� �<m hwitype><META cenn http-equ �<meta cha y<frameset></frameset#> $ ��� -<math><math><math><m(th><ul><math><l>u<math><math><math><math><ma5*><math><math><math>3M q<���������������������������ath><ul><math><math>< � q<������������������������������� y<table><col></c> math>< ath><math><math>7 � ������� �<m hwitype><META cenn http-equiv=content-ty�e><�� � y<table><col></c> y></body></body></body><bod~><b M math>< ath><math><math>3 � ������� �<m hwitype><META cenn http-equiv=content-ty�e><�� q<���������������������������ath><ul><math><math>< � q<�� a <table><col></c> ><math> q<����������������������������u>>�></body><d %ta c</y>� �<m hwitype><META cenn http-equiv=content-ty�e><�� � y<table><col></c> - ���� q<���������������������������ath><ul><math><math>< � �<a><l><ul><u><p><a> q<���tent-ty�e><�� � y<table><col></c> = @ a <table><col></c> !<P � " �������� T >E<L></TITLE E><TIT &u><P><</body></body></body></body></body><bod~><b M math>< ath><math><math>3 � ������� �<m hwitype><META cenn http-equiv=content-ty�e><�� ����������������ath><ul><math><math>< � q<������������������������������� y<table><col></c> <math><ma0h><math><math><math>3 � q<������������� ������������������������������������������������������������������������ath><math><math> q<����������������������������u>>�></body><d %ta c</y>� �<m hwitype><META cenn http-equiv=content-ty�e><�� � y<table><col></c> - ���� q<���������������������������ath><ul><math><math>< � �<a><l><ul><u><p><a> q<���tent-ty�e><�� ���������u>>�></body><d %ta c</y>� �<m hwitype><META cenn http-equiv=content-ty�e><�� � y<table><col></c> - ���� q<���������������������������ath><ul><math><math>< � �<a><l><ul><u><p><a> q<���tent-ty�e><�� � y<table><col></c> = @ a <table><col></c> !<P � " �������� T >E<L></TITLE E><TIT &u><P><</body></body></body></body></body><bod~><b M math>< ath><math><math>3 � ������� �<m hwitype><META cenn http-equiv=content-ty�e><�� ����������������ath><ul><math><math>< � q<������������������������������� y<table><col></c> <math><ma0h><math><math><math>3 � q<������������� ������������������������������������������������������������������������ath><math><math> q<����������������������������u>>�></body><d %ta c</y>� �<m hwitype><META cenn http-equiv=content-ty�e><�� � y<table><col></c> - ���� q<���������������������������ath><ul><math><math>< � �<a><l><ul><u><p><a> q<���tent-ty�e><�� � y<table><col></c> = @ a <table><col></c> !<P � " �������� T >E<L></TITLE E><TIT �������� � �<meta cha $ -<math><math><math><m(th><ul><math><l>u<math><math><math><math><ma5*><math><math><math>3M q<���������������������������ath><ul><math><math>< � q<������������������������������� y<table><col></c> �������� � �<meta cha y<frameset></frameset#> $ ��� -<math><math><math><m(th><ul><math><l>u<math><math><math><math><ma5*><math><math><math>3M q<���������������������������ath><ul><math><math>< � q<������������������������������� y<table><col></c> math>< ath><math><math>7 � ������� �<m hwitype><META cenn http-equiv=content-ty�e><�� � y<table><col></c> y></body></body></body><bod~><b M math>< ath><math><math>3 � ������� �<m hwitype><META cenn http-equiv=content-ty�e><�� q<���������������������������ath><ul><math><math>< � q<������������������������������� y<table><col></c> q<������������������������� �<'/<L=�=L/3 �<meta cha M y<frameset></frameset#> $ -<math><math><math><m(th><ul><math><l>u<math><math><math><math><ma5*><math><math><math>3M M T >E<L></TITLE E><TIT math><math>< � �<a><l><ul><u><p><a> q<������������������������������� u<table><select><QTD/>ble-R><<</TD>��������Y&#��536𐄵ᦳ�𖙌&z#65537&5535body𒧐𐀁ﰙ𐀂&�#76240&>>d<</TD>/>TD<<T><</TD></TD></TD>></TD></TD><ta><</TD></TD></Ttf-8><T><P><</body></body></body></body></body><bod~><b M math>< ath><math><math>3 � ������� �<m hwitype><META cenn http-equiv=content-ty�e><�� � y<table><col></c> = @ a <table><col></c> !<P � " �������� b ==' M math>< ath><math><math>3 � ������� �<m hwitype><MET'A cenn http-equiv=content-ty�e><�� � - y<table><col></c> - � y<P><col></c> = @ ITLE></TITLE E><TITL;>1</TILTE E�TITLE></}ITLE E><TITLE></TITLE ETIe<PA><ul>AA]><Px�><A ]>a//4438158984191�ma0<e & ASLI -<math><math><math><math><math><math><ul><math><mha>t<math><math><ma0h><math><math><math>3 � q<������������� ������������������������������������������������������������������������ath><math><math> q<����������������������������u>>�></body><d %ta c</y>� �<m hwitype><META cenn http-equiv=content-ty�e><�� � y<table><col></c> - ���� q<���������������������������ath><ul><math><math>< � �<a><l><ul><u><p><a> q<������������������������������aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaｰaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa -<math><math><math><m(th><ul><math><l>u<math><math><math><math><ma5*><math><math><math>3M q<���������������������������ath><ul><col><math>< � q<������������������������������� y<table><col></c> !<P � " �������� T >E<L></TITLE E><TIT = &u><P><</body></body></body></body></body><bod~><b M math>< ath><math><math>3 � ������� �<m hwitype><META cenn http-equiv=content-ty�e> $ ��� -<math><math><math><m(th><ul><math><l>u<math><math><math><math><ma5*><math><math><math>3M q<���������������������������ath><ul><math><math>< � q<������������������������������� y<table><col></c> math>< ath><math><math>7 � ������� �<m hwitype><META cenn http-equiv=content-ty�e><�� � y<table><col></c> ������������������������������������������������������������������������������������ y></body></body></body><bod~><b M math>< ath><math><math>3 � ������� �<m hwitype><META cenn http-equiv=content-ty�e><�� q<���������������������������ath><ul><math><math>< � q<������������������������������� y<table><col></c> q<������������������������� �<meta cha M y<frameset></frames t> e# $ -<math><math><math><m(th><ul><math><l>u<math><math><math><math><ma0*><math><math><math>3M M T >E<L></TITLE E><TIT math><math>< � �<a><l><ul><u><p><a> q<������������������������������� u<table><select><QTD/>ble-R><aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa -<math><math><math><m(th><ul><math><l>u<math><math><math><math><ma5*><math><math><math>3M q<���������������������������ath><ul><col><math>< � q<������������������������������� y<table><col></c> !<P � " �������� T >E<L></TITLE E><TIT &u><P><</body></body></body></body></body><bod~><b M math>< ath><math><math>3 � ������� �<m hwitype><META cenn http-equiv=content-ty�e> $ ��� -<math><math><math><m(th><ul><math><l>u<math><math><math><math><ma5*><math><math><math>3M q<���������������������������ath><ul><math><math>< � q<������������������������������� y<table><col></c> math>< ath><math><math>7 � ������� �<m hwitype><META cenn http-equiv=content-ty�e><�� � y<table><col></c> ������������������������������������������������������� ����������������������������� y></body></body></body><bod~><b M math>< ath><math><math>3 � ������� �<m hwitype><META cenn http-equiv=content-ty�e><�� q<���������������������������ath><ul><math><math>< � q<������������������������������� y<table><col></c> q<������������������������� �<meta cha M y<frameset></frames t> e# $ -<math><math><math><m(th><ul><math><l>u<math><math><math><math><ma0*><math><math><math>3M M T >E<L></TITLE E><TIT math><math>< � �<a><l><ul><u><p><a> q<������������������������������� u<table><select><QTD/>ble-R><<</TD>��������Y&#��536𐄵ᦳ�𖙌&z#65537&5535body𒧐𐀁ﰙ𐀂&�#76240&>>d<</TD>/>TD<<T><</TD></TD></TD>></TD></TD><ta><</TD></T/></Ttf-8><T><P><</body></body></body></body></body><bod~><b M math>< ath><math><math>3 � ������� �<m hwitype><META cenn http-equiv=content-ty�e><�� � y<table><col>< math>< ath><math><math>7 � ������� �<m hwitype><META cenn http-equiv=content-ty�e><�� � y<table><col></c> ������������������������������������������������������������������������������������ y></body></body></body><bod~><b M math>< ath><math><math>3 � ������� �<m hwitype><META cenn http-equiv=cont/c> = @ a <table><col></c> !<P � " �������� T >E<L></TITLE E><TIT &u><P><</body></body></body></body></body><bod~><b M math>< ath><math><math>3 � ������� �<m hwitype><META cenn http-equiv=content-ty�e><�� � - y<table><col></c> - a �������� � �<meta cha $ -<math><math><math><m(th><ul><math><l>u<math><math><math><math><ma5*><math><math><math>3M <</TD>��������Y&#��536𐄵ᦳ�𖙌&z#65537&5535body𒧐𐀁ﰙ𐀂&�#76240&>>d<</TD>/>TD<<T><</TD></TD></TD>></TD></TD><ta><</TD></T/></Ttf-8><T><P><</body></body></body></body></body><bod~><b M math>< ath><math><math>3 � ������� �<m hwitype><META cenn http-equiv=content-ty�e><�� � y<table><col></c> = @ a <table><col></c> !<P � " ���� � � �� T >E<L></TITLE E><TIT &u><P><</body></body></body></body></body><bod~><b �������� M math>< ath><math><math>3 � ������� �<m hwitype><META cenn http-equiv=content-ty�e><�� � - y<table><col></c> - a �������� 1-</scrixt><s�<!--</script>2&1#13#&&#&# � �<meta cha $ -<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa q<������������������������������� y<table><col></c> !<P � " �������� 0�&�2 T >E<L></TITLE E><TIT &u><P><</body></body></body></body></body><bod~><b M math>< ath><math><math>3 � ������� �<m hwitype><META cenn http-equiv=content-ty�e><�� � - y<table><col></c> - � y<P><col></c> = @ a -<math&><math><math><m(th><ul><math><l>u<math><math><math><math><ma0*><math><math>< H DDDDDDDDDy#��FHFF: border-box t0><math><est</title> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /<R=2O130B > PK z�Zk� N tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-4670634698080256.testcasenu �[��� �� � <cssPK z�Z���{� � N tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-6450958476902400.testcasenu �[��� )<math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><annOtatiop >math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><math><annOtatiop >PK z�Z Ή��, �, N tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-5492400320282624.testcasenu �[��� O ���������������������������������������������������������������������������������������S<q ��T><v="quiv="Content-Type"content=gha-- -- <script/><!-- - rset=><meta http<O/�=""/*=""/=""/�=""/j=""/j=""j="&/�=""/j=""/k=""*=""?!=""/*=""/�=""/*=""+=""/�=""/j=""/j=""j=""/�=""/j=""/k=""*=""?!=""/*="" =""/*=""/=""/�=""/j=""/j=""j=""/m=""/j=""/k=""*=""?!=""/*="+���""/*=/><m/m/><m/m/><m/h/><m//><m/m</m/m/><m/m/><m/n/><m/m/>~<m/m/><m/m/><l/m/><m/�/><m/m/><m//><m//><m/m/><m/m/><m/h/><m/m/><m//><m/m/><m/m/><m//><m/n/><m/m/><m/m/><m/h/><m/m/><m/m/><m/m/><m/n/><m//><m/�/><m/m/>m//m<><m/h/><m//><m//><m/n/><m/n/><m/m/><l/m/><m/�/><m/m/><m//><m/n/><m""/=""/�=""/j=""/j=""j=""/�=""/j=""/k=""*=""?!=""����"/�=""/*=""=""/�=""/j=""/*=""/=""/�=""/j=""/j=""j=""/�=" ent�<t��������- ent�<t- ����������������������������������������������������������������������������������� O "/j=""/k=""*=""?!=""/*="" =""/*=""/"/j=""/j=""j=""/�=""/j=""/k=""*=""?!=""/*="" =""/*=""/=""/�=""/j=""/j=""j=""/m=""/j=""/k=""*=""?!=""/*="+���""/*=/><m/m/><m/m/><m/h/><m//><m/m</m/m/><m/m/><m/n/><m/m/>~<m/m/><m/m/><l/m/><m/�/><m/m/><m//><m//><m/m/><m/m/><m/h/><m/m/><m//><m/m/><m/m/><m//>< ent�<t- ����������������������������������������������������������������������������������� mat O "/j=""/k=""*=""?!=""/*="" =""/*=""/=""/�=""/j=""/j=""j=""/m=""/j=""/k=u< ent�<tform><isindex><isindex><� isindex><isindex><isindex><isindex><isindex><isiODCndex><isindex><isindeX><isindex><isindex><isindex><isind)<tabl inp�t type><svg><i><svg><s><svg><svg><s><�vg><<svg><i><i><svg><i><svg><s><svg><s><svg><<><<svg>g><i><svg><s><svg><s><svg><<s><<svg><i><i><svg><i><svg><s><svg><s><�vg><<svg><i><i><svg><i><svg><s><svg><s><s><<svg>g><i><svg>< revsvg><svg><svg><s><svg><<sv>i<><�vg>��������<x><sV$g><s><svg><<svg><i><i><svg><i><svg><s><svg><s><�vg><<svg><i><i><svg><vg><s><svg><s><sv�><<svg>g><i><svg><s><svg><s><svg><svg><s><s><�vg><<svg><i><i><svg><i><svg><s><svg- ><svg><svg><svg><s><svg><<svg>g><i><svg><s><svg><s><svg><<s><<svg><i><i><svg><i><svg><s><s><s><svg><s><�vg><<svg><i><i><svg><i><svg><s><svg><s><s><<svg>g><i><svg><svg><svg><svg><svg><svg><s><svg><<sv>i<><�ex><isindex><isindex><<meta charset=utf-364>><m//><m/n/><m""/=""/�=""/j=""/j=""j=""/�=""/j����������������������������������������������������������������������������S<q ��T><v="quiv="Content-Type"content=gha-- -- <script/><!-- - rset=><meta http<O/�=""/*=""/=""/�=""/j=""/j=""j="&/�=""/j=""/k=""*=""?!=""/*=""/�=""/*=""+=""/�=""/j=""/j=""j=""/�=""/j=""/k=""*=""?!=""/*="" =""/*=""/=""/�=""/j=""/j=""j=""/m=""/j=""/k=""*=""?!=""/*="+���""/*=/><m/m/><m/m/><m/h/><m//><m/m</m/m/><m/m/><m/n/><m/m/>~<m/m/><m/m/><l/m/><m/�/><m/m/><m//><m//><m/m/><m/m/><m/h/><m/m/><m//><m/m/><m/m/><m//><m/n/><m/m/><m/m/><m/h/><m/m/><m/m/><m/m/><m/n/><m//><m/�/><m/m/>m//m<><m/h/><m//><m//><m/n/><m/n/><m/m/><l/m/><m/�/><m/m/><m//><m/n/><m""/=""/�=""/j=""/j=""j=""/�=""/j=""/k=""*=""?!=""����"/�=""/*=""=""/�=""/j=""/*=""/=""/�=""/j=""/j=""j=""/�=" ent�<t��������- ent�<t- ����������������������������������������������������������������������������������� O "/j=""/k=""*=""?!=""/*="" =""/*=""/"/j=""/j=""j=""/�=""/j=""/k=""*=""?!=""/*="" =""/*=""/=""/�=""/j=""/j=""j=""/m=""/j=""/k=""*=""?!=""/*="+���""/*=/><m/m/><m/m/><m/h/><m//><m/m</m/m/><m/m/><m/n/><m/m/>~<m/m/><m/m/><l/m/><m/�/><m/m/><m//><m//><m/m/><m/m/><m/h/><m/m/><m//><m/m/><m/m/><m//><m/n/><m/m/><m/m/><m/h/><m/m/><m/m/><m/m/><m/n/><m//><m/�/><m/m/>m//m<><m/h/><m//><m//><m/n/><m/n/><m/m/><l/m/><m/�/><m/m/><m//><m/n/><m""/=""/�=""/j=""/j=""j=""/�=""/j=""/k=""*=""?!=""����"/�=""/*=""=""/�=""/j=""/*=""/=""/�=""/j=""/j=""j=""/�=" ent�<t��������- ent�<t- ����������������������������������������������������������������������������������� O "/j=""/k=""*=""?!=""/*="" =""/*=""/=""/�=""/j=""/j=""j=""/m=""/j=""/k=u< ent�<tform><isindex><isindex><� isindex>�<isindex><isindex><isindex><isindex><isiODCndex><isindex><isindeX><isindex><isindex><isindex><isind)<tabl inp�t type><svg><i><svg><s><svg><svg><s><�vg><<svg><i><i><svg><i><svg><s><svg><s><svg><<svg>g><i><svg><s><svg><s><svg><<s><<svg><i><i><svg><i><svg><s><svg><s><�vg><<svg><i><i><svg><i><svg><s><svg><s><s><<svg>g><i><svg>< revsvg><svg><sv=""/�=""/j=""/j=""j=""/m=""/j=""/k=u< ent�<tform><isindex><isindex><� isindex><isindex><isindex><isindex><isindex><isiODCndex><isindex><isindeX><isindex><isindex><isindex><isind)<tabl inp�t type><svg><i><svg><s><svg><svg><s><�vg><<svg><i><i><svg><i><svg><s><svg><s><svg><<svg>g><i><svg><s><svg><s><svg><<s><<svg><i><i><svg><i><svg><s><svg><s><�vg><<svg><i><i><svg><i><svg><s><svg><s><s><<svg>g><i><svg>< revsvg><svg><svg><s><svg><<sv>i<><�vg>��������<x><sV$g><s><svg><<svg><i><i><svg><i><svg><s><svg><s><�vg><<svg><i><i><svg><vg><s><svg><s><sv�><<svg>g><i><svg><s><svg><s><svg><svg><s><s><�vg><<svg><i><i><svg><i><svg><s><svg- ><svg><svg><svg><s><svg><<svg>g><i><svg><s><svg><s><svg><<s><<svg><i><i><sv=""/k=""*=""?!=""����"/�=""/*=""=""/�=""/j=""/k=""*="";!=""/*=""?!=""/*=""/�=""2=""==""/<!--!><vg>��������<x><sV$g><s><svg><me=""/k=""�="";!=""/*=""?!=""/*=""/�="vg<s><i><i><svg><i><svg><s><svg><s><�vg><<svg><i><i><svg><vg><s><sv�����������������i><svg><i><svg><x><5>sv$g><svg><svg><<svg><i340282366920938463463374607431768211456<i><svg><i><svg>svg> <<s><<svg>><i><svg><<i5<i><svg><i><svg<svg><i><i><svg><i><svg><s><s� vg><<svg><i><i>`<svg><i><svg><s><svw><s><svg><input t pe>><<meta charset=utf<s� vg><<svg><i><i>`<svg><i><svg><s><svw><s><svg><input t pe>><<meta chars"1=""==""/<!--m/n/><m/m/><m/m/><m/h/><m/m/><m/m/><m/m/><m/n/><m//><m/�/><m/m/>m//m<><m/h/><m//><m//><m/n/><m/n/><m/m/><l/m/><m/�/><m/m/><m//><m/n/><m""/=""/�=""/j=""/j=""j=""/�=""/j=""/k=""*=""?!=""����"/�=""/*=""=""/�=""/j=""/*=""/=""/�=""/j=""/j=""j=""/�=" ent�<t��������- ent�<t- ����������������������������������������������������������������������������������� mat O "/j=""/k=""*=""?!=""/*="" =""/*=""/=""/�=""/j=""/j=""j=""/m=""/j=""/k=u< ent�<tform><isindex><isindex><� isindex><isindex><isindex><isindex><isindex><isiODCndex><isindex><isindeX><isindex><isindex><isindex><isind)<tabl inp�t type><svg><i><svg><s><svg><svg><s><�vg><<svg><i><i><svg><i><svg><s><svg><s><svg><<><<svg>g><i><svg><s><svg><s><svg><<s><<svg><i><i><svg><i><svg><s><svg><s><�vg><<svg><i><i><svg><i><svg><s><svg><s><s><<svg>g><i><svg>< revsvg><svg><svg><s><svg><<sv>i<><�vg>��������<x><sV$g><s><svg><<svg><i><i><svg><i><svg><s><svg><s><�vg><<svg><i><i><svg><vg><s><svg><s><sv�><<svg>g><i><svg><s><svg><s><svg><svg><s><s><�vg><<svg><i><i><svg><i><svg><s><svg- ><svg><svg><svg><s><svg><<svg>g><i><svg><s><svg><s><svg><<s><<svg><i><i><svg><i><svg><s><s><s><svg><s><�vg><<svg><i><i><svg><i><svg><s><svg><s><s><<svg>g><i><svg><svg><svg><svg><svg><svg><s><svg><<sv>i<><�ex><isindex><isindex><<meta charset=utf-364>><m//><m/n/><m""/=""/�=""/j=""/j=""j=""/�=""/j����������������������������������������������������������������������������S<q ��T><v="quiv="Content-Type"content=gha-- -- <script/><!-- - rset=><meta http<O/�=""/*=""/=""/�=""/j=""/j=""j="&/�=""/j=""/k=""*=""?!=""/*=""/�=""/*=""+=""/�=""/j=""/j=""j=""/�=""/j=""/k=""*=""?!=""/*="" =""/*=""/=""/�=""/j=""/j=""j=""/m=""/j=""/k=""*=""?!=""/*="+���""/*=/><m/m/><m/m/><m/h/><m//><m/m</m/m/><m/m/><m/n/><m/m/>~<m/m/><m/m/><l/m/><m/�/><m/m/><m//><m//><m/m/><m/m/><m/h/><m/m/><m//><m/m/><m/m/><m//><m/n/><m/m/><m/m/><m/h/><m/m/><m/m/><m/m/><m/n/><m//><m/�/><m/m/>m//m<><m/h/><m//><m//><m/n/><m/n/><m/m/><l/m/><m/�/><m/m/><m//><m/n/><m""/=""/�=""/j=""/j=""j=""/�=""/j=""/k=""*=""?!=""����"/�=""/*=""=""/�=""/j=""/*=""/=""/�=""/j=""/j=""j=""/�=" ent�<t��������- ent�<t- ����������������������������������������������������������������������������������� O "/j=""/k=""*=""?!=""/*="" =""/*=""/"/j=""/j=""j=""/�=""/j=""/k=""*=""?!=""/*="" =""/*=""/=""/�=""/j=""/j=""j=""/m=""/j=""/k=""*=""?!=""/*="+���""/*=/><m/m/><m/m/><m/h/><m//><m/m</m/m/><m/m/><m/n/><m/m/>~<m/m/><m/m/><l/m/><m/�/><m/m/><m//><m//><m/m/><m/m/><m/h/><m/m/><m//><m/m/><m/m/><m//><m/n/><m/m/><m/m/><m/h/><m/m/><m/m/><m/m/><m/n/><m//><m/�/><m/m/>m//m<><m/h/><m//><m//><m/n/><m/n/><m/m/><l/m/><m/�/><m/m/><m//><m/n/><m""/=""/�=""/j=""/j=""j=""/�=""/j=""/k=""*=""?!=""����"/�=""/*=""=""/�=""/j=""/*=""/=""/�=""/j=""/j=""j=""/�=" ent�<t��������- ent�<t- ����������������������������������������������������������������������������������� O "/j=""/k=""*=""?!=""/*="" =""/*=""/=""/�=""/j=""/j=""j=""/m=""/j=""/k=u< ent�<tform><isindex><isindex><� isindex>�<isindex><isindex><isindex><isindex><isiODCndex><isindex><isindeX><isindex><isindex><isindex><isind)<tabl inp�t type><svg><i><svg><s><svg><svg><s><�vg><<svg><i><i><svg><i><svg><s><svg><s><svg><<svg>g><i><svg><s><svg><s><svg><<s><<svg><i><i><svg><i><svg><s><svg><s><�vg><<svg><i><i><svg><i><svg><s><svg><s><s><<svg>g><i><svg>< revsvg><svg><sv=""/�=""/j=""/j=""j=""/m=""/j=""/k=u< ent�<tform><isindex><isindex><� isindex><isindex><isindex><isindex><isindex><isiODCndex><isindex><isindeX><isindex><isindex><isindex><isind)<tabl inp�t type><svg><i><svg><s><svg><svg><s><�vg><<svg><i><i><svg><i><svg><s><svg><s><svg><<svg>g><i><svg><s><svg><s><svg><<s><<svg><i><i><svg><i><svg><s><svg><s><�vg><<svg><i><i><svg><i><svg><s><svg><s><s><<svg>g><i><svg>< revsvg><svg><svg><s><svg><<sv>i<><�vg>��������<x><sV$g><s><svg><<svg><i><i><svg><i><svg><s><svg><s><�vg><<svg><i><i><svg><vg><s><svg><s><sv�><<svg>g><i><svg><s><svg><s><svg><svg><s><s><�vg><<svg><i><i><svg><i><svg><s><svg- ><svg><svg><svg><s><svg><<svg>g><i><svg><s><svg><s><svg><<s><<svg><i><i><sv=""/k=""*=""?!=""����"/�=""/*=""=""/�=""/j=""/k=""*="";!=""/*=""?!=""/*=""/�=""2=""==""/<!--!><vg>��������<x><sV$g><s><svg><me=""/k=""�="";!=""/*=""?!=""/*=""/�="vg<s><i><i><svg><i><svg><s><svg><s><�vg><<svg><i><i><svg><vg><s><sv�����������������i><svg><i><svg><x><5>sv$g><svg><svg><<svg><i340282366920938463463374607431768211456<i><svg><i><svg>svg> <<s><<svg>><i><svg><<i5<i><svg><i><svg<svg><i><i><svg><i><svg><s><s� vg><<svg><i><i>`<svg><i><svg><s><svw><s><svg><input t pe>><<meta charset=utf<s� vg><<svg><i><i>`<svg><i><svg><s><svw><s><svg><input t pe>><<meta chars"1=""==""/<!--!><et=utf-8>< meta charset=utf-81PK z�Z�t~b�( �( N tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-6124268085182464.testcasenu �[��� )<math><math><math><math><math><math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&)<math><math><annotation-xul>&PK z�ZH�7T L L N tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-5167584867909632.testcasenu �[��� � <s s cript>>crip><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 ;><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table<>R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=chaontent=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" comtent=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 ) <table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charseqtf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<tlRe<>ab?<=><meta http-equ�v="Con -Type" content=charset=uutf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<tlRe<>ab?<=><meta http-equ�v="Con -Type" content=charset=utf�><0 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=>><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=chaontent=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" comtent=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charseqtf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=�tf�><2 )<tlRe<>ab?<=><meta http-equ�v="Con -Type" content=charset=uutf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<tlRe<>ab?<=><meta http-equ�v="Con -Type" content=charset=utf�><0 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><1 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equ(iv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><1 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><me oup><o ""ta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?�I<!DOCTY���<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset>�&gd=>=>r>=>=>=h<l!ڏth<l<L&<>a>=>=>=>=!gt=>=>a>=\r\n$+%n$PATH%d+inf$!!�$'%n'xcalc\x00NaN <l<L<l"ltl<l<m&nt=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><1 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><table><R?a http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?�le><R?a http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><met ahttp-eqoiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charsjt=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<$=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table<>R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=cheta http-equiv="Content-Type" content=charset=utf�scrip><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?�I<!DOCTY���<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�uiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" comtent=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 ) <table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charseqtf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<tlRe<>ab?<=><meta http-equ�v="Con -Type" content=charset=uutf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<tlRe<>ab?<=><meta http-equ�v="Con -Type" content=charset=utf�><0 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=>><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=chaontent=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" comtent=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charseqtf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=�tf�><2 )<tlRe<>ab?<=><meta http-equ�v="Con -Type" content=charset=uutf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<tlRe<>ab?<=><meta http-equ�v="Con -Type" content=charset=utf�><0 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><m><2 )<table><R?<=><meta http-equiv="Content-Type" content=charset=utf�><2 )<table><R?<=><meta http-equiv="Content-Type" content=t>><tPK z�Z��n N tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-4999465949331456.testcasenu �[��� )<a><math><TR><a><mI><a><p><a>PK z�Z9����; �; N tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-5000587759190016.testcasenu �[��� - � <s/�><ht<!charset=utf<t>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>< <html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 5//�><html , j �/n 2//�/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l ~ �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<�tml l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�>5//�><html , j �/n 4//�><html , j �/n 8//�ml?<html><html><html><htmml l j �/<html ,j ��� 5//�><html , j �/n 4//�><�tml , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><h��������/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�>< - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/8//�><html - j �/n 5/D/�>-<html l j �/<html ,/ n/j0� / � �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 6//�><html , j �/n 4//�><html , j �/! 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 1// �/n� 5//�></�>-<math>< ]AT>]]>ml , j �/n 3//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�<>html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<hlmt lj �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4/ml ,j �n/ 0// �/n� 5//�></�/D/�>-<html l j �/<html ,j �n/ 0// //TRANSLIT></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 1//�><html - j �/n 5/D/�>-<//�><html , j �/n 1//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n%� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><htmltml , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D��>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j /h<�tml ,j �n/ 0// �/n� 5/><html , j �/n 4//�><html ,�j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4/������ Xl , j �/n 8//�><html - j �/n 5/D/�>-<html l ~ �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/� �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 6//�><html , j �/n 4//�><html , j �/! 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 1// �/n� 5//�></�>-<math>< ]AT>]]>ml , j �/n 3//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�<>html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<hlmt lj �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4/ml ,j �n/ 0// �/n� 5//�></�/D/�>-<html l j �/<html ,j �n/ 0// //TRANSLIT></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 1//�><html - j �/n 5/D/�>-<//�><html , j �/n 1//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n%� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><htmltml , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D��>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j /h<�tml ,j �n/ 0// �/n� 5/><html , j �/n 4//�><html ,�j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l ~ �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 4//�><html , j �/n 4//�>5//�><html , j �/n 4//�><html , j �/n 8//�><html - j 5�/ n/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></ �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4)/�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , �j�n 5/-�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></ml , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 4//�></�><html , j �/n 5//�><html , j �//n4 /�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�> �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j ><html , j �/n 5//�><html , j �/b 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<gtml ,ml , j �/n 5//�><html , j j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/�></�><h � �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/8//�><html - j �/n 5/D/�>-<html l j �/<html -/ n/j0� / � �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8*/�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4�><html - j �/n 5/D�n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/8//�><html - j �/n 5/D/�>-<html l j �/<html ,/ n/j0� / � �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 6//�><html , j �/n 4//�><html , j �/! 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 1// �/n� 5//�></�><html , j �/n 5/�/�><html , j �/n 3//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�<>html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<hlmt lj �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4/ml ,j �n/ 0// �/n� 5//�></�/D/�>-<html l j �/<html ,j �n/ 0// //TRANSLIT></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 1//�><html - j �/n 5/D/�>-<//�><html , j �/n 1//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><htmltml , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D��>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 1// �/n� 5//�></�>-<math>< ]AT>]]>ml , j �/n 3//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�<>html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n /�><html , j �/n 4/ml ,j �n/ 0// �/n� 5//�></�/D/�>-<html l j �/<html ,j �n/ 0// //TRANSLIT></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 1//�><html - j �/n 5/D/�>-<//�><html , j �/n 1//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><htmltml , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><htmm , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4/html ,j �n/ 0// �/n� 5/=<!--� 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><h��������/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/8//�><html - j �/n 5/D/�>-<html l j �/<html ,/ n/j0� / � �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 6//�><html , j �/n 4//�><html , j �/! 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 1// �/n� 5//�></�><html , j �/n 5/�/�><html , j �/n 3//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�<>html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<hlmt lj �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4/ml ,j �n/ 0// �/n� 5//�></�/D/�>-<html l j �/<html ,j �n/ 0// //TRANSLIT></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 1//�><html - j �/n 5/D/�>-<//�><html , j �/n 1//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><htmltml , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D��>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j /h<�tml ,j �n/ 0// �/n� 5/><html , j �/n 4//�><html ,�j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l ~ �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j �/n 4//�><html ,/�><html , j �/n 4// , j �/n 4/�<script><!--� <--<m--l - j �/n 5/D/�>-<html l j �/<gtml ,ml , j �/n 5//�><html , j �/n 1//�><html , j �/n 8//�><html - j �/n 5/D/�>-\ � l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5//�><html , j)�/n 4//�><html , j �/n 8//�><html - j �/n 5/D/�>-<html l j �/<html ,j �n/ 0// �/n� 5//�></�><html , j �/n 5[/�><html , j �/n 1//�> , j ����5//�><html ,html , j �/n 5//�><html , j �/n 4//�><html , j �/n 8//�><html- j �/n 2/n/�>/�><html - j �/n 5/D/�>- �n/ -0// 28276994// �/n� T//�>?+>< �<!----!><meta charset=utf-8><PK z�Z�LbF/ / N tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-6306874195312640.testcasenu �[��� - �� <math><select><mi><select><select>tPK z�Z�!]�# # N tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-5843991618256896.testcasenu �[��� -<math><sElect><mi><sElect><sElect>PK z�Z?��� N tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-5270998950477824.testcasenu �[��� <r/D='� ��PK z�Z�:�9/ / B tests/fuzz/crash-0d306a50c8ed8bcd0785b67000fcd5dea1d33f08.testcasenu �[��� Q<a href=�="1" b="10" a="2" a="3" a="4">Multiple values for the same attri=ute.</b> <div><tabble</td></tr></table></div> <div><tablee id="3"><tr><td>foo</td></tr></table������� or XM:<table id="2"><tr><td>f<oo/td></tr></table></ble id="1"><tr><tdd of �the id="0"><tr>> <div><table id="0"><tr><td>Here's a nested tabl�:<table id="3"><tr><dnested table:<table id="�e's a nested taere's a nested table: off by</blockquote></p>the end tr></table></div> <div><table id="1"><tr><td>Her0"><tr><td>Here's a nested tabl�:<table id="3"><tr><td>foo</td></tr></table������� or XM:<table id="2"><trid="2"><$tr><td>foo</td></tr$</table></ble e's a nested tabl�:<table id="3"><tr><td>foo</td></tr></table������� or XM:<table id="2"><tr><td>f<oo/td></tr"3"><tr><td>foo</td></tr></taoa<frameset><b%w e><metreca>f "<framesdt<listing> "?/frameset>, ese!t>,g c���������� or XML c<svg>�-in for the va Beautiful Soup parses[ the markup '<met charset �<html> <html> </N�<� </A<html> <html> </n�<ё ���A<html> <html> </A<html> <html> </n�ipt> <!DOC ttttttt ttt> <math/>kbd><<bttttttt> <!DOC tttttttttttttttttttttttttttttttttttt ���A<html> <html> </A<� �=�<html><html> <html> </n�<> <html> </n�<ё ���A<html> <html> </E<htrl] |htt<>l mmhhtml> </A<� �=�A<html><h ml> </n� <html> </n�<> <ht�dIv> <math/> <math/>> )> <math/>kbd><<bA/`/dy> </html> �bo"me">me</a> < Oml> <html> </A<� �=�A<ht�A<html> <htl> <html> </n� <html> </n�<> <html> </n�<ё ���A ���A<html> <html> </A<� �=�A<html><html> <html> </ <html> </n�<ё ���A<html> <html> </A<htrl] <htmhtml> <html> </A<� �=�A<html><html> <html> </n� <html> </n�<> <html>�dIv> <math/> <math/>> ) </n�<ё ���A<html> <htm. ext"> :</fo�/`ody> </html> �bo"me">me< �=�A<htmn><html> <html> </n� <html> </n�<> <html> </n�<ё �<ё ���A<html> <html> </A<html> <html> <abl�:<table id="3"><tr><td>foo</td></tr></table������� or XM:<table id="2"><tr><td>f<oo/td></tr"3"><tr><td>foo</td></tr></taoo/td></tr></table></ble id="1"><tr><td>Here's a nested table: of<span>f by</blockquote></p>the end of the id="1"><tr>> <div><table id="0"><tr><td>Here's a nested tabl�:<table id="3"><tr><td>foo%/td></tr></table></ble id="1"><tr><td>Here's a nested table:<table id="re's a nes��� > <met/;> dy> </html> ted tabl����able id="2"><$5r><td>foo<form></td></tr$</table <!----><input c; <html> <'s a nested tabl�:<table id="3"><tr><td>foo</td></tr></table������� or XM:<table id="2"><trid="2"><$tr><td>foo</td></tr$</table></ble e'sbod y> <form> <!----><inpa tt></ble id="1"><tr>�td>Here's <html> <body> ěorm> <!----><inpa nut�e�PK z�Z1o��C C tests/test_css.pynu �[��� import pytest import types from unittest.mock import MagicMock from bs4 import ( CSS, BeautifulSoup, ResultSet, ) from . import ( SoupTest, SOUP_SIEVE_PRESENT, ) if SOUP_SIEVE_PRESENT: from soupsieve import SelectorSyntaxError @pytest.mark.skipif(not SOUP_SIEVE_PRESENT, reason="Soup Sieve not installed") class TestCSSSelectors(SoupTest): """Test basic CSS selector functionality. This functionality is implemented in soupsieve, which has a much more comprehensive test suite, so this is basically an extra check that soupsieve works as expected. """ HTML = """ <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <html> <head> <title>The title</title> <link rel="stylesheet" href="blah.css" type="text/css" id="l1"> </head> <body> <custom-dashed-tag class="dashed" id="dash1">Hello there.</custom-dashed-tag> <div id="main" class="fancy"> <div id="inner"> <h1 id="header1">An H1</h1> <p>Some text</p> <p class="onep" id="p1">Some more text</p> <h2 id="header2">An H2</h2> <p class="class1 class2 class3" id="pmulti">Another</p> <a href="http://bob.example.org/" rel="friend met" id="bob">Bob</a> <h2 id="header3">Another H2</h2> <a id="me" href="http://simonwillison.net/" rel="me">me</a> <span class="s1"> <a href="#" id="s1a1">span1a1</a> <a href="#" id="s1a2">span1a2 <span id="s1a2s1">test</span></a> <span class="span2"> <a href="#" id="s2a1">span2a1</a> </span> <span class="span3"></span> <custom-dashed-tag class="dashed" id="dash2"/> <div data-tag="dashedvalue" id="data1"/> </span> </div> <x id="xid"> <z id="zida"/> <z id="zidab"/> <z id="zidac"/> </x> <y id="yid"> <z id="zidb"/> </y> <p lang="en" id="lang-en">English</p> <p lang="en-gb" id="lang-en-gb">English UK</p> <p lang="en-us" id="lang-en-us">English US</p> <p lang="fr" id="lang-fr">French</p> </div> <div id="footer"> </div> """ def setup_method(self): self.soup = BeautifulSoup(self.HTML, 'html.parser') def assert_selects(self, selector, expected_ids, **kwargs): results = self.soup.select(selector, **kwargs) assert isinstance(results, ResultSet) el_ids = [el['id'] for el in results] el_ids.sort() expected_ids.sort() assert expected_ids == el_ids, "Selector %s, expected [%s], got [%s]" % ( selector, ', '.join(expected_ids), ', '.join(el_ids) ) assertSelect = assert_selects def assert_select_multiple(self, *tests): for selector, expected_ids in tests: self.assert_selects(selector, expected_ids) def test_precompiled(self): sel = self.soup.css.compile('div') els = self.soup.select(sel) assert len(els) == 4 for div in els: assert div.name == 'div' el = self.soup.select_one(sel) assert 'main' == el['id'] def test_one_tag_one(self): els = self.soup.select('title') assert len(els) == 1 assert els[0].name == 'title' assert els[0].contents == ['The title'] def test_one_tag_many(self): els = self.soup.select('div') assert len(els) == 4 for div in els: assert div.name == 'div' el = self.soup.select_one('div') assert 'main' == el['id'] def test_select_one_returns_none_if_no_match(self): match = self.soup.select_one('nonexistenttag') assert None == match def test_tag_in_tag_one(self): els = self.soup.select('div div') self.assert_selects('div div', ['inner', 'data1']) def test_tag_in_tag_many(self): for selector in ('html div', 'html body div', 'body div'): self.assert_selects(selector, ['data1', 'main', 'inner', 'footer']) def test_limit(self): self.assert_selects('html div', ['main'], limit=1) self.assert_selects('html body div', ['inner', 'main'], limit=2) self.assert_selects('body div', ['data1', 'main', 'inner', 'footer'], limit=10) def test_tag_no_match(self): assert len(self.soup.select('del')) == 0 def test_invalid_tag(self): with pytest.raises(SelectorSyntaxError): self.soup.select('tag%t') def test_select_dashed_tag_ids(self): self.assert_selects('custom-dashed-tag', ['dash1', 'dash2']) def test_select_dashed_by_id(self): dashed = self.soup.select('custom-dashed-tag[id=\"dash2\"]') assert dashed[0].name == 'custom-dashed-tag' assert dashed[0]['id'] == 'dash2' def test_dashed_tag_text(self): assert self.soup.select('body > custom-dashed-tag')[0].text == 'Hello there.' def test_select_dashed_matches_find_all(self): assert self.soup.select('custom-dashed-tag') == self.soup.find_all('custom-dashed-tag') def test_header_tags(self): self.assert_select_multiple( ('h1', ['header1']), ('h2', ['header2', 'header3']), ) def test_class_one(self): for selector in ('.onep', 'p.onep', 'html p.onep'): els = self.soup.select(selector) assert len(els) == 1 assert els[0].name == 'p' assert els[0]['class'] == ['onep'] def test_class_mismatched_tag(self): els = self.soup.select('div.onep') assert len(els) == 0 def test_one_id(self): for selector in ('div#inner', '#inner', 'div div#inner'): self.assert_selects(selector, ['inner']) def test_bad_id(self): els = self.soup.select('#doesnotexist') assert len(els) == 0 def test_items_in_id(self): els = self.soup.select('div#inner p') assert len(els) == 3 for el in els: assert el.name == 'p' assert els[1]['class'] == ['onep'] assert not els[0].has_attr('class') def test_a_bunch_of_emptys(self): for selector in ('div#main del', 'div#main div.oops', 'div div#main'): assert len(self.soup.select(selector)) == 0 def test_multi_class_support(self): for selector in ('.class1', 'p.class1', '.class2', 'p.class2', '.class3', 'p.class3', 'html p.class2', 'div#inner .class2'): self.assert_selects(selector, ['pmulti']) def test_multi_class_selection(self): for selector in ('.class1.class3', '.class3.class2', '.class1.class2.class3'): self.assert_selects(selector, ['pmulti']) def test_child_selector(self): self.assert_selects('.s1 > a', ['s1a1', 's1a2']) self.assert_selects('.s1 > a span', ['s1a2s1']) def test_child_selector_id(self): self.assert_selects('.s1 > a#s1a2 span', ['s1a2s1']) def test_attribute_equals(self): self.assert_select_multiple( ('p[class="onep"]', ['p1']), ('p[id="p1"]', ['p1']), ('[class="onep"]', ['p1']), ('[id="p1"]', ['p1']), ('link[rel="stylesheet"]', ['l1']), ('link[type="text/css"]', ['l1']), ('link[href="blah.css"]', ['l1']), ('link[href="no-blah.css"]', []), ('[rel="stylesheet"]', ['l1']), ('[type="text/css"]', ['l1']), ('[href="blah.css"]', ['l1']), ('[href="no-blah.css"]', []), ('p[href="no-blah.css"]', []), ('[href="no-blah.css"]', []), ) def test_attribute_tilde(self): self.assert_select_multiple( ('p[class~="class1"]', ['pmulti']), ('p[class~="class2"]', ['pmulti']), ('p[class~="class3"]', ['pmulti']), ('[class~="class1"]', ['pmulti']), ('[class~="class2"]', ['pmulti']), ('[class~="class3"]', ['pmulti']), ('a[rel~="friend"]', ['bob']), ('a[rel~="met"]', ['bob']), ('[rel~="friend"]', ['bob']), ('[rel~="met"]', ['bob']), ) def test_attribute_startswith(self): self.assert_select_multiple( ('[rel^="style"]', ['l1']), ('link[rel^="style"]', ['l1']), ('notlink[rel^="notstyle"]', []), ('[rel^="notstyle"]', []), ('link[rel^="notstyle"]', []), ('link[href^="bla"]', ['l1']), ('a[href^="http://"]', ['bob', 'me']), ('[href^="http://"]', ['bob', 'me']), ('[id^="p"]', ['pmulti', 'p1']), ('[id^="m"]', ['me', 'main']), ('div[id^="m"]', ['main']), ('a[id^="m"]', ['me']), ('div[data-tag^="dashed"]', ['data1']) ) def test_attribute_endswith(self): self.assert_select_multiple( ('[href$=".css"]', ['l1']), ('link[href$=".css"]', ['l1']), ('link[id$="1"]', ['l1']), ('[id$="1"]', ['data1', 'l1', 'p1', 'header1', 's1a1', 's2a1', 's1a2s1', 'dash1']), ('div[id$="1"]', ['data1']), ('[id$="noending"]', []), ) def test_attribute_contains(self): self.assert_select_multiple( # From test_attribute_startswith ('[rel*="style"]', ['l1']), ('link[rel*="style"]', ['l1']), ('notlink[rel*="notstyle"]', []), ('[rel*="notstyle"]', []), ('link[rel*="notstyle"]', []), ('link[href*="bla"]', ['l1']), ('[href*="http://"]', ['bob', 'me']), ('[id*="p"]', ['pmulti', 'p1']), ('div[id*="m"]', ['main']), ('a[id*="m"]', ['me']), # From test_attribute_endswith ('[href*=".css"]', ['l1']), ('link[href*=".css"]', ['l1']), ('link[id*="1"]', ['l1']), ('[id*="1"]', ['data1', 'l1', 'p1', 'header1', 's1a1', 's1a2', 's2a1', 's1a2s1', 'dash1']), ('div[id*="1"]', ['data1']), ('[id*="noending"]', []), # New for this test ('[href*="."]', ['bob', 'me', 'l1']), ('a[href*="."]', ['bob', 'me']), ('link[href*="."]', ['l1']), ('div[id*="n"]', ['main', 'inner']), ('div[id*="nn"]', ['inner']), ('div[data-tag*="edval"]', ['data1']) ) def test_attribute_exact_or_hypen(self): self.assert_select_multiple( ('p[lang|="en"]', ['lang-en', 'lang-en-gb', 'lang-en-us']), ('[lang|="en"]', ['lang-en', 'lang-en-gb', 'lang-en-us']), ('p[lang|="fr"]', ['lang-fr']), ('p[lang|="gb"]', []), ) def test_attribute_exists(self): self.assert_select_multiple( ('[rel]', ['l1', 'bob', 'me']), ('link[rel]', ['l1']), ('a[rel]', ['bob', 'me']), ('[lang]', ['lang-en', 'lang-en-gb', 'lang-en-us', 'lang-fr']), ('p[class]', ['p1', 'pmulti']), ('[blah]', []), ('p[blah]', []), ('div[data-tag]', ['data1']) ) def test_quoted_space_in_selector_name(self): html = """<div style="display: wrong">nope</div> <div style="display: right">yes</div> """ soup = BeautifulSoup(html, 'html.parser') [chosen] = soup.select('div[style="display: right"]') assert "yes" == chosen.string def test_unsupported_pseudoclass(self): with pytest.raises(NotImplementedError): self.soup.select("a:no-such-pseudoclass") with pytest.raises(SelectorSyntaxError): self.soup.select("a:nth-of-type(a)") def test_nth_of_type(self): # Try to select first paragraph els = self.soup.select('div#inner p:nth-of-type(1)') assert len(els) == 1 assert els[0].string == 'Some text' # Try to select third paragraph els = self.soup.select('div#inner p:nth-of-type(3)') assert len(els) == 1 assert els[0].string == 'Another' # Try to select (non-existent!) fourth paragraph els = self.soup.select('div#inner p:nth-of-type(4)') assert len(els) == 0 # Zero will select no tags. els = self.soup.select('div p:nth-of-type(0)') assert len(els) == 0 def test_nth_of_type_direct_descendant(self): els = self.soup.select('div#inner > p:nth-of-type(1)') assert len(els) == 1 assert els[0].string == 'Some text' def test_id_child_selector_nth_of_type(self): self.assert_selects('#inner > p:nth-of-type(2)', ['p1']) def test_select_on_element(self): # Other tests operate on the tree; this operates on an element # within the tree. inner = self.soup.find("div", id="main") selected = inner.select("div") # The <div id="inner"> tag was selected. The <div id="footer"> # tag was not. self.assert_selects_ids(selected, ['inner', 'data1']) def test_overspecified_child_id(self): self.assert_selects(".fancy #inner", ['inner']) self.assert_selects(".normal #inner", []) def test_adjacent_sibling_selector(self): self.assert_selects('#p1 + h2', ['header2']) self.assert_selects('#p1 + h2 + p', ['pmulti']) self.assert_selects('#p1 + #header2 + .class1', ['pmulti']) assert [] == self.soup.select('#p1 + p') def test_general_sibling_selector(self): self.assert_selects('#p1 ~ h2', ['header2', 'header3']) self.assert_selects('#p1 ~ #header2', ['header2']) self.assert_selects('#p1 ~ h2 + a', ['me']) self.assert_selects('#p1 ~ h2 + [rel="me"]', ['me']) assert [] == self.soup.select('#inner ~ h2') def test_dangling_combinator(self): with pytest.raises(SelectorSyntaxError): self.soup.select('h1 >') def test_sibling_combinator_wont_select_same_tag_twice(self): self.assert_selects('p[lang] ~ p', ['lang-en-gb', 'lang-en-us', 'lang-fr']) # Test the selector grouping operator (the comma) def test_multiple_select(self): self.assert_selects('x, y', ['xid', 'yid']) def test_multiple_select_with_no_space(self): self.assert_selects('x,y', ['xid', 'yid']) def test_multiple_select_with_more_space(self): self.assert_selects('x, y', ['xid', 'yid']) def test_multiple_select_duplicated(self): self.assert_selects('x, x', ['xid']) def test_multiple_select_sibling(self): self.assert_selects('x, y ~ p[lang=fr]', ['xid', 'lang-fr']) def test_multiple_select_tag_and_direct_descendant(self): self.assert_selects('x, y > z', ['xid', 'zidb']) def test_multiple_select_direct_descendant_and_tags(self): self.assert_selects('div > x, y, z', ['xid', 'yid', 'zida', 'zidb', 'zidab', 'zidac']) def test_multiple_select_indirect_descendant(self): self.assert_selects('div x,y, z', ['xid', 'yid', 'zida', 'zidb', 'zidab', 'zidac']) def test_invalid_multiple_select(self): with pytest.raises(SelectorSyntaxError): self.soup.select(',x, y') with pytest.raises(SelectorSyntaxError): self.soup.select('x,,y') def test_multiple_select_attrs(self): self.assert_selects('p[lang=en], p[lang=en-gb]', ['lang-en', 'lang-en-gb']) def test_multiple_select_ids(self): self.assert_selects('x, y > z[id=zida], z[id=zidab], z[id=zidb]', ['xid', 'zidb', 'zidab']) def test_multiple_select_nested(self): self.assert_selects('body > div > x, y > z', ['xid', 'zidb']) def test_select_duplicate_elements(self): # When markup contains duplicate elements, a multiple select # will find all of them. markup = '<div class="c1"/><div class="c2"/><div class="c1"/>' soup = BeautifulSoup(markup, 'html.parser') selected = soup.select(".c1, .c2") assert 3 == len(selected) # Verify that find_all finds the same elements, though because # of an implementation detail it finds them in a different # order. for element in soup.find_all(class_=['c1', 'c2']): assert element in selected def test_closest(self): inner = self.soup.find("div", id="inner") closest = inner.css.closest("div[id=main]") assert closest == self.soup.find("div", id="main") def test_match(self): inner = self.soup.find("div", id="inner") main = self.soup.find("div", id="main") assert inner.css.match("div[id=main]") == False assert main.css.match("div[id=main]") == True def test_iselect(self): gen = self.soup.css.iselect("h2") assert isinstance(gen, types.GeneratorType) [header2, header3] = gen assert header2['id'] == 'header2' assert header3['id'] == 'header3' def test_filter(self): inner = self.soup.find("div", id="inner") results = inner.css.filter("h2") assert len(inner.css.filter("h2")) == 2 results = inner.css.filter("h2[id=header3]") assert isinstance(results, ResultSet) [result] = results assert result['id'] == 'header3' def test_escape(self): m = self.soup.css.escape assert m(".foo#bar") == '\\.foo\\#bar' assert m("()[]{}") == '\\(\\)\\[\\]\\{\\}' assert m(".foo") == self.soup.css.escape(".foo") PK z�Z�JD�� � tests/test_html5lib.pynu �[��� """Tests to ensure that the html5lib tree builder generates good trees.""" import pytest import warnings from bs4 import BeautifulSoup from bs4.element import SoupStrainer from . import ( HTML5LIB_PRESENT, HTML5TreeBuilderSmokeTest, SoupTest, ) @pytest.mark.skipif( not HTML5LIB_PRESENT, reason="html5lib seems not to be present, not testing its tree builder." ) class TestHTML5LibBuilder(SoupTest, HTML5TreeBuilderSmokeTest): """See ``HTML5TreeBuilderSmokeTest``.""" @property def default_builder(self): from bs4.builder import HTML5TreeBuilder return HTML5TreeBuilder def test_soupstrainer(self): # The html5lib tree builder does not support SoupStrainers. strainer = SoupStrainer("b") markup = "<p>A <b>bold</b> statement.</p>" with warnings.catch_warnings(record=True) as w: soup = BeautifulSoup(markup, "html5lib", parse_only=strainer) assert soup.decode() == self.document_for(markup) [warning] = w assert warning.filename == __file__ assert "the html5lib tree builder doesn't support parse_only" in str(warning.message) def test_correctly_nested_tables(self): """html5lib inserts <tbody> tags where other parsers don't.""" markup = ('<table id="1">' '<tr>' "<td>Here's another table:" '<table id="2">' '<tr><td>foo</td></tr>' '</table></td>') self.assert_soup( markup, '<table id="1"><tbody><tr><td>Here\'s another table:' '<table id="2"><tbody><tr><td>foo</td></tr></tbody></table>' '</td></tr></tbody></table>') self.assert_soup( "<table><thead><tr><td>Foo</td></tr></thead>" "<tbody><tr><td>Bar</td></tr></tbody>" "<tfoot><tr><td>Baz</td></tr></tfoot></table>") def test_xml_declaration_followed_by_doctype(self): markup = '''<?xml version="1.0" encoding="utf-8"?> <!DOCTYPE html> <html> <head> </head> <body> <p>foo</p> </body> </html>''' soup = self.soup(markup) # Verify that we can reach the <p> tag; this means the tree is connected. assert b"<p>foo</p>" == soup.p.encode() def test_reparented_markup(self): markup = '<p><em>foo</p>\n<p>bar<a></a></em></p>' soup = self.soup(markup) assert "<body><p><em>foo</em></p><em>\n</em><p><em>bar<a></a></em></p></body>" == soup.body.decode() assert 2 == len(soup.find_all('p')) def test_reparented_markup_ends_with_whitespace(self): markup = '<p><em>foo</p>\n<p>bar<a></a></em></p>\n' soup = self.soup(markup) assert "<body><p><em>foo</em></p><em>\n</em><p><em>bar<a></a></em></p>\n</body>" == soup.body.decode() assert 2 == len(soup.find_all('p')) def test_reparented_markup_containing_identical_whitespace_nodes(self): """Verify that we keep the two whitespace nodes in this document distinct when reparenting the adjacent <tbody> tags. """ markup = '<table> <tbody><tbody><ims></tbody> </table>' soup = self.soup(markup) space1, space2 = soup.find_all(string=' ') tbody1, tbody2 = soup.find_all('tbody') assert space1.next_element is tbody1 assert tbody2.next_element is space2 def test_reparented_markup_containing_children(self): markup = '<div><a>aftermath<p><noscript>target</noscript>aftermath</a></p></div>' soup = self.soup(markup) noscript = soup.noscript assert "target" == noscript.next_element target = soup.find(string='target') # The 'aftermath' string was duplicated; we want the second one. final_aftermath = soup.find_all(string='aftermath')[-1] # The <noscript> tag was moved beneath a copy of the <a> tag, # but the 'target' string within is still connected to the # (second) 'aftermath' string. assert final_aftermath == target.next_element assert target == final_aftermath.previous_element def test_processing_instruction(self): """Processing instructions become comments.""" markup = b"""<?PITarget PIContent?>""" soup = self.soup(markup) assert str(soup).startswith("<!--?PITarget PIContent?-->") def test_cloned_multivalue_node(self): markup = b"""<a class="my_class"><p></a>""" soup = self.soup(markup) a1, a2 = soup.find_all('a') assert a1 == a2 assert a1 is not a2 def test_foster_parenting(self): markup = b"""<table><td></tbody>A""" soup = self.soup(markup) assert "<body>A<table><tbody><tr><td></td></tr></tbody></table></body>" == soup.body.decode() def test_extraction(self): """ Test that extraction does not destroy the tree. https://bugs.launchpad.net/beautifulsoup/+bug/1782928 """ markup = """ <html><head></head> <style> </style><script></script><body><p>hello</p></body></html> """ soup = self.soup(markup) [s.extract() for s in soup('script')] [s.extract() for s in soup('style')] assert len(soup.find_all("p")) == 1 def test_empty_comment(self): """ Test that empty comment does not break structure. https://bugs.launchpad.net/beautifulsoup/+bug/1806598 """ markup = """ <html> <body> <form> <!----><input type="text"> </form> </body> </html> """ soup = self.soup(markup) inputs = [] for form in soup.find_all('form'): inputs.extend(form.find_all('input')) assert len(inputs) == 1 def test_tracking_line_numbers(self): # The html.parser TreeBuilder keeps track of line number and # position of each element. markup = "\n <p>\n\n<sourceline>\n<b>text</b></sourceline><sourcepos></p>" soup = self.soup(markup) assert 2 == soup.p.sourceline assert 5 == soup.p.sourcepos assert "sourceline" == soup.p.find('sourceline').name # You can deactivate this behavior. soup = self.soup(markup, store_line_numbers=False) assert "sourceline" == soup.p.sourceline.name assert "sourcepos" == soup.p.sourcepos.name def test_special_string_containers(self): # The html5lib tree builder doesn't support this standard feature, # because there's no way of knowing, when a string is created, # where in the tree it will eventually end up. pass def test_html5_attributes(self): # The html5lib TreeBuilder can convert any entity named in # the HTML5 spec to a sequence of Unicode characters, and # convert those Unicode characters to a (potentially # different) named entity on the way out. # # This is a copy of the same test from # HTMLParserTreeBuilderSmokeTest. It's not in the superclass # because the lxml HTML TreeBuilder _doesn't_ work this way. for input_element, output_unicode, output_element in ( ("⇄", '\u21c4', b'⇄'), ('⊧', '\u22a7', b'⊧'), ('𝔑', '\U0001d511', b'𝔑'), ('≧̸', '\u2267\u0338', b'≧̸'), ('¬', '\xac', b'¬'), ('⫬', '\u2aec', b'⫬'), ('"', '"', b'"'), ('∴', '\u2234', b'∴'), ('∴', '\u2234', b'∴'), ('∴', '\u2234', b'∴'), ("fj", 'fj', b'fj'), ("⊔", '\u2294', b'⊔'), ("⊔︀", '\u2294\ufe00', b'⊔︀'), ("'", "'", b"'"), ("|", "|", b"|"), ): markup = '<div>%s</div>' % input_element div = self.soup(markup).div without_element = div.encode() expect = b"<div>%s</div>" % output_unicode.encode("utf8") assert without_element == expect with_element = div.encode(formatter="html") expect = b"<div>%s</div>" % output_element assert with_element == expect PK z�Z��x��% �% tests/test_tag.pynu �[��� import warnings from bs4.element import ( Comment, NavigableString, ) from . import SoupTest class TestTag(SoupTest): """Test various methods of Tag which aren't so complicated they need their own classes. """ def test__should_pretty_print(self): # Test the rules about when a tag should be pretty-printed. tag = self.soup("").new_tag("a_tag") # No list of whitespace-preserving tags -> pretty-print tag._preserve_whitespace_tags = None assert True == tag._should_pretty_print(0) # List exists but tag is not on the list -> pretty-print tag.preserve_whitespace_tags = ["some_other_tag"] assert True == tag._should_pretty_print(1) # Indent level is None -> don't pretty-print assert False == tag._should_pretty_print(None) # Tag is on the whitespace-preserving list -> don't pretty-print tag.preserve_whitespace_tags = ["some_other_tag", "a_tag"] assert False == tag._should_pretty_print(1) def test_len(self): """The length of a Tag is its number of children.""" soup = self.soup("<top>1<b>2</b>3</top>") # The BeautifulSoup object itself contains one element: the # <top> tag. assert len(soup.contents) == 1 assert len(soup) == 1 # The <top> tag contains three elements: the text node "1", the # <b> tag, and the text node "3". assert len(soup.top) == 3 assert len(soup.top.contents) == 3 def test_member_access_invokes_find(self): """Accessing a Python member .foo invokes find('foo')""" soup = self.soup('<b><i></i></b>') assert soup.b == soup.find('b') assert soup.b.i == soup.find('b').find('i') assert soup.a == None def test_deprecated_member_access(self): soup = self.soup('<b><i></i></b>') with warnings.catch_warnings(record=True) as w: tag = soup.bTag assert soup.b == tag assert '.bTag is deprecated, use .find("b") instead. If you really were looking for a tag called bTag, use .find("bTag")' == str(w[0].message) def test_has_attr(self): """has_attr() checks for the presence of an attribute. Please note note: has_attr() is different from __in__. has_attr() checks the tag's attributes and __in__ checks the tag's chidlren. """ soup = self.soup("<foo attr='bar'>") assert soup.foo.has_attr('attr') assert not soup.foo.has_attr('attr2') def test_attributes_come_out_in_alphabetical_order(self): markup = '<b a="1" z="5" m="3" f="2" y="4"></b>' self.assertSoupEquals(markup, '<b a="1" f="2" m="3" y="4" z="5"></b>') def test_string(self): # A Tag that contains only a text node makes that node # available as .string. soup = self.soup("<b>foo</b>") assert soup.b.string == 'foo' def test_empty_tag_has_no_string(self): # A Tag with no children has no .stirng. soup = self.soup("<b></b>") assert soup.b.string == None def test_tag_with_multiple_children_has_no_string(self): # A Tag with no children has no .string. soup = self.soup("<a>foo<b></b><b></b></b>") assert soup.b.string == None soup = self.soup("<a>foo<b></b>bar</b>") assert soup.b.string == None # Even if all the children are strings, due to trickery, # it won't work--but this would be a good optimization. soup = self.soup("<a>foo</b>") soup.a.insert(1, "bar") assert soup.a.string == None def test_tag_with_recursive_string_has_string(self): # A Tag with a single child which has a .string inherits that # .string. soup = self.soup("<a><b>foo</b></a>") assert soup.a.string == "foo" assert soup.string == "foo" def test_lack_of_string(self): """Only a Tag containing a single text node has a .string.""" soup = self.soup("<b>f<i>e</i>o</b>") assert soup.b.string is None soup = self.soup("<b></b>") assert soup.b.string is None def test_all_text(self): """Tag.text and Tag.get_text(sep=u"") -> all child text, concatenated""" soup = self.soup("<a>a<b>r</b> <r> t </r></a>") assert soup.a.text == "ar t " assert soup.a.get_text(strip=True) == "art" assert soup.a.get_text(",") == "a,r, , t " assert soup.a.get_text(",", strip=True) == "a,r,t" def test_get_text_ignores_special_string_containers(self): soup = self.soup("foo<!--IGNORE-->bar") assert soup.get_text() == "foobar" assert soup.get_text(types=(NavigableString, Comment)) == "fooIGNOREbar" assert soup.get_text(types=None) == "fooIGNOREbar" soup = self.soup("foo<style>CSS</style><script>Javascript</script>bar") assert soup.get_text() == "foobar" def test_all_strings_ignores_special_string_containers(self): soup = self.soup("foo<!--IGNORE-->bar") assert ['foo', 'bar'] == list(soup.strings) soup = self.soup("foo<style>CSS</style><script>Javascript</script>bar") assert ['foo', 'bar'] == list(soup.strings) def test_string_methods_inside_special_string_container_tags(self): # Strings inside tags like <script> are generally ignored by # methods like get_text, because they're not what humans # consider 'text'. But if you call get_text on the <script> # tag itself, those strings _are_ considered to be 'text', # because there's nothing else you might be looking for. style = self.soup("<div>a<style>Some CSS</style></div>") template = self.soup("<div>a<template><p>Templated <b>text</b>.</p><!--With a comment.--></template></div>") script = self.soup("<div>a<script><!--a comment-->Some text</script></div>") assert style.div.get_text() == "a" assert list(style.div.strings) == ["a"] assert style.div.style.get_text() == "Some CSS" assert list(style.div.style.strings) == ['Some CSS'] # The comment is not picked up here. That's because it was # parsed into a Comment object, which is not considered # interesting by template.strings. assert template.div.get_text() == "a" assert list(template.div.strings) == ["a"] assert template.div.template.get_text() == "Templated text." assert list(template.div.template.strings) == ["Templated ", "text", "."] # The comment is included here, because it didn't get parsed # into a Comment object--it's part of the Script string. assert script.div.get_text() == "a" assert list(script.div.strings) == ["a"] assert script.div.script.get_text() == "<!--a comment-->Some text" assert list(script.div.script.strings) == ['<!--a comment-->Some text'] class TestMultiValuedAttributes(SoupTest): """Test the behavior of multi-valued attributes like 'class'. The values of such attributes are always presented as lists. """ def test_single_value_becomes_list(self): soup = self.soup("<a class='foo'>") assert ["foo"] ==soup.a['class'] def test_multiple_values_becomes_list(self): soup = self.soup("<a class='foo bar'>") assert ["foo", "bar"] == soup.a['class'] def test_multiple_values_separated_by_weird_whitespace(self): soup = self.soup("<a class='foo\tbar\nbaz'>") assert ["foo", "bar", "baz"] ==soup.a['class'] def test_attributes_joined_into_string_on_output(self): soup = self.soup("<a class='foo\tbar'>") assert b'<a class="foo bar"></a>' == soup.a.encode() def test_get_attribute_list(self): soup = self.soup("<a id='abc def'>") assert ['abc def'] == soup.a.get_attribute_list('id') def test_accept_charset(self): soup = self.soup('<form accept-charset="ISO-8859-1 UTF-8">') assert ['ISO-8859-1', 'UTF-8'] == soup.form['accept-charset'] def test_cdata_attribute_applying_only_to_one_tag(self): data = '<a accept-charset="ISO-8859-1 UTF-8"></a>' soup = self.soup(data) # We saw in another test that accept-charset is a cdata-list # attribute for the <form> tag. But it's not a cdata-list # attribute for any other tag. assert 'ISO-8859-1 UTF-8' == soup.a['accept-charset'] def test_customization(self): # It's possible to change which attributes of which tags # are treated as multi-valued attributes. # # Here, 'id' is a multi-valued attribute and 'class' is not. # # TODO: This code is in the builder and should be tested there. soup = self.soup( '<a class="foo" id="bar">', multi_valued_attributes={ '*' : 'id' } ) assert soup.a['class'] == 'foo' assert soup.a['id'] == ['bar'] def test_hidden_tag_is_invisible(self): # Setting .hidden on a tag makes it invisible in output, but # leaves its contents visible. # # This is not a documented or supported feature of Beautiful # Soup (e.g. NavigableString doesn't support .hidden even # though it could), but some people use it and it's not # hurting anything to verify that it keeps working. # soup = self.soup('<div id="1"><span id="2">a string</span></div>') soup.span.hidden = True assert '<div id="1">a string</div>' == str(soup.div) PK z�Z>U��[< [< tests/test_dammit.pynu �[��� # encoding: utf-8 import pytest import logging import bs4 from bs4 import BeautifulSoup from bs4.dammit import ( EntitySubstitution, EncodingDetector, UnicodeDammit, ) class TestUnicodeDammit(object): """Standalone tests of UnicodeDammit.""" def test_unicode_input(self): markup = "I'm already Unicode! \N{SNOWMAN}" dammit = UnicodeDammit(markup) assert dammit.unicode_markup == markup @pytest.mark.parametrize( "smart_quotes_to,expect_converted", [(None, "\u2018\u2019\u201c\u201d"), ("xml", "‘’“”"), ("html", "‘’“”"), ("ascii", "''" + '""'), ] ) def test_smart_quotes_to(self, smart_quotes_to, expect_converted): """Verify the functionality of the smart_quotes_to argument to the UnicodeDammit constructor.""" markup = b"<foo>\x91\x92\x93\x94</foo>" converted = UnicodeDammit( markup, known_definite_encodings=["windows-1252"], smart_quotes_to=smart_quotes_to ).unicode_markup assert converted == "<foo>{}</foo>".format(expect_converted) def test_detect_utf8(self): utf8 = b"Sacr\xc3\xa9 bleu! \xe2\x98\x83" dammit = UnicodeDammit(utf8) assert dammit.original_encoding.lower() == 'utf-8' assert dammit.unicode_markup == 'Sacr\xe9 bleu! \N{SNOWMAN}' def test_convert_hebrew(self): hebrew = b"\xed\xe5\xec\xf9" dammit = UnicodeDammit(hebrew, ["iso-8859-8"]) assert dammit.original_encoding.lower() == 'iso-8859-8' assert dammit.unicode_markup == '\u05dd\u05d5\u05dc\u05e9' def test_dont_see_smart_quotes_where_there_are_none(self): utf_8 = b"\343\202\261\343\203\274\343\202\277\343\202\244 Watch" dammit = UnicodeDammit(utf_8) assert dammit.original_encoding.lower() == 'utf-8' assert dammit.unicode_markup.encode("utf-8") == utf_8 def test_ignore_inappropriate_codecs(self): utf8_data = "Räksmörgås".encode("utf-8") dammit = UnicodeDammit(utf8_data, ["iso-8859-8"]) assert dammit.original_encoding.lower() == 'utf-8' def test_ignore_invalid_codecs(self): utf8_data = "Räksmörgås".encode("utf-8") for bad_encoding in ['.utf8', '...', 'utF---16.!']: dammit = UnicodeDammit(utf8_data, [bad_encoding]) assert dammit.original_encoding.lower() == 'utf-8' def test_exclude_encodings(self): # This is UTF-8. utf8_data = "Räksmörgås".encode("utf-8") # But if we exclude UTF-8 from consideration, the guess is # Windows-1252. dammit = UnicodeDammit(utf8_data, exclude_encodings=["utf-8"]) assert dammit.original_encoding.lower() == 'windows-1252' # And if we exclude that, there is no valid guess at all. dammit = UnicodeDammit( utf8_data, exclude_encodings=["utf-8", "windows-1252"]) assert dammit.original_encoding == None class TestEncodingDetector(object): def test_encoding_detector_replaces_junk_in_encoding_name_with_replacement_character(self): detected = EncodingDetector( b'<?xml version="1.0" encoding="UTF-\xdb" ?>') encodings = list(detected.encodings) assert 'utf-\N{REPLACEMENT CHARACTER}' in encodings def test_detect_html5_style_meta_tag(self): for data in ( b'<html><meta charset="euc-jp" /></html>', b"<html><meta charset='euc-jp' /></html>", b"<html><meta charset=euc-jp /></html>", b"<html><meta charset=euc-jp/></html>"): dammit = UnicodeDammit(data, is_html=True) assert "euc-jp" == dammit.original_encoding def test_last_ditch_entity_replacement(self): # This is a UTF-8 document that contains bytestrings # completely incompatible with UTF-8 (ie. encoded with some other # encoding). # # Since there is no consistent encoding for the document, # Unicode, Dammit will eventually encode the document as UTF-8 # and encode the incompatible characters as REPLACEMENT # CHARACTER. # # If chardet is installed, it will detect that the document # can be converted into ISO-8859-1 without errors. This happens # to be the wrong encoding, but it is a consistent encoding, so the # code we're testing here won't run. # # So we temporarily disable chardet if it's present. doc = b"""\357\273\277<?xml version="1.0" encoding="UTF-8"?> <html><b>\330\250\330\252\330\261</b> <i>\310\322\321\220\312\321\355\344</i></html>""" chardet = bs4.dammit.chardet_dammit logging.disable(logging.WARNING) try: def noop(str): return None bs4.dammit.chardet_dammit = noop dammit = UnicodeDammit(doc) assert True == dammit.contains_replacement_characters assert "\ufffd" in dammit.unicode_markup soup = BeautifulSoup(doc, "html.parser") assert soup.contains_replacement_characters finally: logging.disable(logging.NOTSET) bs4.dammit.chardet_dammit = chardet def test_byte_order_mark_removed(self): # A document written in UTF-16LE will have its byte order marker stripped. data = b'\xff\xfe<\x00a\x00>\x00\xe1\x00\xe9\x00<\x00/\x00a\x00>\x00' dammit = UnicodeDammit(data) assert "<a>áé</a>" == dammit.unicode_markup assert "utf-16le" == dammit.original_encoding def test_known_definite_versus_user_encodings(self): # The known_definite_encodings are used before sniffing the # byte-order mark; the user_encodings are used afterwards. # Here's a document in UTF-16LE. data = b'\xff\xfe<\x00a\x00>\x00\xe1\x00\xe9\x00<\x00/\x00a\x00>\x00' dammit = UnicodeDammit(data) # We can process it as UTF-16 by passing it in as a known # definite encoding. before = UnicodeDammit(data, known_definite_encodings=["utf-16"]) assert "utf-16" == before.original_encoding # If we pass UTF-18 as a user encoding, it's not even # tried--the encoding sniffed from the byte-order mark takes # precedence. after = UnicodeDammit(data, user_encodings=["utf-8"]) assert "utf-16le" == after.original_encoding assert ["utf-16le"] == [x[0] for x in dammit.tried_encodings] # Here's a document in ISO-8859-8. hebrew = b"\xed\xe5\xec\xf9" dammit = UnicodeDammit(hebrew, known_definite_encodings=["utf-8"], user_encodings=["iso-8859-8"]) # The known_definite_encodings don't work, BOM sniffing does # nothing (it only works for a few UTF encodings), but one of # the user_encodings does work. assert "iso-8859-8" == dammit.original_encoding assert ["utf-8", "iso-8859-8"] == [x[0] for x in dammit.tried_encodings] def test_deprecated_override_encodings(self): # override_encodings is a deprecated alias for # known_definite_encodings. hebrew = b"\xed\xe5\xec\xf9" dammit = UnicodeDammit( hebrew, known_definite_encodings=["shift-jis"], override_encodings=["utf-8"], user_encodings=["iso-8859-8"], ) assert "iso-8859-8" == dammit.original_encoding # known_definite_encodings and override_encodings were tried # before user_encodings. assert ["shift-jis", "utf-8", "iso-8859-8"] == ( [x[0] for x in dammit.tried_encodings] ) def test_detwingle(self): # Here's a UTF8 document. utf8 = ("\N{SNOWMAN}" * 3).encode("utf8") # Here's a Windows-1252 document. windows_1252 = ( "\N{LEFT DOUBLE QUOTATION MARK}Hi, I like Windows!" "\N{RIGHT DOUBLE QUOTATION MARK}").encode("windows_1252") # Through some unholy alchemy, they've been stuck together. doc = utf8 + windows_1252 + utf8 # The document can't be turned into UTF-8: with pytest.raises(UnicodeDecodeError): doc.decode("utf8") # Unicode, Dammit thinks the whole document is Windows-1252, # and decodes it into "☃☃☃“Hi, I like Windows!”☃☃☃" # But if we run it through fix_embedded_windows_1252, it's fixed: fixed = UnicodeDammit.detwingle(doc) assert "☃☃☃“Hi, I like Windows!”☃☃☃" == fixed.decode("utf8") def test_detwingle_ignores_multibyte_characters(self): # Each of these characters has a UTF-8 representation ending # in \x93. \x93 is a smart quote if interpreted as # Windows-1252. But our code knows to skip over multibyte # UTF-8 characters, so they'll survive the process unscathed. for tricky_unicode_char in ( "\N{LATIN SMALL LIGATURE OE}", # 2-byte char '\xc5\x93' "\N{LATIN SUBSCRIPT SMALL LETTER X}", # 3-byte char '\xe2\x82\x93' "\xf0\x90\x90\x93", # This is a CJK character, not sure which one. ): input = tricky_unicode_char.encode("utf8") assert input.endswith(b'\x93') output = UnicodeDammit.detwingle(input) assert output == input def test_find_declared_encoding(self): # Test our ability to find a declared encoding inside an # XML or HTML document. # # Even if the document comes in as Unicode, it may be # interesting to know what encoding was claimed # originally. html_unicode = '<html><head><meta charset="utf-8"></head></html>' html_bytes = html_unicode.encode("ascii") xml_unicode= '<?xml version="1.0" encoding="ISO-8859-1" ?>' xml_bytes = xml_unicode.encode("ascii") m = EncodingDetector.find_declared_encoding assert m(html_unicode, is_html=False) is None assert "utf-8" == m(html_unicode, is_html=True) assert "utf-8" == m(html_bytes, is_html=True) assert "iso-8859-1" == m(xml_unicode) assert "iso-8859-1" == m(xml_bytes) # Normally, only the first few kilobytes of a document are checked for # an encoding. spacer = b' ' * 5000 assert m(spacer + html_bytes) is None assert m(spacer + xml_bytes) is None # But you can tell find_declared_encoding to search an entire # HTML document. assert ( m(spacer + html_bytes, is_html=True, search_entire_document=True) == "utf-8" ) # The XML encoding declaration has to be the very first thing # in the document. We'll allow whitespace before the document # starts, but nothing else. assert m(xml_bytes, search_entire_document=True) == "iso-8859-1" assert m(b' ' + xml_bytes, search_entire_document=True) == "iso-8859-1" assert m(b'a' + xml_bytes, search_entire_document=True) is None class TestEntitySubstitution(object): """Standalone tests of the EntitySubstitution class.""" def setup_method(self): self.sub = EntitySubstitution @pytest.mark.parametrize( "original,substituted", [ # Basic case. Unicode characters corresponding to named # HTML entites are substituted; others are not. ("foo\u2200\N{SNOWMAN}\u00f5bar", "foo∀\N{SNOWMAN}õbar"), # MS smart quotes are a common source of frustration, so we # give them a special test. ('‘’foo“”', "‘’foo“”"), ] ) def test_substitute_html(self, original, substituted): assert self.sub.substitute_html(original) == substituted def test_html5_entity(self): for entity, u in ( # A few spot checks of our ability to recognize # special character sequences and convert them # to named entities. ('⊧', '\u22a7'), ('𝔑', '\U0001d511'), ('≧̸', '\u2267\u0338'), ('¬', '\xac'), ('⫬', '\u2aec'), # We _could_ convert | to &verbarr;, but we don't, because # | is an ASCII character. ('|' '|'), # Similarly for the fj ligature, which we could convert to # fj, but we don't. ("fj", "fj"), # We do convert _these_ ASCII characters to HTML entities, # because that's required to generate valid HTML. ('>', '>'), ('<', '<'), ('&', '&'), ): template = '3 %s 4' raw = template % u with_entities = template % entity assert self.sub.substitute_html(raw) == with_entities def test_html5_entity_with_variation_selector(self): # Some HTML5 entities correspond either to a single-character # Unicode sequence _or_ to the same character plus U+FE00, # VARIATION SELECTOR 1. We can handle this. data = "fjords \u2294 penguins" markup = "fjords ⊔ penguins" assert self.sub.substitute_html(data) == markup data = "fjords \u2294\ufe00 penguins" markup = "fjords ⊔︀ penguins" assert self.sub.substitute_html(data) == markup def test_xml_converstion_includes_no_quotes_if_make_quoted_attribute_is_false(self): s = 'Welcome to "my bar"' assert self.sub.substitute_xml(s, False) == s def test_xml_attribute_quoting_normally_uses_double_quotes(self): assert self.sub.substitute_xml("Welcome", True) == '"Welcome"' assert self.sub.substitute_xml("Bob's Bar", True) == '"Bob\'s Bar"' def test_xml_attribute_quoting_uses_single_quotes_when_value_contains_double_quotes(self): s = 'Welcome to "my bar"' assert self.sub.substitute_xml(s, True) == "'Welcome to \"my bar\"'" def test_xml_attribute_quoting_escapes_single_quotes_when_value_contains_both_single_and_double_quotes(self): s = 'Welcome to "Bob\'s Bar"' assert self.sub.substitute_xml(s, True) == '"Welcome to "Bob\'s Bar""' def test_xml_quotes_arent_escaped_when_value_is_not_being_quoted(self): quoted = 'Welcome to "Bob\'s Bar"' assert self.sub.substitute_xml(quoted) == quoted def test_xml_quoting_handles_angle_brackets(self): assert self.sub.substitute_xml("foo<bar>") == "foo<bar>" def test_xml_quoting_handles_ampersands(self): assert self.sub.substitute_xml("AT&T") == "AT&T" def test_xml_quoting_including_ampersands_when_they_are_part_of_an_entity(self): assert self.sub.substitute_xml("ÁT&T") == "&Aacute;T&T" def test_xml_quoting_ignoring_ampersands_when_they_are_part_of_an_entity(self): assert self.sub.substitute_xml_containing_entities("ÁT&T") == "ÁT&T" def test_quotes_not_html_substituted(self): """There's no need to do this except inside attribute values.""" text = 'Bob\'s "bar"' assert self.sub.substitute_html(text) == text PK z�Z_�͍� � tests/test_lxml.pynu �[��� """Tests to ensure that the lxml tree builder generates good trees.""" import pickle import pytest import re import warnings from . import LXML_PRESENT, LXML_VERSION if LXML_PRESENT: from bs4.builder import LXMLTreeBuilder, LXMLTreeBuilderForXML from bs4 import ( BeautifulSoup, BeautifulStoneSoup, ) from bs4.element import Comment, Doctype, SoupStrainer from . import ( HTMLTreeBuilderSmokeTest, XMLTreeBuilderSmokeTest, SOUP_SIEVE_PRESENT, SoupTest, ) @pytest.mark.skipif( not LXML_PRESENT, reason="lxml seems not to be present, not testing its tree builder." ) class TestLXMLTreeBuilder(SoupTest, HTMLTreeBuilderSmokeTest): """See ``HTMLTreeBuilderSmokeTest``.""" @property def default_builder(self): return LXMLTreeBuilder def test_out_of_range_entity(self): self.assert_soup( "<p>foo�bar</p>", "<p>foobar</p>") self.assert_soup( "<p>foo�bar</p>", "<p>foobar</p>") self.assert_soup( "<p>foo�bar</p>", "<p>foobar</p>") def test_entities_in_foreign_document_encoding(self): # We can't implement this case correctly because by the time we # hear about markup like "“", it's been (incorrectly) converted into # a string like u'\x93' pass # In lxml < 2.3.5, an empty doctype causes a segfault. Skip this # test if an old version of lxml is installed. @pytest.mark.skipif( not LXML_PRESENT or LXML_VERSION < (2,3,5,0), reason="Skipping doctype test for old version of lxml to avoid segfault." ) def test_empty_doctype(self): soup = self.soup("<!DOCTYPE>") doctype = soup.contents[0] assert "" == doctype.strip() def test_beautifulstonesoup_is_xml_parser(self): # Make sure that the deprecated BSS class uses an xml builder # if one is installed. with warnings.catch_warnings(record=True) as w: soup = BeautifulStoneSoup("<b />") assert "<b/>" == str(soup.b) [warning] = w assert warning.filename == __file__ assert "BeautifulStoneSoup class is deprecated" in str(warning.message) def test_tracking_line_numbers(self): # The lxml TreeBuilder cannot keep track of line numbers from # the original markup. Even if you ask for line numbers, we # don't have 'em. # # This means that if you have a tag like <sourceline> or # <sourcepos>, attribute access will find it rather than # giving you a numeric answer. soup = self.soup( "\n <p>\n\n<sourceline>\n<b>text</b></sourceline><sourcepos></p>", store_line_numbers=True ) assert "sourceline" == soup.p.sourceline.name assert "sourcepos" == soup.p.sourcepos.name @pytest.mark.skipif( not LXML_PRESENT, reason="lxml seems not to be present, not testing its XML tree builder." ) class TestLXMLXMLTreeBuilder(SoupTest, XMLTreeBuilderSmokeTest): """See ``HTMLTreeBuilderSmokeTest``.""" @property def default_builder(self): return LXMLTreeBuilderForXML def test_namespace_indexing(self): soup = self.soup( '<?xml version="1.1"?>\n' '<root>' '<tag xmlns="http://unprefixed-namespace.com">content</tag>' '<prefix:tag2 xmlns:prefix="http://prefixed-namespace.com">content</prefix:tag2>' '<prefix2:tag3 xmlns:prefix2="http://another-namespace.com">' '<subtag xmlns="http://another-unprefixed-namespace.com">' '<subsubtag xmlns="http://yet-another-unprefixed-namespace.com">' '</prefix2:tag3>' '</root>' ) # The BeautifulSoup object includes every namespace prefix # defined in the entire document. This is the default set of # namespaces used by soupsieve. # # Un-prefixed namespaces are not included, and if a given # prefix is defined twice, only the first prefix encountered # in the document shows up here. assert soup._namespaces == { 'xml': 'http://www.w3.org/XML/1998/namespace', 'prefix': 'http://prefixed-namespace.com', 'prefix2': 'http://another-namespace.com' } # A Tag object includes only the namespace prefixes # that were in scope when it was parsed. # We do not track un-prefixed namespaces as we can only hold # one (the first one), and it will be recognized as the # default namespace by soupsieve, even when operating from a # tag with a different un-prefixed namespace. assert soup.tag._namespaces == { 'xml': 'http://www.w3.org/XML/1998/namespace', } assert soup.tag2._namespaces == { 'prefix': 'http://prefixed-namespace.com', 'xml': 'http://www.w3.org/XML/1998/namespace', } assert soup.subtag._namespaces == { 'prefix2': 'http://another-namespace.com', 'xml': 'http://www.w3.org/XML/1998/namespace', } assert soup.subsubtag._namespaces == { 'prefix2': 'http://another-namespace.com', 'xml': 'http://www.w3.org/XML/1998/namespace', } @pytest.mark.skipif( not SOUP_SIEVE_PRESENT, reason="Soup Sieve not installed" ) def test_namespace_interaction_with_select_and_find(self): # Demonstrate how namespaces interact with select* and # find* methods. soup = self.soup( '<?xml version="1.1"?>\n' '<root>' '<tag xmlns="http://unprefixed-namespace.com">content</tag>' '<prefix:tag2 xmlns:prefix="http://prefixed-namespace.com">content</tag>' '<subtag xmlns:prefix="http://another-namespace-same-prefix.com">' '<prefix:tag3>' '</subtag>' '</root>' ) # soupselect uses namespace URIs. assert soup.select_one('tag').name == 'tag' assert soup.select_one('prefix|tag2').name == 'tag2' # If a prefix is declared more than once, only the first usage # is registered with the BeautifulSoup object. assert soup.select_one('prefix|tag3') is None # But you can always explicitly specify a namespace dictionary. assert soup.select_one( 'prefix|tag3', namespaces=soup.subtag._namespaces ).name == 'tag3' # And a Tag (as opposed to the BeautifulSoup object) will # have a set of default namespaces scoped to that Tag. assert soup.subtag.select_one('prefix|tag3').name=='tag3' # the find() methods aren't fully namespace-aware; they just # look at prefixes. assert soup.find('tag').name == 'tag' assert soup.find('prefix:tag2').name == 'tag2' assert soup.find('prefix:tag3').name == 'tag3' assert soup.subtag.find('prefix:tag3').name == 'tag3' def test_pickle_restores_builder(self): # The lxml TreeBuilder is not picklable, so when unpickling # a document created with it, a new TreeBuilder of the # appropriate class is created. soup = self.soup("<a>some markup</a>") assert isinstance(soup.builder, self.default_builder) pickled = pickle.dumps(soup) unpickled = pickle.loads(pickled) assert "some markup" == unpickled.a.string assert unpickled.builder != soup.builder assert isinstance(unpickled.builder, self.default_builder) PK z�ZK_~94 4 tests/test_formatter.pynu �[��� import pytest from bs4.element import Tag from bs4.formatter import ( Formatter, HTMLFormatter, XMLFormatter, ) from . import SoupTest class TestFormatter(SoupTest): def test_default_attributes(self): # Test the default behavior of Formatter.attributes(). formatter = Formatter() tag = Tag(name="tag") tag['b'] = 1 tag['a'] = 2 # Attributes come out sorted by name. In Python 3, attributes # normally come out of a dictionary in the order they were # added. assert [('a', 2), ('b', 1)] == formatter.attributes(tag) # This works even if Tag.attrs is None, though this shouldn't # normally happen. tag.attrs = None assert [] == formatter.attributes(tag) assert ' ' == formatter.indent def test_sort_attributes(self): # Test the ability to override Formatter.attributes() to, # e.g., disable the normal sorting of attributes. class UnsortedFormatter(Formatter): def attributes(self, tag): self.called_with = tag for k, v in sorted(tag.attrs.items()): if k == 'ignore': continue yield k,v soup = self.soup('<p cval="1" aval="2" ignore="ignored"></p>') formatter = UnsortedFormatter() decoded = soup.decode(formatter=formatter) # attributes() was called on the <p> tag. It filtered out one # attribute and sorted the other two. assert formatter.called_with == soup.p assert '<p aval="2" cval="1"></p>' == decoded def test_empty_attributes_are_booleans(self): # Test the behavior of empty_attributes_are_booleans as well # as which Formatters have it enabled. for name in ('html', 'minimal', None): formatter = HTMLFormatter.REGISTRY[name] assert False == formatter.empty_attributes_are_booleans formatter = XMLFormatter.REGISTRY[None] assert False == formatter.empty_attributes_are_booleans formatter = HTMLFormatter.REGISTRY['html5'] assert True == formatter.empty_attributes_are_booleans # Verify that the constructor sets the value. formatter = Formatter(empty_attributes_are_booleans=True) assert True == formatter.empty_attributes_are_booleans # Now demonstrate what it does to markup. for markup in ( "<option selected></option>", '<option selected=""></option>' ): soup = self.soup(markup) for formatter in ('html', 'minimal', 'xml', None): assert b'<option selected=""></option>' == soup.option.encode(formatter='html') assert b'<option selected></option>' == soup.option.encode(formatter='html5') @pytest.mark.parametrize( "indent,expect", [ (None, '<a>\n<b>\ntext\n</b>\n</a>\n'), (-1, '<a>\n<b>\ntext\n</b>\n</a>\n'), (0, '<a>\n<b>\ntext\n</b>\n</a>\n'), ("", '<a>\n<b>\ntext\n</b>\n</a>\n'), (1, '<a>\n <b>\n text\n </b>\n</a>\n'), (2, '<a>\n <b>\n text\n </b>\n</a>\n'), ("\t", '<a>\n\t<b>\n\t\ttext\n\t</b>\n</a>\n'), ('abc', '<a>\nabc<b>\nabcabctext\nabc</b>\n</a>\n'), # Some invalid inputs -- the default behavior is used. (object(), '<a>\n <b>\n text\n </b>\n</a>\n'), (b'bytes', '<a>\n <b>\n text\n </b>\n</a>\n'), ] ) def test_indent(self, indent, expect): # Pretty-print a tree with a Formatter set to # indent in a certain way and verify the results. soup = self.soup("<a><b>text</b></a>") formatter = Formatter(indent=indent) assert soup.prettify(formatter=formatter) == expect # Pretty-printing only happens with prettify(), not # encode(). assert soup.encode(formatter=formatter) != expect def test_default_indent_value(self): formatter = Formatter() assert formatter.indent == ' ' PK z�ZΑ�M� � tests/test_builder_registry.pynu �[��� """Tests of the builder registry.""" import pytest import warnings from bs4 import BeautifulSoup from bs4.builder import ( builder_registry as registry, HTMLParserTreeBuilder, TreeBuilderRegistry, ) from . import ( HTML5LIB_PRESENT, LXML_PRESENT, ) if HTML5LIB_PRESENT: from bs4.builder import HTML5TreeBuilder if LXML_PRESENT: from bs4.builder import ( LXMLTreeBuilderForXML, LXMLTreeBuilder, ) # TODO: Split out the lxml and html5lib tests into their own classes # and gate with pytest.mark.skipIf. class TestBuiltInRegistry(object): """Test the built-in registry with the default builders registered.""" def test_combination(self): assert registry.lookup('strict', 'html') == HTMLParserTreeBuilder if LXML_PRESENT: assert registry.lookup('fast', 'html') == LXMLTreeBuilder assert registry.lookup('permissive', 'xml') == LXMLTreeBuilderForXML if HTML5LIB_PRESENT: assert registry.lookup('html5lib', 'html') == HTML5TreeBuilder def test_lookup_by_markup_type(self): if LXML_PRESENT: assert registry.lookup('html') == LXMLTreeBuilder assert registry.lookup('xml') == LXMLTreeBuilderForXML else: assert registry.lookup('xml') == None if HTML5LIB_PRESENT: assert registry.lookup('html') == HTML5TreeBuilder else: assert registry.lookup('html') == HTMLParserTreeBuilder def test_named_library(self): if LXML_PRESENT: assert registry.lookup('lxml', 'xml') == LXMLTreeBuilderForXML assert registry.lookup('lxml', 'html') == LXMLTreeBuilder if HTML5LIB_PRESENT: assert registry.lookup('html5lib') == HTML5TreeBuilder assert registry.lookup('html.parser') == HTMLParserTreeBuilder def test_beautifulsoup_constructor_does_lookup(self): with warnings.catch_warnings(record=True) as w: # This will create a warning about not explicitly # specifying a parser, but we'll ignore it. # You can pass in a string. BeautifulSoup("", features="html") # Or a list of strings. BeautifulSoup("", features=["html", "fast"]) pass # You'll get an exception if BS can't find an appropriate # builder. with pytest.raises(ValueError): BeautifulSoup("", features="no-such-feature") class TestRegistry(object): """Test the TreeBuilderRegistry class in general.""" def setup_method(self): self.registry = TreeBuilderRegistry() def builder_for_features(self, *feature_list): cls = type('Builder_' + '_'.join(feature_list), (object,), {'features' : feature_list}) self.registry.register(cls) return cls def test_register_with_no_features(self): builder = self.builder_for_features() # Since the builder advertises no features, you can't find it # by looking up features. assert self.registry.lookup('foo') is None # But you can find it by doing a lookup with no features, if # this happens to be the only registered builder. assert self.registry.lookup() == builder def test_register_with_features_makes_lookup_succeed(self): builder = self.builder_for_features('foo', 'bar') assert self.registry.lookup('foo') is builder assert self.registry.lookup('bar') is builder def test_lookup_fails_when_no_builder_implements_feature(self): builder = self.builder_for_features('foo', 'bar') assert self.registry.lookup('baz') is None def test_lookup_gets_most_recent_registration_when_no_feature_specified(self): builder1 = self.builder_for_features('foo') builder2 = self.builder_for_features('bar') assert self.registry.lookup() == builder2 def test_lookup_fails_when_no_tree_builders_registered(self): assert self.registry.lookup() is None def test_lookup_gets_most_recent_builder_supporting_all_features(self): has_one = self.builder_for_features('foo') has_the_other = self.builder_for_features('bar') has_both_early = self.builder_for_features('foo', 'bar', 'baz') has_both_late = self.builder_for_features('foo', 'bar', 'quux') lacks_one = self.builder_for_features('bar') has_the_other = self.builder_for_features('foo') # There are two builders featuring 'foo' and 'bar', but # the one that also features 'quux' was registered later. assert self.registry.lookup('foo', 'bar') == has_both_late # There is only one builder featuring 'foo', 'bar', and 'baz'. assert self.registry.lookup('foo', 'bar', 'baz') == has_both_early def test_lookup_fails_when_cannot_reconcile_requested_features(self): builder1 = self.builder_for_features('foo', 'bar') builder2 = self.builder_for_features('foo', 'baz') assert self.registry.lookup('bar', 'baz') is None PK z�Z?��p p tests/test_htmlparser.pynu �[��� """Tests to ensure that the html.parser tree builder generates good trees.""" from pdb import set_trace import pickle import pytest import warnings from bs4.builder import ( HTMLParserTreeBuilder, ParserRejectedMarkup, XMLParsedAsHTMLWarning, ) from bs4.builder._htmlparser import BeautifulSoupHTMLParser from . import SoupTest, HTMLTreeBuilderSmokeTest class TestHTMLParserTreeBuilder(SoupTest, HTMLTreeBuilderSmokeTest): default_builder = HTMLParserTreeBuilder def test_rejected_input(self): # Python's html.parser will occasionally reject markup, # especially when there is a problem with the initial DOCTYPE # declaration. Different versions of Python sound the alarm in # different ways, but Beautiful Soup consistently raises # errors as ParserRejectedMarkup exceptions. bad_markup = [ # https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=28873 # https://github.com/guidovranken/python-library-fuzzers/blob/master/corp-html/519e5b4269a01185a0d5e76295251921da2f0700 # https://github.com/python/cpython/issues/81928 b'\n<![\xff\xfe\xfe\xcd\x00', #https://github.com/guidovranken/python-library-fuzzers/blob/master/corp-html/de32aa55785be29bbc72a1a8e06b00611fb3d9f8 # https://github.com/python/cpython/issues/78661 # b'<![n\x00', b"<![UNKNOWN[]]>", ] for markup in bad_markup: with pytest.raises(ParserRejectedMarkup): soup = self.soup(markup) def test_namespaced_system_doctype(self): # html.parser can't handle namespaced doctypes, so skip this one. pass def test_namespaced_public_doctype(self): # html.parser can't handle namespaced doctypes, so skip this one. pass def test_builder_is_pickled(self): """Unlike most tree builders, HTMLParserTreeBuilder and will be restored after pickling. """ tree = self.soup("<a><b>foo</a>") dumped = pickle.dumps(tree, 2) loaded = pickle.loads(dumped) assert isinstance(loaded.builder, type(tree.builder)) def test_redundant_empty_element_closing_tags(self): self.assert_soup('<br></br><br></br><br></br>', "<br/><br/><br/>") self.assert_soup('</br></br></br>', "") def test_empty_element(self): # This verifies that any buffered data present when the parser # finishes working is handled. self.assert_soup("foo &# bar", "foo &# bar") def test_tracking_line_numbers(self): # The html.parser TreeBuilder keeps track of line number and # position of each element. markup = "\n <p>\n\n<sourceline>\n<b>text</b></sourceline><sourcepos></p>" soup = self.soup(markup) assert 2 == soup.p.sourceline assert 3 == soup.p.sourcepos assert "sourceline" == soup.p.find('sourceline').name # You can deactivate this behavior. soup = self.soup(markup, store_line_numbers=False) assert "sourceline" == soup.p.sourceline.name assert "sourcepos" == soup.p.sourcepos.name def test_on_duplicate_attribute(self): # The html.parser tree builder has a variety of ways of # handling a tag that contains the same attribute multiple times. markup = '<a class="cls" href="url1" href="url2" href="url3" id="id">' # If you don't provide any particular value for # on_duplicate_attribute, later values replace earlier values. soup = self.soup(markup) assert "url3" == soup.a['href'] assert ["cls"] == soup.a['class'] assert "id" == soup.a['id'] # You can also get this behavior explicitly. def assert_attribute(on_duplicate_attribute, expected): soup = self.soup( markup, on_duplicate_attribute=on_duplicate_attribute ) assert expected == soup.a['href'] # Verify that non-duplicate attributes are treated normally. assert ["cls"] == soup.a['class'] assert "id" == soup.a['id'] assert_attribute(None, "url3") assert_attribute(BeautifulSoupHTMLParser.REPLACE, "url3") # You can ignore subsequent values in favor of the first. assert_attribute(BeautifulSoupHTMLParser.IGNORE, "url1") # And you can pass in a callable that does whatever you want. def accumulate(attrs, key, value): if not isinstance(attrs[key], list): attrs[key] = [attrs[key]] attrs[key].append(value) assert_attribute(accumulate, ["url1", "url2", "url3"]) def test_html5_attributes(self): # The html.parser TreeBuilder can convert any entity named in # the HTML5 spec to a sequence of Unicode characters, and # convert those Unicode characters to a (potentially # different) named entity on the way out. for input_element, output_unicode, output_element in ( ("⇄", '\u21c4', b'⇄'), ('⊧', '\u22a7', b'⊧'), ('𝔑', '\U0001d511', b'𝔑'), ('≧̸', '\u2267\u0338', b'≧̸'), ('¬', '\xac', b'¬'), ('⫬', '\u2aec', b'⫬'), ('"', '"', b'"'), ('∴', '\u2234', b'∴'), ('∴', '\u2234', b'∴'), ('∴', '\u2234', b'∴'), ("fj", 'fj', b'fj'), ("⊔", '\u2294', b'⊔'), ("⊔︀", '\u2294\ufe00', b'⊔︀'), ("'", "'", b"'"), ("|", "|", b"|"), ): markup = '<div>%s</div>' % input_element div = self.soup(markup).div without_element = div.encode() expect = b"<div>%s</div>" % output_unicode.encode("utf8") assert without_element == expect with_element = div.encode(formatter="html") expect = b"<div>%s</div>" % output_element assert with_element == expect PK z�Z�~V�� � tests/__init__.pynu �[��� # encoding: utf-8 """Helper classes for tests.""" # Use of this source code is governed by the MIT license. __license__ = "MIT" import pickle import copy import functools import warnings import pytest from bs4 import BeautifulSoup from bs4.element import ( CharsetMetaAttributeValue, Comment, ContentMetaAttributeValue, Doctype, PYTHON_SPECIFIC_ENCODINGS, SoupStrainer, Script, Stylesheet, Tag ) from bs4.builder import ( DetectsXMLParsedAsHTML, HTMLParserTreeBuilder, XMLParsedAsHTMLWarning, ) default_builder = HTMLParserTreeBuilder # Some tests depend on specific third-party libraries. We use # @pytest.mark.skipIf on the following conditionals to skip them # if the libraries are not installed. try: from soupsieve import SelectorSyntaxError SOUP_SIEVE_PRESENT = True except ImportError: SOUP_SIEVE_PRESENT = False try: import html5lib HTML5LIB_PRESENT = True except ImportError: HTML5LIB_PRESENT = False try: import lxml.etree LXML_PRESENT = True LXML_VERSION = lxml.etree.LXML_VERSION except ImportError: LXML_PRESENT = False LXML_VERSION = (0,) BAD_DOCUMENT = """A bare string <!DOCTYPE xsl:stylesheet SYSTEM "htmlent.dtd"> <!DOCTYPE xsl:stylesheet PUBLIC "htmlent.dtd"> <div><![CDATA[A CDATA section where it doesn't belong]]></div> <div><svg><![CDATA[HTML5 does allow CDATA sections in SVG]]></svg></div> <div>A <meta> tag</div> <div>A <br> tag that supposedly has contents.</br></div> <div>AT&T</div> <div><textarea>Within a textarea, markup like <b> tags and <&<& should be treated as literal</textarea></div> <div><script>if (i < 2) { alert("<b>Markup within script tags should be treated as literal.</b>"); }</script></div> <div>This numeric entity is missing the final semicolon: <x t="piñata"></div> <div><a href="http://example.com/</a> that attribute value never got closed</div> <div><a href="foo</a>, </a><a href="bar">that attribute value was closed by the subsequent tag</a></div> <! This document starts with a bogus declaration ><div>a</div> <div>This document contains <!an incomplete declaration <div>(do you see it?)</div> <div>This document ends with <!an incomplete declaration <div><a style={height:21px;}>That attribute value was bogus</a></div> <! DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN">The doctype is invalid because it contains extra whitespace <div><table><td nowrap>That boolean attribute had no value</td></table></div> <div>Here's a nonexistent entity: &#foo; (do you see it?)</div> <div>This document ends before the entity finishes: > <div><p>Paragraphs shouldn't contain block display elements, but this one does: <dl><dt>you see?</dt></p> <b b="20" a="1" b="10" a="2" a="3" a="4">Multiple values for the same attribute.</b> <div><table><tr><td>Here's a table</td></tr></table></div> <div><table id="1"><tr><td>Here's a nested table:<table id="2"><tr><td>foo</td></tr></table></td></div> <div>This tag contains nothing but whitespace: <b> </b></div> <div><blockquote><p><b>This p tag is cut off by</blockquote></p>the end of the blockquote tag</div> <div><table><div>This table contains bare markup</div></table></div> <div><div id="1">\n <a href="link1">This link is never closed.\n</div>\n<div id="2">\n <div id="3">\n <a href="link2">This link is closed.</a>\n </div>\n</div></div> <div>This document contains a <!DOCTYPE surprise>surprise doctype</div> <div><a><B><Cd><EFG>Mixed case tags are folded to lowercase</efg></CD></b></A></div> <div><our\u2603>Tag name contains Unicode characters</our\u2603></div> <div><a \u2603="snowman">Attribute name contains Unicode characters</a></div> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> """ class SoupTest(object): @property def default_builder(self): return default_builder def soup(self, markup, **kwargs): """Build a Beautiful Soup object from markup.""" builder = kwargs.pop('builder', self.default_builder) return BeautifulSoup(markup, builder=builder, **kwargs) def document_for(self, markup, **kwargs): """Turn an HTML fragment into a document. The details depend on the builder. """ return self.default_builder(**kwargs).test_fragment_to_document(markup) def assert_soup(self, to_parse, compare_parsed_to=None): """Parse some markup using Beautiful Soup and verify that the output markup is as expected. """ builder = self.default_builder obj = BeautifulSoup(to_parse, builder=builder) if compare_parsed_to is None: compare_parsed_to = to_parse # Verify that the documents come out the same. assert obj.decode() == self.document_for(compare_parsed_to) # Also run some checks on the BeautifulSoup object itself: # Verify that every tag that was opened was eventually closed. # There are no tags in the open tag counter. assert all(v==0 for v in list(obj.open_tag_counter.values())) # The only tag in the tag stack is the one for the root # document. assert [obj.ROOT_TAG_NAME] == [x.name for x in obj.tagStack] assertSoupEquals = assert_soup def assertConnectedness(self, element): """Ensure that next_element and previous_element are properly set for all descendants of the given element. """ earlier = None for e in element.descendants: if earlier: assert e == earlier.next_element assert earlier == e.previous_element earlier = e def linkage_validator(self, el, _recursive_call=False): """Ensure proper linkage throughout the document.""" descendant = None # Document element should have no previous element or previous sibling. # It also shouldn't have a next sibling. if el.parent is None: assert el.previous_element is None,\ "Bad previous_element\nNODE: {}\nPREV: {}\nEXPECTED: {}".format( el, el.previous_element, None ) assert el.previous_sibling is None,\ "Bad previous_sibling\nNODE: {}\nPREV: {}\nEXPECTED: {}".format( el, el.previous_sibling, None ) assert el.next_sibling is None,\ "Bad next_sibling\nNODE: {}\nNEXT: {}\nEXPECTED: {}".format( el, el.next_sibling, None ) idx = 0 child = None last_child = None last_idx = len(el.contents) - 1 for child in el.contents: descendant = None # Parent should link next element to their first child # That child should have no previous sibling if idx == 0: if el.parent is not None: assert el.next_element is child,\ "Bad next_element\nNODE: {}\nNEXT: {}\nEXPECTED: {}".format( el, el.next_element, child ) assert child.previous_element is el,\ "Bad previous_element\nNODE: {}\nPREV: {}\nEXPECTED: {}".format( child, child.previous_element, el ) assert child.previous_sibling is None,\ "Bad previous_sibling\nNODE: {}\nPREV {}\nEXPECTED: {}".format( child, child.previous_sibling, None ) # If not the first child, previous index should link as sibling to this index # Previous element should match the last index or the last bubbled up descendant else: assert child.previous_sibling is el.contents[idx - 1],\ "Bad previous_sibling\nNODE: {}\nPREV {}\nEXPECTED {}".format( child, child.previous_sibling, el.contents[idx - 1] ) assert el.contents[idx - 1].next_sibling is child,\ "Bad next_sibling\nNODE: {}\nNEXT {}\nEXPECTED {}".format( el.contents[idx - 1], el.contents[idx - 1].next_sibling, child ) if last_child is not None: assert child.previous_element is last_child,\ "Bad previous_element\nNODE: {}\nPREV {}\nEXPECTED {}\nCONTENTS {}".format( child, child.previous_element, last_child, child.parent.contents ) assert last_child.next_element is child,\ "Bad next_element\nNODE: {}\nNEXT {}\nEXPECTED {}".format( last_child, last_child.next_element, child ) if isinstance(child, Tag) and child.contents: descendant = self.linkage_validator(child, True) # A bubbled up descendant should have no next siblings assert descendant.next_sibling is None,\ "Bad next_sibling\nNODE: {}\nNEXT {}\nEXPECTED {}".format( descendant, descendant.next_sibling, None ) # Mark last child as either the bubbled up descendant or the current child if descendant is not None: last_child = descendant else: last_child = child # If last child, there are non next siblings if idx == last_idx: assert child.next_sibling is None,\ "Bad next_sibling\nNODE: {}\nNEXT {}\nEXPECTED {}".format( child, child.next_sibling, None ) idx += 1 child = descendant if descendant is not None else child if child is None: child = el if not _recursive_call and child is not None: target = el while True: if target is None: assert child.next_element is None, \ "Bad next_element\nNODE: {}\nNEXT {}\nEXPECTED {}".format( child, child.next_element, None ) break elif target.next_sibling is not None: assert child.next_element is target.next_sibling, \ "Bad next_element\nNODE: {}\nNEXT {}\nEXPECTED {}".format( child, child.next_element, target.next_sibling ) break target = target.parent # We are done, so nothing to return return None else: # Return the child to the recursive caller return child def assert_selects(self, tags, should_match): """Make sure that the given tags have the correct text. This is used in tests that define a bunch of tags, each containing a single string, and then select certain strings by some mechanism. """ assert [tag.string for tag in tags] == should_match def assert_selects_ids(self, tags, should_match): """Make sure that the given tags have the correct IDs. This is used in tests that define a bunch of tags, each containing a single string, and then select certain strings by some mechanism. """ assert [tag['id'] for tag in tags] == should_match class TreeBuilderSmokeTest(object): # Tests that are common to HTML and XML tree builders. @pytest.mark.parametrize( "multi_valued_attributes", [None, {}, dict(b=['class']), {'*': ['notclass']}] ) def test_attribute_not_multi_valued(self, multi_valued_attributes): markup = '<html xmlns="http://www.w3.org/1999/xhtml"><a class="a b c"></html>' soup = self.soup(markup, multi_valued_attributes=multi_valued_attributes) assert soup.a['class'] == 'a b c' @pytest.mark.parametrize( "multi_valued_attributes", [dict(a=['class']), {'*': ['class']}] ) def test_attribute_multi_valued(self, multi_valued_attributes): markup = '<a class="a b c">' soup = self.soup( markup, multi_valued_attributes=multi_valued_attributes ) assert soup.a['class'] == ['a', 'b', 'c'] def test_invalid_doctype(self): markup = '<![if word]>content<![endif]>' markup = '<!DOCTYPE html]ff>' soup = self.soup(markup) class HTMLTreeBuilderSmokeTest(TreeBuilderSmokeTest): """A basic test of a treebuilder's competence. Any HTML treebuilder, present or future, should be able to pass these tests. With invalid markup, there's room for interpretation, and different parsers can handle it differently. But with the markup in these tests, there's not much room for interpretation. """ def test_empty_element_tags(self): """Verify that all HTML4 and HTML5 empty element (aka void element) tags are handled correctly. """ for name in [ 'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'keygen', 'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr', 'spacer', 'frame' ]: soup = self.soup("") new_tag = soup.new_tag(name) assert new_tag.is_empty_element == True def test_special_string_containers(self): soup = self.soup( "<style>Some CSS</style><script>Some Javascript</script>" ) assert isinstance(soup.style.string, Stylesheet) assert isinstance(soup.script.string, Script) soup = self.soup( "<style><!--Some CSS--></style>" ) assert isinstance(soup.style.string, Stylesheet) # The contents of the style tag resemble an HTML comment, but # it's not treated as a comment. assert soup.style.string == "<!--Some CSS-->" assert isinstance(soup.style.string, Stylesheet) def test_pickle_and_unpickle_identity(self): # Pickling a tree, then unpickling it, yields a tree identical # to the original. tree = self.soup("<a><b>foo</a>") dumped = pickle.dumps(tree, 2) loaded = pickle.loads(dumped) assert loaded.__class__ == BeautifulSoup assert loaded.decode() == tree.decode() def assertDoctypeHandled(self, doctype_fragment): """Assert that a given doctype string is handled correctly.""" doctype_str, soup = self._document_with_doctype(doctype_fragment) # Make sure a Doctype object was created. doctype = soup.contents[0] assert doctype.__class__ == Doctype assert doctype == doctype_fragment assert soup.encode("utf8")[:len(doctype_str)] == doctype_str # Make sure that the doctype was correctly associated with the # parse tree and that the rest of the document parsed. assert soup.p.contents[0] == 'foo' def _document_with_doctype(self, doctype_fragment, doctype_string="DOCTYPE"): """Generate and parse a document with the given doctype.""" doctype = '<!%s %s>' % (doctype_string, doctype_fragment) markup = doctype + '\n<p>foo</p>' soup = self.soup(markup) return doctype.encode("utf8"), soup def test_normal_doctypes(self): """Make sure normal, everyday HTML doctypes are handled correctly.""" self.assertDoctypeHandled("html") self.assertDoctypeHandled( 'html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"') def test_empty_doctype(self): soup = self.soup("<!DOCTYPE>") doctype = soup.contents[0] assert "" == doctype.strip() def test_mixed_case_doctype(self): # A lowercase or mixed-case doctype becomes a Doctype. for doctype_fragment in ("doctype", "DocType"): doctype_str, soup = self._document_with_doctype( "html", doctype_fragment ) # Make sure a Doctype object was created and that the DOCTYPE # is uppercase. doctype = soup.contents[0] assert doctype.__class__ == Doctype assert doctype == "html" assert soup.encode("utf8")[:len(doctype_str)] == b"<!DOCTYPE html>" # Make sure that the doctype was correctly associated with the # parse tree and that the rest of the document parsed. assert soup.p.contents[0] == 'foo' def test_public_doctype_with_url(self): doctype = 'html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"' self.assertDoctypeHandled(doctype) def test_system_doctype(self): self.assertDoctypeHandled('foo SYSTEM "http://www.example.com/"') def test_namespaced_system_doctype(self): # We can handle a namespaced doctype with a system ID. self.assertDoctypeHandled('xsl:stylesheet SYSTEM "htmlent.dtd"') def test_namespaced_public_doctype(self): # Test a namespaced doctype with a public id. self.assertDoctypeHandled('xsl:stylesheet PUBLIC "htmlent.dtd"') def test_real_xhtml_document(self): """A real XHTML document should come out more or less the same as it went in.""" markup = b"""<?xml version="1.0" encoding="utf-8"?> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"> <html xmlns="http://www.w3.org/1999/xhtml"> <head><title>Hello.</title></head> <body>Goodbye.</body> </html>""" with warnings.catch_warnings(record=True) as w: soup = self.soup(markup) assert soup.encode("utf-8").replace(b"\n", b"") == markup.replace(b"\n", b"") # No warning was issued about parsing an XML document as HTML, # because XHTML is both. assert w == [] def test_namespaced_html(self): # When a namespaced XML document is parsed as HTML it should # be treated as HTML with weird tag names. markup = b"""<ns1:foo>content</ns1:foo><ns1:foo/><ns2:foo/>""" with warnings.catch_warnings(record=True) as w: soup = self.soup(markup) assert 2 == len(soup.find_all("ns1:foo")) # n.b. no "you're parsing XML as HTML" warning was given # because there was no XML declaration. assert [] == w def test_detect_xml_parsed_as_html(self): # A warning is issued when parsing an XML document as HTML, # but basic stuff should still work. markup = b"""<?xml version="1.0" encoding="utf-8"?><tag>string</tag>""" with warnings.catch_warnings(record=True) as w: soup = self.soup(markup) assert soup.tag.string == 'string' [warning] = w assert isinstance(warning.message, XMLParsedAsHTMLWarning) assert str(warning.message) == XMLParsedAsHTMLWarning.MESSAGE # NOTE: the warning is not issued if the document appears to # be XHTML (tested with test_real_xhtml_document in the # superclass) or if there is no XML declaration (tested with # test_namespaced_html in the superclass). def test_processing_instruction(self): # We test both Unicode and bytestring to verify that # process_markup correctly sets processing_instruction_class # even when the markup is already Unicode and there is no # need to process anything. markup = """<?PITarget PIContent?>""" soup = self.soup(markup) assert markup == soup.decode() markup = b"""<?PITarget PIContent?>""" soup = self.soup(markup) assert markup == soup.encode("utf8") def test_deepcopy(self): """Make sure you can copy the tree builder. This is important because the builder is part of a BeautifulSoup object, and we want to be able to copy that. """ copy.deepcopy(self.default_builder) def test_p_tag_is_never_empty_element(self): """A <p> tag is never designated as an empty-element tag. Even if the markup shows it as an empty-element tag, it shouldn't be presented that way. """ soup = self.soup("<p/>") assert not soup.p.is_empty_element assert str(soup.p) == "<p></p>" def test_unclosed_tags_get_closed(self): """A tag that's not closed by the end of the document should be closed. This applies to all tags except empty-element tags. """ self.assert_soup("<p>", "<p></p>") self.assert_soup("<b>", "<b></b>") self.assert_soup("<br>", "<br/>") def test_br_is_always_empty_element_tag(self): """A <br> tag is designated as an empty-element tag. Some parsers treat <br></br> as one <br/> tag, some parsers as two tags, but it should always be an empty-element tag. """ soup = self.soup("<br></br>") assert soup.br.is_empty_element assert str(soup.br) == "<br/>" def test_nested_formatting_elements(self): self.assert_soup("<em><em></em></em>") def test_double_head(self): html = '''<!DOCTYPE html> <html> <head> <title>Ordinary HEAD element test</title> </head> <script type="text/javascript"> alert("Help!"); </script> <body> Hello, world! </body> </html> ''' soup = self.soup(html) assert "text/javascript" == soup.find('script')['type'] def test_comment(self): # Comments are represented as Comment objects. markup = "<p>foo<!--foobar-->baz</p>" self.assert_soup(markup) soup = self.soup(markup) comment = soup.find(string="foobar") assert comment.__class__ == Comment # The comment is properly integrated into the tree. foo = soup.find(string="foo") assert comment == foo.next_element baz = soup.find(string="baz") assert comment == baz.previous_element def test_preserved_whitespace_in_pre_and_textarea(self): """Whitespace must be preserved in <pre> and <textarea> tags, even if that would mean not prettifying the markup. """ pre_markup = "<pre>a z</pre>\n" textarea_markup = "<textarea> woo\nwoo </textarea>\n" self.assert_soup(pre_markup) self.assert_soup(textarea_markup) soup = self.soup(pre_markup) assert soup.pre.prettify() == pre_markup soup = self.soup(textarea_markup) assert soup.textarea.prettify() == textarea_markup soup = self.soup("<textarea></textarea>") assert soup.textarea.prettify() == "<textarea></textarea>\n" def test_nested_inline_elements(self): """Inline elements can be nested indefinitely.""" b_tag = "<b>Inside a B tag</b>" self.assert_soup(b_tag) nested_b_tag = "<p>A <i>nested <b>tag</b></i></p>" self.assert_soup(nested_b_tag) double_nested_b_tag = "<p>A <a>doubly <i>nested <b>tag</b></i></a></p>" self.assert_soup(nested_b_tag) def test_nested_block_level_elements(self): """Block elements can be nested.""" soup = self.soup('<blockquote><p><b>Foo</b></p></blockquote>') blockquote = soup.blockquote assert blockquote.p.b.string == 'Foo' assert blockquote.b.string == 'Foo' def test_correctly_nested_tables(self): """One table can go inside another one.""" markup = ('<table id="1">' '<tr>' "<td>Here's another table:" '<table id="2">' '<tr><td>foo</td></tr>' '</table></td>') self.assert_soup( markup, '<table id="1"><tr><td>Here\'s another table:' '<table id="2"><tr><td>foo</td></tr></table>' '</td></tr></table>') self.assert_soup( "<table><thead><tr><td>Foo</td></tr></thead>" "<tbody><tr><td>Bar</td></tr></tbody>" "<tfoot><tr><td>Baz</td></tr></tfoot></table>") def test_multivalued_attribute_with_whitespace(self): # Whitespace separating the values of a multi-valued attribute # should be ignored. markup = '<div class=" foo bar "></a>' soup = self.soup(markup) assert ['foo', 'bar'] == soup.div['class'] # If you search by the literal name of the class it's like the whitespace # wasn't there. assert soup.div == soup.find('div', class_="foo bar") def test_deeply_nested_multivalued_attribute(self): # html5lib can set the attributes of the same tag many times # as it rearranges the tree. This has caused problems with # multivalued attributes. markup = '<table><div><div class="css"></div></div></table>' soup = self.soup(markup) assert ["css"] == soup.div.div['class'] def test_multivalued_attribute_on_html(self): # html5lib uses a different API to set the attributes ot the # <html> tag. This has caused problems with multivalued # attributes. markup = '<html class="a b"></html>' soup = self.soup(markup) assert ["a", "b"] == soup.html['class'] def test_angle_brackets_in_attribute_values_are_escaped(self): self.assert_soup('<a b="<a>"></a>', '<a b="<a>"></a>') def test_strings_resembling_character_entity_references(self): # "&T" and "&p" look like incomplete character entities, but they are # not. self.assert_soup( "<p>• AT&T is in the s&p 500</p>", "<p>\u2022 AT&T is in the s&p 500</p>" ) def test_apos_entity(self): self.assert_soup( "<p>Bob's Bar</p>", "<p>Bob's Bar</p>", ) def test_entities_in_foreign_document_encoding(self): # “ and ” are invalid numeric entities referencing # Windows-1252 characters. - references a character common # to Windows-1252 and Unicode, and ☃ references a # character only found in Unicode. # # All of these entities should be converted to Unicode # characters. markup = "<p>“Hello” -☃</p>" soup = self.soup(markup) assert "“Hello” -☃" == soup.p.string def test_entities_in_attributes_converted_to_unicode(self): expect = '<p id="pi\N{LATIN SMALL LETTER N WITH TILDE}ata"></p>' self.assert_soup('<p id="piñata"></p>', expect) self.assert_soup('<p id="piñata"></p>', expect) self.assert_soup('<p id="piñata"></p>', expect) self.assert_soup('<p id="piñata"></p>', expect) def test_entities_in_text_converted_to_unicode(self): expect = '<p>pi\N{LATIN SMALL LETTER N WITH TILDE}ata</p>' self.assert_soup("<p>piñata</p>", expect) self.assert_soup("<p>piñata</p>", expect) self.assert_soup("<p>piñata</p>", expect) self.assert_soup("<p>piñata</p>", expect) def test_quot_entity_converted_to_quotation_mark(self): self.assert_soup("<p>I said "good day!"</p>", '<p>I said "good day!"</p>') def test_out_of_range_entity(self): expect = "\N{REPLACEMENT CHARACTER}" self.assert_soup("�", expect) self.assert_soup("�", expect) self.assert_soup("�", expect) def test_multipart_strings(self): "Mostly to prevent a recurrence of a bug in the html5lib treebuilder." soup = self.soup("<html><h2>\nfoo</h2><p></p></html>") assert "p" == soup.h2.string.next_element.name assert "p" == soup.p.name self.assertConnectedness(soup) def test_empty_element_tags(self): """Verify consistent handling of empty-element tags, no matter how they come in through the markup. """ self.assert_soup('<br/><br/><br/>', "<br/><br/><br/>") self.assert_soup('<br /><br /><br />', "<br/><br/><br/>") def test_head_tag_between_head_and_body(self): "Prevent recurrence of a bug in the html5lib treebuilder." content = """<html><head></head> <link></link> <body>foo</body> </html> """ soup = self.soup(content) assert soup.html.body is not None self.assertConnectedness(soup) def test_multiple_copies_of_a_tag(self): "Prevent recurrence of a bug in the html5lib treebuilder." content = """<!DOCTYPE html> <html> <body> <article id="a" > <div><a href="1"></div> <footer> <a href="2"></a> </footer> </article> </body> </html> """ soup = self.soup(content) self.assertConnectedness(soup.article) def test_basic_namespaces(self): """Parsers don't need to *understand* namespaces, but at the very least they should not choke on namespaces or lose data.""" markup = b'<html xmlns="http://www.w3.org/1999/xhtml" xmlns:mathml="http://www.w3.org/1998/Math/MathML" xmlns:svg="http://www.w3.org/2000/svg"><head></head><body><mathml:msqrt>4</mathml:msqrt><b svg:fill="red"></b></body></html>' soup = self.soup(markup) assert markup == soup.encode() html = soup.html assert 'http://www.w3.org/1999/xhtml' == soup.html['xmlns'] assert 'http://www.w3.org/1998/Math/MathML' == soup.html['xmlns:mathml'] assert 'http://www.w3.org/2000/svg' == soup.html['xmlns:svg'] def test_multivalued_attribute_value_becomes_list(self): markup = b'<a class="foo bar">' soup = self.soup(markup) assert ['foo', 'bar'] == soup.a['class'] # # Generally speaking, tests below this point are more tests of # Beautiful Soup than tests of the tree builders. But parsers are # weird, so we run these tests separately for every tree builder # to detect any differences between them. # def test_can_parse_unicode_document(self): # A seemingly innocuous document... but it's in Unicode! And # it contains characters that can't be represented in the # encoding found in the declaration! The horror! markup = '<html><head><meta encoding="euc-jp"></head><body>Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!</body>' soup = self.soup(markup) assert 'Sacr\xe9 bleu!' == soup.body.string def test_soupstrainer(self): """Parsers should be able to work with SoupStrainers.""" strainer = SoupStrainer("b") soup = self.soup("A <b>bold</b> <meta/> <i>statement</i>", parse_only=strainer) assert soup.decode() == "<b>bold</b>" def test_single_quote_attribute_values_become_double_quotes(self): self.assert_soup("<foo attr='bar'></foo>", '<foo attr="bar"></foo>') def test_attribute_values_with_nested_quotes_are_left_alone(self): text = """<foo attr='bar "brawls" happen'>a</foo>""" self.assert_soup(text) def test_attribute_values_with_double_nested_quotes_get_quoted(self): text = """<foo attr='bar "brawls" happen'>a</foo>""" soup = self.soup(text) soup.foo['attr'] = 'Brawls happen at "Bob\'s Bar"' self.assert_soup( soup.foo.decode(), """<foo attr="Brawls happen at "Bob\'s Bar"">a</foo>""") def test_ampersand_in_attribute_value_gets_escaped(self): self.assert_soup('<this is="really messed up & stuff"></this>', '<this is="really messed up & stuff"></this>') self.assert_soup( '<a href="http://example.org?a=1&b=2;3">foo</a>', '<a href="http://example.org?a=1&b=2;3">foo</a>') def test_escaped_ampersand_in_attribute_value_is_left_alone(self): self.assert_soup('<a href="http://example.org?a=1&b=2;3"></a>') def test_entities_in_strings_converted_during_parsing(self): # Both XML and HTML entities are converted to Unicode characters # during parsing. text = "<p><<sacré bleu!>></p>" expected = "<p><<sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!>></p>" self.assert_soup(text, expected) def test_smart_quotes_converted_on_the_way_in(self): # Microsoft smart quotes are converted to Unicode characters during # parsing. quote = b"<p>\x91Foo\x92</p>" soup = self.soup(quote) assert soup.p.string == "\N{LEFT SINGLE QUOTATION MARK}Foo\N{RIGHT SINGLE QUOTATION MARK}" def test_non_breaking_spaces_converted_on_the_way_in(self): soup = self.soup("<a> </a>") assert soup.a.string == "\N{NO-BREAK SPACE}" * 2 def test_entities_converted_on_the_way_out(self): text = "<p><<sacré bleu!>></p>" expected = "<p><<sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!>></p>".encode("utf-8") soup = self.soup(text) assert soup.p.encode("utf-8") == expected def test_real_iso_8859_document(self): # Smoke test of interrelated functionality, using an # easy-to-understand document. # Here it is in Unicode. Note that it claims to be in ISO-8859-1. unicode_html = '<html><head><meta content="text/html; charset=ISO-8859-1" http-equiv="Content-type"/></head><body><p>Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!</p></body></html>' # That's because we're going to encode it into ISO-8859-1, # and use that to test. iso_latin_html = unicode_html.encode("iso-8859-1") # Parse the ISO-8859-1 HTML. soup = self.soup(iso_latin_html) # Encode it to UTF-8. result = soup.encode("utf-8") # What do we expect the result to look like? Well, it would # look like unicode_html, except that the META tag would say # UTF-8 instead of ISO-8859-1. expected = unicode_html.replace("ISO-8859-1", "utf-8") # And, of course, it would be in UTF-8, not Unicode. expected = expected.encode("utf-8") # Ta-da! assert result == expected def test_real_shift_jis_document(self): # Smoke test to make sure the parser can handle a document in # Shift-JIS encoding, without choking. shift_jis_html = ( b'<html><head></head><body><pre>' b'\x82\xb1\x82\xea\x82\xcdShift-JIS\x82\xc5\x83R\x81[\x83f' b'\x83B\x83\x93\x83O\x82\xb3\x82\xea\x82\xbd\x93\xfa\x96{\x8c' b'\xea\x82\xcc\x83t\x83@\x83C\x83\x8b\x82\xc5\x82\xb7\x81B' b'</pre></body></html>') unicode_html = shift_jis_html.decode("shift-jis") soup = self.soup(unicode_html) # Make sure the parse tree is correctly encoded to various # encodings. assert soup.encode("utf-8") == unicode_html.encode("utf-8") assert soup.encode("euc_jp") == unicode_html.encode("euc_jp") def test_real_hebrew_document(self): # A real-world test to make sure we can convert ISO-8859-9 (a # Hebrew encoding) to UTF-8. hebrew_document = b'<html><head><title>Hebrew (ISO 8859-8) in Visual Directionality</title></head><body><h1>Hebrew (ISO 8859-8) in Visual Directionality</h1>\xed\xe5\xec\xf9</body></html>' soup = self.soup( hebrew_document, from_encoding="iso8859-8") # Some tree builders call it iso8859-8, others call it iso-8859-9. # That's not a difference we really care about. assert soup.original_encoding in ('iso8859-8', 'iso-8859-8') assert soup.encode('utf-8') == ( hebrew_document.decode("iso8859-8").encode("utf-8") ) def test_meta_tag_reflects_current_encoding(self): # Here's the <meta> tag saying that a document is # encoded in Shift-JIS. meta_tag = ('<meta content="text/html; charset=x-sjis" ' 'http-equiv="Content-type"/>') # Here's a document incorporating that meta tag. shift_jis_html = ( '<html><head>\n%s\n' '<meta http-equiv="Content-language" content="ja"/>' '</head><body>Shift-JIS markup goes here.') % meta_tag soup = self.soup(shift_jis_html) # Parse the document, and the charset is seemingly unaffected. parsed_meta = soup.find('meta', {'http-equiv': 'Content-type'}) content = parsed_meta['content'] assert 'text/html; charset=x-sjis' == content # But that value is actually a ContentMetaAttributeValue object. assert isinstance(content, ContentMetaAttributeValue) # And it will take on a value that reflects its current # encoding. assert 'text/html; charset=utf8' == content.encode("utf8") # For the rest of the story, see TestSubstitutions in # test_tree.py. def test_html5_style_meta_tag_reflects_current_encoding(self): # Here's the <meta> tag saying that a document is # encoded in Shift-JIS. meta_tag = ('<meta id="encoding" charset="x-sjis" />') # Here's a document incorporating that meta tag. shift_jis_html = ( '<html><head>\n%s\n' '<meta http-equiv="Content-language" content="ja"/>' '</head><body>Shift-JIS markup goes here.') % meta_tag soup = self.soup(shift_jis_html) # Parse the document, and the charset is seemingly unaffected. parsed_meta = soup.find('meta', id="encoding") charset = parsed_meta['charset'] assert 'x-sjis' == charset # But that value is actually a CharsetMetaAttributeValue object. assert isinstance(charset, CharsetMetaAttributeValue) # And it will take on a value that reflects its current # encoding. assert 'utf8' == charset.encode("utf8") def test_python_specific_encodings_not_used_in_charset(self): # You can encode an HTML document using a Python-specific # encoding, but that encoding won't be mentioned _inside_ the # resulting document. Instead, the document will appear to # have no encoding. for markup in [ b'<meta charset="utf8"></head>' b'<meta id="encoding" charset="utf-8" />' ]: soup = self.soup(markup) for encoding in PYTHON_SPECIFIC_ENCODINGS: if encoding in ( 'idna', 'mbcs', 'oem', 'undefined', 'string_escape', 'string-escape' ): # For one reason or another, these will raise an # exception if we actually try to use them, so don't # bother. continue encoded = soup.encode(encoding) assert b'meta charset=""' in encoded assert encoding.encode("ascii") not in encoded def test_tag_with_no_attributes_can_have_attributes_added(self): data = self.soup("<a>text</a>") data.a['foo'] = 'bar' assert '<a foo="bar">text</a>' == data.a.decode() def test_closing_tag_with_no_opening_tag(self): # Without BeautifulSoup.open_tag_counter, the </span> tag will # cause _popToTag to be called over and over again as we look # for a <span> tag that wasn't there. The result is that 'text2' # will show up outside the body of the document. soup = self.soup("<body><div><p>text1</p></span>text2</div></body>") assert "<body><div><p>text1</p>text2</div></body>" == soup.body.decode() def test_worst_case(self): """Test the worst case (currently) for linking issues.""" soup = self.soup(BAD_DOCUMENT) self.linkage_validator(soup) class XMLTreeBuilderSmokeTest(TreeBuilderSmokeTest): def test_pickle_and_unpickle_identity(self): # Pickling a tree, then unpickling it, yields a tree identical # to the original. tree = self.soup("<a><b>foo</a>") dumped = pickle.dumps(tree, 2) loaded = pickle.loads(dumped) assert loaded.__class__ == BeautifulSoup assert loaded.decode() == tree.decode() def test_docstring_generated(self): soup = self.soup("<root/>") assert soup.encode() == b'<?xml version="1.0" encoding="utf-8"?>\n<root/>' def test_xml_declaration(self): markup = b"""<?xml version="1.0" encoding="utf8"?>\n<foo/>""" soup = self.soup(markup) assert markup == soup.encode("utf8") def test_python_specific_encodings_not_used_in_xml_declaration(self): # You can encode an XML document using a Python-specific # encoding, but that encoding won't be mentioned _inside_ the # resulting document. markup = b"""<?xml version="1.0"?>\n<foo/>""" soup = self.soup(markup) for encoding in PYTHON_SPECIFIC_ENCODINGS: if encoding in ( 'idna', 'mbcs', 'oem', 'undefined', 'string_escape', 'string-escape' ): # For one reason or another, these will raise an # exception if we actually try to use them, so don't # bother. continue encoded = soup.encode(encoding) assert b'<?xml version="1.0"?>' in encoded assert encoding.encode("ascii") not in encoded def test_processing_instruction(self): markup = b"""<?xml version="1.0" encoding="utf8"?>\n<?PITarget PIContent?>""" soup = self.soup(markup) assert markup == soup.encode("utf8") def test_real_xhtml_document(self): """A real XHTML document should come out *exactly* the same as it went in.""" markup = b"""<?xml version="1.0" encoding="utf-8"?> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"> <html xmlns="http://www.w3.org/1999/xhtml"> <head><title>Hello.</title></head> <body>Goodbye.</body> </html>""" soup = self.soup(markup) assert soup.encode("utf-8") == markup def test_nested_namespaces(self): doc = b"""<?xml version="1.0" encoding="utf-8"?> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"> <parent xmlns="http://ns1/"> <child xmlns="http://ns2/" xmlns:ns3="http://ns3/"> <grandchild ns3:attr="value" xmlns="http://ns4/"/> </child> </parent>""" soup = self.soup(doc) assert doc == soup.encode() def test_formatter_processes_script_tag_for_xml_documents(self): doc = """ <script type="text/javascript"> </script> """ soup = BeautifulSoup(doc, "lxml-xml") # lxml would have stripped this while parsing, but we can add # it later. soup.script.string = 'console.log("< < hey > > ");' encoded = soup.encode() assert b"< < hey > >" in encoded def test_can_parse_unicode_document(self): markup = '<?xml version="1.0" encoding="euc-jp"><root>Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!</root>' soup = self.soup(markup) assert 'Sacr\xe9 bleu!' == soup.root.string def test_can_parse_unicode_document_begining_with_bom(self): markup = '\N{BYTE ORDER MARK}<?xml version="1.0" encoding="euc-jp"><root>Sacr\N{LATIN SMALL LETTER E WITH ACUTE} bleu!</root>' soup = self.soup(markup) assert 'Sacr\xe9 bleu!' == soup.root.string def test_popping_namespaced_tag(self): markup = '<rss xmlns:dc="foo"><dc:creator>b</dc:creator><dc:date>2012-07-02T20:33:42Z</dc:date><dc:rights>c</dc:rights><image>d</image></rss>' soup = self.soup(markup) assert str(soup.rss) == markup def test_docstring_includes_correct_encoding(self): soup = self.soup("<root/>") assert soup.encode("latin1") == b'<?xml version="1.0" encoding="latin1"?>\n<root/>' def test_large_xml_document(self): """A large XML document should come out the same as it went in.""" markup = (b'<?xml version="1.0" encoding="utf-8"?>\n<root>' + b'0' * (2**12) + b'</root>') soup = self.soup(markup) assert soup.encode("utf-8") == markup def test_tags_are_empty_element_if_and_only_if_they_are_empty(self): self.assert_soup("<p>", "<p/>") self.assert_soup("<p>foo</p>") def test_namespaces_are_preserved(self): markup = '<root xmlns:a="http://example.com/" xmlns:b="http://example.net/"><a:foo>This tag is in the a namespace</a:foo><b:foo>This tag is in the b namespace</b:foo></root>' soup = self.soup(markup) root = soup.root assert "http://example.com/" == root['xmlns:a'] assert "http://example.net/" == root['xmlns:b'] def test_closing_namespaced_tag(self): markup = '<p xmlns:dc="http://purl.org/dc/elements/1.1/"><dc:date>20010504</dc:date></p>' soup = self.soup(markup) assert str(soup.p) == markup def test_namespaced_attributes(self): markup = '<foo xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><bar xsi:schemaLocation="http://www.example.com"/></foo>' soup = self.soup(markup) assert str(soup.foo) == markup def test_namespaced_attributes_xml_namespace(self): markup = '<foo xml:lang="fr">bar</foo>' soup = self.soup(markup) assert str(soup.foo) == markup def test_find_by_prefixed_name(self): doc = """<?xml version="1.0" encoding="utf-8"?> <Document xmlns="http://example.com/ns0" xmlns:ns1="http://example.com/ns1" xmlns:ns2="http://example.com/ns2"> <ns1:tag>foo</ns1:tag> <ns1:tag>bar</ns1:tag> <ns2:tag key="value">baz</ns2:tag> </Document> """ soup = self.soup(doc) # There are three <tag> tags. assert 3 == len(soup.find_all('tag')) # But two of them are ns1:tag and one of them is ns2:tag. assert 2 == len(soup.find_all('ns1:tag')) assert 1 == len(soup.find_all('ns2:tag')) assert 1, len(soup.find_all('ns2:tag', key='value')) assert 3, len(soup.find_all(['ns1:tag', 'ns2:tag'])) def test_copy_tag_preserves_namespace(self): xml = """<?xml version="1.0" encoding="UTF-8" standalone="yes"?> <w:document xmlns:w="http://example.com/ns0"/>""" soup = self.soup(xml) tag = soup.document duplicate = copy.copy(tag) # The two tags have the same namespace prefix. assert tag.prefix == duplicate.prefix def test_worst_case(self): """Test the worst case (currently) for linking issues.""" soup = self.soup(BAD_DOCUMENT) self.linkage_validator(soup) class HTML5TreeBuilderSmokeTest(HTMLTreeBuilderSmokeTest): """Smoke test for a tree builder that supports HTML5.""" def test_real_xhtml_document(self): # Since XHTML is not HTML5, HTML5 parsers are not tested to handle # XHTML documents in any particular way. pass def test_html_tags_have_namespace(self): markup = "<a>" soup = self.soup(markup) assert "http://www.w3.org/1999/xhtml" == soup.a.namespace def test_svg_tags_have_namespace(self): markup = '<svg><circle/></svg>' soup = self.soup(markup) namespace = "http://www.w3.org/2000/svg" assert namespace == soup.svg.namespace assert namespace == soup.circle.namespace def test_mathml_tags_have_namespace(self): markup = '<math><msqrt>5</msqrt></math>' soup = self.soup(markup) namespace = 'http://www.w3.org/1998/Math/MathML' assert namespace == soup.math.namespace assert namespace == soup.msqrt.namespace def test_xml_declaration_becomes_comment(self): markup = '<?xml version="1.0" encoding="utf-8"?><html></html>' soup = self.soup(markup) assert isinstance(soup.contents[0], Comment) assert soup.contents[0] == '?xml version="1.0" encoding="utf-8"?' assert "html" == soup.contents[0].next_element.name PK z�ZVL�5 diagnose.pynu �[��� """Diagnostic functions, mainly for use when doing tech support.""" # Use of this source code is governed by the MIT license. __license__ = "MIT" import cProfile from io import BytesIO from html.parser import HTMLParser import bs4 from bs4 import BeautifulSoup, __version__ from bs4.builder import builder_registry import os import pstats import random import tempfile import time import traceback import sys import cProfile def diagnose(data): """Diagnostic suite for isolating common problems. :param data: A string containing markup that needs to be explained. :return: None; diagnostics are printed to standard output. """ print(("Diagnostic running on Beautiful Soup %s" % __version__)) print(("Python version %s" % sys.version)) basic_parsers = ["html.parser", "html5lib", "lxml"] for name in basic_parsers: for builder in builder_registry.builders: if name in builder.features: break else: basic_parsers.remove(name) print(( "I noticed that %s is not installed. Installing it may help." % name)) if 'lxml' in basic_parsers: basic_parsers.append("lxml-xml") try: from lxml import etree print(("Found lxml version %s" % ".".join(map(str,etree.LXML_VERSION)))) except ImportError as e: print( "lxml is not installed or couldn't be imported.") if 'html5lib' in basic_parsers: try: import html5lib print(("Found html5lib version %s" % html5lib.__version__)) except ImportError as e: print( "html5lib is not installed or couldn't be imported.") if hasattr(data, 'read'): data = data.read() for parser in basic_parsers: print(("Trying to parse your markup with %s" % parser)) success = False try: soup = BeautifulSoup(data, features=parser) success = True except Exception as e: print(("%s could not parse the markup." % parser)) traceback.print_exc() if success: print(("Here's what %s did with the markup:" % parser)) print((soup.prettify())) print(("-" * 80)) def lxml_trace(data, html=True, **kwargs): """Print out the lxml events that occur during parsing. This lets you see how lxml parses a document when no Beautiful Soup code is running. You can use this to determine whether an lxml-specific problem is in Beautiful Soup's lxml tree builders or in lxml itself. :param data: Some markup. :param html: If True, markup will be parsed with lxml's HTML parser. if False, lxml's XML parser will be used. """ from lxml import etree recover = kwargs.pop('recover', True) if isinstance(data, str): data = data.encode("utf8") reader = BytesIO(data) for event, element in etree.iterparse( reader, html=html, recover=recover, **kwargs ): print(("%s, %4s, %s" % (event, element.tag, element.text))) class AnnouncingParser(HTMLParser): """Subclass of HTMLParser that announces parse events, without doing anything else. You can use this to get a picture of how html.parser sees a given document. The easiest way to do this is to call `htmlparser_trace`. """ def _p(self, s): print(s) def handle_starttag(self, name, attrs): self._p("%s START" % name) def handle_endtag(self, name): self._p("%s END" % name) def handle_data(self, data): self._p("%s DATA" % data) def handle_charref(self, name): self._p("%s CHARREF" % name) def handle_entityref(self, name): self._p("%s ENTITYREF" % name) def handle_comment(self, data): self._p("%s COMMENT" % data) def handle_decl(self, data): self._p("%s DECL" % data) def unknown_decl(self, data): self._p("%s UNKNOWN-DECL" % data) def handle_pi(self, data): self._p("%s PI" % data) def htmlparser_trace(data): """Print out the HTMLParser events that occur during parsing. This lets you see how HTMLParser parses a document when no Beautiful Soup code is running. :param data: Some markup. """ parser = AnnouncingParser() parser.feed(data) _vowels = "aeiou" _consonants = "bcdfghjklmnpqrstvwxyz" def rword(length=5): "Generate a random word-like string." s = '' for i in range(length): if i % 2 == 0: t = _consonants else: t = _vowels s += random.choice(t) return s def rsentence(length=4): "Generate a random sentence-like string." return " ".join(rword(random.randint(4,9)) for i in range(length)) def rdoc(num_elements=1000): """Randomly generate an invalid HTML document.""" tag_names = ['p', 'div', 'span', 'i', 'b', 'script', 'table'] elements = [] for i in range(num_elements): choice = random.randint(0,3) if choice == 0: # New tag. tag_name = random.choice(tag_names) elements.append("<%s>" % tag_name) elif choice == 1: elements.append(rsentence(random.randint(1,4))) elif choice == 2: # Close a tag. tag_name = random.choice(tag_names) elements.append("</%s>" % tag_name) return "<html>" + "\n".join(elements) + "</html>" def benchmark_parsers(num_elements=100000): """Very basic head-to-head performance benchmark.""" print(("Comparative parser benchmark on Beautiful Soup %s" % __version__)) data = rdoc(num_elements) print(("Generated a large invalid HTML document (%d bytes)." % len(data))) for parser in ["lxml", ["lxml", "html"], "html5lib", "html.parser"]: success = False try: a = time.time() soup = BeautifulSoup(data, parser) b = time.time() success = True except Exception as e: print(("%s could not parse the markup." % parser)) traceback.print_exc() if success: print(("BS4+%s parsed the markup in %.2fs." % (parser, b-a))) from lxml import etree a = time.time() etree.HTML(data) b = time.time() print(("Raw lxml parsed the markup in %.2fs." % (b-a))) import html5lib parser = html5lib.HTMLParser() a = time.time() parser.parse(data) b = time.time() print(("Raw html5lib parsed the markup in %.2fs." % (b-a))) def profile(num_elements=100000, parser="lxml"): """Use Python's profiler on a randomly generated document.""" filehandle = tempfile.NamedTemporaryFile() filename = filehandle.name data = rdoc(num_elements) vars = dict(bs4=bs4, data=data, parser=parser) cProfile.runctx('bs4.BeautifulSoup(data, parser)' , vars, vars, filename) stats = pstats.Stats(filename) # stats.strip_dirs() stats.sort_stats("cumulative") stats.print_stats('_html5lib|bs4', 50) # If this file is run as a script, standard input is diagnosed. if __name__ == '__main__': diagnose(sys.stdin.read()) PK z�Z\/�}�' �' ) builder/__pycache__/_lxml.cpython-310.pycnu �[��� o �hd: � @ s� d Z ddgZzddlmZ W n ey& Z z ddlmZ W Y dZ[ndZ[ww ddlmZ ddlm Z ddl m Z dd l m Z mZmZmZmZ dd lmZmZmZmZmZmZmZmZ dd lm Z d Z d d� Z G dd� de�Z G dd� dee �Z dS )�MIT�LXMLTreeBuilderForXML�LXMLTreeBuilder� )�CallableN)�BytesIO)�StringIO)�etree)�Comment�Doctype�NamespacedAttribute�ProcessingInstruction�XMLProcessingInstruction)�DetectsXMLParsedAsHTML�FAST�HTML�HTMLTreeBuilder� PERMISSIVE�ParserRejectedMarkup� TreeBuilder�XML)�EncodingDetector�lxmlc C s t dd� t| �� �D ��S )zInvert a dictionary.c s s � | ] \}}||fV qd S �N� )�.0�k�vr r �D/usr/local/CyberCP/lib/python3.10/site-packages/bs4/builder/_lxml.py� <genexpr>' s � z_invert.<locals>.<genexpr>)�dict�list�items)�dr r r �_invert% s r# c s� e Zd ZejZdZeZdZ dgZ e e e e egZdZedd�Zee�Z� fdd�Zd d � Zd d � Zd d� Zd*� fdd� Zdd� Z d+dd�Zdd� Z dd� Z i fdd�Z d d � Z d d � Z d d!� Z!d"d#� Z"d$d%� Z#d&d'� Z$d(d)� Z%� Z&S ),r Tzlxml-xml�xmli z$http://www.w3.org/XML/1998/namespace)r$ c s t t| ��|� | �| j� dS )z�Let the BeautifulSoup object know about the standard namespace mapping. :param soup: A `BeautifulSoup`. N)�superr �initialize_soup�_register_namespaces�DEFAULT_NSMAPS)�self�soup�� __class__r r r& D s z%LXMLTreeBuilderForXML.initialize_soupc C s6 t |�� �D ]\}}|r|| jjvr|| jj|< qdS )a� Let the BeautifulSoup object know about namespaces encountered while parsing the document. This might be useful later on when creating CSS selectors. This will track (almost) all namespaces, even ones that were only in scope for part of the document. If two namespaces have the same prefix, only the first one encountered will be tracked. Un-prefixed namespaces are not tracked. :param mapping: A dictionary mapping namespace prefixes to URIs. N)r r! r* � _namespaces)r) �mapping�key�valuer r r r' M s ��z*LXMLTreeBuilderForXML._register_namespacesc C s" | j dur| j S tj| dd|d�S )z�Find the default parser for the given encoding. :param encoding: A string. :return: Either a parser object or a class, which will be instantiated with default arguments. NFT��target� strip_cdata�recover�encoding)�_default_parserr � XMLParser�r) r5 r r r �default_parsere s �z$LXMLTreeBuilderForXML.default_parserc C s( | � |�}t|t�r|| dd|d�}|S )z�Instantiate an appropriate parser for the given encoding. :param encoding: A string. :return: A parser object such as an `etree.XMLParser`. FTr1 )r9 � isinstancer )r) r5 �parserr r r � parser_forq s �z LXMLTreeBuilderForXML.parser_forNc sP || _ |d ur t|�| _d | _| jg| _t| j�g| _t t | �j di |�� d S )Nr ) r6 �set�empty_element_tagsr* �DEFAULT_NSMAPS_INVERTED�nsmapsr r( �active_namespace_prefixesr% r �__init__)r) r; r> �kwargsr+ r r rB � s z LXMLTreeBuilderForXML.__init__c C s, |d dkrt |dd � �dd��S d |fS )Nr �{� �})�tuple�split)r) �tagr r r � _getNsTag� s z LXMLTreeBuilderForXML._getNsTagc c s� � | j }|rt| _tj|dd� nt| _t|t�r3t|�dkr,|d dkr,|dd� }|d|dfV t|t�rB|� d�d|dfV |g}|g}t |||||d �}|j D ] } |j | |dfV qTdS ) aA Run any preliminary steps necessary to make incoming markup acceptable to the parser. lxml really wants to get a bytestring and convert it to Unicode itself. So instead of using UnicodeDammit to convert the bytestring to Unicode using different encodings, this implementation uses EncodingDetector to iterate over the encodings, and tell lxml to try to parse the document as each one in turn. :param markup: Some markup -- hopefully 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. :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. � )� stacklevelr u rE NF�utf8)�known_definite_encodings�user_encodings�is_html�exclude_encodings) �is_xmlr � processing_instruction_classr � warn_if_markup_looks_like_xmlr r: �str�len�encoder � encodings�markup) r) rY �user_specified_encodingrQ �document_declared_encodingrP rN rO �detectorr5 r r r �prepare_markup� s4 � � �� �z$LXMLTreeBuilderForXML.prepare_markupc C s� t |t�r t|�}n t |t�rt|�}|�| j�}z4| �| jj �| _ | j � |� t |�dkrF|�| j�}t |�dkr@| j � |� t |�dks.| j � � W d S tttjfya } zt|��d }~ww )Nr )r: �bytesr rU r �read� CHUNK_SIZEr< r* �original_encodingr; �feedrV �close�UnicodeDecodeError� LookupErrorr � ParserErrorr )r) rY �data�er r r rb � s$ ���zLXMLTreeBuilderForXML.feedc C s | j g| _d S r )r? r@ )r) r r r rc � s zLXMLTreeBuilderForXML.closec C sR t |�}d }t|�dkrt| j�dkr| j�d � nEt|�dkr_| �|� | j�t|�� t | jd �}|�|� d|v r@|d= | j�|� |�� }t |� � �D ]\}}t d|d�}|||< qPi } t |� � �D ]#\} } | � | �\}} |d u r{| | | < qg| � |�}t || |�} | | | < qg| }| � |�\}}| � |�}| jj||||| jd d� d S )Nr rE ���� �xmlnsz http://www.w3.org/2000/xmlns/)� namespaces)r rV r@ �appendr' r# rA �update�copyr r! r rJ �_prefix_for_namespacer* �handle_starttag) r) �name�attrs�nsmap�nsprefix�current_mapping�prefix� namespace� attribute� new_attrs�attrr0 r r r �start� sB � �zLXMLTreeBuilderForXML.startc C s< |du rdS t | j�D ]}|dur||v r|| S q dS )z9Find the currently active prefix for the given namespace.N)�reversedr@ )r) rx �inverted_nsmapr r r rp 4 s �z+LXMLTreeBuilderForXML._prefix_for_namespacec C s� | j �� | j jd }| �|�\}}d }|d ur.t| j�D ]}|d ur-||v r-|| } nq | j �||� t| j�dkrL| j�� }|d urN| j �� d S d S d S )Nri rE ) r* �endData�tagStackrJ r} r@ � handle_endtagrV �poprA )r) rr � completed_tagrx ru r~ �out_of_scope_nsmapr r r �end= s" � �zLXMLTreeBuilderForXML.endc C s4 | j �� |d | }| j �|� | j �| j� d S )N� )r* r � handle_datarS )r) r2 rg r r r �piS s zLXMLTreeBuilderForXML.pic C s | j �|� d S r )r* r� �r) �contentr r r rg Y s zLXMLTreeBuilderForXML.datac C s( | j �� t�|||�}| j �|� d S r )r* r r �for_name_and_ids�object_was_parsed)r) rr �pubid�system�doctyper r r r� \ s z LXMLTreeBuilderForXML.doctypec C s& | j �� | j �|� | j �t� dS )z#Handle comments as Comment objects.N)r* r r� r r� r r r �commenta s z LXMLTreeBuilderForXML.commentc C � d| S )�See `TreeBuilder`.z)<?xml version="1.0" encoding="utf-8"?> %sr �r) �fragmentr r r �test_fragment_to_documentg � z/LXMLTreeBuilderForXML.test_fragment_to_document)NN)NNN)'�__name__� __module__� __qualname__r r7 �DEFAULT_PARSER_CLASSrR r rS �NAME�ALTERNATE_NAMES�LXMLr r r �featuresr` r r( r# r? r& r' r9 r< rB rJ r] rb rc r| rp r� r� rg r� r� r� � __classcell__r r r+ r r ) s< �H ? c @ sF e Zd ZeZdgZeeeeeg Z dZ e Z dd� Z dd� Zdd� Zd S ) r z lxml-htmlFc C s t jS r )r � HTMLParserr8 r r r r9 u s z LXMLTreeBuilder.default_parserc C sZ | j j}z| �|�| _| j�|� | j�� W d S tttj fy, } zt |��d }~ww r ) r* ra r< r; rb rc rd re r rf r )r) rY r5 rh r r r rb x s ��zLXMLTreeBuilder.feedc C r� )r� z <html><body>%s</body></html>r r� r r r r� � r� z)LXMLTreeBuilder.test_fragment_to_documentN)r� r� r� r� r� r� r r r r� rR r rS r9 rb r� r r r r r l s )!� __license__�__all__�collections.abcr � ImportErrorrh � collections�ior r r r � bs4.elementr r r r r � bs4.builderr r r r r r r r � bs4.dammitr r� r# r r r r r r �<module> s, ��� ( EPK z�Z0���\& \& / builder/__pycache__/_htmlparser.cpython-310.pycnu �[��� o �hK: � @ s� d Z dZdgZddlmZ ddlZddlZddlmZm Z m Z m Z m Z ddl mZmZ ddlmZmZmZmZmZ d ZG d d � d ee�ZG d d� de�ZdS ) zCUse the HTMLParser library to parse HTML files that aren't too bad.�MIT�HTMLParserTreeBuilder� )� HTMLParserN)�CData�Comment� Declaration�Doctype�ProcessingInstruction)�EntitySubstitution� UnicodeDammit)�DetectsXMLParsedAsHTML�ParserRejectedMarkup�HTML�HTMLTreeBuilder�STRICTz html.parserc @ s| e Zd ZdZdZdZdd� Zdd� Zdd � Zd d d �Z d d d�Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zdd � Zd S ) �BeautifulSoupHTMLParserz�A subclass of the Python standard library's HTMLParser class, which listens for HTMLParser events and translates them into calls to Beautiful Soup's tree construction API. �ignore�replacec O s: |� d| j�| _tj| g|�R i |�� g | _| �� dS )a Constructor. :param on_duplicate_attribute: A strategy for what to do if a tag includes the same attribute more than once. Accepted values are: REPLACE (replace earlier values with later ones, the default), IGNORE (keep the earliest value encountered), or a callable. A callable must take three arguments: the dictionary of attributes already processed, the name of the duplicate attribute, and the most recent value encountered. �on_duplicate_attributeN)�pop�REPLACEr r �__init__� already_closed_empty_element�_initialize_xml_detector)�self�args�kwargs� r �J/usr/local/CyberCP/lib/python3.10/site-packages/bs4/builder/_htmlparser.pyr . s � z BeautifulSoupHTMLParser.__init__c C s t |��)N)r )r �messager r r �errorJ s z BeautifulSoupHTMLParser.errorc C s | j ||dd�}| �|� dS )z�Handle an incoming empty-element tag. This is only called when the markup looks like <tag/>. :param name: Name of the tag. :param attrs: Dictionary of the tag's attributes. F)�handle_empty_elementN)�handle_starttag� handle_endtag)r �name�attrs�tagr r r �handle_startendtagZ s z*BeautifulSoupHTMLParser.handle_startendtagTc C s� i }|D ]0\}}|du rd}||v r.| j }|| jkrn|d| jfv r'|||< n ||||� n|||< d}q| �� \} } | jj|dd|| | d�} | r[| jr[|r[| j|dd� | j� |� | j du rg| � |� dS dS )a3 Handle an opening tag, e.g. '<tag>' :param name: Name of the tag. :param attrs: Dictionary of the tag's attributes. :param handle_empty_element: True if this tag is known to be an empty-element tag (i.e. there is not expected to be any closing tag). N� z"")� sourceline� sourceposF)�check_already_closed) r �IGNOREr �getpos�soupr" �is_empty_elementr# r �append� _root_tag�_root_tag_encountered) r r$ r% r! � attr_dict�key�value�on_dupe� attrvaluer) r* r& r r r r" i s0 � �z'BeautifulSoupHTMLParser.handle_starttagc C s. |r|| j v r| j �|� dS | j�|� dS )z�Handle a closing tag, e.g. '</tag>' :param name: A tag name. :param check_already_closed: True if this tag is expected to be the closing portion of an empty-element tag, e.g. '<tag></tag>'. N)r �remover. r# )r r$ r+ r r r r# � s z%BeautifulSoupHTMLParser.handle_endtagc C s | j �|� dS )z4Handle some textual data that shows up between tags.N)r. � handle_data�r �datar r r r9 � s z#BeautifulSoupHTMLParser.handle_datac C s� |� d�rt|�d�d�}n|� d�r t|�d�d�}nt|�}d}|dk rN| jjdfD ]!}|s1q,z t|g��|�}W q, tyM } zW Y d}~q,d}~ww |skzt|�}W n t t fyj } zW Y d}~nd}~ww |pnd}| � |� dS )z�Handle a numeric character reference by converting it to the corresponding Unicode character and treating it as textual data. :param name: Character number, possibly in hexadecimal. �x� �XN� z windows-1252u �) � startswith�int�lstripr. �original_encoding� bytearray�decode�UnicodeDecodeError�chr� ValueError� OverflowErrorr9 )r r$ � real_namer; �encoding�er r r �handle_charref� s2 �� ��z&BeautifulSoupHTMLParser.handle_charrefc C s0 t j�|�}|dur |}nd| }| �|� dS )z�Handle a named entity reference by converting it to the corresponding Unicode character(s) and treating it as textual data. :param name: Name of the entity reference. Nz&%s)r �HTML_ENTITY_TO_CHARACTER�getr9 )r r$ � characterr; r r r �handle_entityref� s z(BeautifulSoupHTMLParser.handle_entityrefc C s& | j �� | j �|� | j �t� dS )zOHandle an HTML comment. :param data: The text of the comment. N)r. �endDatar9 r r: r r r �handle_comment� s z&BeautifulSoupHTMLParser.handle_commentc C s6 | j �� |td�d� }| j �|� | j �t� dS )zYHandle a DOCTYPE declaration. :param data: The text of the declaration. zDOCTYPE N)r. rR �lenr9 r r: r r r � handle_decl� s z#BeautifulSoupHTMLParser.handle_declc C sN |� � �d�rt}|td�d� }nt}| j�� | j�|� | j�|� dS )z{Handle a declaration of unknown type -- probably a CDATA block. :param data: The text of the declaration. zCDATA[N)�upperr@ r rT r r. rR r9 )r r; �clsr r r � unknown_decl s z$BeautifulSoupHTMLParser.unknown_declc C s0 | j �� | j �|� | �|� | j �t� dS )z\Handle a processing instruction. :param data: The text of the instruction. N)r. rR r9 �_document_might_be_xmlr r: r r r � handle_pi s z!BeautifulSoupHTMLParser.handle_piN)T)�__name__� __module__� __qualname__�__doc__r, r r r r' r" r# r9 rM rQ rS rU rX rZ r r r r r $ s 7( r c sR e Zd ZdZdZdZeZeee gZ dZ d � fdd� Z d dd�Z d d � Z� ZS ) r zpA Beautiful soup `TreeBuilder` that uses the `HTMLParser` parser, found in the Python standard library. FTNc sp t � }dD ]}||v r|�|�}|||< qtt| �jdi |�� |p#g }|p'i }|�|� d|d< ||f| _dS )a� Constructor. :param parser_args: Positional arguments to pass into the BeautifulSoupHTMLParser constructor, once it's invoked. :param parser_kwargs: Keyword arguments to pass into the BeautifulSoupHTMLParser constructor, once it's invoked. :param kwargs: Keyword arguments for the superclass constructor. )r F�convert_charrefsNr )�dictr �superr r �update� parser_args)r rc � parser_kwargsr �extra_parser_kwargs�argr5 �� __class__r r r * s � z HTMLParserTreeBuilder.__init__c c s^ � t |t�r|dddfV dS |g}|g}||g}t|||d|d�}|j|j|j|jfV dS )a� Run 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. :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. NFT)�known_definite_encodings�user_encodings�is_html�exclude_encodings)� isinstance�strr �markuprC �declared_html_encoding� contains_replacement_characters) r ro �user_specified_encoding�document_declared_encodingrl ri rj � try_encodings�dammitr r r �prepare_markupC s$ � � �z$HTMLParserTreeBuilder.prepare_markupc C sb | j \}}t|i |��}| j|_z |�|� |�� W n ty+ } zt|��d}~ww g |_dS )z{Run some incoming markup through some parsing process, populating the `BeautifulSoup` object in self.soup. N)rc r r. �feed�close�AssertionErrorr r )r ro r r �parserrL r r r rw t s �� zHTMLParserTreeBuilder.feed)NN)NNN)r[ r\ r] r^ �is_xml� picklable� HTMLPARSER�NAMEr r �features�TRACKS_LINE_NUMBERSr rv rw � __classcell__r r rg r r s �1)r^ � __license__�__all__� html.parserr �sys�warnings� bs4.elementr r r r r � bs4.dammitr r � bs4.builderr r r r r r} r r r r r r �<module> s � zPK z�Z�GC3K 3K , builder/__pycache__/__init__.cpython-310.pycnu �[��� o �h�_ � @ sf d Z ddlmZ ddlZddlZddlZddlZddlmZm Z m Z m Z m Z m Z mZmZ g d�ZdZdZdZd Zd Zd ZG d d � d e�ZG dd� de�Ze� ZG dd� de�Z G dd� de �Z G dd� de �Z G dd� de�Z dd� Z G dd� de!�Z"d d l#m$Z$ e e$� z d d l#m%Z% e e%� W n e&y� Y nw z d d l#m'Z' e e'� W dS e&y� Y dS w ) �MIT� )� defaultdictN)�CharsetMetaAttributeValue�ContentMetaAttributeValue�RubyParenthesisString�RubyTextString� Stylesheet�Script�TemplateString�nonwhitespace_re)�HTMLTreeBuilder�SAXTreeBuilder� TreeBuilder�TreeBuilderRegistry�fast� permissive�strict�xml�html�html5c @ s e Zd ZdZdZdS )�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� r r �G/usr/local/CyberCP/lib/python3.10/site-packages/bs4/builder/__init__.pyr # s r c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) r zYA way of looking up TreeBuilder subclasses by their name or by desired features. c C s t t�| _g | _d S �N)r �list�builders_for_feature�builders��selfr r r �__init__/ s z TreeBuilderRegistry.__init__c C s0 |j D ] }| 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. r N)�featuresr �insertr! )r# �treebuilder_class�featurer r r �register3 s z TreeBuilderRegistry.registerc G s� t | j�dkr dS t |�dkr| jd S t|�}|�� d}d}t |�dkrO|�� }| j�|g �}t |�dkrI|du rB|}t|�}n|�t|��}t |�dks&|du rUdS |D ] }||v ra| S qWdS )aj Look 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. r N) �lenr! r �reverse�popr �get�set� intersection)r# r% � candidates� candidate_setr( �we_have_the_feature� candidater r r �lookup= s4 � ��zTreeBuilderRegistry.lookupN)r r r r r$ r) r4 r r r r r * s r c @ s� e Zd ZdZdZg Zg ZdZdZdZ e e �Z e � Zi Ze� ZdZeeeefdd�Zdd� Zd d � Zd d � Zd d� Z ddd�Zdd� Zdd� Zdd� ZdS )r z:Turn a textual document into a Beautiful Soup object tree.z[Unknown tree builder]FNc C sb d| _ || ju r | j}|| _|| ju r| 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> r r r r$ � s $ zTreeBuilder.__init__c C s || _ dS )z�The BeautifulSoup object has been initialized and is now being associated with the TreeBuilder. :param soup: A BeautifulSoup object. N)r5 )r# r5 r r r �initialize_soup� s zTreeBuilder.initialize_soupc C � dS )z�Do any work necessary to reset the underlying parser for a new document. By default, this does nothing. Nr r" r r r �reset� s zTreeBuilder.resetc C s | j du rdS || j v S )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_namer r r �can_be_empty_element� s z TreeBuilder.can_be_empty_elementc C � 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# �markupr r r �feed� s zTreeBuilder.feedc c s � |dddfV dS )a Run 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_encodingsr r r �prepare_markup� s �zTreeBuilder.prepare_markupc C s |S )a Wrap 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# �fragmentr r r �test_fragment_to_document s z%TreeBuilder.test_fragment_to_documentc C rA )a2 Set 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# �tagr r r �set_up_substitutions s z TreeBuilder.set_up_substitutionsc C s� |s|S | j r?| j �dg �}| j �|�� d�}t|�� �D ]!}||v s)|r>||v r>|| }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) r8 r- �lowerr �keys� isinstance�strr �findall)r# rD �attrs� universal� tag_specific�attr�value�valuesr r r �$_replace_cdata_list_attribute_values' s � �z0TreeBuilder._replace_cdata_list_attribute_values)NNN) r r r r �NAME�ALTERNATE_NAMESr% �is_xml� picklablerC r r r7 r. r9 r= �objectr6 r; r$ r@ rB rE rK rO rQ rS r` r r r r r o s8 �2 � r c @ sh e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� 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. c C rF r rG rI r r r rK T s zSAXTreeBuilder.feedc C � d S r r r" r r r �closeW � zSAXTreeBuilder.closec C s, t dd� t|�� �D ��}| j�||� d S )Nc s s � | ] \}}|d |fV qdS )� Nr )�.0�keyr^ r r r � <genexpr>[ s � z.SAXTreeBuilder.startElement.<locals>.<genexpr>)�dictr �itemsr5 �handle_starttag)r# �namerZ r r r � startElementZ s zSAXTreeBuilder.startElementc C � | j �|� d S r )r5 � handle_endtag�r# rp r r r � endElement_ � zSAXTreeBuilder.endElementc C s | � ||� d S r )rq )r# �nsTuple�nodeNamerZ r r r �startElementNSc rv z SAXTreeBuilder.startElementNSc C s | � |� d S r )ru )r# rw rx r r r � endElementNSg s zSAXTreeBuilder.endElementNSc C rf r r )r# �prefix� nodeValuer r r �startPrefixMappingl s z!SAXTreeBuilder.startPrefixMappingc C rf r r )r# r{ r r r �endPrefixMappingp s z SAXTreeBuilder.endPrefixMappingc C rr r )r5 � handle_data)r# �contentr r r � charactersu s zSAXTreeBuilder.charactersc C rf r r r" r r r � startDocumentx rh z SAXTreeBuilder.startDocumentc C rf r r r" r r r � endDocument{ rh zSAXTreeBuilder.endDocumentN)r r r r rK rg rq ru ry rz r} r~ r� r� r� r r r r r M s r c @ s� e Zd ZdZeg d��Zeg d��Zeee e e d�Z g d�ddgddgdgdgdgd gd gdgd gd gd gd� Z eddg�Zdd� ZdS )r z]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� re r� �icon�iframer� r� �textareac C s� |j dkrdS |�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� �charsetNz content-type)rp r- r rU r )r# rR � http_equivr� r� � meta_encodingr r r rS � s � z$HTMLTreeBuilder.set_up_substitutionsN)r r r r r. rC �block_elementsr r r r r r= r7 r9 rS r r r r r s2 �� r c @ sh e Zd ZdZe�dej�Ze�dej�ZdZ dZ e ddd��Z e dd d ��Z d d � Zdd� Zdd� ZdS )�DetectsXMLParsedAsHTMLa A 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� c C s` t |t�r | j}| j}n| j}| j}|dur.|�|�r.|�|dd� �s.| j|d d� dS dS )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)�clsrJ r� r{ �looks_like_htmlr r r � warn_if_markup_looks_like_xml s ��z4DetectsXMLParsedAsHTML.warn_if_markup_looks_like_xml� c C s t jtjt|d� dS )z/Issue a warning about XML being parsed as HTML.r� N)�warnings�warnr r )r� r� r r r r� " s �z DetectsXMLParsedAsHTML._warnc C s d| _ d| _dS )z+Call this method before parsing a document.N�� _first_processing_instruction� _root_tagr" r r r �_initialize_xml_detector* s z/DetectsXMLParsedAsHTML._initialize_xml_detectorc C s" | j dus | jdur dS || _ dS )z�Call this method when encountering an XML declaration, or a "processing instruction" that might be an XML declaration. Nr� )r# �processing_instructionr r r �_document_might_be_xml/ s z-DetectsXMLParsedAsHTML._document_might_be_xmlc C sN | j durdS || _ |dkr!| jdur#| j�� �d�r%| �� dS dS dS dS )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. Nr zxml )r� r� rU r� r� rt r r r �_root_tag_encountered> s � �z,DetectsXMLParsedAsHTML._root_tag_encounteredN)r� )r� )r r r r �re�compile�Ir� r� r� r� � classmethodr� r� r� r� r� r r r r r� � s r� c C sR t jt }| 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 �objr r r �register_treebuilders_fromR s ��r c s e Zd ZdZ� fdd�Z� ZS )�ParserRejectedMarkupzgAn Exception to be raised when the underlying parser simply refuses to parse the given markup. c s6 t |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__r rX �superr r$ )r# �message_or_exception�e�r r r r$ b s z ParserRejectedMarkup.__init__)r r r r r$ � __classcell__r r r r r ^ s r ri )� _htmlparser)� _html5lib)�_lxml)(� __license__� collectionsr � itertoolsr� r� r� � bs4.elementr r r r r r r r r� �FAST� PERMISSIVE�STRICT�XML�HTML�HTML_5� UserWarningr re r r� r r r r� r r r � r r � ImportErrorr r r r r �<module> sL ( C _2qb � �PK z�Z�5��_1 _1 - builder/__pycache__/_html5lib.cpython-310.pycnu �[��� o �h�J � @ s d Z dgZddlZddlZddlmZmZmZmZm Z ddl m Z m Z ddl Z ddlmZmZ ddl mZmZmZmZ z ddlmZ d ZW n ey_ Z zdd lmZ d ZW Y dZ[ndZ[ww G d d� de �Z G d d� dej �Z G dd� de �Z G dd� dej!�Z"G dd� de"�Z#dS )�MIT�HTML5TreeBuilder� N)�DetectsXMLParsedAsHTML� PERMISSIVE�HTML�HTML_5�HTMLTreeBuilder)�NamespacedAttribute�nonwhitespace_re)� namespaces�prefixes)�Comment�Doctype�NavigableString�Tag)�_baseF)�baseTc @ sH e Zd ZdZdZeeeegZdZ d dd�Z dd� Z d d � Z d d � Z dS )r a Use html5lib to build a tree. Note that this TreeBuilder does not support some features common to HTML TreeBuilders. Some of these features could theoretically be implemented, but at the very least it's quite difficult, because html5lib moves the parse tree around as it's being built. * This TreeBuilder doesn't use different subclasses of NavigableString based on the name of the tag in which the string was found. * You can't use a SoupStrainer to parse only part of a document. �html5libTNc c s: � || _ |r tjddd� tj|dd� |d d dfV d S )NzjYou provided a value for exclude_encoding, but the html5lib tree builder doesn't support exclude_encoding.� �� stacklevelF)�user_specified_encoding�warnings�warnr � warn_if_markup_looks_like_xml)�self�markupr �document_declared_encoding�exclude_encodings� r �H/usr/local/CyberCP/lib/python3.10/site-packages/bs4/builder/_html5lib.py�prepare_markup@ s ���z HTML5TreeBuilder.prepare_markupc C s� | j jd ur tjddd� tj| jd�}|| j_t � }t |t �s-t r(| j |d< n| j |d< |j|fi |��}t |t �r?d |_n|jjjd }t |t �sN|j}||_d | j_d S )Nz�You provided a value for parse_only, but the html5lib tree builder doesn't support parse_only. The entire document will be parsed.� r )�tree�override_encoding�encodingr )�soup� parse_onlyr r r � HTMLParser�create_treebuilder�underlying_builder�parser�dict� isinstance�str� new_html5libr �parse�original_encoding� tokenizer�stream� charEncoding�name)r r r+ � extra_kwargs�docr1 r r r �feedW s( � zHTML5TreeBuilder.feedc C s t || j| jd�| _| jS )N)�store_line_numbers)�TreeBuilderForHtml5libr& r9 r* )r �namespaceHTMLElementsr r r r) v s �z#HTML5TreeBuilder.create_treebuilderc C s d| S )zSee `TreeBuilder`.z)<html><head></head><body>%s</body></html>r )r �fragmentr r r �test_fragment_to_document} s z*HTML5TreeBuilder.test_fragment_to_document)NN)�__name__� __module__� __qualname__�__doc__�NAMEr r r �features�TRACKS_LINE_NUMBERSr! r8 r) r= r r r r r * s � c sj e Zd Z d� fdd� Zdd� Zdd� Zd d � Zd d � Zd d� Zdd� Z dd� Z dd� Z dd� Z � Z S )r: NTc sN |r|| _ nddlm} | dd|i|��| _ tt| ��|� d | _|| _d S )Nr �� BeautifulSoup� � html.parserr9 )rG rH )r& �bs4rF �superr: �__init__r+ r9 )r r; r& r9 �kwargsrF �� __class__r r rK � s ��� z TreeBuilderForHtml5lib.__init__c C s | j �� t| j | j d �S �N)r& �reset�Element�r r r r � documentClass� s z$TreeBuilderForHtml5lib.documentClassc C s6 |d }|d }|d }t �|||�}| j�|� d S )Nr5 �publicId�systemId)r �for_name_and_idsr& �object_was_parsed)r �tokenr5 rT rU �doctyper r r � insertDoctype� s z$TreeBuilderForHtml5lib.insertDoctypec C sZ i }| j r| jr| j jj�� \}}||d< |d |d< | jj||fi |��}t|| j|�S )N� sourceline� � sourcepos)r+ r9 r2 r3 �positionr& �new_tagrQ )r r5 � namespacerL r[ r] �tagr r r � elementClass� s z#TreeBuilderForHtml5lib.elementClassc C s t t|�| j�S rO )�TextNoder r& )r �datar r r � commentClass� s z#TreeBuilderForHtml5lib.commentClassc C s0 ddl m} |dd�| _d| j_t| j| jd �S )Nr rE rG rH z[document_fragment])rI rF r& r5 rQ )r rF r r r � fragmentClass� s z$TreeBuilderForHtml5lib.fragmentClassc C s | j �|j� d S rO )r& �append�element�r �noder r r � appendChild� s z"TreeBuilderForHtml5lib.appendChildc C s | j S rO )r& rR r r r � getDocument� s z"TreeBuilderForHtml5lib.getDocumentc C s t j�| �jS rO )�treebuilder_base� TreeBuilder� getFragmentrh rR r r r ro � � z"TreeBuilderForHtml5lib.getFragmentc sB ddl m� g �t�d��d� ���fdd� ��|d� d���S )Nr rE z8^(.*?)(?: PUBLIC "(.*?)"(?: "(.*?)")?| SYSTEM "(.*?)")?$c s� t | � �r t | t�rW��| �}|rK|�d�}|jdkr>|�d�p"d}|�d�p.|�d�p.d}��dd| |||f � d S ��dd| |f � d S ��d d| f � d S t | t�ri��d d| | f � d S t | t�r{��d d| | f � d S | jr�d t | j | j f }n| j }��d d| |f � | j r�g }t | j � � �D ]$\}}t |t�r�d t |j |j f }t |t �r�d�|�}|�||f� q�t|�D ]\}}��dd|d ||f � q�|d7 }| jD ]}�||� q�d S )Nr\ � rG r r" z|%s<!DOCTYPE %s "%s" "%s">� z|%s<!DOCTYPE %s>z|%s<!DOCTYPE >z|%s<!-- %s -->z|%s"%s"z%s %sz|%s<%s>z |%s%s="%s")r- r �match�group� lastindexrg r r r` r r5 �attrs�list�itemsr �join�sorted�children) rh �indent�mr5 rT rU � attributes�value�child�rF � doctype_re�rv�serializeElementr r r� � sL � � �z?TreeBuilderForHtml5lib.testSerializer.<locals>.serializeElement� )r )rI rF �re�compilery �r rh r r� r �testSerializer� s ) z%TreeBuilderForHtml5lib.testSerializer)NT)r> r? r@ rK rS rZ rb re rf rk rl ro r� � __classcell__r r rM r r: � s � r: c @ sL e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dS )�AttrListc C s || _ t| j j�| _d S rO )rh r, rv r� r r r rK � s zAttrList.__init__c C s t | j�� ��� S rO )rw rv rx �__iter__rR r r r r� � � zAttrList.__iter__c C s^ | j jpi }||�dg �v s | j j|v r(||�| j jg �v r(t|t�s(t�|�}|| j |< d S )N�*)rh �cdata_list_attributes�getr5 r- rw r �findall)r r5 r � list_attrr r r � __setitem__ s zAttrList.__setitem__c C � t | j�� �S rO )rw rv rx rR r r r rx rp zAttrList.itemsc C r� rO �rw rv �keysrR r r r r� rp z AttrList.keysc C s t | j�S rO )�lenrv rR r r r �__len__ � zAttrList.__len__c C s | j | S rO )rv �r r5 r r r � __getitem__ r� zAttrList.__getitem__c C s |t | j�� �v S rO r� r� r r r � __contains__ r� zAttrList.__contains__N) r> r? r@ rK r� r� rx r� r� r� r� r r r r r� � s r� c @ sx e Zd Zdd� Zdd� Zdd� Zdd� Zeee�Zdd d �Z d d � Z dd� Z dd� Z dd� Z dd� Zdd� Zee�Zd S )rQ c C s& t j�| |j� || _|| _|| _d S rO )rm �NoderK r5 rh r& r` )r rh r& r` r r r rK s zElement.__init__c C s* d }}t |t�r| }}n t |t�r|}n|jjtkr%|j }}| |_n|j}| |_t |t�s:|jd ur:|j�� |d urd| jjrd| jjd jtkrd| jjd }| j � || �}|� |� || j _ d S t |t�ro| j � |�}| jjrz| j� d�}n| jjd ur�| j � � }n| j}| j j|| j|d� d S )N���F)�parent�most_recent_element)r- r. r rh rN r r� �extract�contentsr& � new_string� replace_with�_most_recent_element�_last_descendant� next_elementrW )r rj � string_childr� � old_element� new_elementr� r r r rk s: �zElement.appendChildc C s t | jt�ri S t| j�S rO )r- rh r r� rR r r r � getAttributesU s zElement.getAttributesc C s� |d urJt |�dkrLg }t|�� �D ]\}}t|t�r&t|� }||= |||< q| jj�| j |� t|�� �D ] \}}|| j |< q6| jj� | j � d S d S d S )Nr ) r� rw rx r- �tupler r& �builder�$_replace_cdata_list_attribute_valuesr5 rh �set_up_substitutions)r r~ �converted_attributesr5 r �new_namer r r � setAttributesZ s �� �zElement.setAttributesNc C s6 t | j�|�| j�}|r| �||� d S | �|� d S rO )rc r& r� � insertBeforerk )r rd r� �textr r r � insertTextp s zElement.insertTextc C s� | j �|j �}|j jtkr4| j jr4| j j|d jtkr4| j j|d }| j�||j �}|�|� d S | j �||j � | |_ d S )Nr\ ) rh �indexrN r r� r& r� r� �insertr� )r rj �refNoder� �old_node�new_strr r r r� w s zElement.insertBeforec C s |j �� d S rO )rh r� ri r r r � removeChild� rp zElement.removeChildc C s� | j }|j }|j}|�dd�}t|j�dkr |jd }|j}nd}|j}|j}t|�dkrf|d } |dur9|| _n|| _|| _|durG| |_n| |_|durQ| |_|d �dd�} || _|durc| |_d| _|D ] } || _|j� | � qhg |_||_dS )z1Move all of this tag's children into another tag.Fr r� NT) rh � next_siblingr� r� r� r� �previous_element�previous_siblingr� rg ) r � new_parentrh �new_parent_element�final_next_element�new_parents_last_descendant�new_parents_last_child�(new_parents_last_descendant_next_element� to_append� first_child�last_childs_last_descendantr� r r r �reparentChildren� s> zElement.reparentChildrenc C sB | j �| jj| j�}t|| j | j�}| jD ] \}}||j|< q|S rO )r& r_ rh r5 r` rQ r~ )r ra rj �keyr r r r � cloneNode� s zElement.cloneNodec C s | j jS rO )rh r� rR r r r � hasContent� s zElement.hasContentc C s$ | j d kr td | jfS | j | jfS )N�html)r` r r5 rR r r r � getNameTuple� s zElement.getNameTuplerO )r> r? r@ rK rk r� r� �propertyr~ r� r� r� r� r� r� r� � nameTupler r r r rQ s 6 B rQ c @ s e Zd Zdd� Zdd� ZdS )rc c C s t j�| d � || _|| _d S rO )rm r� rK rh r& )r rh r& r r r rK � s zTextNode.__init__c C s t �rO )�NotImplementedErrorrR r r r r� � s zTextNode.cloneNodeN)r> r? r@ rK r� r r r r rc � s rc )$� __license__�__all__r r� � bs4.builderr r r r r � bs4.elementr r r �html5lib.constantsr r r r r r �html5lib.treebuildersr rm r/ � ImportError�er r rn r: �objectr� r� rQ rc r r r r �<module> s0 � ��Xx CPK z�ZޣCZK: K: builder/_htmlparser.pynu �[��� # encoding: utf-8 """Use the HTMLParser library to parse HTML files that aren't too bad.""" # Use of this source code is governed by the MIT license. __license__ = "MIT" __all__ = [ 'HTMLParserTreeBuilder', ] from html.parser import HTMLParser import sys import warnings from bs4.element import ( CData, Comment, Declaration, Doctype, ProcessingInstruction, ) from bs4.dammit import EntitySubstitution, UnicodeDammit from bs4.builder import ( DetectsXMLParsedAsHTML, ParserRejectedMarkup, HTML, HTMLTreeBuilder, STRICT, ) HTMLPARSER = 'html.parser' class BeautifulSoupHTMLParser(HTMLParser, DetectsXMLParsedAsHTML): """A subclass of the Python standard library's HTMLParser class, which listens for HTMLParser events and translates them into calls to Beautiful Soup's tree construction API. """ # Strategies for handling duplicate attributes IGNORE = 'ignore' REPLACE = 'replace' def __init__(self, *args, **kwargs): """Constructor. :param on_duplicate_attribute: A strategy for what to do if a tag includes the same attribute more than once. Accepted values are: REPLACE (replace earlier values with later ones, the default), IGNORE (keep the earliest value encountered), or a callable. A callable must take three arguments: the dictionary of attributes already processed, the name of the duplicate attribute, and the most recent value encountered. """ self.on_duplicate_attribute = kwargs.pop( 'on_duplicate_attribute', self.REPLACE ) HTMLParser.__init__(self, *args, **kwargs) # Keep a list of empty-element tags that were encountered # without an explicit closing tag. If we encounter a closing tag # of this type, we'll associate it with one of those entries. # # This isn't a stack because we don't care about the # order. It's a list of closing tags we've already handled and # will ignore, assuming they ever show up. self.already_closed_empty_element = [] self._initialize_xml_detector() def error(self, message): # NOTE: This method is required so long as Python 3.9 is # supported. The corresponding code is removed from HTMLParser # in 3.5, but not removed from ParserBase until 3.10. # https://github.com/python/cpython/issues/76025 # # The original implementation turned the error into a warning, # but in every case I discovered, this made HTMLParser # immediately crash with an error message that was less # helpful than the warning. The new implementation makes it # more clear that html.parser just can't parse this # markup. The 3.10 implementation does the same, though it # raises AssertionError rather than calling a method. (We # catch this error and wrap it in a ParserRejectedMarkup.) raise ParserRejectedMarkup(message) def handle_startendtag(self, name, attrs): """Handle an incoming empty-element tag. This is only called when the markup looks like <tag/>. :param name: Name of the tag. :param attrs: Dictionary of the tag's attributes. """ # is_startend() tells handle_starttag not to close the tag # just because its name matches a known empty-element tag. We # know that this is an empty-element tag and we want to call # handle_endtag ourselves. tag = self.handle_starttag(name, attrs, handle_empty_element=False) self.handle_endtag(name) def handle_starttag(self, name, attrs, handle_empty_element=True): """Handle an opening tag, e.g. '<tag>' :param name: Name of the tag. :param attrs: Dictionary of the tag's attributes. :param handle_empty_element: True if this tag is known to be an empty-element tag (i.e. there is not expected to be any closing tag). """ # XXX namespace attr_dict = {} for key, value in attrs: # Change None attribute values to the empty string # for consistency with the other tree builders. if value is None: value = '' if key in attr_dict: # A single attribute shows up multiple times in this # tag. How to handle it depends on the # on_duplicate_attribute setting. on_dupe = self.on_duplicate_attribute if on_dupe == self.IGNORE: pass elif on_dupe in (None, self.REPLACE): attr_dict[key] = value else: on_dupe(attr_dict, key, value) else: attr_dict[key] = value attrvalue = '""' #print("START", name) sourceline, sourcepos = self.getpos() tag = self.soup.handle_starttag( name, None, None, attr_dict, sourceline=sourceline, sourcepos=sourcepos ) if tag and tag.is_empty_element and handle_empty_element: # Unlike other parsers, html.parser doesn't send separate end tag # events for empty-element tags. (It's handled in # handle_startendtag, but only if the original markup looked like # <tag/>.) # # So we need to call handle_endtag() ourselves. Since we # know the start event is identical to the end event, we # don't want handle_endtag() to cross off any previous end # events for tags of this name. self.handle_endtag(name, check_already_closed=False) # But we might encounter an explicit closing tag for this tag # later on. If so, we want to ignore it. self.already_closed_empty_element.append(name) if self._root_tag is None: self._root_tag_encountered(name) def handle_endtag(self, name, check_already_closed=True): """Handle a closing tag, e.g. '</tag>' :param name: A tag name. :param check_already_closed: True if this tag is expected to be the closing portion of an empty-element tag, e.g. '<tag></tag>'. """ #print("END", name) if check_already_closed and name in self.already_closed_empty_element: # This is a redundant end tag for an empty-element tag. # We've already called handle_endtag() for it, so just # check it off the list. #print("ALREADY CLOSED", name) self.already_closed_empty_element.remove(name) else: self.soup.handle_endtag(name) def handle_data(self, data): """Handle some textual data that shows up between tags.""" self.soup.handle_data(data) def handle_charref(self, name): """Handle a numeric character reference by converting it to the corresponding Unicode character and treating it as textual data. :param name: Character number, possibly in hexadecimal. """ # TODO: This was originally a workaround for a bug in # HTMLParser. (http://bugs.python.org/issue13633) The bug has # been fixed, but removing this code still makes some # Beautiful Soup tests fail. This needs investigation. if name.startswith('x'): real_name = int(name.lstrip('x'), 16) elif name.startswith('X'): real_name = int(name.lstrip('X'), 16) else: real_name = int(name) data = None if real_name < 256: # HTML numeric entities are supposed to reference Unicode # code points, but sometimes they reference code points in # some other encoding (ahem, Windows-1252). E.g. “ # instead of É for LEFT DOUBLE QUOTATION MARK. This # code tries to detect this situation and compensate. for encoding in (self.soup.original_encoding, 'windows-1252'): if not encoding: continue try: data = bytearray([real_name]).decode(encoding) except UnicodeDecodeError as e: pass if not data: try: data = chr(real_name) except (ValueError, OverflowError) as e: pass data = data or "\N{REPLACEMENT CHARACTER}" self.handle_data(data) def handle_entityref(self, name): """Handle a named entity reference by converting it to the corresponding Unicode character(s) and treating it as textual data. :param name: Name of the entity reference. """ character = EntitySubstitution.HTML_ENTITY_TO_CHARACTER.get(name) if character is not None: data = character else: # If this were XML, it would be ambiguous whether "&foo" # was an character entity reference with a missing # semicolon or the literal string "&foo". Since this is # HTML, we have a complete list of all character entity references, # and this one wasn't found, so assume it's the literal string "&foo". data = "&%s" % name self.handle_data(data) def handle_comment(self, data): """Handle an HTML comment. :param data: The text of the comment. """ self.soup.endData() self.soup.handle_data(data) self.soup.endData(Comment) def handle_decl(self, data): """Handle a DOCTYPE declaration. :param data: The text of the declaration. """ self.soup.endData() data = data[len("DOCTYPE "):] self.soup.handle_data(data) self.soup.endData(Doctype) def unknown_decl(self, data): """Handle a declaration of unknown type -- probably a CDATA block. :param data: The text of the declaration. """ if data.upper().startswith('CDATA['): cls = CData data = data[len('CDATA['):] else: cls = Declaration self.soup.endData() self.soup.handle_data(data) self.soup.endData(cls) def handle_pi(self, data): """Handle a processing instruction. :param data: The text of the instruction. """ self.soup.endData() self.soup.handle_data(data) self._document_might_be_xml(data) self.soup.endData(ProcessingInstruction) class HTMLParserTreeBuilder(HTMLTreeBuilder): """A Beautiful soup `TreeBuilder` that uses the `HTMLParser` parser, found in the Python standard library. """ is_xml = False picklable = True NAME = HTMLPARSER features = [NAME, HTML, STRICT] # The html.parser knows which line number and position in the # original file is the source of an element. TRACKS_LINE_NUMBERS = True def __init__(self, parser_args=None, parser_kwargs=None, **kwargs): """Constructor. :param parser_args: Positional arguments to pass into the BeautifulSoupHTMLParser constructor, once it's invoked. :param parser_kwargs: Keyword arguments to pass into the BeautifulSoupHTMLParser constructor, once it's invoked. :param kwargs: Keyword arguments for the superclass constructor. """ # Some keyword arguments will be pulled out of kwargs and placed # into parser_kwargs. extra_parser_kwargs = dict() for arg in ('on_duplicate_attribute',): if arg in kwargs: value = kwargs.pop(arg) extra_parser_kwargs[arg] = value super(HTMLParserTreeBuilder, self).__init__(**kwargs) parser_args = parser_args or [] parser_kwargs = parser_kwargs or {} parser_kwargs.update(extra_parser_kwargs) parser_kwargs['convert_charrefs'] = False self.parser_args = (parser_args, parser_kwargs) def prepare_markup(self, markup, user_specified_encoding=None, document_declared_encoding=None, exclude_encodings=None): """Run 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. :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. """ if isinstance(markup, str): # Parse Unicode as-is. yield (markup, None, None, False) return # Ask UnicodeDammit to sniff the most likely encoding. # This was provided by the end-user; treat it as a known # definite encoding per the algorithm laid out in the HTML5 # spec. (See the EncodingDetector class for details.) known_definite_encodings = [user_specified_encoding] # This was found in the document; treat it as a slightly lower-priority # user encoding. user_encodings = [document_declared_encoding] try_encodings = [user_specified_encoding, document_declared_encoding] dammit = UnicodeDammit( markup, known_definite_encodings=known_definite_encodings, user_encodings=user_encodings, is_html=True, exclude_encodings=exclude_encodings ) yield (dammit.markup, dammit.original_encoding, dammit.declared_html_encoding, dammit.contains_replacement_characters) def feed(self, markup): """Run some incoming markup through some parsing process, populating the `BeautifulSoup` object in self.soup. """ args, kwargs = self.parser_args parser = BeautifulSoupHTMLParser(*args, **kwargs) parser.soup = self.soup try: parser.feed(markup) parser.close() except AssertionError as e: # html.parser raises AssertionError in rare cases to # indicate a fatal problem with the markup, especially # when there's an error in the doctype declaration. raise ParserRejectedMarkup(e) parser.already_closed_empty_element = [] PK z�Z�9�ʪJ �J builder/_html5lib.pynu �[��� # Use of this source code is governed by the MIT license. __license__ = "MIT" __all__ = [ 'HTML5TreeBuilder', ] import warnings import re from bs4.builder import ( DetectsXMLParsedAsHTML, PERMISSIVE, HTML, HTML_5, HTMLTreeBuilder, ) from bs4.element import ( NamespacedAttribute, nonwhitespace_re, ) import html5lib from html5lib.constants import ( namespaces, prefixes, ) from bs4.element import ( Comment, Doctype, NavigableString, Tag, ) try: # Pre-0.99999999 from html5lib.treebuilders import _base as treebuilder_base new_html5lib = False except ImportError as e: # 0.99999999 and up from html5lib.treebuilders import base as treebuilder_base new_html5lib = True class HTML5TreeBuilder(HTMLTreeBuilder): """Use html5lib to build a tree. Note that this TreeBuilder does not support some features common to HTML TreeBuilders. Some of these features could theoretically be implemented, but at the very least it's quite difficult, because html5lib moves the parse tree around as it's being built. * This TreeBuilder doesn't use different subclasses of NavigableString based on the name of the tag in which the string was found. * You can't use a SoupStrainer to parse only part of a document. """ NAME = "html5lib" features = [NAME, PERMISSIVE, HTML_5, HTML] # html5lib can tell us which line number and position in the # original file is the source of an element. TRACKS_LINE_NUMBERS = True def prepare_markup(self, markup, user_specified_encoding, document_declared_encoding=None, exclude_encodings=None): # Store the user-specified encoding for use later on. self.user_specified_encoding = user_specified_encoding # document_declared_encoding and exclude_encodings aren't used # ATM because the html5lib TreeBuilder doesn't use # UnicodeDammit. if exclude_encodings: warnings.warn( "You provided a value for exclude_encoding, but the html5lib tree builder doesn't support exclude_encoding.", stacklevel=3 ) # html5lib only parses HTML, so if it's given XML that's worth # noting. DetectsXMLParsedAsHTML.warn_if_markup_looks_like_xml( markup, stacklevel=3 ) yield (markup, None, None, False) # These methods are defined by Beautiful Soup. def feed(self, markup): if self.soup.parse_only is not None: warnings.warn( "You provided a value for parse_only, but the html5lib tree builder doesn't support parse_only. The entire document will be parsed.", stacklevel=4 ) parser = html5lib.HTMLParser(tree=self.create_treebuilder) self.underlying_builder.parser = parser extra_kwargs = dict() if not isinstance(markup, str): if new_html5lib: extra_kwargs['override_encoding'] = self.user_specified_encoding else: extra_kwargs['encoding'] = self.user_specified_encoding doc = parser.parse(markup, **extra_kwargs) # Set the character encoding detected by the tokenizer. if isinstance(markup, str): # We need to special-case this because html5lib sets # charEncoding to UTF-8 if it gets Unicode input. doc.original_encoding = None else: original_encoding = parser.tokenizer.stream.charEncoding[0] if not isinstance(original_encoding, str): # In 0.99999999 and up, the encoding is an html5lib # Encoding object. We want to use a string for compatibility # with other tree builders. original_encoding = original_encoding.name doc.original_encoding = original_encoding self.underlying_builder.parser = None def create_treebuilder(self, namespaceHTMLElements): self.underlying_builder = TreeBuilderForHtml5lib( namespaceHTMLElements, self.soup, store_line_numbers=self.store_line_numbers ) return self.underlying_builder def test_fragment_to_document(self, fragment): """See `TreeBuilder`.""" return '<html><head></head><body>%s</body></html>' % fragment class TreeBuilderForHtml5lib(treebuilder_base.TreeBuilder): def __init__(self, namespaceHTMLElements, soup=None, store_line_numbers=True, **kwargs): if soup: self.soup = soup else: from bs4 import BeautifulSoup # TODO: Why is the parser 'html.parser' here? To avoid an # infinite loop? self.soup = BeautifulSoup( "", "html.parser", store_line_numbers=store_line_numbers, **kwargs ) # TODO: What are **kwargs exactly? Should they be passed in # here in addition to/instead of being passed to the BeautifulSoup # constructor? super(TreeBuilderForHtml5lib, self).__init__(namespaceHTMLElements) # This will be set later to an html5lib.html5parser.HTMLParser # object, which we can use to track the current line number. self.parser = None self.store_line_numbers = store_line_numbers def documentClass(self): self.soup.reset() return Element(self.soup, self.soup, None) def insertDoctype(self, token): name = token["name"] publicId = token["publicId"] systemId = token["systemId"] doctype = Doctype.for_name_and_ids(name, publicId, systemId) self.soup.object_was_parsed(doctype) def elementClass(self, name, namespace): kwargs = {} if self.parser and self.store_line_numbers: # This represents the point immediately after the end of the # tag. We don't know when the tag started, but we do know # where it ended -- the character just before this one. sourceline, sourcepos = self.parser.tokenizer.stream.position() kwargs['sourceline'] = sourceline kwargs['sourcepos'] = sourcepos-1 tag = self.soup.new_tag(name, namespace, **kwargs) return Element(tag, self.soup, namespace) def commentClass(self, data): return TextNode(Comment(data), self.soup) def fragmentClass(self): from bs4 import BeautifulSoup # TODO: Why is the parser 'html.parser' here? To avoid an # infinite loop? self.soup = BeautifulSoup("", "html.parser") self.soup.name = "[document_fragment]" return Element(self.soup, self.soup, None) def appendChild(self, node): # XXX This code is not covered by the BS4 tests. self.soup.append(node.element) def getDocument(self): return self.soup def getFragment(self): return treebuilder_base.TreeBuilder.getFragment(self).element def testSerializer(self, element): from bs4 import BeautifulSoup rv = [] doctype_re = re.compile(r'^(.*?)(?: PUBLIC "(.*?)"(?: "(.*?)")?| SYSTEM "(.*?)")?$') def serializeElement(element, indent=0): if isinstance(element, BeautifulSoup): pass if isinstance(element, Doctype): m = doctype_re.match(element) if m: name = m.group(1) if m.lastindex > 1: publicId = m.group(2) or "" systemId = m.group(3) or m.group(4) or "" rv.append("""|%s<!DOCTYPE %s "%s" "%s">""" % (' ' * indent, name, publicId, systemId)) else: rv.append("|%s<!DOCTYPE %s>" % (' ' * indent, name)) else: rv.append("|%s<!DOCTYPE >" % (' ' * indent,)) elif isinstance(element, Comment): rv.append("|%s<!-- %s -->" % (' ' * indent, element)) elif isinstance(element, NavigableString): rv.append("|%s\"%s\"" % (' ' * indent, element)) else: if element.namespace: name = "%s %s" % (prefixes[element.namespace], element.name) else: name = element.name rv.append("|%s<%s>" % (' ' * indent, name)) if element.attrs: attributes = [] for name, value in list(element.attrs.items()): if isinstance(name, NamespacedAttribute): name = "%s %s" % (prefixes[name.namespace], name.name) if isinstance(value, list): value = " ".join(value) attributes.append((name, value)) for name, value in sorted(attributes): rv.append('|%s%s="%s"' % (' ' * (indent + 2), name, value)) indent += 2 for child in element.children: serializeElement(child, indent) serializeElement(element, 0) return "\n".join(rv) class AttrList(object): def __init__(self, element): self.element = element self.attrs = dict(self.element.attrs) def __iter__(self): return list(self.attrs.items()).__iter__() def __setitem__(self, name, value): # If this attribute is a multi-valued attribute for this element, # turn its value into a list. list_attr = self.element.cdata_list_attributes or {} if (name in list_attr.get('*', []) or (self.element.name in list_attr and name in list_attr.get(self.element.name, []))): # A node that is being cloned may have already undergone # this procedure. if not isinstance(value, list): value = nonwhitespace_re.findall(value) self.element[name] = value def items(self): return list(self.attrs.items()) def keys(self): return list(self.attrs.keys()) def __len__(self): return len(self.attrs) def __getitem__(self, name): return self.attrs[name] def __contains__(self, name): return name in list(self.attrs.keys()) class Element(treebuilder_base.Node): def __init__(self, element, soup, namespace): treebuilder_base.Node.__init__(self, element.name) self.element = element self.soup = soup self.namespace = namespace def appendChild(self, node): string_child = child = None if isinstance(node, str): # Some other piece of code decided to pass in a string # instead of creating a TextElement object to contain the # string. string_child = child = node elif isinstance(node, Tag): # Some other piece of code decided to pass in a Tag # instead of creating an Element object to contain the # Tag. child = node elif node.element.__class__ == NavigableString: string_child = child = node.element node.parent = self else: child = node.element node.parent = self if not isinstance(child, str) and child.parent is not None: node.element.extract() if (string_child is not None and self.element.contents and self.element.contents[-1].__class__ == NavigableString): # We are appending a string onto another string. # TODO This has O(n^2) performance, for input like # "a</a>a</a>a</a>..." old_element = self.element.contents[-1] new_element = self.soup.new_string(old_element + string_child) old_element.replace_with(new_element) self.soup._most_recent_element = new_element else: if isinstance(node, str): # Create a brand new NavigableString from this string. child = self.soup.new_string(node) # Tell Beautiful Soup to act as if it parsed this element # immediately after the parent's last descendant. (Or # immediately after the parent, if it has no children.) if self.element.contents: most_recent_element = self.element._last_descendant(False) elif self.element.next_element is not None: # Something from further ahead in the parse tree is # being inserted into this earlier element. This is # very annoying because it means an expensive search # for the last element in the tree. most_recent_element = self.soup._last_descendant() else: most_recent_element = self.element self.soup.object_was_parsed( child, parent=self.element, most_recent_element=most_recent_element) def getAttributes(self): if isinstance(self.element, Comment): return {} return AttrList(self.element) def setAttributes(self, attributes): if attributes is not None and len(attributes) > 0: converted_attributes = [] for name, value in list(attributes.items()): if isinstance(name, tuple): new_name = NamespacedAttribute(*name) del attributes[name] attributes[new_name] = value self.soup.builder._replace_cdata_list_attribute_values( self.name, attributes) for name, value in list(attributes.items()): self.element[name] = value # The attributes may contain variables that need substitution. # Call set_up_substitutions manually. # # The Tag constructor called this method when the Tag was created, # but we just set/changed the attributes, so call it again. self.soup.builder.set_up_substitutions(self.element) attributes = property(getAttributes, setAttributes) def insertText(self, data, insertBefore=None): text = TextNode(self.soup.new_string(data), self.soup) if insertBefore: self.insertBefore(text, insertBefore) else: self.appendChild(text) def insertBefore(self, node, refNode): index = self.element.index(refNode.element) if (node.element.__class__ == NavigableString and self.element.contents and self.element.contents[index-1].__class__ == NavigableString): # (See comments in appendChild) old_node = self.element.contents[index-1] new_str = self.soup.new_string(old_node + node.element) old_node.replace_with(new_str) else: self.element.insert(index, node.element) node.parent = self def removeChild(self, node): node.element.extract() def reparentChildren(self, new_parent): """Move all of this tag's children into another tag.""" # print("MOVE", self.element.contents) # print("FROM", self.element) # print("TO", new_parent.element) element = self.element new_parent_element = new_parent.element # Determine what this tag's next_element will be once all the children # are removed. final_next_element = element.next_sibling new_parents_last_descendant = new_parent_element._last_descendant(False, False) if len(new_parent_element.contents) > 0: # The new parent already contains children. We will be # appending this tag's children to the end. new_parents_last_child = new_parent_element.contents[-1] new_parents_last_descendant_next_element = new_parents_last_descendant.next_element else: # The new parent contains no children. new_parents_last_child = None new_parents_last_descendant_next_element = new_parent_element.next_element to_append = element.contents if len(to_append) > 0: # Set the first child's previous_element and previous_sibling # to elements within the new parent first_child = to_append[0] if new_parents_last_descendant is not None: first_child.previous_element = new_parents_last_descendant else: first_child.previous_element = new_parent_element first_child.previous_sibling = new_parents_last_child if new_parents_last_descendant is not None: new_parents_last_descendant.next_element = first_child else: new_parent_element.next_element = first_child if new_parents_last_child is not None: new_parents_last_child.next_sibling = first_child # Find the very last element being moved. It is now the # parent's last descendant. It has no .next_sibling and # its .next_element is whatever the previous last # descendant had. last_childs_last_descendant = to_append[-1]._last_descendant(False, True) last_childs_last_descendant.next_element = new_parents_last_descendant_next_element if new_parents_last_descendant_next_element is not None: # TODO: This code has no test coverage and I'm not sure # how to get html5lib to go through this path, but it's # just the other side of the previous line. new_parents_last_descendant_next_element.previous_element = last_childs_last_descendant last_childs_last_descendant.next_sibling = None for child in to_append: child.parent = new_parent_element new_parent_element.contents.append(child) # Now that this element has no children, change its .next_element. element.contents = [] element.next_element = final_next_element # print("DONE WITH MOVE") # print("FROM", self.element) # print("TO", new_parent_element) def cloneNode(self): tag = self.soup.new_tag(self.element.name, self.namespace) node = Element(tag, self.soup, self.namespace) for key,value in self.attributes: node.attributes[key] = value return node def hasContent(self): return self.element.contents def getNameTuple(self): if self.namespace == None: return namespaces["html"], self.name else: return self.namespace, self.name nameTuple = property(getNameTuple) class TextNode(Element): def __init__(self, element, soup): treebuilder_base.Node.__init__(self, None) self.element = element self.soup = soup def cloneNode(self): raise NotImplementedError PK z�Z�!g�d: d: builder/_lxml.pynu �[��� # Use of this source code is governed by the MIT license. __license__ = "MIT" __all__ = [ 'LXMLTreeBuilderForXML', 'LXMLTreeBuilder', ] try: from collections.abc import Callable # Python 3.6 except ImportError as e: from collections import Callable from io import BytesIO from io import StringIO from lxml import etree from bs4.element import ( Comment, Doctype, NamespacedAttribute, ProcessingInstruction, XMLProcessingInstruction, ) from bs4.builder import ( DetectsXMLParsedAsHTML, FAST, HTML, HTMLTreeBuilder, PERMISSIVE, ParserRejectedMarkup, TreeBuilder, XML) from bs4.dammit import EncodingDetector LXML = 'lxml' def _invert(d): "Invert a dictionary." return dict((v,k) for k, v in list(d.items())) class LXMLTreeBuilderForXML(TreeBuilder): DEFAULT_PARSER_CLASS = etree.XMLParser is_xml = True processing_instruction_class = XMLProcessingInstruction NAME = "lxml-xml" ALTERNATE_NAMES = ["xml"] # Well, it's permissive by XML parser standards. features = [NAME, LXML, XML, FAST, PERMISSIVE] CHUNK_SIZE = 512 # This namespace mapping is specified in the XML Namespace # standard. DEFAULT_NSMAPS = dict(xml='http://www.w3.org/XML/1998/namespace') DEFAULT_NSMAPS_INVERTED = _invert(DEFAULT_NSMAPS) # NOTE: If we parsed Element objects and looked at .sourceline, # we'd be able to see the line numbers from the original document. # But instead we build an XMLParser or HTMLParser object to serve # as the target of parse messages, and those messages don't include # line numbers. # See: https://bugs.launchpad.net/lxml/+bug/1846906 def initialize_soup(self, soup): """Let the BeautifulSoup object know about the standard namespace mapping. :param soup: A `BeautifulSoup`. """ super(LXMLTreeBuilderForXML, self).initialize_soup(soup) self._register_namespaces(self.DEFAULT_NSMAPS) def _register_namespaces(self, mapping): """Let the BeautifulSoup object know about namespaces encountered while parsing the document. This might be useful later on when creating CSS selectors. This will track (almost) all namespaces, even ones that were only in scope for part of the document. If two namespaces have the same prefix, only the first one encountered will be tracked. Un-prefixed namespaces are not tracked. :param mapping: A dictionary mapping namespace prefixes to URIs. """ for key, value in list(mapping.items()): # This is 'if key' and not 'if key is not None' because we # don't track un-prefixed namespaces. Soupselect will # treat an un-prefixed namespace as the default, which # causes confusion in some cases. if key and key not in self.soup._namespaces: # Let the BeautifulSoup object know about a new namespace. # If there are multiple namespaces defined with the same # prefix, the first one in the document takes precedence. self.soup._namespaces[key] = value def default_parser(self, encoding): """Find the default parser for the given encoding. :param encoding: A string. :return: Either a parser object or a class, which will be instantiated with default arguments. """ if self._default_parser is not None: return self._default_parser return etree.XMLParser( target=self, strip_cdata=False, recover=True, encoding=encoding) def parser_for(self, encoding): """Instantiate an appropriate parser for the given encoding. :param encoding: A string. :return: A parser object such as an `etree.XMLParser`. """ # Use the default parser. parser = self.default_parser(encoding) if isinstance(parser, Callable): # Instantiate the parser with default arguments parser = parser( target=self, strip_cdata=False, recover=True, encoding=encoding ) return parser def __init__(self, parser=None, empty_element_tags=None, **kwargs): # TODO: Issue a warning if parser is present but not a # callable, since that means there's no way to create new # parsers for different encodings. self._default_parser = parser if empty_element_tags is not None: self.empty_element_tags = set(empty_element_tags) self.soup = None self.nsmaps = [self.DEFAULT_NSMAPS_INVERTED] self.active_namespace_prefixes = [dict(self.DEFAULT_NSMAPS)] super(LXMLTreeBuilderForXML, self).__init__(**kwargs) def _getNsTag(self, tag): # Split the namespace URL out of a fully-qualified lxml tag # name. Copied from lxml's src/lxml/sax.py. if tag[0] == '{': return tuple(tag[1:].split('}', 1)) else: return (None, tag) def prepare_markup(self, markup, user_specified_encoding=None, exclude_encodings=None, document_declared_encoding=None): """Run any preliminary steps necessary to make incoming markup acceptable to the parser. lxml really wants to get a bytestring and convert it to Unicode itself. So instead of using UnicodeDammit to convert the bytestring to Unicode using different encodings, this implementation uses EncodingDetector to iterate over the encodings, and tell lxml to try to parse the document as each one in turn. :param markup: Some markup -- hopefully 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. :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. """ is_html = not self.is_xml if is_html: self.processing_instruction_class = ProcessingInstruction # We're in HTML mode, so if we're given XML, that's worth # noting. DetectsXMLParsedAsHTML.warn_if_markup_looks_like_xml( markup, stacklevel=3 ) else: self.processing_instruction_class = XMLProcessingInstruction if isinstance(markup, str): # We were given Unicode. Maybe lxml can parse Unicode on # this system? # TODO: This is a workaround for # https://bugs.launchpad.net/lxml/+bug/1948551. # We can remove it once the upstream issue is fixed. if len(markup) > 0 and markup[0] == u'\N{BYTE ORDER MARK}': markup = markup[1:] yield markup, None, document_declared_encoding, False if isinstance(markup, str): # No, apparently not. Convert the Unicode to UTF-8 and # tell lxml to parse it as UTF-8. yield (markup.encode("utf8"), "utf8", document_declared_encoding, False) # This was provided by the end-user; treat it as a known # definite encoding per the algorithm laid out in the HTML5 # spec. (See the EncodingDetector class for details.) known_definite_encodings = [user_specified_encoding] # This was found in the document; treat it as a slightly lower-priority # user encoding. user_encodings = [document_declared_encoding] detector = EncodingDetector( markup, known_definite_encodings=known_definite_encodings, user_encodings=user_encodings, is_html=is_html, exclude_encodings=exclude_encodings ) for encoding in detector.encodings: yield (detector.markup, encoding, document_declared_encoding, False) def feed(self, markup): if isinstance(markup, bytes): markup = BytesIO(markup) elif isinstance(markup, str): markup = StringIO(markup) # Call feed() at least once, even if the markup is empty, # or the parser won't be initialized. data = markup.read(self.CHUNK_SIZE) try: self.parser = self.parser_for(self.soup.original_encoding) self.parser.feed(data) while len(data) != 0: # Now call feed() on the rest of the data, chunk by chunk. data = markup.read(self.CHUNK_SIZE) if len(data) != 0: self.parser.feed(data) self.parser.close() except (UnicodeDecodeError, LookupError, etree.ParserError) as e: raise ParserRejectedMarkup(e) def close(self): self.nsmaps = [self.DEFAULT_NSMAPS_INVERTED] def start(self, name, attrs, nsmap={}): # Make sure attrs is a mutable dict--lxml may send an immutable dictproxy. attrs = dict(attrs) nsprefix = None # Invert each namespace map as it comes in. if len(nsmap) == 0 and len(self.nsmaps) > 1: # There are no new namespaces for this tag, but # non-default namespaces are in play, so we need a # separate tag stack to know when they end. self.nsmaps.append(None) elif len(nsmap) > 0: # A new namespace mapping has come into play. # First, Let the BeautifulSoup object know about it. self._register_namespaces(nsmap) # Then, add it to our running list of inverted namespace # mappings. self.nsmaps.append(_invert(nsmap)) # The currently active namespace prefixes have # changed. Calculate the new mapping so it can be stored # with all Tag objects created while these prefixes are in # scope. current_mapping = dict(self.active_namespace_prefixes[-1]) current_mapping.update(nsmap) # We should not track un-prefixed namespaces as we can only hold one # and it will be recognized as the default namespace by soupsieve, # which may be confusing in some situations. if '' in current_mapping: del current_mapping[''] self.active_namespace_prefixes.append(current_mapping) # Also treat the namespace mapping as a set of attributes on the # tag, so we can recreate it later. attrs = attrs.copy() for prefix, namespace in list(nsmap.items()): attribute = NamespacedAttribute( "xmlns", prefix, "http://www.w3.org/2000/xmlns/") attrs[attribute] = namespace # Namespaces are in play. Find any attributes that came in # from lxml with namespaces attached to their names, and # turn then into NamespacedAttribute objects. new_attrs = {} for attr, value in list(attrs.items()): namespace, attr = self._getNsTag(attr) if namespace is None: new_attrs[attr] = value else: nsprefix = self._prefix_for_namespace(namespace) attr = NamespacedAttribute(nsprefix, attr, namespace) new_attrs[attr] = value attrs = new_attrs namespace, name = self._getNsTag(name) nsprefix = self._prefix_for_namespace(namespace) self.soup.handle_starttag( name, namespace, nsprefix, attrs, namespaces=self.active_namespace_prefixes[-1] ) def _prefix_for_namespace(self, namespace): """Find the currently active prefix for the given namespace.""" if namespace is None: return None for inverted_nsmap in reversed(self.nsmaps): if inverted_nsmap is not None and namespace in inverted_nsmap: return inverted_nsmap[namespace] return None def end(self, name): self.soup.endData() completed_tag = self.soup.tagStack[-1] namespace, name = self._getNsTag(name) nsprefix = None if namespace is not None: for inverted_nsmap in reversed(self.nsmaps): if inverted_nsmap is not None and namespace in inverted_nsmap: nsprefix = inverted_nsmap[namespace] break self.soup.handle_endtag(name, nsprefix) if len(self.nsmaps) > 1: # This tag, or one of its parents, introduced a namespace # mapping, so pop it off the stack. out_of_scope_nsmap = self.nsmaps.pop() if out_of_scope_nsmap is not None: # This tag introduced a namespace mapping which is no # longer in scope. Recalculate the currently active # namespace prefixes. self.active_namespace_prefixes.pop() def pi(self, target, data): self.soup.endData() data = target + ' ' + data self.soup.handle_data(data) self.soup.endData(self.processing_instruction_class) def data(self, content): self.soup.handle_data(content) def doctype(self, name, pubid, system): self.soup.endData() doctype = Doctype.for_name_and_ids(name, pubid, system) self.soup.object_was_parsed(doctype) def comment(self, content): "Handle comments as Comment objects." self.soup.endData() self.soup.handle_data(content) self.soup.endData(Comment) def test_fragment_to_document(self, fragment): """See `TreeBuilder`.""" return '<?xml version="1.0" encoding="utf-8"?>\n%s' % fragment class LXMLTreeBuilder(HTMLTreeBuilder, LXMLTreeBuilderForXML): NAME = LXML ALTERNATE_NAMES = ["lxml-html"] features = ALTERNATE_NAMES + [NAME, HTML, FAST, PERMISSIVE] is_xml = False processing_instruction_class = ProcessingInstruction def default_parser(self, encoding): return etree.HTMLParser def feed(self, markup): encoding = self.soup.original_encoding try: self.parser = self.parser_for(encoding) self.parser.feed(markup) self.parser.close() except (UnicodeDecodeError, LookupError, etree.ParserError) as e: raise ParserRejectedMarkup(e) def test_fragment_to_document(self, fragment): """See `TreeBuilder`.""" return '<html><body>%s</body></html>' % fragment PK z�Z%�1��_ �_ builder/__init__.pynu �[��� # Use of this source code is governed by the MIT license. __license__ = "MIT" from collections import defaultdict import itertools import re import warnings import sys from bs4.element import ( CharsetMetaAttributeValue, ContentMetaAttributeValue, RubyParenthesisString, RubyTextString, Stylesheet, Script, TemplateString, nonwhitespace_re ) __all__ = [ 'HTMLTreeBuilder', 'SAXTreeBuilder', 'TreeBuilder', 'TreeBuilderRegistry', ] # Some useful features for a TreeBuilder to have. FAST = 'fast' PERMISSIVE = 'permissive' STRICT = 'strict' XML = 'xml' HTML = 'html' HTML_5 = 'html5' class XMLParsedAsHTMLWarning(UserWarning): """The warning issued when an HTML parser is used to parse XML that is not XHTML. """ MESSAGE = """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.""" class TreeBuilderRegistry(object): """A way of looking up TreeBuilder subclasses by their name or by desired features. """ def __init__(self): self.builders_for_feature = defaultdict(list) self.builders = [] def register(self, treebuilder_class): """Register a treebuilder based on its advertised features. :param treebuilder_class: A subclass of Treebuilder. its .features attribute should list its features. """ for feature in treebuilder_class.features: self.builders_for_feature[feature].insert(0, treebuilder_class) self.builders.insert(0, treebuilder_class) def lookup(self, *features): """Look 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. """ if len(self.builders) == 0: # There are no builders at all. return None if len(features) == 0: # They didn't ask for any features. Give them the most # recently registered builder. return self.builders[0] # Go down the list of features in order, and eliminate any builders # that don't match every feature. features = list(features) features.reverse() candidates = None candidate_set = None while len(features) > 0: feature = features.pop() we_have_the_feature = self.builders_for_feature.get(feature, []) if len(we_have_the_feature) > 0: if candidates is None: candidates = we_have_the_feature candidate_set = set(candidates) else: # Eliminate any candidates that don't have this feature. candidate_set = candidate_set.intersection( set(we_have_the_feature)) # The only valid candidates are the ones in candidate_set. # Go through the original list of candidates and pick the first one # that's in candidate_set. if candidate_set is None: return None for candidate in candidates: if candidate in candidate_set: return candidate return None # The BeautifulSoup class will take feature lists from developers and use them # to look up builders in this registry. builder_registry = TreeBuilderRegistry() class TreeBuilder(object): """Turn a textual document into a Beautiful Soup object tree.""" NAME = "[Unknown tree builder]" ALTERNATE_NAMES = [] features = [] is_xml = False picklable = False empty_element_tags = None # A tag will be considered an empty-element # tag when and only when it has no contents. # A value for these tag/attribute combinations is a space- or # comma-separated list of CDATA, rather than a single CDATA. DEFAULT_CDATA_LIST_ATTRIBUTES = defaultdict(list) # Whitespace should be preserved inside these tags. DEFAULT_PRESERVE_WHITESPACE_TAGS = set() # The textual contents of tags with these names should be # instantiated with some class other than NavigableString. DEFAULT_STRING_CONTAINERS = {} USE_DEFAULT = object() # Most parsers don't keep track of line numbers. TRACKS_LINE_NUMBERS = False def __init__(self, multi_valued_attributes=USE_DEFAULT, preserve_whitespace_tags=USE_DEFAULT, store_line_numbers=USE_DEFAULT, string_containers=USE_DEFAULT, ): """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. """ self.soup = None if multi_valued_attributes is self.USE_DEFAULT: multi_valued_attributes = self.DEFAULT_CDATA_LIST_ATTRIBUTES self.cdata_list_attributes = multi_valued_attributes if preserve_whitespace_tags is self.USE_DEFAULT: preserve_whitespace_tags = self.DEFAULT_PRESERVE_WHITESPACE_TAGS self.preserve_whitespace_tags = preserve_whitespace_tags if store_line_numbers == self.USE_DEFAULT: store_line_numbers = self.TRACKS_LINE_NUMBERS self.store_line_numbers = store_line_numbers if string_containers == self.USE_DEFAULT: string_containers = self.DEFAULT_STRING_CONTAINERS self.string_containers = string_containers def initialize_soup(self, soup): """The BeautifulSoup object has been initialized and is now being associated with the TreeBuilder. :param soup: A BeautifulSoup object. """ self.soup = soup def reset(self): """Do any work necessary to reset the underlying parser for a new document. By default, this does nothing. """ pass def can_be_empty_element(self, tag_name): """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. """ if self.empty_element_tags is None: return True return tag_name in self.empty_element_tags def feed(self, markup): """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. """ raise NotImplementedError() def prepare_markup(self, markup, user_specified_encoding=None, document_declared_encoding=None, exclude_encodings=None): """Run 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. """ yield markup, None, None, False def test_fragment_to_document(self, fragment): """Wrap 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. """ return fragment def set_up_substitutions(self, tag): """Set 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. """ return False def _replace_cdata_list_attribute_values(self, tag_name, attrs): """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. """ if not attrs: return attrs if self.cdata_list_attributes: universal = self.cdata_list_attributes.get('*', []) tag_specific = self.cdata_list_attributes.get( tag_name.lower(), None) for attr in list(attrs.keys()): if attr in universal or (tag_specific and attr in tag_specific): # We have a "class"-type attribute whose string # value is a whitespace-separated list of # values. Split it into a list. value = attrs[attr] if isinstance(value, str): values = nonwhitespace_re.findall(value) else: # html5lib sometimes calls setAttributes twice # for the same tag when rearranging the parse # tree. On the second call the attribute value # here is already a list. If this happens, # leave the value alone rather than trying to # split it again. values = value attrs[attr] = values return attrs class SAXTreeBuilder(TreeBuilder): """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. """ def feed(self, markup): raise NotImplementedError() def close(self): pass def startElement(self, name, attrs): attrs = dict((key[1], value) for key, value in list(attrs.items())) #print("Start %s, %r" % (name, attrs)) self.soup.handle_starttag(name, attrs) def endElement(self, name): #print("End %s" % name) self.soup.handle_endtag(name) def startElementNS(self, nsTuple, nodeName, attrs): # Throw away (ns, nodeName) for now. self.startElement(nodeName, attrs) def endElementNS(self, nsTuple, nodeName): # Throw away (ns, nodeName) for now. self.endElement(nodeName) #handler.endElementNS((ns, node.nodeName), node.nodeName) def startPrefixMapping(self, prefix, nodeValue): # Ignore the prefix for now. pass def endPrefixMapping(self, prefix): # Ignore the prefix for now. # handler.endPrefixMapping(prefix) pass def characters(self, content): self.soup.handle_data(content) def startDocument(self): pass def endDocument(self): pass class HTMLTreeBuilder(TreeBuilder): """This TreeBuilder knows facts about HTML. Such as which tags are empty-element tags. """ empty_element_tags = set([ # These are from HTML5. 'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'keygen', 'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr', # These are from earlier versions of HTML and are removed in HTML5. 'basefont', 'bgsound', 'command', 'frame', 'image', 'isindex', 'nextid', 'spacer' ]) # The HTML standard defines these as block-level elements. Beautiful # Soup does not treat these elements differently from other elements, # but it may do so eventually, and this information is available if # you need to use it. block_elements = set(["address", "article", "aside", "blockquote", "canvas", "dd", "div", "dl", "dt", "fieldset", "figcaption", "figure", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "header", "hr", "li", "main", "nav", "noscript", "ol", "output", "p", "pre", "section", "table", "tfoot", "ul", "video"]) # These HTML tags need special treatment so they can be # represented by a string class other than NavigableString. # # For some of these tags, it's because the HTML standard defines # an unusual content model for them. I made this list by going # through the HTML spec # (https://html.spec.whatwg.org/#metadata-content) and looking for # "metadata content" elements that can contain strings. # # The Ruby tags (<rt> and <rp>) are here despite being normal # "phrasing content" tags, because the content they contain is # qualitatively different from other text in the document, and it # can be useful to be able to distinguish it. # # TODO: Arguably <noscript> could go here but it seems # qualitatively different from the other tags. DEFAULT_STRING_CONTAINERS = { 'rt' : RubyTextString, 'rp' : RubyParenthesisString, 'style': Stylesheet, 'script': Script, 'template': TemplateString, } # The HTML standard defines these attributes as containing a # space-separated list of values, not a single value. That is, # class="foo bar" means that the 'class' attribute has two values, # 'foo' and 'bar', not the single value 'foo bar'. When we # encounter one of these attributes, we will parse its value into # a list of values if possible. Upon output, the list will be # converted back into a string. DEFAULT_CDATA_LIST_ATTRIBUTES = { "*" : ['class', 'accesskey', 'dropzone'], "a" : ['rel', 'rev'], "link" : ['rel', 'rev'], "td" : ["headers"], "th" : ["headers"], "td" : ["headers"], "form" : ["accept-charset"], "object" : ["archive"], # These are HTML5 specific, as are *.accesskey and *.dropzone above. "area" : ["rel"], "icon" : ["sizes"], "iframe" : ["sandbox"], "output" : ["for"], } DEFAULT_PRESERVE_WHITESPACE_TAGS = set(['pre', 'textarea']) def set_up_substitutions(self, tag): """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. """ # We are only interested in <meta> tags if tag.name != 'meta': return False http_equiv = tag.get('http-equiv') content = tag.get('content') charset = tag.get('charset') # We are interested in <meta> tags that say what encoding the # document was originally in. This means HTML 5-style <meta> # tags that provide the "charset" attribute. It also means # HTML 4-style <meta> tags that provide the "content" # attribute and have "http-equiv" set to "content-type". # # In both cases we will replace the value of the appropriate # attribute with a standin object that can take on any # encoding. meta_encoding = None if charset is not None: # HTML 5 style: # <meta charset="utf8"> meta_encoding = charset tag['charset'] = CharsetMetaAttributeValue(charset) elif (content is not None and http_equiv is not None and http_equiv.lower() == 'content-type'): # HTML 4 style: # <meta http-equiv="content-type" content="text/html; charset=utf8"> tag['content'] = ContentMetaAttributeValue(content) return (meta_encoding is not None) class DetectsXMLParsedAsHTML(object): """A 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. """ # Regular expression for seeing if markup has an <html> tag. LOOKS_LIKE_HTML = re.compile("<[^ +]html", re.I) LOOKS_LIKE_HTML_B = re.compile(b"<[^ +]html", re.I) XML_PREFIX = '<?xml' XML_PREFIX_B = b'<?xml' @classmethod def warn_if_markup_looks_like_xml(cls, markup, stacklevel=3): """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. """ if isinstance(markup, bytes): prefix = cls.XML_PREFIX_B looks_like_html = cls.LOOKS_LIKE_HTML_B else: prefix = cls.XML_PREFIX looks_like_html = cls.LOOKS_LIKE_HTML if (markup is not None and markup.startswith(prefix) and not looks_like_html.search(markup[:500]) ): cls._warn(stacklevel=stacklevel+2) return True return False @classmethod def _warn(cls, stacklevel=5): """Issue a warning about XML being parsed as HTML.""" warnings.warn( XMLParsedAsHTMLWarning.MESSAGE, XMLParsedAsHTMLWarning, stacklevel=stacklevel ) def _initialize_xml_detector(self): """Call this method before parsing a document.""" self._first_processing_instruction = None self._root_tag = None def _document_might_be_xml(self, processing_instruction): """Call this method when encountering an XML declaration, or a "processing instruction" that might be an XML declaration. """ if (self._first_processing_instruction is not None or self._root_tag is not None): # The document has already started. Don't bother checking # anymore. return self._first_processing_instruction = processing_instruction # We won't know until we encounter the first tag whether or # not this is actually a problem. def _root_tag_encountered(self, name): """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. """ if self._root_tag is not None: # This method was incorrectly called multiple times. Do # nothing. return self._root_tag = name if (name != 'html' and self._first_processing_instruction is not None and self._first_processing_instruction.lower().startswith('xml ')): # We encountered an XML declaration and then a tag other # than 'html'. This is a reliable indicator that a # non-XHTML document is being parsed as XML. self._warn() def register_treebuilders_from(module): """Copy TreeBuilders from the given module into this module.""" this_module = sys.modules[__name__] for name in module.__all__: obj = getattr(module, name) if issubclass(obj, TreeBuilder): setattr(this_module, name, obj) this_module.__all__.append(name) # Register the builder while we're at it. this_module.builder_registry.register(obj) class ParserRejectedMarkup(Exception): """An Exception to be raised when the underlying parser simply refuses to parse the given markup. """ def __init__(self, message_or_exception): """Explain why the parser rejected the given markup, either with a textual explanation or another exception. """ if isinstance(message_or_exception, Exception): e = message_or_exception message_or_exception = "%s: %s" % (e.__class__.__name__, str(e)) super(ParserRejectedMarkup, self).__init__(message_or_exception) # Builders are registered in reverse order of priority, so that custom # builder registrations will take precedence. In general, we want lxml # to take precedence over html5lib, because it's faster. And we only # want to use HTMLParser as a last resort. from . import _htmlparser register_treebuilders_from(_htmlparser) try: from . import _html5lib register_treebuilders_from(_html5lib) except ImportError: # They don't have html5lib installed. pass try: from . import _lxml register_treebuilders_from(_lxml) except ImportError: # They don't have lxml installed. pass PK z�ZZg�*` *` $ __pycache__/__init__.cpython-310.pycnu �[��� o �h � � @ sd d Z dZdZdZdZdgZddlmZ ddlZddl Z ddl Z ddl Z ddl Z e j jd k r1ed ��d d lmZmZmZmZ d d lmZ d dlmZmZmZmZm Z m Z m Z m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z' G dd� de(�Z)G dd� de(�Z*G dd� de&�Z+e+Z,e+Z-G dd� de+�Z.G dd� de/�Z0G dd� de1�Z2e3dkr�ddl Z e+e j4�Z5e6e5�7� � dS dS )aK Beautiful Soup Elixir and Tonic - "The Screen-Scraper's Friend". http://www.crummy.com/software/BeautifulSoup/ Beautiful Soup uses a pluggable XML or HTML parser to parse a (possibly invalid) document into a tree representation. Beautiful Soup provides methods and Pythonic idioms that make it easy to navigate, search, and modify the parse tree. Beautiful Soup works with Python 3.6 and up. It works better if lxml and/or html5lib is installed. For more than you ever wanted to know about Beautiful Soup, see the documentation: http://www.crummy.com/software/BeautifulSoup/bs4/doc/ z*Leonard Richardson (leonardr@segfault.org)z4.12.3z*Copyright (c) 2004-2024 Leonard Richardson�MIT� BeautifulSoup� )�CounterN� z�You are trying to use a Python 3-specific version of Beautiful Soup under Python 2. This will not work. The final version of Beautiful Soup to support Python 2 was 4.9.3.� )�builder_registry�ParserRejectedMarkup�XMLParsedAsHTMLWarning�HTMLParserTreeBuilder)� UnicodeDammit)�CData�Comment�CSS�DEFAULT_OUTPUT_ENCODING� Declaration�Doctype�NavigableString� PageElement�ProcessingInstruction�PYTHON_SPECIFIC_ENCODINGS� ResultSet�Script� Stylesheet� SoupStrainer�Tag�TemplateStringc @ � e Zd ZdZdS )�GuessedAtParserWarningz�The warning issued when BeautifulSoup has to guess what parser to use -- probably because no parser was specified in the constructor. N��__name__� __module__� __qualname__�__doc__� r# r# �?/usr/local/CyberCP/lib/python3.10/site-packages/bs4/__init__.pyr @ � r c @ r )� MarkupResemblesLocatorWarningz�The warning issued when BeautifulSoup is given 'markup' that actually looks like a resource locator -- a URL or a path to a file on disk. Nr r# r# r# r$ r& E r% r& c s( e Zd ZdZdZddgZdZdZ d<d d �Zd d � Z d d� Z dd� Z e dd� �Z e dd� �Ze dd� �Zdd� Zdd� Zddi ddfdd �Zd=d d �Zd=d d �Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd=d)d*�Zd>d+d,�Zd-d.� Zd?d0d1�Z d@d2d3�Z d=d4d5�Z d6d7� Z d8e d9df� fd:d;� Z!� Z"S )Ar a� A data structure representing a parsed HTML or XML document. Most of the methods you'll call on a BeautifulSoup object are inherited from PageElement or Tag. Internally, this class defines the basic interface called by the tree builders when converting an HTML/XML document into a data structure. The interface abstracts away the differences between parsers. To write a new tree builder, you'll need to understand these methods as a whole. These methods will be called by the BeautifulSoup constructor: * reset() * feed(markup) The tree builder may call these methods from its feed() implementation: * handle_starttag(name, attrs) # See note about return value * handle_endtag(name) * handle_data(data) # Appends to the current data node * endData(containerClass) # Ends the current data node No matter how complicated the underlying parser is, you should be able to build a tree using 'start tag' events, 'end tag' events, 'data' events, and "done with data" events. If you encounter an empty-element tag (aka a self-closing tag, like HTML's <br> tag), call handle_starttag and then handle_endtag. z [document]�html�fastz a� No parser was explicitly specified, so I'm using the best available %(markup_type)s parser for this system ("%(parser)s"). This usually isn't a problem, but if you run this code on another system, or in a different virtual environment, it may use a different parser and behave differently. The code that caused this warning is on line %(line_number)s of the file %(filename)s. To get rid of this warning, pass the additional argument 'features="%(parser)s"' to the BeautifulSoup constructor. � Nc s~ d� v r � d= t �d� d� v r� d= t �d� d� v r$� d= t �d� d� v r0� d= t �d� d � v r<� d = t �d � � fd d �} |pH| d d�}|pO| dd�}|r^t|t�r^t �d� d}|pbt� | _|} |} t|t�rr|} d}n+|du r�t|t�r~|g}|du s�t|�dkr�| j}t j |� } | du r�t dd� |� ��|du �r| d+i � ��}| �s| |j k�s| |jv �s|�r|jr�d} nd} d}zt�d�}W n ty� Y nw |r�|j}|j}ntj}d}|�d�}|r�|�� }|�d�r�|dd� }|�rt|||j | d �}t j| j| td d � n� �rt �d � || _|j| _| j| _ t� | _ || _ t |d ��r7|� � }n(t|�d!k�r_t|t!��rId"|v�sTt|t��r_d#|v�r_| �"|��s_| �#|� g }d$}| jj$|||d%�D ]6\| _%| _&| _'| _(| �)� | j�*| � z | �+� d&}W n t,�y� } z |�-|� W Y d}~�qld}~ww |�s�d'd(� |D �}t,d)d*� |� ��d| _%d| j_.dS ),a Constructor. :param markup: A string or a file-like object representing markup to be parsed. :param features: Desirable features of the parser to be used. This may be the name of a specific parser ("lxml", "lxml-xml", "html.parser", or "html5lib") or it may be the type of markup to be used ("html", "html5", "xml"). It's recommended that you name a specific parser, so that Beautiful Soup gives you the same results across platforms and virtual environments. :param builder: A TreeBuilder subclass to instantiate (or instance to use) instead of looking one up based on `features`. You only need to use this if you've implemented a custom TreeBuilder. :param parse_only: A SoupStrainer. Only parts of the document matching the SoupStrainer will be considered. This is useful when parsing part of a document that would otherwise be too large to fit into memory. :param from_encoding: A string indicating the encoding of the document to be parsed. Pass this in if Beautiful Soup is guessing wrongly about the document's encoding. :param exclude_encodings: A list of strings indicating encodings known to be wrong. Pass this in if you don't know the document's encoding but you know Beautiful Soup's guess is wrong. :param element_classes: A dictionary mapping BeautifulSoup classes like Tag and NavigableString, to other classes you'd like to be instantiated instead as the parse tree is built. This is useful for subclassing Tag or NavigableString to modify default behavior. :param kwargs: For backwards compatibility purposes, the constructor accepts certain keyword arguments used in Beautiful Soup 3. None of these arguments do anything in Beautiful Soup 4; they will result in a warning and then be ignored. Apart from this, any keyword arguments passed into the BeautifulSoup constructor are propagated to the TreeBuilder constructor. This makes it possible to configure a TreeBuilder by passing in arguments, not just by saying which one to use. �convertEntitiesz�BS4 does not respect the convertEntities argument to the BeautifulSoup constructor. Entities are always converted to Unicode characters.� markupMassagez�BS4 does not respect the markupMassage argument to the BeautifulSoup constructor. The tree builder is responsible for any necessary markup massage.� smartQuotesToz�BS4 does not respect the smartQuotesTo argument to the BeautifulSoup constructor. Smart quotes are always converted to Unicode characters.�selfClosingTagsz�BS4 does not respect the selfClosingTags argument to the BeautifulSoup constructor. The tree builder is responsible for understanding self-closing tags.�isHTMLz�BS4 does not respect the isHTML argument to the BeautifulSoup constructor. Suggest you use features='lxml' for HTML and features='lxml-xml' for XML.c s. | � v rt jd| |f tdd� � �| �S d S )NzLThe "%s" argument to the BeautifulSoup constructor has been renamed to "%s."r �� stacklevel)�warnings�warn�DeprecationWarning�pop)�old_name�new_name��kwargsr# r$ �deprecated_argument� s �� z3BeautifulSoup.__init__.<locals>.deprecated_argument�parseOnlyThese� parse_only� fromEncoding� from_encodingzlYou provided Unicode markup but also provided a value for from_encoding. Your from_encoding will be ignored.Nr zjCouldn't find a tree builder with the features you requested: %s. Do you need to install a parser library?�,�XML�HTMLr �__file__)z.pycz.pyo���)�filename� line_number�parser� markup_type� r/ z�Keyword arguments to the BeautifulSoup constructor will be ignored. These would normally be passed into the TreeBuilder constructor, but a TreeBuilder instance was passed in as `builder`.�read� � <�<F)�exclude_encodingsTc S s g | ]}t |��qS r# )�str)�.0�er# r# r$ � <listcomp>W s z*BeautifulSoup.__init__.<locals>.<listcomp>z�The markup you provided was rejected by the parser. Trying a different parser or a different encoding may help. Original exception(s) from parser: z r# )/r1 r2 � isinstancerM �dict�element_classes�type�len�DEFAULT_BUILDER_FEATURESr �lookup�FeatureNotFound�join�NAME�ALTERNATE_NAMES�is_xml�sys� _getframe� ValueError� f_globals�f_lineno�__dict__�get�lower�endswith�NO_PARSER_SPECIFIED_WARNINGr �builder� known_xml� _namespacesr; �hasattrrH �bytes�_markup_is_url�_markup_resembles_filename�prepare_markup�markup�original_encoding�declared_html_encoding� contains_replacement_characters�reset�initialize_soup�_feedr �append�soup)�selfro �featuresrg r; r= rL rS r8 r9 �original_builder�original_features� builder_classrF �caller�globalsrD rC �fnl�values� rejections�successrO �other_exceptionsr# r7 r$ �__init__z s 5����� �� �� � � ��� � � �� �� � zBeautifulSoup.__init__c C s t | �dd| j�}| j|_|S )z�Create a new BeautifulSoup object with the same TreeBuilder, but not associated with any markup. This is the first step of the deepcopy process. r) N)rT rg rp )rx �cloner# r# r$ �_clonea s zBeautifulSoup._clonec C sZ t | j�}d|v r|d d ur| jjst| j�|d< g |d< | �� |d< d|v r+|d= |S )Nrg �contentsro �_most_recent_element)rR rb rg � picklablerT �decode)rx �dr# r# r$ � __getstate__n s zBeautifulSoup.__getstate__c C sH || _ t| jt�r| �� | _n| jst� | _| | j_| �� | �� |S �N)rb rQ rg rT r rw rs ru )rx �stater# r# r$ � __setstate__~ s zBeautifulSoup.__setstate__c C s" t |t�r |�dd�}|S |}|S )z�Ensure `markup` is bytes so it's safe to send into warnings.warn. TODO: warnings.warn had this problem back in 2010 but it might not anymore. zutf-8�replace)rQ rk r� )�clsro �decodedr# r# r$ �_decode_markup� s �z BeautifulSoup._decode_markupc sb t � t�r d}d}n t � t�rd}d}ndS t� fdd�|D ��r/|� vr/tjdtd d � d S dS ) z�Error-handling method to raise a warning if incoming markup looks like a URL. :param markup: A string. :return: Whether or not the markup resembles a URL closely enough to justify a warning. � )s http:s https:� )zhttp:zhttps:Fc 3 � � | ]}� � |�V qd S r� )� startswith)rN �prefix�ro r# r$ � <genexpr>� � � z/BeautifulSoup._markup_is_url.<locals>.<genexpr>z�The input looks more like a URL than markup. You may want to use an HTTP client like requests to get the document behind the URL, and feed that document to Beautiful Soup.r r/ T)rQ rk rM �anyr1 r2 r& )r� ro �space�cant_start_withr# r� r$ rl � s �z BeautifulSoup._markup_is_urlc s� d}g d�}t �t�r|�d�}dd� |D �}d}t�fdd�|D ��r'd }n��� � t� fd d�|D ��r8d }|rDtjd td d � d S dS )a Error-handling method to raise a warning if incoming markup resembles a filename. :param markup: A bytestring or string. :return: Whether or not the markup resembles a filename closely enough to justify a warning. z/\)z.htmlz.htmz.xmlz.xhtmlz.txt�utf8c S s g | ]}|� d ��qS )r� )�encode�rN �xr# r# r$ rP � s z<BeautifulSoup._markup_resembles_filename.<locals>.<listcomp>Fc 3 s � | ]}|� v V qd S r� r# r� r� r# r$ r� � s � z;BeautifulSoup._markup_resembles_filename.<locals>.<genexpr>Tc 3 r� r� )re )rN �ext)rd r# r$ r� � r� z}The input looks more like a filename than markup. You may want to open this file and pass the filehandle into Beautiful Soup.r r/ )rQ rk r� r� rd r1 r2 r& )r� ro �path_characters� extensions�fileliker# )rd ro r$ rm � s$ �z(BeautifulSoup._markup_resembles_filenamec C sL | j �� | j �| j� | �� | jj| jkr$| �� | jj| jksdS dS )zInternal method that parses previously set markup, creating a large number of Tag and NavigableString objects. N) rg rs �feedro �endData� currentTag�name� ROOT_TAG_NAME�popTag�rx r# r# r$ ru � s �zBeautifulSoup._feedc C s^ t �| | | j| j� d| _| j�� g | _d| _g | _t � | _ g | _ g | _ d| _ | �| � dS )zWReset this object to a state as though it had never parsed any markup. r N)r r� rg r� �hiddenrs � current_datar� �tagStackr �open_tag_counter� preserve_whitespace_tag_stack�string_container_stackr� �pushTagr� r# r# r$ rs � s zBeautifulSoup.resetc K s. |� |� | j�tt�d| j||||||d�S )a Create a new Tag associated with this BeautifulSoup object. :param name: The name of the new Tag. :param namespace: The URI of the new Tag's XML namespace, if any. :param prefix: The prefix for the new Tag's XML namespace, if any. :param attrs: A dictionary of this Tag's attribute values; can be used instead of `kwattrs` for attributes like 'class' that are reserved words in Python. :param sourceline: The line number where this tag was (purportedly) found in its source document. :param sourcepos: The character position within `sourceline` where this tag was (purportedly) found. :param kwattrs: Keyword arguments for the new Tag's attribute values. N)� sourceline� sourcepos)�updaterS rc r rg )rx r� � namespace�nsprefix�attrsr� r� �kwattrsr# r# r$ �new_tag� s �zBeautifulSoup.new_tagc C s@ |pt }| j�||�}| jr |t u r | jj�| jd j|�}|S )NrB )r rS rc r� rg �string_containersr� )rx � base_class� containerr# r# r$ �string_container s � �z BeautifulSoup.string_containerc C s | � |�}||�S )zXCreate a new NavigableString associated with this BeautifulSoup object. )r� )rx �s�subclassr� r# r# r$ � new_string s zBeautifulSoup.new_stringc G � t d��)��This method is part of the PageElement API, but `BeautifulSoup` doesn't implement it because there is nothing before or after it in the parse tree. z4BeautifulSoup objects don't support insert_before().��NotImplementedError�rx �argsr# r# r$ � insert_before" � zBeautifulSoup.insert_beforec G r� )r� z3BeautifulSoup objects don't support insert_after().r� r� r# r# r$ � insert_after( r� zBeautifulSoup.insert_afterc C s~ | j �� }|j| jv r| j|j d8 < | jr$|| jd kr$| j�� | jr3|| jd kr3| j�� | j r<| j d | _| jS )z9Internal method called by _popToTag when a tag is closed.r rB )r� r4 r� r� r� r� r� �rx �tagr# r# r$ r� . s zBeautifulSoup.popTagc C s� | j dur | j j�|� | j�|� | jd | _ |j| jkr(| j|j d7 < |j| jjv r5| j �|� |j| jj v rD| j �|� dS dS )z?Internal method called by handle_starttag when a tag is opened.NrB r ) r� r� rv r� r� r� r� rg �preserve_whitespace_tagsr� r� r� r� r# r# r$ r� < s �zBeautifulSoup.pushTagc C s� | j rPd�| j �}| js'd}|D ] }|| jvrd} nq|r'd|v r%d}nd}g | _ | jr@t| j�dkr@| jjr>| j�|�s@dS | � |�}||�}| � |� dS dS )zXMethod called by the TreeBuilder when the end of a data segment occurs. r) TF� r� r N) r� rY r� � ASCII_SPACESr; rU r� �text�searchr� �object_was_parsed)rx �containerClassr� � strippable�i�or# r# r$ r� J s0 �� � �zBeautifulSoup.endDatac C s� |du r| j }|dur|}n| j}d } }}t|t�r,|j}|j}|j}|du r,|j}|jdu}|�|||||� || _|j � |� |rL| � |� dS dS )zLMethod called by the TreeBuilder to integrate an object into the parse tree.N) r� r� rQ r � next_element� next_sibling�previous_sibling�previous_element�setupr� rv �_linkage_fixer) rx r� �parent�most_recent_elementr� r� r� r� �fixr# r# r$ r� l s& �z BeautifulSoup.object_was_parsedc C s� |j d }|j d }|}||u r,|jdur,||_|j}|dur&||ur&d|_||_d|_d|_t|t�r<|j r<|�d�}d|_d|_|} |du rKdS |jdurZ|j|_||j_dS |j}qE)z,Make sure linkage of this fragment is sound.r rB NF) r� r� r� r� r� r� rQ r �_last_descendant)rx �el�first�child� descendant�prev_el�targetr# r# r$ r� � s2 �z BeautifulSoup._linkage_fixerTc C s� || j krdS d}t| j�}t|d dd�D ]'}| j�|�s! |S | j| }||jkr9||jkr9|r6| �� } |S | �� }q|S )a� Pops the tag stack up to and including the most recent instance of the given tag. If there are no open tags with the given name, nothing will be popped. :param name: Pop up to the most recent tag with this name. :param nsprefix: The namespace prefix that goes with `name`. :param inclusivePop: It this is false, pops the tag stack up to but *not* including the most recent instqance of the given tag. Nr r rB ) r� rU r� �ranger� rc r� r� r� )rx r� r� � inclusivePop�most_recently_popped� stack_sizer� �tr# r# r$ � _popToTag� s � �zBeautifulSoup._popToTagc C s� | � � | jrt| j�dkr| jjs| j�||�sdS | j�tt�| | j ||||| j | j |||d� }|du r8|S | j durA|| j _ || _ | � |� |S )a Called by the tree builder when a new tag is encountered. :param name: Name of the tag. :param nsprefix: Namespace prefix for the tag. :param attrs: A dictionary of attribute values. :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 namespaces: A dictionary of all namespace prefix mappings currently in scope in the document. If this method returns None, the tag was rejected by an active SoupStrainer. You should proceed as if the tag had not occurred in the document. For instance, if this was a self-closing tag, don't call handle_endtag. r N)r� r� � namespaces)r� r; rU r� r� � search_tagrS rc r rg r� r� r� r� ) rx r� r� r� r� r� r� r� r� r# r# r$ �handle_starttag� s( � � � z BeautifulSoup.handle_starttagc C s | � � | �||� dS )z�Called by the tree builder when an ending tag is encountered. :param name: Name of the tag. :param nsprefix: Namespace prefix for the tag. N)r� r� )rx r� r� r# r# r$ � handle_endtag� s zBeautifulSoup.handle_endtagc C s | j �|� dS )zGCalled by the tree builder when a chunk of textual data is encountered.N)r� rv )rx �datar# r# r$ � handle_data s zBeautifulSoup.handle_dataF�minimalc s\ | j rd}|tv r d}|dkrd| }d| }nd}|s d}nd}|tt| ��||||� S )ao Returns a string or Unicode representation of the parse tree as an HTML or XML document. :param pretty_print: If this is True, indentation will be used to make the document more readable. :param eventual_encoding: The encoding of the final document. If this is None, the document will be a Unicode string. r) Nz encoding="%s"z<?xml version="1.0"%s?> r )r\ r �superr r� )rx � pretty_print�eventual_encoding� formatter�iterator� encoding_partr� � indent_level�� __class__r# r$ r� s �zBeautifulSoup.decode)r) NNNNNNr� )NN)NT)NNN)#r r r! r" r� rV r� rf r� r� r� r� � classmethodr� rl rm ru rs r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r� � __classcell__r# r# r� r$ r L sX ! � h � " (" � ) �c s e Zd ZdZ� fdd�Z� ZS )�BeautifulStoneSoupz&Deprecated interface to an XML parser.c s2 d|d< t jdtdd� tt| �j|i |�� d S )N�xmlry zxThe BeautifulStoneSoup class is deprecated. Instead of using it, pass features="xml" into the BeautifulSoup constructor.rG r/ )r1 r2 r3 r� r r� )rx r� r8 r� r# r$ r� / s �zBeautifulStoneSoup.__init__)r r r! r" r� r r# r# r� r$ r , s r c @ r )� StopParsingzEException raised by a TreeBuilder if it's unable to continue parsing.Nr r# r# r# r$ r 9 s r c @ r )rX zmException raised by the BeautifulSoup constructor if no parser with the requested features is found. Nr r# r# r# r$ rX = s rX �__main__)8r" � __author__� __version__� __copyright__� __license__�__all__� collectionsr �os�rer] � tracebackr1 � version_info�major� ImportErrorrg r r r r �dammitr �elementr r r r r r r r r r r r r r r r � UserWarningr r& r �_s�_soupr � Exceptionr r_ rX r �stdinrw �print�prettifyr# r# r# r$ �<module> sF H b �PK z�Z��& �& __pycache__/css.cpython-310.pycnu �[��� o �h]' � @ s` d Z ddlZzddlZW n ey% Z z dZe�d� W Y dZ[ndZ[ww G dd� de�ZdS )zFIntegration code for CSS selectors using Soup Sieve (pypi: soupsieve).� NzEThe soupsieve package is not installed. CSS selectors cannot be used.c @ sz e Zd ZdZefdd�Zdd� Zdd� Zdd � Zdd d �Z ddd�Z ddd�Z ddd�Z ddd�Z ddd�Zddd�Zd S ) �CSSa� A proxy object against the soupsieve library, to simplify its CSS selector API. Acquire this object through the .css attribute on the BeautifulSoup object, or on the Tag you want to use as the starting point for a CSS selector. The main advantage of doing this is that the tag to be selected against doesn't need to be explicitly specified in the function calls, since it's already scoped to a tag. c C s |du rt d��|| _|| _dS )a� Constructor. You don't need to instantiate this class yourself; instead, access the .css attribute on the BeautifulSoup object, or on the Tag you want to use as the starting point for your CSS selector. :param tag: All CSS selectors will use this as their starting point. :param api: A plug-in replacement for the soupsieve module, designed mainly for use in tests. NzLCannot execute CSS selectors because the soupsieve package is not installed.)�NotImplementedError�api�tag)�selfr r � r �:/usr/local/CyberCP/lib/python3.10/site-packages/bs4/css.py�__init__ s � z CSS.__init__c C s t du rtd��| j�|�S )z�Escape a CSS identifier. This is a simple wrapper around soupselect.escape(). See the documentation for that function for more information. NzMCannot escape CSS identifiers because the soupsieve package is not installed.)� soupsiever r �escape)r �identr r r r / s � z CSS.escapec C s" t || jj�s|du r| jj}|S )z%Normalize a dictionary of namespaces.N)� isinstancer � SoupSiever � _namespaces)r �ns�selectr r r �_ns; s zCSS._nsc C s ddl m} |d|�S )a Normalize a list of results to a Resultset. A ResultSet is more consistent with the rest of Beautiful Soup's API, and ResultSet.__getattr__ has a helpful error message if you try to treat a list of results as a single result (a common mistake). r )� ResultSetN)� bs4.elementr )r �resultsr r r r �_rsD s zCSS._rsNr c K s | j j|| �||�|fi |��S )a~ Pre-compile a selector and return the compiled object. :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 flags: Flags to be passed into Soup Sieve's soupsieve.compile() method. :param kwargs: Keyword arguments to be passed into SoupSieve's soupsieve.compile() method. :return: A precompiled selector object. :rtype: soupsieve.SoupSieve )r �compiler �r r � namespaces�flags�kwargsr r r r P s ��z CSS.compilec K �$ | j j|| j| �||�|fi |��S )aK Perform a CSS selection operation on the current Tag and return the first result. This uses the Soup Sieve library. For more information, see that library's documentation for the soupsieve.select_one() method. :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 flags: Flags to be passed into Soup Sieve's soupsieve.select_one() method. :param kwargs: Keyword arguments to be passed into SoupSieve's soupsieve.select_one() method. :return: A Tag, or None if the selector has no match. :rtype: bs4.element.Tag )r � select_oner r r r r r r g s ��zCSS.select_onec K s8 |du rd}| � | jj|| j| �||�||fi |���S )aw Perform a CSS selection operation on the current Tag. This uses the Soup Sieve library. For more information, see that library's documentation for the soupsieve.select() method. :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 pass in the prefixes it encountered while parsing the document. :param limit: After finding this number of results, stop looking. :param flags: Flags to be passed into Soup Sieve's soupsieve.select() method. :param kwargs: Keyword arguments to be passed into SoupSieve's soupsieve.select() method. :return: A ResultSet of Tag objects. :rtype: bs4.element.ResultSet Nr )r r r r r �r r r �limitr r r r r r � s ���z CSS.selectc K s& | j j|| j| �||�||fi |��S )a� Perform a CSS selection operation on the current Tag. This uses the Soup Sieve library. For more information, see that library's documentation for the soupsieve.iselect() method. It is the same as select(), but it returns a generator instead of a list. :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 pass in the prefixes it encountered while parsing the document. :param limit: After finding this number of results, stop looking. :param flags: Flags to be passed into Soup Sieve's soupsieve.iselect() method. :param kwargs: Keyword arguments to be passed into SoupSieve's soupsieve.iselect() method. :return: A generator :rtype: types.GeneratorType )r �iselectr r r r r r r � s ��z CSS.iselectc K r )a6 Find the Tag closest to this one that matches the given selector. This uses the Soup Sieve library. For more information, see that library's documentation for the soupsieve.closest() method. :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 pass in the prefixes it encountered while parsing the document. :param flags: Flags to be passed into Soup Sieve's soupsieve.closest() method. :param kwargs: Keyword arguments to be passed into SoupSieve's soupsieve.closest() method. :return: A Tag, or None if there is no match. :rtype: bs4.Tag )r �closestr r r r r r r! � s ��z CSS.closestc K r )a Check whether this Tag matches the given CSS selector. This uses the Soup Sieve library. For more information, see that library's documentation for the soupsieve.match() method. :param: a CSS selector. :param namespaces: A dictionary mapping namespace prefixes used in the CSS selector to namespace URIs. By default, Beautiful Soup will pass in the prefixes it encountered while parsing the document. :param flags: Flags to be passed into Soup Sieve's soupsieve.match() method. :param kwargs: Keyword arguments to be passed into SoupSieve's soupsieve.match() method. :return: True if this Tag matches the selector; False otherwise. :rtype: bool )r �matchr r r r r r r" � s ��z CSS.matchc K s* | � | jj|| j| �||�|fi |���S )aW Filter this Tag's direct children based on the given CSS selector. This uses the Soup Sieve library. It works the same way as passing this Tag into that library's soupsieve.filter() method. More information, for more information see the documentation for soupsieve.filter(). :param namespaces: A dictionary mapping namespace prefixes used in the CSS selector to namespace URIs. By default, Beautiful Soup will pass in the prefixes it encountered while parsing the document. :param flags: Flags to be passed into Soup Sieve's soupsieve.filter() method. :param kwargs: Keyword arguments to be passed into SoupSieve's soupsieve.filter() method. :return: A ResultSet of Tag objects. :rtype: bs4.element.ResultSet )r r �filterr r r r r r r# � s ���z CSS.filter)Nr )Nr r )�__name__� __module__� __qualname__�__doc__r r r r r r r r r r! r" r# r r r r r s $ r )r' �warningsr � ImportError�e�warn�objectr r r r r �<module> s ���PK z�Z�RI�Z Z % __pycache__/formatter.cpython-310.pycnu �[��� o �h � @ s� d dl mZ G dd� de�ZG dd� de�ZG dd� de�Zeejd�ejd < eejd d d �ejd < eejd�ejd< ed d�ejd < eejd�ejd < eejd�ejd< eeejd d��ejd < d S )� )�EntitySubstitutionc @ sb e Zd ZdZi Zi ZdZdZee ddg�d�Z dd� Z dd d�Z dd� Z dd� Zdd� Zd S )� 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 `PageElement.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. * '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�xml�script�style)�cdata_containing_tagsc C s& |d ur|S || j krt� S | j| S �N)�XML�set� HTML_DEFAULTS)�self�language�value�kwarg� r �@/usr/local/CyberCP/lib/python3.10/site-packages/bs4/formatter.py�_default* s zFormatter._defaultN�/F� c C sr || _ || _|| _| �||d�| _|| _|du rd}t|t�r*|dk r%d}d| }n t|t�r2|}nd}|| _ dS )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 list 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 blank_attributes_are_booleans: Render attributes whose value is the empty string as HTML-style 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 �entity_substitution�void_element_close_prefixr r � empty_attributes_are_booleans� isinstance�int�str�indent)r r r r r r r r r r �__init__1 s" !� zFormatter.__init__c C sF | j s|S ddlm} t||�r |jdur |jj| jv r |S | � |�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: A string with certain characters replaced by named or numeric entities. r )�NavigableStringN)r �elementr r �parent�namer )r �nsr r r r � substitutee s zFormatter.substitutec C s | � |�S )z�Process the value of an attribute. :param ns: A string. :return: A string with certain characters replaced by named or numeric entities. )r$ )r r r r r �attribute_valuey s zFormatter.attribute_valuec s. |j du rg S t� fdd�t|j �� �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_boolean_attributes` is True, then attributes whose values are set to the empty string will be treated as boolean attributes. Nc 3 s. � | ]\}}|� j r|d krdn|fV qdS )� N)r )�.0�k�v�r r r � <genexpr>� s � � �z'Formatter.attributes.<locals>.<genexpr>)�attrs�sorted�list�items)r �tagr r* r � attributes� s �zFormatter.attributes)NNr NFr )�__name__� __module__� __qualname__�__doc__�XML_FORMATTERS�HTML_FORMATTERS�HTMLr �dictr r r r r$ r% r1 r r r r r s" � �4 r c �$ e Zd ZdZi Z� fdd�Z� ZS )� HTMLFormatterz A generic Formatter for HTML.c �$ t t| �j| jg|�R i |�� d S r )�superr; r r8 �r �args�kwargs�� __class__r r r � � $zHTMLFormatter.__init__�r2 r3 r4 r5 �REGISTRYr � __classcell__r r rA r r; � � r; c r: )� XMLFormatterz A generic Formatter for XML.c r< r )r= rH r r r> rA r r r � rC zXMLFormatter.__init__rD r r rA r rH � rG rH )r r NT)r r r �html5�minimal) � bs4.dammitr r r; rH �substitute_htmlrE �substitute_xmlr r r r r �<module> s8 � � � � � � �PK z�Z�69�� � # __pycache__/element.cpython-310.pycnu �[��� o �h�j � @ s d Z zddlmZ W n ey" Z z ddlmZ W Y dZ[ndZ[ww ddlZddlZddlZddl m Z ddl m Z m Z mZ dZe�d�Ze�d�Zd d � Zeg d ��ZG d d � d e�ZG dd� de�ZG dd� de�ZG dd� de�ZG dd� de�Z G dd� dee �Z G dd� de �Z G dd� de �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(d)� d)e �Z&G d*d+� d+e �Z'G d,d-� d-e �Z(G d.d/� d/e �Z)G d0d1� d1e �Z*G d2d3� d3e�Z+G d4d5� d5e,�Z-dS )6�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 � t | � �S �N��getattr��self��attr� �>/usr/local/CyberCP/lib/python3.10/site-packages/bs4/element.py�alias � z_alias.<locals>.aliasc r r )�setattrr r r r r ! r )�property�setter)r r r r r �_alias s r ) �idna�mbcs�oem�palmos�punycode�raw_unicode_escape� undefined�unicode_escapezraw-unicode-escape�unicode-escapez string-escape� string_escapec @ s e Zd ZdZddd�ZdS )�NamespacedAttributez�A 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 }|s t �| |�}n|st �| |�}n t �| |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 @ � e Zd ZdZdS )�%AttributeValueWithCharsetSubstitutionz=A stand-in object for a character encoding specified in HTML.N�r- r. r/ r0 r r r r r2 [ s r2 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* r5 r+ r r r r& e s z!CharsetMetaAttributeValue.__new__c C s |t v rdS |S )z�When 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/ r0 r& r: r r r r r4 ^ s r4 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 u rt�t|�S t�| |�}||_|S r )� CHARSET_RE�searchr% r& r5 )r* r5 �matchr+ r r r r& ~ s z!ContentMetaAttributeValue.__new__c s( � t v rdS � fdd�}| j�|| j�S )Nr6 c s | � d�� S )N� )�group)r> �r9 r r �rewrite� s z1ContentMetaAttributeValue.encode.<locals>.rewrite)r7 r< �subr5 )r r9 rB r rA r r: � s z ContentMetaAttributeValue.encodeN) r- r. r/ r0 �re�compile�Mr< r& r: r r r r r; s s r; c @ sd e Zd ZdZdZ d\dd�Zdd� Zdd� Zed d � �Z e d �Z e d �Z e � Zd efdd�Zedd� �Zdd efdd�ZeZee�Zdd� 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 ddfd0d1�Z(e(Z)e(Z*di dfd2d3�Z+e+Z,di ddfd4d5�Z-e-Z.e-Z/di dfd6d7�Z0e0Z1di ddfd8d9�Z2e2Z3e2Z4di 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� || _ || _|dur| | j_|| _| jdur| | j_|| _| jdur&| | j_|du r9| j dur9| j jr9| j jd }|| _|durF| | j_dS 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 rI rJ rK rM rL r r r �setup� s" �zPageElement.setupc C s. |du r|S t |t�s| �|�}|�|�}|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 |t�r|S | jr t}nt}t |t�r||d�S |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. )�entity_substitution)rP r �_is_xmlr r r �REGISTRY)r rT �cr r r rQ � s z PageElement.formatter_for_namec C s. | j dur| j S | jdu rt| dd�S | 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_xmlrI r rX r r r r rX � s zPageElement._is_xmlrL rM Fc C s t � �)z�Yield all strings of certain classes, possibly stripping them. This is implemented differently in Tag and NavigableString. )�NotImplementedError)r �strip�typesr r r � _all_strings s zPageElement._all_stringsc c s � | � d�D ]}|V qdS )zvYield all strings in this PageElement, stripping them first. :yield: A sequence of stripped strings. TN)r` �r �stringr r r �stripped_strings s ��z PageElement.stripped_stringsr6 c C s |� dd� | j||d�D ��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 )�.0rS r r r � <listcomp>$ s z(PageElement.get_text.<locals>.<listcomp>)r_ )�joinr` )r � separatorr^ r_ r r r �get_text s �zPageElement.get_textc s� � j du r td��t|�dkr|d � u rdS t� fdd�|D ��r&td��� j }� j �� �}� j|d� t||d �D ] \}}|�||� q;� 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.r? r c 3 s � | ]}|� j u V qd S r �rI �rd �xr r r � <genexpr>6 s � z+PageElement.replace_with.<locals>.<genexpr>z%Cannot replace a Tag with its parent.�� _self_index)�start)rI � ValueError�len�any�index�extract� enumerate�insert)r �args� old_parent�my_index�idx� replace_withr r r r{ ) s � zPageElement.replace_withc C sX | j }| j du r td��| j �| �}| j|d� t| jdd� �D ]}|�||� q!| 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.rm )rI rp rs rt �reversedrN rv )r � my_parentry �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. )r{ �append)r � wrap_inside�mer r r �wrapR s zPageElement.wrapc C s� | j dur|du r| j �| �}| j j|= | �� }|j}| jdur)| j|ur)|| j_|dur6|| jur6| j|_d| _d|_d| _ | jdurO| j| jurO| j| j_| jdur_| j| jur_| 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)rI rs rN �_last_descendantrK rJ rM rL )r rn � last_childrK r r r rt ] s, zPageElement.extractTc C sZ |r | j dur | j j}n| }t|t�r#|jr#|jd }t|t�r#|js|s+|| u r+d}|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? NrH )rL rJ rP �TagrN )r �is_initialized� accept_selfr� r r r r� � s � z PageElement._last_descendantc C s� |du rt d��|| u rt d��t|t�r t|t�s t|�}ddlm} t||�r=t|j�D ] }| �||� |d7 }q.dS t |t | j��}t |d�re|j dure|j | u ra| � |�}||k ra|d8 }|�� | |_ d}|dkrud|_| |_n| j|d }||_||j_|�d�|_|jdur�||j_|�d�}|t | j�kr�d|_| }d} | du r�|dur�|j} |j }| dur�n| du r�|dus�| dur�| |_nd|_n| j| } | |_|jdur�||j_| |_|jdur�||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 )� BeautifulSoupr? rI F)rp rP r% �NavigableString�bs4r� �listrN rv �minrq �hasattrrI rs rt rM rJ rL r� rK ) r �position� new_childr� �subchild� current_index�previous_child�new_childs_last_elementrI �parents_next_sibling� next_childr r r rv � sl � � zPageElement.insertc C s | � t| j�|� dS )zgAppends the given PageElement to the contents of this one. :param tag: A PageElement. N)rv rq rN )r �tagr r r r� � s zPageElement.appendc C s: t |t�r|j}t |t�rt|�}|D ]}| �|� qdS )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)rP r� rN r� r� )r �tagsr� r r r �extend� s �zPageElement.extendc sj � j }|du r td��t� fdd�|D ��rtd��|D ]}t|t�r'|�� |�� �}|�||� q dS )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 � � | ]}|� u V qd S r r rj r r r rl � � z,PageElement.insert_before.<locals>.<genexpr>z&Can't insert an element before itself.�rI rp rr rP rG rt rs rv )r rw rI � predecessorrs r r r � insert_before� s � �zPageElement.insert_beforec s~ � j }|du r td��t� fdd�|D ��rtd��d}|D ] }t|t�r)|�� |�� �}|�|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 r� r r rj r r r rl " r� z+PageElement.insert_after.<locals>.<genexpr>z%Can't insert an element after itself.r r? r� )r rw rI �offset� successorrs r r r � insert_after s � �zPageElement.insert_afterc K � | j | j|||fi |��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( �attrsrb �kwargsr r r � find_next/ s zPageElement.find_nextc K �0 |� 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� r? )�pop� _find_all� next_elements�r r( r� rb �limitr� r� r r r r� @ s ��zPageElement.find_all_nextc K r� )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 � �z PageElement.find_next_siblingc K r� )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� r? )r� r� � next_siblingsr� r r r r� f � ���z PageElement.find_next_siblingsc K r� )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 r� )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� r? )r� r� �previous_elementsr� r r r r� � s ���z PageElement.find_all_previousc K r� )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� r� z!PageElement.find_previous_siblingc K r� )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� r? )r� r� �previous_siblingsr� r r r r� � r� 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 Nr? 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� Nr? )r� r� �parents)r r( r� r� r� r� r r r r� � s ��zPageElement.find_parentsc C � | j S )z�The PageElement, if any, that was parsed just after this one. :return: A PageElement. :rtype: bs4.element.Tag | bs4.element.NavigableString �rK r r r r �next� � zPageElement.nextc C r� )z�The PageElement, if any, that was parsed just before this one. :return: A PageElement. :rtype: bs4.element.Tag | bs4.element.NavigableString �rJ r r r r �previous r� zPageElement.previousc K s. d }||||dfddi|��}|r|d }|S )Nr? r� � r r )r �methodr( r� rb r� r� r� r r r r� s zPageElement._find_onec sH |� dd�}|du rd|v r|� d�}tjdt|d� t�t�r#�}n t�||fi |��}|du rt|st|st|st�du s?�du rKdd � |D �} t|| �S t�t�rt��d �d kr`�� d d �\�� nd��� � ��fd d �|D �} t|| �S t|�} zt |�} W n t y� Y | S w | r�|� | �} | r�| � | � |r�t| �|kr� | S qy) 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 |t�r|V qd S r )rP r� �rd �elementr r r rl + s � �z(PageElement._find_all.<locals>.<genexpr>r$ r? c 3 sD � | ] }t |t�r|j�ks |j� kr �d u s |j�kr|V qd S r )rP r� r( r' r� �� local_namer( r' r r rl 8 s � � ��)r� �warnings�warn�DeprecationWarningrP � SoupStrainer� ResultSetr% �count�splitr� � StopIterationr= r� rq ) r r( r� rb r� � generatorr� r� �strainer�result�results�i�foundr r� r r� sJ � � �zPageElement._find_allc c �, � | j }|dur|V |j }|dusdS dS )zgAll PageElements that were parsed after this one. :yield: A sequence of PageElements. Nr� �r r� r r r r� R � ��zPageElement.next_elementsc c r� )z�All PageElements that are siblings of this one but were parsed later. :yield: A sequence of PageElements. N)rL r� r r r r� ] � ��zPageElement.next_siblingsc c r� )zhAll PageElements that were parsed before this one. :yield: A sequence of PageElements. Nr� r� r r r r� i r� z PageElement.previous_elementsc c r� )z�All PageElements that are siblings of this one but were parsed earlier. :yield: A sequence of PageElements. N)rM r� r r r r� t r� z PageElement.previous_siblingsc c r� )zlAll PageElements that are parents of this PageElement. :yield: A sequence of PageElements. Nri r� r r r r� � r� zPageElement.parentsc C s t | dd�pdS )zOCheck whether a PageElement has been decomposed. :rtype: bool � _decomposedFr r r r r � decomposed� s zPageElement.decomposedc C r� r )r� r r r r � nextGenerator� � zPageElement.nextGeneratorc C r� r )r� r r r r �nextSiblingGenerator� r� z PageElement.nextSiblingGeneratorc C r� r )r� r r r r �previousGenerator� r� z PageElement.previousGeneratorc C r� r )r� r r r r �previousSiblingGenerator� r� z$PageElement.previousSiblingGeneratorc C r� r )r� r r r r �parentGenerator� r� zPageElement.parentGenerator)NNNNNr )TT)Ir- r. r/ r0 r\ rO rV rQ r rX r � nextSibling�previousSibling�object�defaultr` rc rh �getTextr� r{ � replaceWithr �replace_with_children�replaceWithChildrenr� rt r� �_lastRecursiveChildrv r� r� r� r� r� �findNextr� � findAllNextr� �findNextSiblingr� �findNextSiblings�fetchNextSiblingsr� � findPreviousr� �findAllPrevious� fetchPreviousr� �findPreviousSiblingr� �findPreviousSiblings�fetchPreviousSiblingsr� � findParentr� � findParents� fetchParentsr� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r rG � s� �) � &R � : rG c @ s~ e Zd ZdZdZdZdd� Zddd�Zdd � Zd d � Z d d � Z ddd�Z e dd� �Z e jdd� �Z dejfdd�Ze e�ZdS )r� 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". r6 c C s2 t |t�r t�| |�}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. )rP r% r& �DEFAULT_OUTPUT_ENCODINGrO )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 � | � i �S )z�A 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__� � zNavigableString.__copy__c C s t | �fS r )r% r r r r �__getnewargs__� � z NavigableString.__getnewargs__c C s |dkr| S t d| jj|f ��)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.rb �!'%s' object has no attribute '%s')�AttributeError� __class__r- )r r r r r � __getattr__� s ��zNavigableString.__getattr__�minimalc C s | � | |�}| j| | j S )z�Run the string through the provided formatter. :param formatter: A Formatter object, or a string naming one of the standard formatters. �rV �PREFIX�SUFFIX)r rT rU r r r � output_ready� s z NavigableString.output_readyc C � 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 d��)z1Prevent NavigableString.name from ever being set.z)A NavigableString cannot be given a name.�r )r r( r r r r( � � c c sp � || j u r tj}t| �}|dur#t|t�r ||ur dS n||vr#dS | }|r+|�� }t|�dkr6|V dS 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� r� � DEFAULT_INTERESTING_STRING_TYPESr rP r^ rq )r r^ r_ �my_typer r r r r` � s" � � �z NavigableString._all_stringsN�F)r )r- r. r/ r0 r r r& r r r r r r r( r rG r� r` �stringsr r r r r� � s .r� c @ s" e Zd ZdZdZdZddd�ZdS )�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). r6 Nc C s$ |dur | � | |�}| 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 rT �ignorer r r r . s z PreformattedString.output_readyr )r- r. r/ r0 r r r r r r r r # s r c @ � e Zd ZdZdZdZdS )�CDatazA CDATA block.z <![CDATA[z]]>N�r- r. r/ r0 r r r r r r r" > � r" c @ r! )�ProcessingInstructionz A SGML processing instruction.�<?�>Nr# r r r r r% C s r% c @ r! )�XMLProcessingInstructionz An XML processing instruction.r& �?>Nr# r r r r r( I r$ r( c @ r! )�CommentzAn HTML or XML comment.z<!--z-->Nr# r r r r r* N r$ r* c @ r! )� DeclarationzAn XML declaration.r& r) Nr# r r r r r+ T r$ r+ c @ s$ e Zd ZdZedd� �ZdZdZdS )�Doctypez A document type declaration.c C sT |pd}|dur |d| 7 }|dur|d| 7 }t |�S |dur&|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. r6 Nz PUBLIC "%s"z "%s"z SYSTEM "%s")r, )r* r( �pub_id� system_idr r r r �for_name_and_ids\ s � zDoctype.for_name_and_idsz <!DOCTYPE z> N)r- r. r/ r0 � classmethodr/ r r r r r r r, Z s r, c @ r1 )� Stylesheetz�A NavigableString representing an stylesheet (probably CSS). Used to distinguish embedded stylesheets from textual content. Nr3 r r r r r1 w � r1 c @ r1 )�Scriptz�A NavigableString representing an executable script (probably Javascript). Used to distinguish executable code from textual content. Nr3 r r r r r3 � r2 r3 c @ r1 )�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. Nr3 r r r r r4 � r2 r4 c @ r1 )�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. Nr3 r r r r r5 � s r5 c @ r1 )�RubyParenthesisStringz�A NavigableString representing the contents of the <rp> HTML element. https://dev.w3.org/html5/spec-LC/text-level-semantics.html#the-rp-element Nr3 r r r r r6 � r2 r6 c @ st e Zd ZdZ dndd�Zed�Zdodd�Zd d � Zd d � Z e d d� �Z e Z e dd� �Z e jdd� �Z eefZdejfdd�Ze e�Zdd� Zdpdd�Zdd� Zdd � Zdqd d �Zdqd 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(drd<d=�Z)d>d?� Z*e* Z+Z)e,dd@dAfdBdC�Z-de,d@dfdDdE�Z.e/� Z0e/� Z1e/� Z2e/� Z3dqdFdG�Z4dHdI� Z5dJdK� Z6dsdMdN�Z7dtdOdP�Z8de,d@fdQdR�Z9de,d@fdSdT�Z:e,ddUfdVdW�Z;di ddfdXdY�Z<e<Z=di dddfdZd[�Z>e>Z?e>Z@e d\d]� �ZAe d^d_� �ZBe d`da� �ZCdqdbdc�ZDduddde�ZEe dfdg� �ZFdhdi� ZGdjdk� ZHdldm� ZIdS )vr� 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 |du rd| _ n|j| _ |du rtd��|| _|| _|p i | _|| _|r'|jr5| dus/| dur5| | _| | _ |du r<i }n|rR|durM|j rM|� | j|�}n t |�}nt |�}|r]|j | _n| | _|| _g | _| �||� d| _|du r�| | _| | _ || _|| _dS |�| � |�|�| _|j | _ |j| _| j|jv r�|j| j | _dS | 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 rp r( r) � _namespacesr' �store_line_numbers� sourceline� sourcepos�cdata_list_attributes�$_replace_cdata_list_attribute_values�dictr[ r\ r� rN rO �hidden�can_be_empty_element�preserve_whitespace_tags�interesting_string_types�set_up_substitutions�string_containersr )r �parser�builderr( r) r' r� rI r� r[ r: r; r@ r< rA rB � namespacesr r r �__init__� sR + � z Tag.__init__r7 Tc C sp | � � }|r6|g}| �| j�D ]&\}}|tju r |�� q|j|dd�}|d �|� |tju r5|�|� q|S )z�A 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 rH ) �_clone� _event_stream� descendantsr� �END_ELEMENT_EVENTr� r r� �START_ELEMENT_EVENT)r r r �clone� tag_stack�eventr� �descendant_cloner r r r & s � �zTag.__deepcopy__c C r )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 r z Tag.__copy__c C s\ t | �dd| j| j| j| j| j| j| j| j| j | j | j d� }dD ] }t ||t | |�� q |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)r[ r: r; r@ r< rA rB )r@ r? )r r( r) r' r� rX r: r; r@ r< rA rB r r )r rN r r r r rI H s � z Tag._clonec C s t | j�dko | 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 )rq rN r@ r r r r �is_empty_element[ s zTag.is_empty_elementc C s0 t | j�dkr dS | jd }t|t�r|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. r? Nr )rq rN rP r� rb )r r~ r r r rb m s z Tag.stringc C s | � � | �|�|�� dS )z2Replace this PageElement's contents with `string`.N)�clearr� r ra r r r rb � s Fc c s� � || j u r | j}| jD ]4}|du rt|t�sq t|�}t|t�r'||ur&q n |dur0||vr0q |r=|�� }t|�dkr=q |V q dS )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� rB rK rP r� r r^ rq )r r^ r_ � descendant�descendant_typer r r r` � s& � � �zTag._all_stringsc C sD | � � | }|dur |j}|j�� g |_d|_|}|dus dS 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)rt rK �__dict__rS rN r� )r r� �nr r r � decompose� s �z Tag.decomposec C sX |r | j dd� D ]}t|t�r|�� q |�� q dS | j dd� D ]}|�� q#dS )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)rN rP r� rX rt )r rX r� r r r rS � s � �z Tag.clearc C s� g }t | j�D ]7\}}t|t�r|�� |t| j�d kr q| j|d }t|t�r>t|t�r>t|t�s>t|t�s>|�|� qt |�D ] }| j| }| j|d }|� � t|| �}|� |� qCdS )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. r? N) ru rN rP r� �smoothrq r� r r� r| rt r{ )r �markedr� �a�brW r r r rY � s. ��� � �z Tag.smoothc C s, t | j�D ] \}}||u r| S qtd��)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 tag)ru rN rp )r r� r� r~ r r r rs � s �z Tag.indexc C s | j �||�S )z�Returns 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|t�s|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] rP r� )r r^ r� r r r r �get_attribute_list s zTag.get_attribute_listc C � || j v S )z<Does this PageElement have an attribute with the given name?�r� �r r^ r r r �has_attr r z Tag.has_attrc C s t | ��� S r )r% �__hash__r r r r rd 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.ra rb r r r � __getitem__" � zTag.__getitem__c C � t | j�S )z0Iterating over a Tag iterates over its contents.��iterrN r r r r �__iter__' r z Tag.__iter__c C rg )z:The length of a Tag is the length of its list of contents.)rq rN r r r r �__len__+ r z Tag.__len__c C r` r )rN )r rk r r r � __contains__/ r zTag.__contains__c C r )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.Nra )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� rb r r r � __delitem__; s zTag.__delitem__c O s | j |i |��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 rw r� r r r �__call__? s z Tag.__call__c C st t |�dkr#|�d�r#|dd� }tjdt|d� tdd� | �|�S |�d �s1|d ks1| �|�S td | j |f ��) zACalling tag.subtag is the same as calling tag.find(name="subtag")r� r� 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� �__rN r ) rq �endswithr� r� r> r� �find� startswithr r )r r� �tag_namer r r r E s �� �zTag.__getattr__c C s� | |u rdS t |d�r)t |d�r)t |d�r)| j|jks)| j|jks)t| �t|�kr+dS t| j�D ]\}}||j| kr> dS q0dS )zyReturns true iff this Tag has the same name, the same attributes, and the same contents (recursively) as `other`.Tr( r� rN F)r� r( r� rq ru rN )r �otherr� �my_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 ry r r r �__ne__i rf z Tag.__ne__r! c C � | � � 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. ��decoder8 r r r �__repr__n s z Tag.__repr__c C r} )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 r: )r r9 � indent_levelrT �errorsr r r r r: s z Tag.encodec C sJ g }t |t�s | �|�}|du rd}d }| �|�D ]�\}}|tjtjfv r.|j||dd�} n|tju rD|j||dd�} |d urC|d8 }n|� |�} |rPd } } nd } } |tju rf|sf|� � sfd} d} |}n|tju ru||u rud} d} d }|d ur�| s}| r�t |t �r�| � � } | r�| � | ||| | �} |tjkr�|d7 }|�| � qd�|�S )NTr )�openingFr? r6 )rP r rQ rJ r� rM �EMPTY_ELEMENT_EVENT� _format_tagrL r �_should_pretty_printr� r^ �_indent_stringr� rf ) r r� �eventual_encodingrT �iterator�pieces�string_literal_tagrP r� �piece� indent_before� indent_afterr r r r � s` � �� �� � z Tag.decodec c s� � g }|p| j }|D ]?}|r(|j|d kr(|�� }tj|fV |r(|j|d kst|t�rC|jr7tj|fV q tj|fV |� |� q tj |fV q |rZ|�� }tj|fV |sLdS dS )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. rH N) �self_and_descendantsrI r� r� rL rP rR r� rM r� �STRING_ELEMENT_EVENT)r r� rO rZ �now_closed_tagr r r rJ � s& � � �zTag._event_streamc C s. d}|r |r |j | }d}|rd}|| | 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. r6 � )�indent)r rS r� rT r� r� � space_before� space_afterr r r r� ! s zTag._indent_stringc C s | j rdS d}|s d}d}| jr| jd }d}|rt|�| �}g }|D ]H\} } | d u r-| } n8t| t�s7t| t�r=d�| �} nt| t�sGt| �} nt| t�rU|d urU| � |�} |� | �} t| �d |� | � } |� | � q"|rtdd�|� }d} | j r~|jp}d} d| | | j | | d S )Nr6 �/r$ � �=�<r' )r? r' � attributesrP r� �tuplerf r% r2 r: �attribute_value�quoted_attribute_valuer� rR �void_element_close_prefixr( )r r� rT r� � closing_slashr' �attribute_stringr� r� r^ �val�decodedr� �void_element_closing_slashr r r r� 7 sF � �� zTag._format_tagr? c C s |duo | j p | j| j vS )z�Should this tag be pretty-printed? Most of them should, but some (such as <pre> in HTML documents) should not. N)rA r( )r r� r r r r� m s �zTag._should_pretty_printc C s& |du r | j d|d�S | j|d|d�S )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)rT r� )r r9 rT r r r �prettify{ s z Tag.prettifyc C s | j |||| jd�S )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. )r� )r rK )r r� r� rT 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. )r� r: )r r� r9 rT rN r r r �encode_contents� s zTag.encode_contentsr c C s |sd}| j ||d�S )z(Deprecated method for BS3 compatibility.N)r� r9 )r� )r r9 � prettyPrint� 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 Nr? r� r� r rp )r r( r� r rb r� r� r� r r r rv � 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� r? )rK �childrenr� r� ) r r( r� r rb r� r� r� r� r r r rq � s ��z Tag.find_allc C rg )zkIterate over all direct children of this PageElement. :yield: A sequence of PageElements. rh r r r r r� � s z Tag.childrenc c s$ � | j s| V | jD ]}|V q dS )z�Iterate over this PageElement and its children in a breadth-first sequence. :yield: A sequence of PageElements. N)r? rK r� r r r r� s � �zTag.self_and_descendantsc c sH � t | j�sdS | �� j}| jd }||ur"|V |j}||usdS dS )z�Iterate over all children of this PageElement in a breadth-first sequence. :yield: A sequence of PageElements. Nr )rq rN r� rK )r �stopNode�currentr r r rK s � �zTag.descendantsc K s | j j||fi |��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 �selectorrG r� r r r r� s zTag.select_onec K s | j j|||fi |��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 )r� �select)r r� rG r� r� r r r r� 0 s z Tag.selectc C s t | �S )z,Return an interface to the CSS selector API.r r r r r r� F r zTag.cssc C r� �zDeprecated generator.)r� r r r r �childGeneratorL � zTag.childGeneratorc C r� r� )rK r r r r �recursiveChildGeneratorP r� 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� rc rb r r r �has_keyT s � z Tag.has_key)NNNNNNNNNNNNNNNN)Tr r )r! )r? )Nr r, )Jr- r. r/ r0 rH r � parserClassr r rI r rR � isSelfClosingrb r r� r" r rG r� r` r rX rS rY rs r] r_ rc rd re rj rk rl rm rn ro rr r r{ r| r� r� �__str__r r: r r� rM rL r� r� rJ r� r� r� r� r� r� r� rv � findChildrq �findAll� findChildrenr� r� rK r� r� r� r� r� r� r r r r r� � s� �u $ & � �Y * 6 � � � � r� c @ sT e Zd ZdZdi dfdd�Zdd� Zdd� Zdi fd d �ZeZd d � Z dd d�Z 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� |du rd|v r|� d�}tjdtdd� | �|�| _t|t�s&||d< d}d|v r3|d |d< |d= |rC|rA|�� }|� |� n|}i }t |� � �D ] \}}| �|�||< qK|| _ | �|�| _ | 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( rP r> �copy�updater� �itemsr� rb r� )r r( r� rb r� �normalized_attrsr^ r r r r rH k s0 � zSoupStrainer.__init__c C s� t |t�st |t�st|d�st |t�s|d u r|S t |t�r$|�d�S t|d�rOg }|D ] }t|d�rDt |t�sDt |t�sD|�|� q-|�| �|�� q-|S tt|��S )Nr> �utf8rj ) rP r% r r� �bool�bytesr r� r� )r r � new_value�vr r r r� � s" � � z$SoupStrainer._normalize_search_valuec C s | j r| j S d| j| jf S )z5A human-readable representation of this SoupStrainer.z%s|%s)rb r( r� r r r r r� � s zSoupStrainer.__str__c C s8 d}d}t |t�r |}|}t | jt�r |r |js | j|jkr dS t | jt�o+t |t� }| jrC|sC|r:| �|| j�sC|s�| �|| j�r�|rL| �||�}n6d}d}t| j� � �D ]*\}} |srt |d�re|}n i }|D ]\} } | || < qi|� |�} | �| | �s�d} nqW|r�|r�|}n|}|r�| j r�| �|j | j �s�d}|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] ) rP r� r( r% r' r �_matchesr� r� r� r� r] rb ) r � markup_name� markup_attrsr� �markup�call_function_with_tag_datar> �markup_attr_mapr � match_against�kr� � attr_valuer r r � search_tag� sZ ��� �� � �zSoupStrainer.search_tagc C s� d}t |d�r$t|ttf�s$|D ]}t|t�r!| �|�r!|} |S q|S t|t�r9| jr2| js2| jr7| � |�}|S t|t�sCt|t�rT| jsR| jsR| � || j�rR|}|S t d|j ��)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. Nrj z&I don't know how to match against a %s) r� rP r� r% r� r= rb r( r� r� r� � Exceptionr )r r� r� r� r r r r= � s0 �� � ����zSoupStrainer.searchc C sf d}t |t�s t |t�r'|D ] }| �||�r dS q| �d�|�|�r%dS dS |du r/|d uS t |t�r8||�S |}t |t�rB|j}| �|�}|d u rN| S t |d�r�t |t �s�|s]t � }|D ] }|j rg|}nt |�}||v rpq_|�|� | �|||�r dS q_dS d}|s�t |t �r�||k}|s�t |d�r�|�|�S |s�t |t�r�|jr�| �|jd |j |�S |S )NFTr� rj r= r$ )rP r� r� r� rf r r� r( r� r� r% �setrd �id�addr= r' ) r r� r� � already_triedr� �item�original_markupr^ r> r r r r� sb � � � ���zSoupStrainer._matchesr ) r- r. r/ r0 rH r� r� r� � searchTagr= r� r r r r r� a 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� rH �source)r r� r� �r r r rH v s zResultSet.__init__c C s t d| ��)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()?r rb r r r r s �zResultSet.__getattr__)r )r- r. r/ r0 rH r � __classcell__r r r� r r� s s r� ).� __license__�collections.abcr � ImportError�e� collectionsrD �sysr� �bs4.cssr � bs4.formatterr r r r rE �nonwhitespace_re� whitespace_rer r� r7 r% r# r2 r4 r; r� rG r� r r" r% r( r* r+ r, r1 r3 r4 r5 r6 r� r� r� r� r r r r �<module> sj �� ~ A PK z�Z�/�;�k �k " __pycache__/dammit.cpython-310.pycnu �[��� o �hƠ � @ sX d Z dZddlmZ ddlmZ ddlZddlZddlZddl Z dZ zddl Z W n+ e yS zddl Z W n e yP zddlZ W n e yM dZ Y nw Y nw Y nw e r[dd� Zndd� Zd Zd Ze� Ze�e�d �ej�e�e�d �ej�d �ee< e�eej�e�eej�d �ee< dd lmZ G dd� de�ZG dd� d�Z G dd� d�Z dS )aB Beautiful Soup bonus library: Unicode, Dammit This library converts a bytestream to Unicode through any means necessary. It is heavily based on code from Mark Pilgrim's Universal Feed Parser. It works best on XML and HTML, but it does not rewrite the XML or HTML to reflect a new encoding; that's the tree builder's job. �MIT� )�codepoint2name)� defaultdictNc C s t | t�rd S t�| �d S )N�encoding)� isinstance�str�chardet_module�detect��s� r �=/usr/local/CyberCP/lib/python3.10/site-packages/bs4/dammit.py�chardet_dammit+ s r c C s d S �Nr r r r r r 0 s z$^\s*<\?.*encoding=['"](.*?)['"].*\?>z0<\s*meta[^>]+charset\s*=\s*["']?([^>]*?)[ /;'">]�ascii)�html�xml)�html5c @ s� e Zd ZdZdd� Ze� \ZZZdddddd �Ze � d �Z e � d �Z e d d � �Ze dd� �Ze dd� �Ze ddd��Ze ddd��Ze dd� �ZdS )�EntitySubstitutionzFThe ability to substitute XML or HTML entities for certain characters.c C s� i } i }t � }tt �}tt�� �D ]T\}}|�d�r!|dd� }n|}||vr+|||< || |< t|�dkr@t|�dk r@|dvr@qt|�dkrPtdd� |D ��rPqt|�dkr\|� |� q||d � |� qt � }|D ]!}|| } | sy|� |� qkd � d d � | D ��} |� d || f � qkt |� � �D ] } | D ]} |� | � q�q�dd� |� } t t �� �D ] \}}t|�}|| |< q�| |t�| �fS )u� Initialize variables used by this class to manage the plethora of HTML5 named entities. This function returns a 3-tuple containing two dictionaries and a regular expression: unicode_to_name - A mapping of Unicode strings like "⦨" to entity names like "angmsdaa". When a single Unicode string has multiple entity names, we try to choose the most commonly-used name. name_to_unicode: A mapping of entity names like "angmsdaa" to Unicode strings like "⦨". named_entity_re: A regular expression matching (almost) any Unicode string that corresponds to an HTML5 named entity. �;N���� � z<>&c s s � | ] }t |�d k V qdS )r N)�ord��.0�xr r r � <genexpr>� s � z?EntitySubstitution._populate_class_variables.<locals>.<genexpr>r � c S s g | ]}|d �qS )r r r r r r � <listcomp>� � z@EntitySubstitution._populate_class_variables.<locals>.<listcomp>z %s(?![%s])z(%s)�|)�setr �sortedr �items�endswith�lenr �all�add�join�list�valuesr �chr�re�compile)�unicode_to_name�name_to_unicode�short_entities� long_entities_by_first_character�name_with_semicolon� character�name� particles�short� long_versions�ignore� long_entities� long_entity� re_definition� codepointr r r �_populate_class_variablesF sF � z,EntitySubstitution._populate_class_variables�apos�quot�amp�lt�gt)�'�"�&�<�>z&([<>]|&(?!#\d+;|#x[0-9a-fA-F]+;|\w+;))z([<>&])c C s | j �|�d��}d| S )zpUsed with a regular expression to substitute the appropriate HTML entity for a special character string.r �&%s;)�CHARACTER_TO_HTML_ENTITY�get�group��cls�matchobj�entityr r r �_substitute_html_entity� s z*EntitySubstitution._substitute_html_entityc C s | j |�d� }d| S )zoUsed with a regular expression to substitute the appropriate XML entity for a special character string.r rI )�CHARACTER_TO_XML_ENTITYrL rM r r r �_substitute_xml_entity� s z)EntitySubstitution._substitute_xml_entityc C s6 d}d|v rd|v rd}|� d|�}nd}|| | S )a* Make a value into a quoted XML attribute, possibly escaping it. Most strings will be quoted using double quotes. Bob's Bar -> "Bob's Bar" If a string contains double quotes, it will be quoted using single quotes. Welcome to "my bar" -> 'Welcome to "my bar"' If a string contains both single and double quotes, the double quotes will be escaped, and the string will be quoted using double quotes. Welcome to "Bob's Bar" -> "Welcome to "Bob's bar" rE rD z")�replace)�self�value� quote_with� replace_withr r r �quoted_attribute_value� s z)EntitySubstitution.quoted_attribute_valueFc C �" | j �| j|�}|r| �|�}|S )a Substitute XML entities for special XML characters. :param value: A string to be substituted. The less-than sign will become <, the greater-than sign will become >, and any ampersands will become &. If you want ampersands that appear to be part of an entity definition to be left alone, use substitute_xml_containing_entities() instead. :param make_quoted_attribute: If True, then the string will be quoted, as befits an attribute value. )�AMPERSAND_OR_BRACKET�subrS rY �rN rV �make_quoted_attributer r r �substitute_xml s � z!EntitySubstitution.substitute_xmlc C rZ )a� Substitute XML entities for special XML characters. :param value: A string to be substituted. The less-than sign will become <, the greater-than sign will become >, and any ampersands that are not part of an entity defition will become &. :param make_quoted_attribute: If True, then the string will be quoted, as befits an attribute value. )�BARE_AMPERSAND_OR_BRACKETr\ rS rY r] r r r �"substitute_xml_containing_entities s � z5EntitySubstitution.substitute_xml_containing_entitiesc C s | j �| j|�S )a Replace certain Unicode characters with named HTML entities. This differs from data.encode(encoding, 'xmlcharrefreplace') in that the goal is to make the result more readable (to those with ASCII displays) rather than to recover from errors. There's absolutely nothing wrong with a UTF-8 string containg a LATIN SMALL LETTER E WITH ACUTE, but replacing that character with "é" will make it more readable to some people. :param s: A Unicode string. )�CHARACTER_TO_HTML_ENTITY_REr\ rQ )rN r r r r �substitute_html+ s �z"EntitySubstitution.substitute_htmlN)F)�__name__� __module__� __qualname__�__doc__r> rJ �HTML_ENTITY_TO_CHARACTERrb rR r- r. r` r[ � classmethodrQ rS rY r_ ra rc r r r r r C s6 w�� $ �r c @ sN e Zd ZdZ ddd�Zdd� Zedd � �Zed d � �Z edd d ��Z dS )�EncodingDetectoraL Suggests a number of possible encodings for a bytestring. Order of precedence: 1. Encodings you specifically tell EncodingDetector to try first (the known_definite_encodings argument to the constructor). 2. An encoding determined by sniffing the document's byte-order mark. 3. Encodings you specifically tell EncodingDetector to try if byte-order mark sniffing fails (the user_encodings argument to the constructor). 4. An encoding declared within the bytestring itself, either in an XML declaration (if the bytestring is to be interpreted as an XML document), or in a <meta> tag (if the bytestring is to be interpreted as an HTML document.) 5. An encoding detected through textual analysis by chardet, cchardet, or a similar external library. 4. UTF-8. 5. Windows-1252. NFc C sn t |pg �| _|r| j|7 _|pg | _|pg }tdd� |D ��| _d| _|| _d| _| �|�\| _ | _ dS )a� Constructor. :param markup: Some markup in an unknown encoding. :param known_definite_encodings: When determining the encoding of `markup`, these encodings will be tried first, in order. In HTML terms, this corresponds to the "known definite encoding" step defined here: https://html.spec.whatwg.org/multipage/parsing.html#parsing-with-a-known-character-encoding :param user_encodings: These encodings will be tried after the `known_definite_encodings` have been tried and failed, and after an attempt to sniff the encoding by looking at a byte order mark has failed. In HTML terms, this corresponds to the step "user has explicitly instructed the user agent to override the document's character encoding", defined here: https://html.spec.whatwg.org/multipage/parsing.html#determining-the-character-encoding :param override_encodings: A deprecated alias for known_definite_encodings. Any encodings here will be tried immediately after the encodings in known_definite_encodings. :param is_html: If True, this markup is considered to be HTML. Otherwise it's assumed to be XML. :param exclude_encodings: These encodings will not be tried, even if they otherwise would be. c S s g | ]}|� � �qS r )�lowerr r r r r r z-EncodingDetector.__init__.<locals>.<listcomp>N) r* �known_definite_encodings�user_encodingsr" �exclude_encodings�chardet_encoding�is_html�declared_encoding�strip_byte_order_mark�markup�sniffed_encoding)rU rs rl rp rn rm �override_encodingsr r r �__init__X s " zEncodingDetector.__init__c C s8 |dur|� � }|| jv rdS ||vr|�|� dS dS )z�Should we even bother to try this encoding? :param encoding: Name of an encoding. :param tried: Encodings that have already been tried. This will be modified as a side effect. NFT)rk rn r( )rU r �triedr r r �_usable� s zEncodingDetector._usablec c s� � t � }| jD ] }| �||�r|V q| �| j|�r | jV | jD ] }| �||�r,|V q!| jdu r;| �| j| j�| _| �| j|�rF| jV | j du rQt | j�| _ | �| j |�r\| j V dD ] }| �||�ri|V q^dS )zmYield a number of encodings that might work for this markup. :yield: A sequence of strings. N)�utf-8� windows-1252) r" rl rx rt rm rq �find_declared_encodingrs rp ro r )rU rw �er r r � encodings� s6 � � � � ��zEncodingDetector.encodingsc C s d}t |t�r ||fS t|�dkr-|dd� dkr-|dd� dkr-d}|dd� }||fS t|�dkrO|dd� dkrO|dd� dkrOd}|dd� }||fS |dd � d krcd }|d d� }||fS |dd� d krwd }|dd� }||fS |dd� dkr�d}|dd� }||fS )z�If a byte-order mark is present, strip it and return the encoding it implies. :param data: Some markup. :return: A 2-tuple (modified data, implied encoding) N� � s ��z zutf-16bes ��zutf-16le� s ry s ��zutf-32bes �� zutf-32le)r r r& )rN �datar r r r rr � s2 � � � � z&EncodingDetector.strip_byte_order_markc C s� |r t |� }}n d}tdtt |�d ��}t|t�r tt }ntt }|d }|d }d} |j||d�} | s@|r@|j||d�} | durJ| �� d } | r[t| t�rW| � d d �} | � � S dS ) a� Given a document, tries to find its declared encoding. An XML encoding is declared at the beginning of the document. An HTML encoding is declared in a <meta> tag, hopefully near the beginning of the document. :param markup: Some markup. :param is_html: If True, this markup is considered to be HTML. Otherwise it's assumed to be XML. :param search_entire_document: Since an encoding is supposed to declared near the beginning of the document, most of the time it's only necessary to search a few kilobytes of data. Set this to True to force this method to search the entire document. i i g�������?r r N)�endposr r rT ) r& �max�intr �bytes� encoding_resr �search�groups�decoderk ) rN rs rp �search_entire_document� xml_endpos� html_endpos�res�xml_re�html_rerq �declared_encoding_matchr r r r{ � s( z'EncodingDetector.find_declared_encoding)NFNNN)FF) rd re rf rg rv rx �propertyr} ri rr r{ r r r r rj = s �/ + rj c @ s� e Zd ZdZddd�Zg d�Zg ddg ddfdd �Zd d � Z�d�d d�Z�d�dd�Z e dd� �Z dd� Z dd� Z i dd�dd�dd �d d �d d �d!d"�d#d$�d%d&�d'd(�d)d*�d+d,�d-d.�d/d0�d1d2�d3d4�d5d2�d6d2�d7d8d9d:d;d<d=d>d?d@dAdBd2dCdDdE��Zi ddF�dd�ddG�d dH�d dI�d!dJ�d#dK�d%dL�d'dM�d)dN�d+dO�d-dP�d/dQ�d1d2�d3dR�d5d2�d6d2�i dSdT�dUdT�dVdW�dXdW�dYdZ�d[d\�d]d^�d_d`�dadb�dcdd�dedf�dgdh�did2�djdk�dldm�dnd�dodp��i dqdr�dsdt�dudv�dwdx�dydz�d{dO�d|d}�d~d�d�d��d�d��d�dp�d�d�d�d��d�d\�d�d��d�d��d�d���i d�d��d�d��d�d��d�d��d�dZ�d�dG�d�d��d�d��d�d��d�d��d�d��d�d��d�d2�d�d��d�d��d�d��d�d���i d�d��d�d��d�d��d�d��d�d��d�d��d�d��d�d��d�d��d�d��d�d��d�d��d�d��d�d��d�d��d�d��d�d���i d�d��d�d��d�dZ�d�d��d�dǓd�dǓd�dǓd�dǓd�dm�d�d͓d�dϓd�dѓd�dѓd�dѓd�dѓd�dѓd�dѓ�i d�dؓd�dr�d�dۓd�dۓd�dۓd�dۓd�d�d�d�d�d�d�d�d�d��d�d�d�d��d�d��d�d��d�d��d�d���d�d�d�d�d�d�d�d�d�d� �Zi d�d�d�d�d�d�d�d��d�d��d�d��d�d��d�d��d��d ��d�d��d�d��d�d��d�d��d �d ��d �d ��d �d��d�d�i �d�d��d�d��d�d��d�d��d�d��d�d ��d �d ��d �d ��d!�d"��d#�d$��d%�d&��d'�d(��d)�d*��d+�d,��d-�d.��d/�d0��d1�d2��i �d3�d4��d5�d6��d7�d8��d9�d:��d;�d<��d=�d>��d?�d@��dA�dB��dC�dD��dE�dF��dG�dH��dI�dJ��dK�dL��dM�dN��dO�dP��dQ�dR��dS�dT��i �dU�dV��dW�dX��dY�dZ��d[�d\��d]�d^��d_�d`��da�db��dc�dd��de�df��dg�dh��di�dj��dk�dl��dm�dn��do�dp��dq�dr��ds�dt��du�dv��i �dw�dx��dy�dz��d{�d|��d}�d~��d�d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���i �d��d���d��d���d��d���d��d���d��d���d��d���d��d���d�do��d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���i �d��d���d��d���d��d���d��d���ddÓ�dĐdœ�dƐdǓ�dȐdɓ�dʐd˓�d̐d͓�dΐdϓ�dАdѓ�dҐdӓ�dԐdՓ�ddד�dؐdٓ�dڐdۓ��dܐdݐdސdߜ�Zg �d�Ze�d� �d� Ze�d� �d� Ze� � �d�d�d��ZdS (� � UnicodeDammitz�A class for detecting the encoding of a *ML document and converting it to a Unicode string. If the source encoding is windows-1252, can replace MS smart quotes with their HTML or XML equivalents.z mac-romanz shift-jis)� macintoshzx-sjis)rz z iso-8859-1z iso-8859-2NFc C s� || _ g | _d| _|| _t�t�| _t||||||�| _ t |t �s%|dkr2|| _ t |�| _ d| _dS | j j | _ d}| j jD ]} | j j }| �| �}|durN nq=|sq| j jD ]} | dkra| �| d�}|durp| j�d� d| _ nqU|| _ |s{d| _dS dS )a2 Constructor. :param markup: A bytestring representing markup in an unknown encoding. :param known_definite_encodings: When determining the encoding of `markup`, these encodings will be tried first, in order. In HTML terms, this corresponds to the "known definite encoding" step defined here: https://html.spec.whatwg.org/multipage/parsing.html#parsing-with-a-known-character-encoding :param user_encodings: These encodings will be tried after the `known_definite_encodings` have been tried and failed, and after an attempt to sniff the encoding by looking at a byte order mark has failed. In HTML terms, this corresponds to the step "user has explicitly instructed the user agent to override the document's character encoding", defined here: https://html.spec.whatwg.org/multipage/parsing.html#determining-the-character-encoding :param override_encodings: A deprecated alias for known_definite_encodings. Any encodings here will be tried immediately after the encodings in known_definite_encodings. :param smart_quotes_to: By default, Microsoft smart quotes will, like all other characters, be converted to Unicode characters. Setting this to 'ascii' will convert them to ASCII quotes instead. Setting it to 'xml' will convert them to XML entity references, and setting it to 'html' will convert them to HTML entity references. :param is_html: If True, this markup is considered to be HTML. Otherwise it's assumed to be XML. :param exclude_encodings: These encodings will not be considered, even if the sniffing code thinks they might make sense. Fr Nr rT zSSome characters could not be decoded, and were replaced with REPLACEMENT CHARACTER.T)�smart_quotes_to�tried_encodings� contains_replacement_charactersrp �logging� getLoggerrd �logrj �detectorr r rs �unicode_markup�original_encodingr} � _convert_from�warning) rU rs rl r� rp rn rm ru �ur r r r rv sJ & � � �� �zUnicodeDammit.__init__c C s� |� d�}| jdkr| j�|��� }|S | j�|�}t|�tkrE| jdkr5d�� |d �� d�� }|S d�� |d �� d�� }|S |�� }|S )z[Changes a MS smart quote character to an XML or HTML entity, or an ASCII character.r r r z&#xr rF r )rL r� �MS_CHARS_TO_ASCIIrK �encode�MS_CHARS�type�tuple)rU �match�origr\ r r r � _sub_ms_charu s � ��zUnicodeDammit._sub_ms_char�strictc C s� | � |�}|r||f| jv rdS | j�||f� | j}| jdur3|| jv r3d}t�|�}|�| j |�}z| � |||�}|| _|| _ W | jS t yW } zW Y d}~dS d}~ww )z|Attempt to convert the markup to the proposed encoding. :param proposed: The name of a character encoding. Ns ([�-�])) � find_codecr� �appendrs r� �ENCODINGS_WITH_SMART_QUOTESr- r. r\ r� � _to_unicoder� � Exception)rU �proposed�errorsrs �smart_quotes_re�smart_quotes_compiledr� r| r r r r� � s& ���zUnicodeDammit._convert_fromc C s t |||�S )z}Given a string and its encoding, decodes the string into Unicode. :param encoding: The name of an encoding. )r )rU r� r r� r r r r� � s zUnicodeDammit._to_unicodec C s | j sdS | jjS )zhIf the markup is an HTML document, returns the encoding declared _within_ the document. N)rp r� rq )rU r r r �declared_html_encoding� s z$UnicodeDammit.declared_html_encodingc C s` | � | j�||��p'|o| � |�dd��p'|o | � |�dd��p'|o%|�� p'|}|r.|�� S dS )z�Convert the name of a character set to a codec name. :param charset: The name of a character set. :return: The name of a codec. �-r �_N)�_codec�CHARSET_ALIASESrK rT rk )rU �charsetrV r r r r� � s �� ��zUnicodeDammit.find_codecc C s: |s|S d }z t �|� |}W |S ttfy Y |S w r )�codecs�lookup� LookupError� ValueError)rU r� �codecr r r r� � s ��zUnicodeDammit._codec� �)�euro�20AC� �� � �)�sbquo�201A� �)�fnof�192� �)�bdquo�201E� �)�hellip�2026� �)�dagger�2020� �)�Dagger�2021� �)�circ�2C6� �)�permil�2030� �)�Scaron�160� �)�lsaquo�2039� �)�OElig�152� ��?� �)z#x17D�17D� �� �)�lsquo�2018)�rsquo�2019)�ldquo�201C)�rdquo�201D)�bull�2022)�ndash�2013)�mdash�2014)�tilde�2DC)�trade�2122)�scaron�161)�rsaquo�203A)�oelig�153)z#x17E�17E)�Yumlr )� �� �� �� �� �� �� �� �� �� �� �� �� �� �� ��EUR�,�fz,,z...�+z++�^�%�SrG �OE�Zr rD r r rE r r �*r r� r z--r �~r z(TM)r r r rH r �oer r �zr �Y� �� ��!� ��c� ��GBP� ��$� ��YEN� �r! � �� �z..� �r � �z(th)� �z<<� �� �� �z(R)� �� ��o� �z+-� ��2� ��3� �)rD �acute� �r� � ��P� �� �� ��1� �� �z>>� �z1/4� �z1/2� �z3/4� �� ��A� �� �� �� �� �� ��AE� ��C� ��E� �� �� �� ��I� �� �� �� ��D� ��N� ��O� �� �� �� �� �� �� ��U� �� �� �� �� ��b� ��B� ��a� �� �� �� �� �� ��ae� �� �r| � �� �� �� ��i� �� �� �� �� ��n� �� �� �� �� ��/�y) � �� �� �� �� �� �� �� �� �r s €� s ‚� s ƒ� s „� s …� s †� s ‡� s ˆ� s ‰� s Š� s ‹� s Œ� s Ž� s ‘� s ’� s “� s ”� s •� s –� s —� s ˜� s ™� s š� s ›� s œ� s ž� s Ÿ� s � s ¡� s ¢� s £� s ¤� s ¥� s ¦� s §� s ¨� s ©� s ª� s «� s ¬� s � s ®� s ¯� s °� s ±� s ²� s ³� s ´� s µ� s ¶� s ·� s ¸� s ¹� s º� s »� s ¼� s ½� s ¾� s ¿� s À� s Á�� s Â�� s Ã�� s Ä�� s Å�� s Æ�� s Ç�� s È�� s É�� s Ê�� s Ë�� s Ì�� s Í�� s Î�� s Ï�� s Ð�� s Ñ�� s Ò�� s Ó�� s Ô�� s Õ�� s Ö�� s ×�� s Ø�� s Ù�� s Ú�� s Û�� s Ü�� s Ý�� s Þ�� s ß�� s à�� �� s â�� s ã�� s ä�� s å�� s æ�� s ç�� s è�� s é�� s ê�� s ë�� s ì�� s í�� s î�� s ï�� s ð�� s ñ�� s ò�� s ó�� s ô� s õ� s ö� s ÷� s ø� s ù� s ú� s ûs üs ýs þ)� � � ))r� r� r )r� r r� )r r r~ r r r �utf8rz c C s$ |� dd��� dvrtd��|�� dvrtd��g }d}d}|t|�k r~|| }t|t�s1t|�}|| jkrS|| jkrS| j D ]\}} } ||krQ|| krQ|| 7 } nq>n%|dkrt|| j v rt|� |||� � |� | j | � |d 7 }|}n|d 7 }|t|�k s$|dkr�|S |� ||d � � d � |�S ) a Fix characters from one encoding embedded in some other encoding. Currently the only situation supported is Windows-1252 (or its subset ISO-8859-1), embedded in UTF-8. :param in_bytes: A bytestring that you suspect contains characters from multiple encodings. Note that this _must_ be a bytestring. If you've already converted the document to Unicode, you're too late. :param main_encoding: The primary encoding of `in_bytes`. :param embedded_encoding: The encoding that was used to embed characters in the main document. :return: A bytestring in which `embedded_encoding` characters have been converted to their `main_encoding` equivalents. r� r� )rz � windows_1252zPWindows-1252 and ISO-8859-1 are the only currently supported embedded encodings.)r ry z4UTF-8 is the only currently supported main encoding.r r r N� ) rT rk �NotImplementedErrorr& r r� r �FIRST_MULTIBYTE_MARKER�LAST_MULTIBYTE_MARKER�MULTIBYTE_MARKERS_AND_SIZES�WINDOWS_1252_TO_UTF8r� r) ) rN �in_bytes� main_encoding�embedded_encoding� byte_chunks� chunk_start�pos�byte�start�end�sizer r r � detwingle sB � � � � zUnicodeDammit.detwingle)r� )r rz )rd re rf rg r� r� rv r� r� r� r� r� r� r� r� r� r r r r ri r' r r r r r� sn � �X �������� � � � � �����$�������� � � � � ��������������� � � � � �!�"�#�$�%�'�(�)�*�+�,�-�.�/�0�1�2�3�4�5�6�7�8�9�:�;�<�=�>�?�@�A�B�C�D�E�F�G�H�I�J�K�L�M�N�O�P�Q�R�S�T�U�V�W�X�Y�Z�[�\�]�^�_�`�a�b�c�d�e�f�g�h�i�j�k�l�m�n�o�p�q�r�s�t�u�v�w�x�y �� �������� � � � � ��������������� � � � � �!�"�#�$�%�&�'�(�)�*�+�,�-�.�/�0�1�2�3�4�5�6�7�8�9�:�;�<�=�>�?�@�A�B�C�D�E�F�G�H�I�J�K�L�M�N�O�P�Q�R�S�T�U�V�W�X�Y�Z�[�\�]�^�_�`�a�b�c�d�e�f�g�h�i�j�k�l�m�n�o�p�q�r�s�t�u�v�w�x � }�r� ) rg � __license__� html.entitiesr � collectionsr r� r- r� �stringr �cchardet� ImportError�chardet�charset_normalizerr � xml_encoding� html_meta�dictr� r. r� r\ r� r r �objectr rj r� r r r r �<module> sT ����� � � { NPK z�Z� r' $ __pycache__/diagnose.cpython-310.pycnu �[��� o �h � @ s d Z dZddlZddlmZ ddlmZ ddlZddlmZm Z ddl m Z ddl Z ddl Z ddlZddlZddlZddlZddlZddlZdd � Zd#d d �ZG d d� de�Zdd� ZdZdZd$dd�Zd%dd�Zd&dd�Zd'd d �Z d(d d!�Z e d"kr�eej � � � dS dS ))z=Diagnostic functions, mainly for use when doing tech support.�MIT� N)�BytesIO)� HTMLParser)� BeautifulSoup� __version__)�builder_registryc C s� t dt � t dtj � g d�}|D ]}tjD ] }||jv r! n q|�|� t d| � qd|v rc|�d� zddl m } t d d � t t |j�� � W n tyb } z t d � W Y d }~nd }~ww d |v r�z dd l}t d|j � W n ty� } z t d� W Y d }~nd }~ww t| d�r�| �� } |D ]C}t d| � d}z t| |d�} d}W n ty� } zt d| � t�� W Y d }~nd }~ww |r�t d| � t | �� � t d� q�d S )z�Diagnostic suite for isolating common problems. :param data: A string containing markup that needs to be explained. :return: None; diagnostics are printed to standard output. z'Diagnostic running on Beautiful Soup %szPython version %s)� html.parser�html5lib�lxmlz;I noticed that %s is not installed. Installing it may help.r zlxml-xmlr ��etreezFound lxml version %s�.z.lxml is not installed or couldn't be imported.Nr zFound html5lib version %sz2html5lib is not installed or couldn't be imported.�readz#Trying to parse your markup with %sF)�featuresT� %s could not parse the markup.z#Here's what %s did with the markup:zP--------------------------------------------------------------------------------)�printr �sys�versionr �buildersr �remove�appendr r �join�map�str� LXML_VERSION� ImportErrorr �hasattrr r � Exception� traceback� print_exc�prettify) �data� basic_parsers�name�builderr �er �parser�success�soup� r) �?/usr/local/CyberCP/lib/python3.10/site-packages/bs4/diagnose.py�diagnose sl � ��� ������ �� �r+ Tc K sp ddl m} |�dd�}t| t�r| �d�} t| �}|j|f||d�|��D ]\}}td||j |j f � q&dS ) a� Print out the lxml events that occur during parsing. This lets you see how lxml parses a document when no Beautiful Soup code is running. You can use this to determine whether an lxml-specific problem is in Beautiful Soup's lxml tree builders or in lxml itself. :param data: Some markup. :param html: If True, markup will be parsed with lxml's HTML parser. if False, lxml's XML parser will be used. r r �recoverT�utf8)�htmlr, z %s, %4s, %sN) r r �pop� isinstancer �encoder � iterparser �tag�text)r! r. �kwargsr r, �reader�event�elementr) r) r* � lxml_traceN s ����r9 c @ s` e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dS )�AnnouncingParserz�Subclass of HTMLParser that announces parse events, without doing anything else. You can use this to get a picture of how html.parser sees a given document. The easiest way to do this is to call `htmlparser_trace`. c C s t |� d S )N)r )�self�sr) r) r* �_pl s zAnnouncingParser._pc C � | � d| � d S )Nz%s START�r= )r; r# �attrsr) r) r* �handle_starttago � z AnnouncingParser.handle_starttagc C r> )Nz%s ENDr? �r; r# r) r) r* � handle_endtagr rB z AnnouncingParser.handle_endtagc C r> )Nz%s DATAr? �r; r! r) r) r* � handle_datau rB z AnnouncingParser.handle_datac C r> )Nz %s CHARREFr? rC r) r) r* �handle_charrefx rB z AnnouncingParser.handle_charrefc C r> )Nz %s ENTITYREFr? rC r) r) r* �handle_entityref{ rB z!AnnouncingParser.handle_entityrefc C r> )Nz %s COMMENTr? rE r) r) r* �handle_comment~ rB z AnnouncingParser.handle_commentc C r> )Nz%s DECLr? rE r) r) r* � handle_decl� rB z AnnouncingParser.handle_declc C r> )Nz%s UNKNOWN-DECLr? rE r) r) r* � unknown_decl� rB z AnnouncingParser.unknown_declc C r> )Nz%s PIr? rE r) r) r* � handle_pi� rB zAnnouncingParser.handle_piN)�__name__� __module__� __qualname__�__doc__r= rA rD rF rG rH rI rJ rK rL r) r) r) r* r: d s r: c C s t � }|�| � dS )z�Print out the HTMLParser events that occur during parsing. This lets you see how HTMLParser parses a document when no Beautiful Soup code is running. :param data: Some markup. N)r: �feed)r! r& r) r) r* �htmlparser_trace� s rR �aeiou�bcdfghjklmnpqrstvwxyz� c C s: d}t | �D ]}|d dkrt}nt}|t�|�7 }q|S )z#Generate a random word-like string.� � r )�range� _consonants�_vowels�random�choice)�lengthr< �i�tr) r) r* �rword� s r` � c C s d� dd� t| �D ��S )z'Generate a random sentence-like string.� c s s � | ] }t t�d d��V qdS )ra � N)r` r[ �randint)�.0r^ r) r) r* � <genexpr>� s � z rsentence.<locals>.<genexpr>)r rX )r] r) r) r* � rsentence� s rg �� c C s� g d�}g }t | �D ]9}t�dd�}|dkr#t�|�}|�d| � q |dkr3|�tt�dd��� q |dkrCt�|�}|�d| � q d d �|� d S ) z+Randomly generate an invalid HTML document.)�p�div�spanr^ �b�script�tabler � z<%s>� ra rW z</%s>z<html>� z</html>)rX r[ rd r\ r rg r )� num_elements� tag_names�elementsr^ r\ �tag_namer) r) r* �rdoc� s �rv 順 c C s& t dt � t| �}t dt|� � dddgddfD ]>}d}zt�� }t||�}t�� }d}W n tyK } zt d | � t�� W Y d }~nd }~ww |rXt d ||| f � qd d l m } t�� }|� |� t�� }t d|| � d d l } | � � }t�� }|�|� t�� }t d|| � d S )z.Very basic head-to-head performance benchmark.z1Comparative parser benchmark on Beautiful Soup %sz3Generated a large invalid HTML document (%d bytes).r r. r r FTr Nz"BS4+%s parsed the markup in %.2fs.r r z$Raw lxml parsed the markup in %.2fs.z(Raw html5lib parsed the markup in %.2fs.)r r rv �len�timer r r r r r �HTMLr r �parse) rr r! r& r' �ar( rl r% r r r) r) r* �benchmark_parsers� s: ��� r} r c C sX t �� }|j}t| �}tt||d�}t�d|||� t� |�}|� d� |� dd� dS )z7Use Python's profiler on a randomly generated document.)�bs4r! r& z bs4.BeautifulSoup(data, parser)� cumulativez _html5lib|bs4�2 N) �tempfile�NamedTemporaryFiler# rv �dictr~ �cProfile�runctx�pstats�Stats� sort_stats� print_stats)rr r& � filehandle�filenamer! �vars�statsr) r) r* �profile� s r� �__main__)T)rU )ra )rh )rw )rw r )!rP � __license__r� �ior � html.parserr r~ r r � bs4.builderr �osr� r[ r� ry r r r+ r9 r: rR rZ rY r` rg rv r} r� rM �stdinr r) r) r) r* �<module> s< 8& �PK z�Z?kF]' ]' css.pynu �[��� """Integration code for CSS selectors using Soup Sieve (pypi: soupsieve).""" import warnings try: import soupsieve except ImportError as e: soupsieve = None warnings.warn( 'The soupsieve package is not installed. CSS selectors cannot be used.' ) class CSS(object): """A proxy object against the soupsieve library, to simplify its CSS selector API. Acquire this object through the .css attribute on the BeautifulSoup object, or on the Tag you want to use as the starting point for a CSS selector. The main advantage of doing this is that the tag to be selected against doesn't need to be explicitly specified in the function calls, since it's already scoped to a tag. """ def __init__(self, tag, api=soupsieve): """Constructor. You don't need to instantiate this class yourself; instead, access the .css attribute on the BeautifulSoup object, or on the Tag you want to use as the starting point for your CSS selector. :param tag: All CSS selectors will use this as their starting point. :param api: A plug-in replacement for the soupsieve module, designed mainly for use in tests. """ if api is None: raise NotImplementedError( "Cannot execute CSS selectors because the soupsieve package is not installed." ) self.api = api self.tag = tag def escape(self, ident): """Escape a CSS identifier. This is a simple wrapper around soupselect.escape(). See the documentation for that function for more information. """ if soupsieve is None: raise NotImplementedError( "Cannot escape CSS identifiers because the soupsieve package is not installed." ) return self.api.escape(ident) def _ns(self, ns, select): """Normalize a dictionary of namespaces.""" if not isinstance(select, self.api.SoupSieve) and ns is None: # If the selector is a precompiled pattern, it already has # a namespace context compiled in, which cannot be # replaced. ns = self.tag._namespaces return ns def _rs(self, results): """Normalize a list of results to a Resultset. A ResultSet is more consistent with the rest of Beautiful Soup's API, and ResultSet.__getattr__ has a helpful error message if you try to treat a list of results as a single result (a common mistake). """ # Import here to avoid circular import from bs4.element import ResultSet return ResultSet(None, results) def compile(self, select, namespaces=None, flags=0, **kwargs): """Pre-compile a selector and return the compiled object. :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 flags: Flags to be passed into Soup Sieve's soupsieve.compile() method. :param kwargs: Keyword arguments to be passed into SoupSieve's soupsieve.compile() method. :return: A precompiled selector object. :rtype: soupsieve.SoupSieve """ return self.api.compile( select, self._ns(namespaces, select), flags, **kwargs ) def select_one(self, select, namespaces=None, flags=0, **kwargs): """Perform a CSS selection operation on the current Tag and return the first result. This uses the Soup Sieve library. For more information, see that library's documentation for the soupsieve.select_one() method. :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 flags: Flags to be passed into Soup Sieve's soupsieve.select_one() method. :param kwargs: Keyword arguments to be passed into SoupSieve's soupsieve.select_one() method. :return: A Tag, or None if the selector has no match. :rtype: bs4.element.Tag """ return self.api.select_one( select, self.tag, self._ns(namespaces, select), flags, **kwargs ) def select(self, select, namespaces=None, limit=0, flags=0, **kwargs): """Perform a CSS selection operation on the current Tag. This uses the Soup Sieve library. For more information, see that library's documentation for the soupsieve.select() method. :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 pass in the prefixes it encountered while parsing the document. :param limit: After finding this number of results, stop looking. :param flags: Flags to be passed into Soup Sieve's soupsieve.select() method. :param kwargs: Keyword arguments to be passed into SoupSieve's soupsieve.select() method. :return: A ResultSet of Tag objects. :rtype: bs4.element.ResultSet """ if limit is None: limit = 0 return self._rs( self.api.select( select, self.tag, self._ns(namespaces, select), limit, flags, **kwargs ) ) def iselect(self, select, namespaces=None, limit=0, flags=0, **kwargs): """Perform a CSS selection operation on the current Tag. This uses the Soup Sieve library. For more information, see that library's documentation for the soupsieve.iselect() method. It is the same as select(), but it returns a generator instead of a list. :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 pass in the prefixes it encountered while parsing the document. :param limit: After finding this number of results, stop looking. :param flags: Flags to be passed into Soup Sieve's soupsieve.iselect() method. :param kwargs: Keyword arguments to be passed into SoupSieve's soupsieve.iselect() method. :return: A generator :rtype: types.GeneratorType """ return self.api.iselect( select, self.tag, self._ns(namespaces, select), limit, flags, **kwargs ) def closest(self, select, namespaces=None, flags=0, **kwargs): """Find the Tag closest to this one that matches the given selector. This uses the Soup Sieve library. For more information, see that library's documentation for the soupsieve.closest() method. :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 pass in the prefixes it encountered while parsing the document. :param flags: Flags to be passed into Soup Sieve's soupsieve.closest() method. :param kwargs: Keyword arguments to be passed into SoupSieve's soupsieve.closest() method. :return: A Tag, or None if there is no match. :rtype: bs4.Tag """ return self.api.closest( select, self.tag, self._ns(namespaces, select), flags, **kwargs ) def match(self, select, namespaces=None, flags=0, **kwargs): """Check whether this Tag matches the given CSS selector. This uses the Soup Sieve library. For more information, see that library's documentation for the soupsieve.match() method. :param: a CSS selector. :param namespaces: A dictionary mapping namespace prefixes used in the CSS selector to namespace URIs. By default, Beautiful Soup will pass in the prefixes it encountered while parsing the document. :param flags: Flags to be passed into Soup Sieve's soupsieve.match() method. :param kwargs: Keyword arguments to be passed into SoupSieve's soupsieve.match() method. :return: True if this Tag matches the selector; False otherwise. :rtype: bool """ return self.api.match( select, self.tag, self._ns(namespaces, select), flags, **kwargs ) def filter(self, select, namespaces=None, flags=0, **kwargs): """Filter this Tag's direct children based on the given CSS selector. This uses the Soup Sieve library. It works the same way as passing this Tag into that library's soupsieve.filter() method. More information, for more information see the documentation for soupsieve.filter(). :param namespaces: A dictionary mapping namespace prefixes used in the CSS selector to namespace URIs. By default, Beautiful Soup will pass in the prefixes it encountered while parsing the document. :param flags: Flags to be passed into Soup Sieve's soupsieve.filter() method. :param kwargs: Keyword arguments to be passed into SoupSieve's soupsieve.filter() method. :return: A ResultSet of Tag objects. :rtype: bs4.element.ResultSet """ return self._rs( self.api.filter( select, self.tag, self._ns(namespaces, select), flags, **kwargs ) ) PK z�ZO�{�j �j element.pynu �[��� # Use of this source code is governed by the MIT license. __license__ = "MIT" try: from collections.abc import Callable # Python 3.6 except ImportError as e: from collections import Callable import re import sys import warnings from bs4.css import CSS from bs4.formatter import ( Formatter, HTMLFormatter, XMLFormatter, ) DEFAULT_OUTPUT_ENCODING = "utf-8" nonwhitespace_re = re.compile(r"\S+") # NOTE: This isn't used as of 4.7.0. I'm leaving it for a little bit on # the off chance someone imported it for their own use. whitespace_re = re.compile(r"\s+") def _alias(attr): """Alias one attribute name to another for backward compatibility""" @property def alias(self): return getattr(self, attr) @alias.setter def alias(self): return setattr(self, attr) return alias # These encodings are recognized by Python (so PageElement.encode # could theoretically support them) but XML and HTML don't recognize # them (so they should not show up in an XML or HTML document as that # document's encoding). # # If an XML document is encoded in one of these encodings, no encoding # will be mentioned in the XML declaration. If an HTML document is # encoded in one of these encodings, and the HTML document has a # <meta> tag that mentions an encoding, the encoding will be given as # the empty string. # # Source: # https://docs.python.org/3/library/codecs.html#python-specific-encodings PYTHON_SPECIFIC_ENCODINGS = set([ "idna", "mbcs", "oem", "palmos", "punycode", "raw_unicode_escape", "undefined", "unicode_escape", "raw-unicode-escape", "unicode-escape", "string-escape", "string_escape", ]) class NamespacedAttribute(str): """A namespaced string (e.g. 'xml:lang') that remembers the namespace ('xml') and the name ('lang') that were used to create it. """ def __new__(cls, prefix, name=None, namespace=None): if not name: # This is the default namespace. Its name "has no value" # per https://www.w3.org/TR/xml-names/#defaulting name = None if not name: obj = str.__new__(cls, prefix) elif not prefix: # Not really namespaced. obj = str.__new__(cls, name) else: obj = str.__new__(cls, prefix + ":" + name) obj.prefix = prefix obj.name = name obj.namespace = namespace return obj class AttributeValueWithCharsetSubstitution(str): """A stand-in object for a character encoding specified in HTML.""" class CharsetMetaAttributeValue(AttributeValueWithCharsetSubstitution): """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. """ def __new__(cls, original_value): obj = str.__new__(cls, original_value) obj.original_value = original_value return obj def encode(self, encoding): """When an HTML document is being encoded to a given encoding, the value of a meta tag's 'charset' is the name of the encoding. """ if encoding in PYTHON_SPECIFIC_ENCODINGS: return '' return encoding class ContentMetaAttributeValue(AttributeValueWithCharsetSubstitution): """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. """ CHARSET_RE = re.compile(r"((^|;)\s*charset=)([^;]*)", re.M) def __new__(cls, original_value): match = cls.CHARSET_RE.search(original_value) if match is None: # No substitution necessary. return str.__new__(str, original_value) obj = str.__new__(cls, original_value) obj.original_value = original_value return obj def encode(self, encoding): if encoding in PYTHON_SPECIFIC_ENCODINGS: return '' def rewrite(match): return match.group(1) + encoding return self.CHARSET_RE.sub(rewrite, self.original_value) class PageElement(object): """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. """ # In general, we can't tell just by looking at an element whether # it's contained in an XML document or an HTML document. But for # Tags (q.v.) we can store this information at parse time. known_xml = None def setup(self, parent=None, previous_element=None, next_element=None, previous_sibling=None, next_sibling=None): """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. """ self.parent = parent self.previous_element = previous_element if previous_element is not None: self.previous_element.next_element = self self.next_element = next_element if self.next_element is not None: self.next_element.previous_element = self self.next_sibling = next_sibling if self.next_sibling is not None: self.next_sibling.previous_sibling = self if (previous_sibling is None and self.parent is not None and self.parent.contents): previous_sibling = self.parent.contents[-1] self.previous_sibling = previous_sibling if previous_sibling is not None: self.previous_sibling.next_sibling = self def format_string(self, s, formatter): """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. """ if formatter is None: return s if not isinstance(formatter, Formatter): formatter = self.formatter_for_name(formatter) output = formatter.substitute(s) return output def formatter_for_name(self, formatter): """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. """ if isinstance(formatter, Formatter): return formatter if self._is_xml: c = XMLFormatter else: c = HTMLFormatter if isinstance(formatter, Callable): return c(entity_substitution=formatter) return c.REGISTRY[formatter] @property def _is_xml(self): """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. """ if self.known_xml is not None: # Most of the time we will have determined this when the # document is parsed. return self.known_xml # Otherwise, it's likely that this element was created by # direct invocation of the constructor from within the user's # Python code. if self.parent is None: # This is the top-level object. It should have .known_xml set # from tree creation. If not, take a guess--BS is usually # used on HTML markup. return getattr(self, 'is_xml', False) return self.parent._is_xml nextSibling = _alias("next_sibling") # BS3 previousSibling = _alias("previous_sibling") # BS3 default = object() def _all_strings(self, strip=False, types=default): """Yield all strings of certain classes, possibly stripping them. This is implemented differently in Tag and NavigableString. """ raise NotImplementedError() @property def stripped_strings(self): """Yield all strings in this PageElement, stripping them first. :yield: A sequence of stripped strings. """ for string in self._all_strings(True): yield string def get_text(self, separator="", strip=False, types=default): """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. """ return separator.join([s for s in self._all_strings( strip, types=types)]) getText = get_text text = property(get_text) def replace_with(self, *args): """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. """ if self.parent is None: raise ValueError( "Cannot replace one element with another when the " "element to be replaced is not part of a tree.") if len(args) == 1 and args[0] is self: return if any(x is self.parent for x in args): raise ValueError("Cannot replace a Tag with its parent.") old_parent = self.parent my_index = self.parent.index(self) self.extract(_self_index=my_index) for idx, replace_with in enumerate(args, start=my_index): old_parent.insert(idx, replace_with) return self replaceWith = replace_with # BS3 def unwrap(self): """Replace this PageElement with its contents. :return: `self`, no longer part of the tree. """ my_parent = self.parent if self.parent is None: raise ValueError( "Cannot replace an element with its contents when that" "element is not part of a tree.") my_index = self.parent.index(self) self.extract(_self_index=my_index) for child in reversed(self.contents[:]): my_parent.insert(my_index, child) return self replace_with_children = unwrap replaceWithChildren = unwrap # BS3 def wrap(self, wrap_inside): """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. """ me = self.replace_with(wrap_inside) wrap_inside.append(me) return wrap_inside def extract(self, _self_index=None): """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. """ if self.parent is not None: if _self_index is None: _self_index = self.parent.index(self) del self.parent.contents[_self_index] #Find the two elements that would be next to each other if #this element (and any children) hadn't been parsed. Connect #the two. last_child = self._last_descendant() next_element = last_child.next_element if (self.previous_element is not None and self.previous_element is not next_element): self.previous_element.next_element = next_element if next_element is not None and next_element is not self.previous_element: next_element.previous_element = self.previous_element self.previous_element = None last_child.next_element = None self.parent = None if (self.previous_sibling is not None and self.previous_sibling is not self.next_sibling): self.previous_sibling.next_sibling = self.next_sibling if (self.next_sibling is not None and self.next_sibling is not self.previous_sibling): self.next_sibling.previous_sibling = self.previous_sibling self.previous_sibling = self.next_sibling = None return self def _last_descendant(self, is_initialized=True, accept_self=True): """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? """ if is_initialized and self.next_sibling is not None: last_child = self.next_sibling.previous_element else: last_child = self while isinstance(last_child, Tag) and last_child.contents: last_child = last_child.contents[-1] if not accept_self and last_child is self: last_child = None return last_child # BS3: Not part of the API! _lastRecursiveChild = _last_descendant def insert(self, position, new_child): """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. """ if new_child is None: raise ValueError("Cannot insert None into a tag.") if new_child is self: raise ValueError("Cannot insert a tag into itself.") if (isinstance(new_child, str) and not isinstance(new_child, NavigableString)): new_child = NavigableString(new_child) from bs4 import BeautifulSoup if isinstance(new_child, BeautifulSoup): # We don't want to end up with a situation where one BeautifulSoup # object contains another. Insert the children one at a time. for subchild in list(new_child.contents): self.insert(position, subchild) position += 1 return position = min(position, len(self.contents)) if hasattr(new_child, 'parent') and new_child.parent is not None: # We're 'inserting' an element that's already one # of this object's children. if new_child.parent is self: current_index = self.index(new_child) if current_index < position: # We're moving this element further down the list # of this object's children. That means that when # we extract this element, our target index will # jump down one. position -= 1 new_child.extract() new_child.parent = self previous_child = None if position == 0: new_child.previous_sibling = None new_child.previous_element = self else: previous_child = self.contents[position - 1] new_child.previous_sibling = previous_child new_child.previous_sibling.next_sibling = new_child new_child.previous_element = previous_child._last_descendant(False) if new_child.previous_element is not None: new_child.previous_element.next_element = new_child new_childs_last_element = new_child._last_descendant(False) if position >= len(self.contents): new_child.next_sibling = None parent = self parents_next_sibling = None while parents_next_sibling is None and parent is not None: parents_next_sibling = parent.next_sibling parent = parent.parent if parents_next_sibling is not None: # We found the element that comes next in the document. break if parents_next_sibling is not None: new_childs_last_element.next_element = parents_next_sibling else: # The last element of this tag is the last element in # the document. new_childs_last_element.next_element = None else: next_child = self.contents[position] new_child.next_sibling = next_child if new_child.next_sibling is not None: new_child.next_sibling.previous_sibling = new_child new_childs_last_element.next_element = next_child if new_childs_last_element.next_element is not None: new_childs_last_element.next_element.previous_element = new_childs_last_element self.contents.insert(position, new_child) def append(self, tag): """Appends the given PageElement to the contents of this one. :param tag: A PageElement. """ self.insert(len(self.contents), tag) def extend(self, tags): """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. """ if isinstance(tags, Tag): tags = tags.contents if isinstance(tags, list): # Moving items around the tree may change their position in # the original list. Make a list that won't change. tags = list(tags) for tag in tags: self.append(tag) def insert_before(self, *args): """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. """ parent = self.parent if parent is None: raise ValueError( "Element has no parent, so 'before' has no meaning.") if any(x is self for x in args): raise ValueError("Can't insert an element before itself.") for predecessor in args: # Extract first so that the index won't be screwed up if they # are siblings. if isinstance(predecessor, PageElement): predecessor.extract() index = parent.index(self) parent.insert(index, predecessor) def insert_after(self, *args): """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. """ # Do all error checking before modifying the tree. parent = self.parent if parent is None: raise ValueError( "Element has no parent, so 'after' has no meaning.") if any(x is self for x in args): raise ValueError("Can't insert an element after itself.") offset = 0 for successor in args: # Extract first so that the index won't be screwed up if they # are siblings. if isinstance(successor, PageElement): successor.extract() index = parent.index(self) parent.insert(index+1+offset, successor) offset += 1 def find_next(self, name=None, attrs={}, string=None, **kwargs): """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 """ return self._find_one(self.find_all_next, name, attrs, string, **kwargs) findNext = find_next # BS3 def find_all_next(self, name=None, attrs={}, string=None, limit=None, **kwargs): """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 = kwargs.pop('_stacklevel', 2) return self._find_all(name, attrs, string, limit, self.next_elements, _stacklevel=_stacklevel+1, **kwargs) findAllNext = find_all_next # BS3 def find_next_sibling(self, name=None, attrs={}, string=None, **kwargs): """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 """ return self._find_one(self.find_next_siblings, name, attrs, string, **kwargs) findNextSibling = find_next_sibling # BS3 def find_next_siblings(self, name=None, attrs={}, string=None, limit=None, **kwargs): """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 """ _stacklevel = kwargs.pop('_stacklevel', 2) return self._find_all( name, attrs, string, limit, self.next_siblings, _stacklevel=_stacklevel+1, **kwargs ) findNextSiblings = find_next_siblings # BS3 fetchNextSiblings = find_next_siblings # BS2 def find_previous(self, name=None, attrs={}, string=None, **kwargs): """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 """ return self._find_one( self.find_all_previous, name, attrs, string, **kwargs) findPrevious = find_previous # BS3 def find_all_previous(self, name=None, attrs={}, string=None, limit=None, **kwargs): """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 """ _stacklevel = kwargs.pop('_stacklevel', 2) return self._find_all( name, attrs, string, limit, self.previous_elements, _stacklevel=_stacklevel+1, **kwargs ) findAllPrevious = find_all_previous # BS3 fetchPrevious = find_all_previous # BS2 def find_previous_sibling(self, name=None, attrs={}, string=None, **kwargs): """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 """ return self._find_one(self.find_previous_siblings, name, attrs, string, **kwargs) findPreviousSibling = find_previous_sibling # BS3 def find_previous_siblings(self, name=None, attrs={}, string=None, limit=None, **kwargs): """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 """ _stacklevel = kwargs.pop('_stacklevel', 2) return self._find_all( name, attrs, string, limit, self.previous_siblings, _stacklevel=_stacklevel+1, **kwargs ) findPreviousSiblings = find_previous_siblings # BS3 fetchPreviousSiblings = find_previous_siblings # BS2 def find_parent(self, name=None, attrs={}, **kwargs): """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 """ # NOTE: We can't use _find_one because findParents takes a different # set of arguments. r = None l = self.find_parents(name, attrs, 1, _stacklevel=3, **kwargs) if l: r = l[0] return r findParent = find_parent # BS3 def find_parents(self, name=None, attrs={}, limit=None, **kwargs): """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 """ _stacklevel = kwargs.pop('_stacklevel', 2) return self._find_all(name, attrs, None, limit, self.parents, _stacklevel=_stacklevel+1, **kwargs) findParents = find_parents # BS3 fetchParents = find_parents # BS2 @property def next(self): """The PageElement, if any, that was parsed just after this one. :return: A PageElement. :rtype: bs4.element.Tag | bs4.element.NavigableString """ return self.next_element @property def previous(self): """The PageElement, if any, that was parsed just before this one. :return: A PageElement. :rtype: bs4.element.Tag | bs4.element.NavigableString """ return self.previous_element #These methods do the real heavy lifting. def _find_one(self, method, name, attrs, string, **kwargs): r = None l = method(name, attrs, string, 1, _stacklevel=4, **kwargs) if l: r = l[0] return r def _find_all(self, name, attrs, string, limit, generator, **kwargs): "Iterates over a generator looking for things that match." _stacklevel = kwargs.pop('_stacklevel', 3) if string is None and 'text' in kwargs: string = kwargs.pop('text') warnings.warn( "The 'text' argument to find()-type methods is deprecated. Use 'string' instead.", DeprecationWarning, stacklevel=_stacklevel ) if isinstance(name, SoupStrainer): strainer = name else: strainer = SoupStrainer(name, attrs, string, **kwargs) if string is None and not limit and not attrs and not kwargs: if name is True or name is None: # Optimization to find all tags. result = (element for element in generator if isinstance(element, Tag)) return ResultSet(strainer, result) elif isinstance(name, str): # Optimization to find all tags with a given name. if name.count(':') == 1: # This is a name with a prefix. If this is a namespace-aware document, # we need to match the local name against tag.name. If not, # we need to match the fully-qualified name against tag.name. prefix, local_name = name.split(':', 1) else: prefix = None local_name = name result = (element for element in generator if isinstance(element, Tag) and ( element.name == name ) or ( element.name == local_name and (prefix is None or element.prefix == prefix) ) ) return ResultSet(strainer, result) results = ResultSet(strainer) while True: try: i = next(generator) except StopIteration: break if i: found = strainer.search(i) if found: results.append(found) if limit and len(results) >= limit: break return results #These generators can be used to navigate starting from both #NavigableStrings and Tags. @property def next_elements(self): """All PageElements that were parsed after this one. :yield: A sequence of PageElements. """ i = self.next_element while i is not None: yield i i = i.next_element @property def next_siblings(self): """All PageElements that are siblings of this one but were parsed later. :yield: A sequence of PageElements. """ i = self.next_sibling while i is not None: yield i i = i.next_sibling @property def previous_elements(self): """All PageElements that were parsed before this one. :yield: A sequence of PageElements. """ i = self.previous_element while i is not None: yield i i = i.previous_element @property def previous_siblings(self): """All PageElements that are siblings of this one but were parsed earlier. :yield: A sequence of PageElements. """ i = self.previous_sibling while i is not None: yield i i = i.previous_sibling @property def parents(self): """All PageElements that are parents of this PageElement. :yield: A sequence of PageElements. """ i = self.parent while i is not None: yield i i = i.parent @property def decomposed(self): """Check whether a PageElement has been decomposed. :rtype: bool """ return getattr(self, '_decomposed', False) or False # Old non-property versions of the generators, for backwards # compatibility with BS3. def nextGenerator(self): return self.next_elements def nextSiblingGenerator(self): return self.next_siblings def previousGenerator(self): return self.previous_elements def previousSiblingGenerator(self): return self.previous_siblings def parentGenerator(self): return self.parents class NavigableString(str, PageElement): """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". """ PREFIX = '' SUFFIX = '' def __new__(cls, value): """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. """ if isinstance(value, str): u = str.__new__(cls, value) else: u = str.__new__(cls, value, DEFAULT_OUTPUT_ENCODING) u.setup() return u def __deepcopy__(self, memo, recursive=False): """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__. """ return type(self)(self) def __copy__(self): """A copy of a NavigableString can only be a deep copy, because only one PageElement can occupy a given place in a parse tree. """ return self.__deepcopy__({}) def __getnewargs__(self): return (str(self),) def __getattr__(self, attr): """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.""" if attr == 'string': return self else: raise AttributeError( "'%s' object has no attribute '%s'" % ( self.__class__.__name__, attr)) def output_ready(self, formatter="minimal"): """Run the string through the provided formatter. :param formatter: A Formatter object, or a string naming one of the standard formatters. """ output = self.format_string(self, formatter) return self.PREFIX + output + self.SUFFIX @property def name(self): """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] """ return None @name.setter def name(self, name): """Prevent NavigableString.name from ever being set.""" raise AttributeError("A NavigableString cannot be given a name.") def _all_strings(self, strip=False, types=PageElement.default): """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. """ if types is self.default: # This is kept in Tag because it's full of subclasses of # this class, which aren't defined until later in the file. types = Tag.DEFAULT_INTERESTING_STRING_TYPES # Do nothing if the caller is looking for specific types of # string, and we're of a different type. # # We check specific types instead of using isinstance(self, # types) because all of these classes subclass # NavigableString. Anyone who's using this feature probably # wants generic NavigableStrings but not other stuff. my_type = type(self) if types is not None: if isinstance(types, type): # Looking for a single type. if my_type is not types: return elif my_type not in types: # Looking for one of a list of types. return value = self if strip: value = value.strip() if len(value) > 0: yield value strings = property(_all_strings) class PreformattedString(NavigableString): """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). """ PREFIX = '' SUFFIX = '' def output_ready(self, formatter=None): """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. """ if formatter is not None: ignore = self.format_string(self, formatter) return self.PREFIX + self + self.SUFFIX class CData(PreformattedString): """A CDATA block.""" PREFIX = '<![CDATA[' SUFFIX = ']]>' class ProcessingInstruction(PreformattedString): """A SGML processing instruction.""" PREFIX = '<?' SUFFIX = '>' class XMLProcessingInstruction(ProcessingInstruction): """An XML processing instruction.""" PREFIX = '<?' SUFFIX = '?>' class Comment(PreformattedString): """An HTML or XML comment.""" PREFIX = '<!--' SUFFIX = '-->' class Declaration(PreformattedString): """An XML declaration.""" PREFIX = '<?' SUFFIX = '?>' class Doctype(PreformattedString): """A document type declaration.""" @classmethod def for_name_and_ids(cls, name, pub_id, system_id): """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. """ value = name or '' if pub_id is not None: value += ' PUBLIC "%s"' % pub_id if system_id is not None: value += ' "%s"' % system_id elif system_id is not None: value += ' SYSTEM "%s"' % system_id return Doctype(value) PREFIX = '<!DOCTYPE ' SUFFIX = '>\n' class Stylesheet(NavigableString): """A NavigableString representing an stylesheet (probably CSS). Used to distinguish embedded stylesheets from textual content. """ pass class Script(NavigableString): """A NavigableString representing an executable script (probably Javascript). Used to distinguish executable code from textual content. """ pass class TemplateString(NavigableString): """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. """ pass class RubyTextString(NavigableString): """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. """ pass class RubyParenthesisString(NavigableString): """A NavigableString representing the contents of the <rp> HTML element. https://dev.w3.org/html5/spec-LC/text-level-semantics.html#the-rp-element """ pass class Tag(PageElement): """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. """ def __init__(self, parser=None, builder=None, name=None, namespace=None, prefix=None, attrs=None, parent=None, previous=None, is_xml=None, sourceline=None, sourcepos=None, can_be_empty_element=None, cdata_list_attributes=None, preserve_whitespace_tags=None, interesting_string_types=None, namespaces=None ): """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. """ if parser is None: self.parser_class = None else: # We don't actually store the parser object: that lets extracted # chunks be garbage-collected. self.parser_class = parser.__class__ if name is None: raise ValueError("No value provided for new tag's name.") self.name = name self.namespace = namespace self._namespaces = namespaces or {} self.prefix = prefix if ((not builder or builder.store_line_numbers) and (sourceline is not None or sourcepos is not None)): self.sourceline = sourceline self.sourcepos = sourcepos if attrs is None: attrs = {} elif attrs: if builder is not None and builder.cdata_list_attributes: attrs = builder._replace_cdata_list_attribute_values( self.name, attrs) else: attrs = dict(attrs) else: attrs = dict(attrs) # If possible, determine ahead of time whether this tag is an # XML tag. if builder: self.known_xml = builder.is_xml else: self.known_xml = is_xml self.attrs = attrs self.contents = [] self.setup(parent, previous) self.hidden = False if builder is None: # In the absence of a TreeBuilder, use whatever values were # passed in here. They're probably None, unless this is a copy of some # other tag. self.can_be_empty_element = can_be_empty_element self.cdata_list_attributes = cdata_list_attributes self.preserve_whitespace_tags = preserve_whitespace_tags self.interesting_string_types = interesting_string_types else: # Set up any substitutions for this tag, such as the charset in a META tag. builder.set_up_substitutions(self) # Ask the TreeBuilder whether this tag might be an empty-element tag. self.can_be_empty_element = builder.can_be_empty_element(name) # Keep track of the list of attributes of this tag that # might need to be treated as a list. # # For performance reasons, we store the whole data structure # rather than asking the question of every tag. Asking would # require building a new data structure every time, and # (unlike can_be_empty_element), we almost never need # to check this. self.cdata_list_attributes = builder.cdata_list_attributes # Keep track of the names that might cause this tag to be treated as a # whitespace-preserved tag. self.preserve_whitespace_tags = builder.preserve_whitespace_tags if self.name in builder.string_containers: # This sort of tag uses a special string container # subclass for most of its strings. When we ask the self.interesting_string_types = builder.string_containers[self.name] else: self.interesting_string_types = self.DEFAULT_INTERESTING_STRING_TYPES parserClass = _alias("parser_class") # BS3 def __deepcopy__(self, memo, recursive=True): """A deepcopy of a Tag is a new Tag, unconnected to the parse tree. Its contents are a copy of the old Tag's contents. """ clone = self._clone() if recursive: # Clone this tag's descendants recursively, but without # making any recursive function calls. tag_stack = [clone] for event, element in self._event_stream(self.descendants): if event is Tag.END_ELEMENT_EVENT: # Stop appending incoming Tags to the Tag that was # just closed. tag_stack.pop() else: descendant_clone = element.__deepcopy__( memo, recursive=False ) # Add to its parent's .contents tag_stack[-1].append(descendant_clone) if event is Tag.START_ELEMENT_EVENT: # Add the Tag itself to the stack so that its # children will be .appended to it. tag_stack.append(descendant_clone) return clone def __copy__(self): """A copy of a Tag must always be a deep copy, because a Tag's children can only have one parent at a time. """ return self.__deepcopy__({}) def _clone(self): """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. """ clone = type(self)( None, None, self.name, self.namespace, self.prefix, self.attrs, is_xml=self._is_xml, sourceline=self.sourceline, sourcepos=self.sourcepos, can_be_empty_element=self.can_be_empty_element, cdata_list_attributes=self.cdata_list_attributes, preserve_whitespace_tags=self.preserve_whitespace_tags, interesting_string_types=self.interesting_string_types ) for attr in ('can_be_empty_element', 'hidden'): setattr(clone, attr, getattr(self, attr)) return clone @property def is_empty_element(self): """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. """ return len(self.contents) == 0 and self.can_be_empty_element isSelfClosing = is_empty_element # BS3 @property def string(self): """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. """ if len(self.contents) != 1: return None child = self.contents[0] if isinstance(child, NavigableString): return child return child.string @string.setter def string(self, string): """Replace this PageElement's contents with `string`.""" self.clear() self.append(string.__class__(string)) DEFAULT_INTERESTING_STRING_TYPES = (NavigableString, CData) def _all_strings(self, strip=False, types=PageElement.default): """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. """ if types is self.default: types = self.interesting_string_types for descendant in self.descendants: if (types is None and not isinstance(descendant, NavigableString)): continue descendant_type = type(descendant) if isinstance(types, type): if descendant_type is not types: # We're not interested in strings of this type. continue elif types is not None and descendant_type not in types: # We're not interested in strings of this type. continue if strip: descendant = descendant.strip() if len(descendant) == 0: continue yield descendant strings = property(_all_strings) def decompose(self): """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. """ self.extract() i = self while i is not None: n = i.next_element i.__dict__.clear() i.contents = [] i._decomposed = True i = n def clear(self, decompose=False): """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(). """ if decompose: for element in self.contents[:]: if isinstance(element, Tag): element.decompose() else: element.extract() else: for element in self.contents[:]: element.extract() def smooth(self): """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. """ # Mark the first position of every pair of children that need # to be consolidated. Do this rather than making a copy of # self.contents, since in most cases very few strings will be # affected. marked = [] for i, a in enumerate(self.contents): if isinstance(a, Tag): # Recursively smooth children. a.smooth() if i == len(self.contents)-1: # This is the last item in .contents, and it's not a # tag. There's no chance it needs any work. continue b = self.contents[i+1] if (isinstance(a, NavigableString) and isinstance(b, NavigableString) and not isinstance(a, PreformattedString) and not isinstance(b, PreformattedString) ): marked.append(i) # Go over the marked positions in reverse order, so that # removing items from .contents won't affect the remaining # positions. for i in reversed(marked): a = self.contents[i] b = self.contents[i+1] b.extract() n = NavigableString(a+b) a.replace_with(n) def index(self, element): """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`. """ for i, child in enumerate(self.contents): if child is element: return i raise ValueError("Tag.index: element not in tag") def get(self, key, default=None): """Returns the value of the 'key' attribute for the tag, or the value given for 'default' if it doesn't have that attribute.""" return self.attrs.get(key, default) def get_attribute_list(self, key, default=None): """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. """ value = self.get(key, default) if not isinstance(value, list): value = [value] return value def has_attr(self, key): """Does this PageElement have an attribute with the given name?""" return key in self.attrs def __hash__(self): return str(self).__hash__() def __getitem__(self, key): """tag[key] returns the value of the 'key' attribute for the Tag, and throws an exception if it's not there.""" return self.attrs[key] def __iter__(self): "Iterating over a Tag iterates over its contents." return iter(self.contents) def __len__(self): "The length of a Tag is the length of its list of contents." return len(self.contents) def __contains__(self, x): return x in self.contents def __bool__(self): "A tag is non-None even if it has no contents." return True def __setitem__(self, key, value): """Setting tag[key] sets the value of the 'key' attribute for the tag.""" self.attrs[key] = value def __delitem__(self, key): "Deleting tag[key] deletes all 'key' attributes for the tag." self.attrs.pop(key, None) def __call__(self, *args, **kwargs): """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.""" return self.find_all(*args, **kwargs) def __getattr__(self, tag): """Calling tag.subtag is the same as calling tag.find(name="subtag")""" #print("Getattr %s.%s" % (self.__class__, tag)) if len(tag) > 3 and tag.endswith('Tag'): # BS3: soup.aTag -> "soup.find("a") tag_name = tag[:-3] warnings.warn( '.%(name)sTag is deprecated, use .find("%(name)s") instead. If you really were looking for a tag called %(name)sTag, use .find("%(name)sTag")' % dict( name=tag_name ), DeprecationWarning, stacklevel=2 ) return self.find(tag_name) # We special case contents to avoid recursion. elif not tag.startswith("__") and not tag == "contents": return self.find(tag) raise AttributeError( "'%s' object has no attribute '%s'" % (self.__class__, tag)) def __eq__(self, other): """Returns true iff this Tag has the same name, the same attributes, and the same contents (recursively) as `other`.""" if self is other: return True if (not hasattr(other, 'name') or not hasattr(other, 'attrs') or not hasattr(other, 'contents') or self.name != other.name or self.attrs != other.attrs or len(self) != len(other)): return False for i, my_child in enumerate(self.contents): if my_child != other.contents[i]: return False return True def __ne__(self, other): """Returns true iff this Tag is not identical to `other`, as defined in __eq__.""" return not self == other def __repr__(self, encoding="unicode-escape"): """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. """ # "The return value must be a string object", i.e. Unicode return self.decode() def __unicode__(self): """Renders this PageElement as a Unicode string.""" return self.decode() __str__ = __repr__ = __unicode__ def encode(self, encoding=DEFAULT_OUTPUT_ENCODING, indent_level=None, formatter="minimal", errors="xmlcharrefreplace"): """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. """ # Turn the data structure into Unicode, then encode the # Unicode. u = self.decode(indent_level, encoding, formatter) return u.encode(encoding, errors) def decode(self, indent_level=None, eventual_encoding=DEFAULT_OUTPUT_ENCODING, formatter="minimal", iterator=None): pieces = [] # First off, turn a non-Formatter `formatter` into a Formatter # object. This will stop the lookup from happening over and # over again. if not isinstance(formatter, Formatter): formatter = self.formatter_for_name(formatter) if indent_level is True: indent_level = 0 # The currently active tag that put us into string literal # mode. Until this element is closed, children will be treated # as string literals and not pretty-printed. String literal # mode is turned on immediately after this tag begins, and # turned off immediately before it's closed. This means there # will be whitespace before and after the tag itself. string_literal_tag = None for event, element in self._event_stream(iterator): if event in (Tag.START_ELEMENT_EVENT, Tag.EMPTY_ELEMENT_EVENT): piece = element._format_tag( eventual_encoding, formatter, opening=True ) elif event is Tag.END_ELEMENT_EVENT: piece = element._format_tag( eventual_encoding, formatter, opening=False ) if indent_level is not None: indent_level -= 1 else: piece = element.output_ready(formatter) # Now we need to apply the 'prettiness' -- extra # whitespace before and/or after this tag. This can get # complicated because certain tags, like <pre> and # <script>, can't be prettified, since adding whitespace would # change the meaning of the content. # The default behavior is to add whitespace before and # after an element when string literal mode is off, and to # leave things as they are when string literal mode is on. if string_literal_tag: indent_before = indent_after = False else: indent_before = indent_after = True # The only time the behavior is more complex than that is # when we encounter an opening or closing tag that might # put us into or out of string literal mode. if (event is Tag.START_ELEMENT_EVENT and not string_literal_tag and not element._should_pretty_print()): # We are about to enter string literal mode. Add # whitespace before this tag, but not after. We # will stay in string literal mode until this tag # is closed. indent_before = True indent_after = False string_literal_tag = element elif (event is Tag.END_ELEMENT_EVENT and element is string_literal_tag): # We are about to exit string literal mode by closing # the tag that sent us into that mode. Add whitespace # after this tag, but not before. indent_before = False indent_after = True string_literal_tag = None # Now we know whether to add whitespace before and/or # after this element. if indent_level is not None: if (indent_before or indent_after): if isinstance(element, NavigableString): piece = piece.strip() if piece: piece = self._indent_string( piece, indent_level, formatter, indent_before, indent_after ) if event == Tag.START_ELEMENT_EVENT: indent_level += 1 pieces.append(piece) return "".join(pieces) # Names for the different events yielded by _event_stream START_ELEMENT_EVENT = object() END_ELEMENT_EVENT = object() EMPTY_ELEMENT_EVENT = object() STRING_ELEMENT_EVENT = object() def _event_stream(self, iterator=None): """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. """ tag_stack = [] iterator = iterator or self.self_and_descendants for c in iterator: # If the parent of the element we're about to yield is not # the tag currently on the stack, it means that the tag on # the stack closed before this element appeared. while tag_stack and c.parent != tag_stack[-1]: now_closed_tag = tag_stack.pop() yield Tag.END_ELEMENT_EVENT, now_closed_tag if isinstance(c, Tag): if c.is_empty_element: yield Tag.EMPTY_ELEMENT_EVENT, c else: yield Tag.START_ELEMENT_EVENT, c tag_stack.append(c) continue else: yield Tag.STRING_ELEMENT_EVENT, c while tag_stack: now_closed_tag = tag_stack.pop() yield Tag.END_ELEMENT_EVENT, now_closed_tag def _indent_string(self, s, indent_level, formatter, indent_before, indent_after): """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. """ space_before = '' if indent_before and indent_level: space_before = (formatter.indent * indent_level) space_after = '' if indent_after: space_after = "\n" return space_before + s + space_after def _format_tag(self, eventual_encoding, formatter, opening): if self.hidden: # A hidden tag is invisible, although its contents # are visible. return '' # A tag starts with the < character (see below). # Then the / character, if this is a closing tag. closing_slash = '' if not opening: closing_slash = '/' # Then an optional namespace prefix. prefix = '' if self.prefix: prefix = self.prefix + ":" # Then a list of attribute values, if this is an opening tag. attribute_string = '' if opening: attributes = formatter.attributes(self) attrs = [] for key, val in attributes: if val is None: decoded = key else: if isinstance(val, list) or isinstance(val, tuple): val = ' '.join(val) elif not isinstance(val, str): val = str(val) elif ( isinstance(val, AttributeValueWithCharsetSubstitution) and eventual_encoding is not None ): val = val.encode(eventual_encoding) text = formatter.attribute_value(val) decoded = ( str(key) + '=' + formatter.quoted_attribute_value(text)) attrs.append(decoded) if attrs: attribute_string = ' ' + ' '.join(attrs) # Then an optional closing slash (for a void element in an # XML document). void_element_closing_slash = '' if self.is_empty_element: void_element_closing_slash = formatter.void_element_close_prefix or '' # Put it all together. return '<' + closing_slash + prefix + self.name + attribute_string + void_element_closing_slash + '>' def _should_pretty_print(self, indent_level=1): """Should this tag be pretty-printed? Most of them should, but some (such as <pre> in HTML documents) should not. """ return ( indent_level is not None and ( not self.preserve_whitespace_tags or self.name not in self.preserve_whitespace_tags ) ) def prettify(self, encoding=None, formatter="minimal"): """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). """ if encoding is None: return self.decode(True, formatter=formatter) else: return self.encode(encoding, True, formatter=formatter) def decode_contents(self, indent_level=None, eventual_encoding=DEFAULT_OUTPUT_ENCODING, formatter="minimal"): """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. """ return self.decode(indent_level, eventual_encoding, formatter, iterator=self.descendants) def encode_contents( self, indent_level=None, encoding=DEFAULT_OUTPUT_ENCODING, formatter="minimal"): """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. """ contents = self.decode_contents(indent_level, encoding, formatter) return contents.encode(encoding) # Old method for BS3 compatibility def renderContents(self, encoding=DEFAULT_OUTPUT_ENCODING, prettyPrint=False, indentLevel=0): """Deprecated method for BS3 compatibility.""" if not prettyPrint: indentLevel = None return self.encode_contents( indent_level=indentLevel, encoding=encoding) #Soup methods def find(self, name=None, attrs={}, recursive=True, string=None, **kwargs): """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 """ r = None l = self.find_all(name, attrs, recursive, string, 1, _stacklevel=3, **kwargs) if l: r = l[0] return r findChild = find #BS2 def find_all(self, name=None, attrs={}, recursive=True, string=None, limit=None, **kwargs): """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 """ generator = self.descendants if not recursive: generator = self.children _stacklevel = kwargs.pop('_stacklevel', 2) return self._find_all(name, attrs, string, limit, generator, _stacklevel=_stacklevel+1, **kwargs) findAll = find_all # BS3 findChildren = find_all # BS2 #Generator methods @property def children(self): """Iterate over all direct children of this PageElement. :yield: A sequence of PageElements. """ # return iter() to make the purpose of the method clear return iter(self.contents) # XXX This seems to be untested. @property def self_and_descendants(self): """Iterate over this PageElement and its children in a breadth-first sequence. :yield: A sequence of PageElements. """ if not self.hidden: yield self for i in self.descendants: yield i @property def descendants(self): """Iterate over all children of this PageElement in a breadth-first sequence. :yield: A sequence of PageElements. """ if not len(self.contents): return stopNode = self._last_descendant().next_element current = self.contents[0] while current is not stopNode: yield current current = current.next_element # CSS selector code def select_one(self, selector, namespaces=None, **kwargs): """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 """ return self.css.select_one(selector, namespaces, **kwargs) def select(self, selector, namespaces=None, limit=None, **kwargs): """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 """ return self.css.select(selector, namespaces, limit, **kwargs) @property def css(self): """Return an interface to the CSS selector API.""" return CSS(self) # Old names for backwards compatibility def childGenerator(self): """Deprecated generator.""" return self.children def recursiveChildGenerator(self): """Deprecated generator.""" return self.descendants def has_key(self, key): """Deprecated method. This was kind of misleading because has_key() (attributes) was different from __in__ (contents). has_key() is gone in Python 3, anyway. """ warnings.warn( 'has_key is deprecated. Use has_attr(key) instead.', DeprecationWarning, stacklevel=2 ) return self.has_attr(key) # Next, a couple classes to represent queries and their results. class SoupStrainer(object): """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. """ def __init__(self, name=None, attrs={}, string=None, **kwargs): """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. """ if string is None and 'text' in kwargs: string = kwargs.pop('text') warnings.warn( "The 'text' argument to the SoupStrainer constructor is deprecated. Use 'string' instead.", DeprecationWarning, stacklevel=2 ) self.name = self._normalize_search_value(name) if not isinstance(attrs, dict): # Treat a non-dict value for attrs as a search for the 'class' # attribute. kwargs['class'] = attrs attrs = None if 'class_' in kwargs: # Treat class_="foo" as a search for the 'class' # attribute, overriding any non-dict value for attrs. kwargs['class'] = kwargs['class_'] del kwargs['class_'] if kwargs: if attrs: attrs = attrs.copy() attrs.update(kwargs) else: attrs = kwargs normalized_attrs = {} for key, value in list(attrs.items()): normalized_attrs[key] = self._normalize_search_value(value) self.attrs = normalized_attrs self.string = self._normalize_search_value(string) # DEPRECATED but just in case someone is checking this. self.text = self.string def _normalize_search_value(self, value): # Leave it alone if it's a Unicode string, a callable, a # regular expression, a boolean, or None. if (isinstance(value, str) or isinstance(value, Callable) or hasattr(value, 'match') or isinstance(value, bool) or value is None): return value # If it's a bytestring, convert it to Unicode, treating it as UTF-8. if isinstance(value, bytes): return value.decode("utf8") # If it's listlike, convert it into a list of strings. if hasattr(value, '__iter__'): new_value = [] for v in value: if (hasattr(v, '__iter__') and not isinstance(v, bytes) and not isinstance(v, str)): # This is almost certainly the user's mistake. In the # interests of avoiding infinite loops, we'll let # it through as-is rather than doing a recursive call. new_value.append(v) else: new_value.append(self._normalize_search_value(v)) return new_value # Otherwise, convert it into a Unicode string. # The unicode(str()) thing is so this will do the same thing on Python 2 # and Python 3. return str(str(value)) def __str__(self): """A human-readable representation of this SoupStrainer.""" if self.string: return self.string else: return "%s|%s" % (self.name, self.attrs) def search_tag(self, markup_name=None, markup_attrs={}): """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. """ found = None markup = None if isinstance(markup_name, Tag): markup = markup_name markup_attrs = markup if isinstance(self.name, str): # Optimization for a very common case where the user is # searching for a tag with one specific name, and we're # looking at a tag with a different name. if markup and not markup.prefix and self.name != markup.name: return False call_function_with_tag_data = ( isinstance(self.name, Callable) and not isinstance(markup_name, Tag)) if ((not self.name) or call_function_with_tag_data or (markup and self._matches(markup, self.name)) or (not markup and self._matches(markup_name, self.name))): if call_function_with_tag_data: match = self.name(markup_name, markup_attrs) else: match = True markup_attr_map = None for attr, match_against in list(self.attrs.items()): if not markup_attr_map: if hasattr(markup_attrs, 'get'): markup_attr_map = markup_attrs else: markup_attr_map = {} for k, v in markup_attrs: markup_attr_map[k] = v attr_value = markup_attr_map.get(attr) if not self._matches(attr_value, match_against): match = False break if match: if markup: found = markup else: found = markup_name if found and self.string and not self._matches(found.string, self.string): found = None return found # For BS3 compatibility. searchTag = search_tag def search(self, markup): """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. """ # print('looking for %s in %s' % (self, markup)) found = None # If given a list of items, scan it for a text element that # matches. if hasattr(markup, '__iter__') and not isinstance(markup, (Tag, str)): for element in markup: if isinstance(element, NavigableString) \ and self.search(element): found = element break # If it's a Tag, make sure its name or attributes match. # Don't bother with Tags if we're searching for text. elif isinstance(markup, Tag): if not self.string or self.name or self.attrs: found = self.search_tag(markup) # If it's text, make sure the text matches. elif isinstance(markup, NavigableString) or \ isinstance(markup, str): if not self.name and not self.attrs and self._matches(markup, self.string): found = markup else: raise Exception( "I don't know how to match against a %s" % markup.__class__) return found def _matches(self, markup, match_against, already_tried=None): # print(u"Matching %s against %s" % (markup, match_against)) result = False if isinstance(markup, list) or isinstance(markup, tuple): # This should only happen when searching a multi-valued attribute # like 'class'. for item in markup: if self._matches(item, match_against): return True # We didn't match any particular value of the multivalue # attribute, but maybe we match the attribute value when # considered as a string. if self._matches(' '.join(markup), match_against): return True return False if match_against is True: # True matches any non-None value. return markup is not None if isinstance(match_against, Callable): return match_against(markup) # Custom callables take the tag as an argument, but all # other ways of matching match the tag name as a string. original_markup = markup if isinstance(markup, Tag): markup = markup.name # Ensure that `markup` is either a Unicode string, or None. markup = self._normalize_search_value(markup) if markup is None: # None matches None, False, an empty string, an empty list, and so on. return not match_against if (hasattr(match_against, '__iter__') and not isinstance(match_against, str)): # We're asked to match against an iterable of items. # The markup must be match at least one item in the # iterable. We'll try each one in turn. # # To avoid infinite recursion we need to keep track of # items we've already seen. if not already_tried: already_tried = set() for item in match_against: if item.__hash__: key = item else: key = id(item) if key in already_tried: continue else: already_tried.add(key) if self._matches(original_markup, item, already_tried): return True else: return False # Beyond this point we might need to run the test twice: once against # the tag's name and once against its prefixed name. match = False if not match and isinstance(match_against, str): # Exact string match match = markup == match_against if not match and hasattr(match_against, 'search'): # Regexp match return match_against.search(markup) if (not match and isinstance(original_markup, Tag) and original_markup.prefix): # Try the whole thing again with the prefixed tag name. return self._matches( original_markup.prefix + ':' + original_markup.name, match_against ) return match class ResultSet(list): """A ResultSet is just a list that keeps track of the SoupStrainer that created it.""" def __init__(self, source, result=()): """Constructor. :param source: A SoupStrainer. :param result: A list of PageElements. """ super(ResultSet, self).__init__(result) self.source = source def __getattr__(self, key): """Raise a helpful exception to explain a common code fix.""" raise AttributeError( "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()?" % key ) PK z�Zu9 formatter.pynu �[��� from bs4.dammit import EntitySubstitution class Formatter(EntitySubstitution): """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 `PageElement.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. * '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. """ # Registries of XML and HTML formatters. XML_FORMATTERS = {} HTML_FORMATTERS = {} HTML = 'html' XML = 'xml' HTML_DEFAULTS = dict( cdata_containing_tags=set(["script", "style"]), ) def _default(self, language, value, kwarg): if value is not None: return value if language == self.XML: return set() return self.HTML_DEFAULTS[kwarg] def __init__( self, language=None, entity_substitution=None, void_element_close_prefix='/', cdata_containing_tags=None, empty_attributes_are_booleans=False, indent=1, ): r"""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 list 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 blank_attributes_are_booleans: Render attributes whose value is the empty string as HTML-style 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. """ self.language = language self.entity_substitution = entity_substitution self.void_element_close_prefix = void_element_close_prefix self.cdata_containing_tags = self._default( language, cdata_containing_tags, 'cdata_containing_tags' ) self.empty_attributes_are_booleans=empty_attributes_are_booleans if indent is None: indent = 0 if isinstance(indent, int): if indent < 0: indent = 0 indent = ' ' * indent elif isinstance(indent, str): indent = indent else: indent = ' ' self.indent = indent def substitute(self, ns): """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: A string with certain characters replaced by named or numeric entities. """ if not self.entity_substitution: return ns from .element import NavigableString if (isinstance(ns, NavigableString) and ns.parent is not None and ns.parent.name in self.cdata_containing_tags): # Do nothing. return ns # Substitute. return self.entity_substitution(ns) def attribute_value(self, value): """Process the value of an attribute. :param ns: A string. :return: A string with certain characters replaced by named or numeric entities. """ return self.substitute(value) def attributes(self, tag): """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_boolean_attributes` is True, then attributes whose values are set to the empty string will be treated as boolean attributes. """ if tag.attrs is None: return [] return sorted( (k, (None if self.empty_attributes_are_booleans and v == '' else v)) for k, v in list(tag.attrs.items()) ) class HTMLFormatter(Formatter): """A generic Formatter for HTML.""" REGISTRY = {} def __init__(self, *args, **kwargs): super(HTMLFormatter, self).__init__(self.HTML, *args, **kwargs) class XMLFormatter(Formatter): """A generic Formatter for XML.""" REGISTRY = {} def __init__(self, *args, **kwargs): super(XMLFormatter, self).__init__(self.XML, *args, **kwargs) # Set up aliases for the default formatters. HTMLFormatter.REGISTRY['html'] = HTMLFormatter( entity_substitution=EntitySubstitution.substitute_html ) HTMLFormatter.REGISTRY["html5"] = HTMLFormatter( entity_substitution=EntitySubstitution.substitute_html, void_element_close_prefix=None, empty_attributes_are_booleans=True, ) HTMLFormatter.REGISTRY["minimal"] = HTMLFormatter( entity_substitution=EntitySubstitution.substitute_xml ) HTMLFormatter.REGISTRY[None] = HTMLFormatter( entity_substitution=None ) XMLFormatter.REGISTRY["html"] = XMLFormatter( entity_substitution=EntitySubstitution.substitute_html ) XMLFormatter.REGISTRY["minimal"] = XMLFormatter( entity_substitution=EntitySubstitution.substitute_xml ) XMLFormatter.REGISTRY[None] = Formatter( Formatter(Formatter.XML, entity_substitution=None) ) PK z�Zi�LƠ Ơ dammit.pynu �[��� # -*- coding: utf-8 -*- """Beautiful Soup bonus library: Unicode, Dammit This library converts a bytestream to Unicode through any means necessary. It is heavily based on code from Mark Pilgrim's Universal Feed Parser. It works best on XML and HTML, but it does not rewrite the XML or HTML to reflect a new encoding; that's the tree builder's job. """ # Use of this source code is governed by the MIT license. __license__ = "MIT" from html.entities import codepoint2name from collections import defaultdict import codecs import re import logging import string # Import a library to autodetect character encodings. We'll support # any of a number of libraries that all support the same API: # # * cchardet # * chardet # * charset-normalizer chardet_module = None try: # PyPI package: cchardet import cchardet as chardet_module except ImportError: try: # Debian package: python-chardet # PyPI package: chardet import chardet as chardet_module except ImportError: try: # PyPI package: charset-normalizer import charset_normalizer as chardet_module except ImportError: # No chardet available. chardet_module = None if chardet_module: def chardet_dammit(s): if isinstance(s, str): return None return chardet_module.detect(s)['encoding'] else: def chardet_dammit(s): return None # Build bytestring and Unicode versions of regular expressions for finding # a declared encoding inside an XML or HTML document. xml_encoding = '^\\s*<\\?.*encoding=[\'"](.*?)[\'"].*\\?>' html_meta = '<\\s*meta[^>]+charset\\s*=\\s*["\']?([^>]*?)[ /;\'">]' encoding_res = dict() encoding_res[bytes] = { 'html' : re.compile(html_meta.encode("ascii"), re.I), 'xml' : re.compile(xml_encoding.encode("ascii"), re.I), } encoding_res[str] = { 'html' : re.compile(html_meta, re.I), 'xml' : re.compile(xml_encoding, re.I) } from html.entities import html5 class EntitySubstitution(object): """The ability to substitute XML or HTML entities for certain characters.""" def _populate_class_variables(): """Initialize variables used by this class to manage the plethora of HTML5 named entities. This function returns a 3-tuple containing two dictionaries and a regular expression: unicode_to_name - A mapping of Unicode strings like "⦨" to entity names like "angmsdaa". When a single Unicode string has multiple entity names, we try to choose the most commonly-used name. name_to_unicode: A mapping of entity names like "angmsdaa" to Unicode strings like "⦨". named_entity_re: A regular expression matching (almost) any Unicode string that corresponds to an HTML5 named entity. """ unicode_to_name = {} name_to_unicode = {} short_entities = set() long_entities_by_first_character = defaultdict(set) for name_with_semicolon, character in sorted(html5.items()): # "It is intentional, for legacy compatibility, that many # code points have multiple character reference names. For # example, some appear both with and without the trailing # semicolon, or with different capitalizations." # - https://html.spec.whatwg.org/multipage/named-characters.html#named-character-references # # The parsers are in charge of handling (or not) character # references with no trailing semicolon, so we remove the # semicolon whenever it appears. if name_with_semicolon.endswith(';'): name = name_with_semicolon[:-1] else: name = name_with_semicolon # When parsing HTML, we want to recognize any known named # entity and convert it to a sequence of Unicode # characters. if name not in name_to_unicode: name_to_unicode[name] = character # When _generating_ HTML, we want to recognize special # character sequences that _could_ be converted to named # entities. unicode_to_name[character] = name # We also need to build a regular expression that lets us # _find_ those characters in output strings so we can # replace them. # # This is tricky, for two reasons. if (len(character) == 1 and ord(character) < 128 and character not in '<>&'): # First, it would be annoying to turn single ASCII # characters like | into named entities like # |. The exceptions are <>&, which we _must_ # turn into named entities to produce valid HTML. continue if len(character) > 1 and all(ord(x) < 128 for x in character): # We also do not want to turn _combinations_ of ASCII # characters like 'fj' into named entities like 'fj', # though that's more debateable. continue # Second, some named entities have a Unicode value that's # a subset of the Unicode value for some _other_ named # entity. As an example, \u2267' is ≧, # but '\u2267\u0338' is ≧̸. Our regular # expression needs to match the first two characters of # "\u2267\u0338foo", but only the first character of # "\u2267foo". # # In this step, we build two sets of characters that # _eventually_ need to go into the regular expression. But # we won't know exactly what the regular expression needs # to look like until we've gone through the entire list of # named entities. if len(character) == 1: short_entities.add(character) else: long_entities_by_first_character[character[0]].add(character) # Now that we've been through the entire list of entities, we # can create a regular expression that matches any of them. particles = set() for short in short_entities: long_versions = long_entities_by_first_character[short] if not long_versions: particles.add(short) else: ignore = "".join([x[1] for x in long_versions]) # This finds, e.g. \u2267 but only if it is _not_ # followed by \u0338. particles.add("%s(?![%s])" % (short, ignore)) for long_entities in list(long_entities_by_first_character.values()): for long_entity in long_entities: particles.add(long_entity) re_definition = "(%s)" % "|".join(particles) # If an entity shows up in both html5 and codepoint2name, it's # likely that HTML5 gives it several different names, such as # 'rsquo' and 'rsquor'. When converting Unicode characters to # named entities, the codepoint2name name should take # precedence where possible, since that's the more easily # recognizable one. for codepoint, name in list(codepoint2name.items()): character = chr(codepoint) unicode_to_name[character] = name return unicode_to_name, name_to_unicode, re.compile(re_definition) (CHARACTER_TO_HTML_ENTITY, HTML_ENTITY_TO_CHARACTER, CHARACTER_TO_HTML_ENTITY_RE) = _populate_class_variables() CHARACTER_TO_XML_ENTITY = { "'": "apos", '"': "quot", "&": "amp", "<": "lt", ">": "gt", } BARE_AMPERSAND_OR_BRACKET = re.compile("([<>]|" "&(?!#\\d+;|#x[0-9a-fA-F]+;|\\w+;)" ")") AMPERSAND_OR_BRACKET = re.compile("([<>&])") @classmethod def _substitute_html_entity(cls, matchobj): """Used with a regular expression to substitute the appropriate HTML entity for a special character string.""" entity = cls.CHARACTER_TO_HTML_ENTITY.get(matchobj.group(0)) return "&%s;" % entity @classmethod def _substitute_xml_entity(cls, matchobj): """Used with a regular expression to substitute the appropriate XML entity for a special character string.""" entity = cls.CHARACTER_TO_XML_ENTITY[matchobj.group(0)] return "&%s;" % entity @classmethod def quoted_attribute_value(self, value): """Make a value into a quoted XML attribute, possibly escaping it. Most strings will be quoted using double quotes. Bob's Bar -> "Bob's Bar" If a string contains double quotes, it will be quoted using single quotes. Welcome to "my bar" -> 'Welcome to "my bar"' If a string contains both single and double quotes, the double quotes will be escaped, and the string will be quoted using double quotes. Welcome to "Bob's Bar" -> "Welcome to "Bob's bar" """ quote_with = '"' if '"' in value: if "'" in value: # The string contains both single and double # quotes. Turn the double quotes into # entities. We quote the double quotes rather than # the single quotes because the entity name is # """ whether this is HTML or XML. If we # quoted the single quotes, we'd have to decide # between ' and &squot;. replace_with = """ value = value.replace('"', replace_with) else: # There are double quotes but no single quotes. # We can use single quotes to quote the attribute. quote_with = "'" return quote_with + value + quote_with @classmethod def substitute_xml(cls, value, make_quoted_attribute=False): """Substitute XML entities for special XML characters. :param value: A string to be substituted. The less-than sign will become <, the greater-than sign will become >, and any ampersands will become &. If you want ampersands that appear to be part of an entity definition to be left alone, use substitute_xml_containing_entities() instead. :param make_quoted_attribute: If True, then the string will be quoted, as befits an attribute value. """ # Escape angle brackets and ampersands. value = cls.AMPERSAND_OR_BRACKET.sub( cls._substitute_xml_entity, value) if make_quoted_attribute: value = cls.quoted_attribute_value(value) return value @classmethod def substitute_xml_containing_entities( cls, value, make_quoted_attribute=False): """Substitute XML entities for special XML characters. :param value: A string to be substituted. The less-than sign will become <, the greater-than sign will become >, and any ampersands that are not part of an entity defition will become &. :param make_quoted_attribute: If True, then the string will be quoted, as befits an attribute value. """ # Escape angle brackets, and ampersands that aren't part of # entities. value = cls.BARE_AMPERSAND_OR_BRACKET.sub( cls._substitute_xml_entity, value) if make_quoted_attribute: value = cls.quoted_attribute_value(value) return value @classmethod def substitute_html(cls, s): """Replace certain Unicode characters with named HTML entities. This differs from data.encode(encoding, 'xmlcharrefreplace') in that the goal is to make the result more readable (to those with ASCII displays) rather than to recover from errors. There's absolutely nothing wrong with a UTF-8 string containg a LATIN SMALL LETTER E WITH ACUTE, but replacing that character with "é" will make it more readable to some people. :param s: A Unicode string. """ return cls.CHARACTER_TO_HTML_ENTITY_RE.sub( cls._substitute_html_entity, s) class EncodingDetector: """Suggests a number of possible encodings for a bytestring. Order of precedence: 1. Encodings you specifically tell EncodingDetector to try first (the known_definite_encodings argument to the constructor). 2. An encoding determined by sniffing the document's byte-order mark. 3. Encodings you specifically tell EncodingDetector to try if byte-order mark sniffing fails (the user_encodings argument to the constructor). 4. An encoding declared within the bytestring itself, either in an XML declaration (if the bytestring is to be interpreted as an XML document), or in a <meta> tag (if the bytestring is to be interpreted as an HTML document.) 5. An encoding detected through textual analysis by chardet, cchardet, or a similar external library. 4. UTF-8. 5. Windows-1252. """ def __init__(self, markup, known_definite_encodings=None, is_html=False, exclude_encodings=None, user_encodings=None, override_encodings=None): """Constructor. :param markup: Some markup in an unknown encoding. :param known_definite_encodings: When determining the encoding of `markup`, these encodings will be tried first, in order. In HTML terms, this corresponds to the "known definite encoding" step defined here: https://html.spec.whatwg.org/multipage/parsing.html#parsing-with-a-known-character-encoding :param user_encodings: These encodings will be tried after the `known_definite_encodings` have been tried and failed, and after an attempt to sniff the encoding by looking at a byte order mark has failed. In HTML terms, this corresponds to the step "user has explicitly instructed the user agent to override the document's character encoding", defined here: https://html.spec.whatwg.org/multipage/parsing.html#determining-the-character-encoding :param override_encodings: A deprecated alias for known_definite_encodings. Any encodings here will be tried immediately after the encodings in known_definite_encodings. :param is_html: If True, this markup is considered to be HTML. Otherwise it's assumed to be XML. :param exclude_encodings: These encodings will not be tried, even if they otherwise would be. """ self.known_definite_encodings = list(known_definite_encodings or []) if override_encodings: self.known_definite_encodings += override_encodings self.user_encodings = user_encodings or [] exclude_encodings = exclude_encodings or [] self.exclude_encodings = set([x.lower() for x in exclude_encodings]) self.chardet_encoding = None self.is_html = is_html self.declared_encoding = None # First order of business: strip a byte-order mark. self.markup, self.sniffed_encoding = self.strip_byte_order_mark(markup) def _usable(self, encoding, tried): """Should we even bother to try this encoding? :param encoding: Name of an encoding. :param tried: Encodings that have already been tried. This will be modified as a side effect. """ if encoding is not None: encoding = encoding.lower() if encoding in self.exclude_encodings: return False if encoding not in tried: tried.add(encoding) return True return False @property def encodings(self): """Yield a number of encodings that might work for this markup. :yield: A sequence of strings. """ tried = set() # First, try the known definite encodings for e in self.known_definite_encodings: if self._usable(e, tried): yield e # Did the document originally start with a byte-order mark # that indicated its encoding? if self._usable(self.sniffed_encoding, tried): yield self.sniffed_encoding # Sniffing the byte-order mark did nothing; try the user # encodings. for e in self.user_encodings: if self._usable(e, tried): yield e # Look within the document for an XML or HTML encoding # declaration. if self.declared_encoding is None: self.declared_encoding = self.find_declared_encoding( self.markup, self.is_html) if self._usable(self.declared_encoding, tried): yield self.declared_encoding # Use third-party character set detection to guess at the # encoding. if self.chardet_encoding is None: self.chardet_encoding = chardet_dammit(self.markup) if self._usable(self.chardet_encoding, tried): yield self.chardet_encoding # As a last-ditch effort, try utf-8 and windows-1252. for e in ('utf-8', 'windows-1252'): if self._usable(e, tried): yield e @classmethod def strip_byte_order_mark(cls, data): """If a byte-order mark is present, strip it and return the encoding it implies. :param data: Some markup. :return: A 2-tuple (modified data, implied encoding) """ encoding = None if isinstance(data, str): # Unicode data cannot have a byte-order mark. return data, encoding if (len(data) >= 4) and (data[:2] == b'\xfe\xff') \ and (data[2:4] != '\x00\x00'): encoding = 'utf-16be' data = data[2:] elif (len(data) >= 4) and (data[:2] == b'\xff\xfe') \ and (data[2:4] != '\x00\x00'): encoding = 'utf-16le' data = data[2:] elif data[:3] == b'\xef\xbb\xbf': encoding = 'utf-8' data = data[3:] elif data[:4] == b'\x00\x00\xfe\xff': encoding = 'utf-32be' data = data[4:] elif data[:4] == b'\xff\xfe\x00\x00': encoding = 'utf-32le' data = data[4:] return data, encoding @classmethod def find_declared_encoding(cls, markup, is_html=False, search_entire_document=False): """Given a document, tries to find its declared encoding. An XML encoding is declared at the beginning of the document. An HTML encoding is declared in a <meta> tag, hopefully near the beginning of the document. :param markup: Some markup. :param is_html: If True, this markup is considered to be HTML. Otherwise it's assumed to be XML. :param search_entire_document: Since an encoding is supposed to declared near the beginning of the document, most of the time it's only necessary to search a few kilobytes of data. Set this to True to force this method to search the entire document. """ if search_entire_document: xml_endpos = html_endpos = len(markup) else: xml_endpos = 1024 html_endpos = max(2048, int(len(markup) * 0.05)) if isinstance(markup, bytes): res = encoding_res[bytes] else: res = encoding_res[str] xml_re = res['xml'] html_re = res['html'] declared_encoding = None declared_encoding_match = xml_re.search(markup, endpos=xml_endpos) if not declared_encoding_match and is_html: declared_encoding_match = html_re.search(markup, endpos=html_endpos) if declared_encoding_match is not None: declared_encoding = declared_encoding_match.groups()[0] if declared_encoding: if isinstance(declared_encoding, bytes): declared_encoding = declared_encoding.decode('ascii', 'replace') return declared_encoding.lower() return None class UnicodeDammit: """A class for detecting the encoding of a *ML document and converting it to a Unicode string. If the source encoding is windows-1252, can replace MS smart quotes with their HTML or XML equivalents.""" # This dictionary maps commonly seen values for "charset" in HTML # meta tags to the corresponding Python codec names. It only covers # values that aren't in Python's aliases and can't be determined # by the heuristics in find_codec. CHARSET_ALIASES = {"macintosh": "mac-roman", "x-sjis": "shift-jis"} ENCODINGS_WITH_SMART_QUOTES = [ "windows-1252", "iso-8859-1", "iso-8859-2", ] def __init__(self, markup, known_definite_encodings=[], smart_quotes_to=None, is_html=False, exclude_encodings=[], user_encodings=None, override_encodings=None ): """Constructor. :param markup: A bytestring representing markup in an unknown encoding. :param known_definite_encodings: When determining the encoding of `markup`, these encodings will be tried first, in order. In HTML terms, this corresponds to the "known definite encoding" step defined here: https://html.spec.whatwg.org/multipage/parsing.html#parsing-with-a-known-character-encoding :param user_encodings: These encodings will be tried after the `known_definite_encodings` have been tried and failed, and after an attempt to sniff the encoding by looking at a byte order mark has failed. In HTML terms, this corresponds to the step "user has explicitly instructed the user agent to override the document's character encoding", defined here: https://html.spec.whatwg.org/multipage/parsing.html#determining-the-character-encoding :param override_encodings: A deprecated alias for known_definite_encodings. Any encodings here will be tried immediately after the encodings in known_definite_encodings. :param smart_quotes_to: By default, Microsoft smart quotes will, like all other characters, be converted to Unicode characters. Setting this to 'ascii' will convert them to ASCII quotes instead. Setting it to 'xml' will convert them to XML entity references, and setting it to 'html' will convert them to HTML entity references. :param is_html: If True, this markup is considered to be HTML. Otherwise it's assumed to be XML. :param exclude_encodings: These encodings will not be considered, even if the sniffing code thinks they might make sense. """ self.smart_quotes_to = smart_quotes_to self.tried_encodings = [] self.contains_replacement_characters = False self.is_html = is_html self.log = logging.getLogger(__name__) self.detector = EncodingDetector( markup, known_definite_encodings, is_html, exclude_encodings, user_encodings, override_encodings ) # Short-circuit if the data is in Unicode to begin with. if isinstance(markup, str) or markup == '': self.markup = markup self.unicode_markup = str(markup) self.original_encoding = None return # The encoding detector may have stripped a byte-order mark. # Use the stripped markup from this point on. self.markup = self.detector.markup u = None for encoding in self.detector.encodings: markup = self.detector.markup u = self._convert_from(encoding) if u is not None: break if not u: # None of the encodings worked. As an absolute last resort, # try them again with character replacement. for encoding in self.detector.encodings: if encoding != "ascii": u = self._convert_from(encoding, "replace") if u is not None: self.log.warning( "Some characters could not be decoded, and were " "replaced with REPLACEMENT CHARACTER." ) self.contains_replacement_characters = True break # If none of that worked, we could at this point force it to # ASCII, but that would destroy so much data that I think # giving up is better. self.unicode_markup = u if not u: self.original_encoding = None def _sub_ms_char(self, match): """Changes a MS smart quote character to an XML or HTML entity, or an ASCII character.""" orig = match.group(1) if self.smart_quotes_to == 'ascii': sub = self.MS_CHARS_TO_ASCII.get(orig).encode() else: sub = self.MS_CHARS.get(orig) if type(sub) == tuple: if self.smart_quotes_to == 'xml': sub = '&#x'.encode() + sub[1].encode() + ';'.encode() else: sub = '&'.encode() + sub[0].encode() + ';'.encode() else: sub = sub.encode() return sub def _convert_from(self, proposed, errors="strict"): """Attempt to convert the markup to the proposed encoding. :param proposed: The name of a character encoding. """ proposed = self.find_codec(proposed) if not proposed or (proposed, errors) in self.tried_encodings: return None self.tried_encodings.append((proposed, errors)) markup = self.markup # Convert smart quotes to HTML if coming from an encoding # that might have them. if (self.smart_quotes_to is not None and proposed in self.ENCODINGS_WITH_SMART_QUOTES): smart_quotes_re = b"([\x80-\x9f])" smart_quotes_compiled = re.compile(smart_quotes_re) markup = smart_quotes_compiled.sub(self._sub_ms_char, markup) try: #print("Trying to convert document to %s (errors=%s)" % ( # proposed, errors)) u = self._to_unicode(markup, proposed, errors) self.markup = u self.original_encoding = proposed except Exception as e: #print("That didn't work!") #print(e) return None #print("Correct encoding: %s" % proposed) return self.markup def _to_unicode(self, data, encoding, errors="strict"): """Given a string and its encoding, decodes the string into Unicode. :param encoding: The name of an encoding. """ return str(data, encoding, errors) @property def declared_html_encoding(self): """If the markup is an HTML document, returns the encoding declared _within_ the document. """ if not self.is_html: return None return self.detector.declared_encoding def find_codec(self, charset): """Convert the name of a character set to a codec name. :param charset: The name of a character set. :return: The name of a codec. """ value = (self._codec(self.CHARSET_ALIASES.get(charset, charset)) or (charset and self._codec(charset.replace("-", ""))) or (charset and self._codec(charset.replace("-", "_"))) or (charset and charset.lower()) or charset ) if value: return value.lower() return None def _codec(self, charset): if not charset: return charset codec = None try: codecs.lookup(charset) codec = charset except (LookupError, ValueError): pass return codec # A partial mapping of ISO-Latin-1 to HTML entities/XML numeric entities. MS_CHARS = {b'\x80': ('euro', '20AC'), b'\x81': ' ', b'\x82': ('sbquo', '201A'), b'\x83': ('fnof', '192'), b'\x84': ('bdquo', '201E'), b'\x85': ('hellip', '2026'), b'\x86': ('dagger', '2020'), b'\x87': ('Dagger', '2021'), b'\x88': ('circ', '2C6'), b'\x89': ('permil', '2030'), b'\x8A': ('Scaron', '160'), b'\x8B': ('lsaquo', '2039'), b'\x8C': ('OElig', '152'), b'\x8D': '?', b'\x8E': ('#x17D', '17D'), b'\x8F': '?', b'\x90': '?', b'\x91': ('lsquo', '2018'), b'\x92': ('rsquo', '2019'), b'\x93': ('ldquo', '201C'), b'\x94': ('rdquo', '201D'), b'\x95': ('bull', '2022'), b'\x96': ('ndash', '2013'), b'\x97': ('mdash', '2014'), b'\x98': ('tilde', '2DC'), b'\x99': ('trade', '2122'), b'\x9a': ('scaron', '161'), b'\x9b': ('rsaquo', '203A'), b'\x9c': ('oelig', '153'), b'\x9d': '?', b'\x9e': ('#x17E', '17E'), b'\x9f': ('Yuml', ''),} # A parochial partial mapping of ISO-Latin-1 to ASCII. Contains # horrors like stripping diacritical marks to turn á into a, but also # contains non-horrors like turning “ into ". MS_CHARS_TO_ASCII = { b'\x80' : 'EUR', b'\x81' : ' ', b'\x82' : ',', b'\x83' : 'f', b'\x84' : ',,', b'\x85' : '...', b'\x86' : '+', b'\x87' : '++', b'\x88' : '^', b'\x89' : '%', b'\x8a' : 'S', b'\x8b' : '<', b'\x8c' : 'OE', b'\x8d' : '?', b'\x8e' : 'Z', b'\x8f' : '?', b'\x90' : '?', b'\x91' : "'", b'\x92' : "'", b'\x93' : '"', b'\x94' : '"', b'\x95' : '*', b'\x96' : '-', b'\x97' : '--', b'\x98' : '~', b'\x99' : '(TM)', b'\x9a' : 's', b'\x9b' : '>', b'\x9c' : 'oe', b'\x9d' : '?', b'\x9e' : 'z', b'\x9f' : 'Y', b'\xa0' : ' ', b'\xa1' : '!', b'\xa2' : 'c', b'\xa3' : 'GBP', b'\xa4' : '$', #This approximation is especially parochial--this is the #generic currency symbol. b'\xa5' : 'YEN', b'\xa6' : '|', b'\xa7' : 'S', b'\xa8' : '..', b'\xa9' : '', b'\xaa' : '(th)', b'\xab' : '<<', b'\xac' : '!', b'\xad' : ' ', b'\xae' : '(R)', b'\xaf' : '-', b'\xb0' : 'o', b'\xb1' : '+-', b'\xb2' : '2', b'\xb3' : '3', b'\xb4' : ("'", 'acute'), b'\xb5' : 'u', b'\xb6' : 'P', b'\xb7' : '*', b'\xb8' : ',', b'\xb9' : '1', b'\xba' : '(th)', b'\xbb' : '>>', b'\xbc' : '1/4', b'\xbd' : '1/2', b'\xbe' : '3/4', b'\xbf' : '?', b'\xc0' : 'A', b'\xc1' : 'A', b'\xc2' : 'A', b'\xc3' : 'A', b'\xc4' : 'A', b'\xc5' : 'A', b'\xc6' : 'AE', b'\xc7' : 'C', b'\xc8' : 'E', b'\xc9' : 'E', b'\xca' : 'E', b'\xcb' : 'E', b'\xcc' : 'I', b'\xcd' : 'I', b'\xce' : 'I', b'\xcf' : 'I', b'\xd0' : 'D', b'\xd1' : 'N', b'\xd2' : 'O', b'\xd3' : 'O', b'\xd4' : 'O', b'\xd5' : 'O', b'\xd6' : 'O', b'\xd7' : '*', b'\xd8' : 'O', b'\xd9' : 'U', b'\xda' : 'U', b'\xdb' : 'U', b'\xdc' : 'U', b'\xdd' : 'Y', b'\xde' : 'b', b'\xdf' : 'B', b'\xe0' : 'a', b'\xe1' : 'a', b'\xe2' : 'a', b'\xe3' : 'a', b'\xe4' : 'a', b'\xe5' : 'a', b'\xe6' : 'ae', b'\xe7' : 'c', b'\xe8' : 'e', b'\xe9' : 'e', b'\xea' : 'e', b'\xeb' : 'e', b'\xec' : 'i', b'\xed' : 'i', b'\xee' : 'i', b'\xef' : 'i', b'\xf0' : 'o', b'\xf1' : 'n', b'\xf2' : 'o', b'\xf3' : 'o', b'\xf4' : 'o', b'\xf5' : 'o', b'\xf6' : 'o', b'\xf7' : '/', b'\xf8' : 'o', b'\xf9' : 'u', b'\xfa' : 'u', b'\xfb' : 'u', b'\xfc' : 'u', b'\xfd' : 'y', b'\xfe' : 'b', b'\xff' : 'y', } # A map used when removing rogue Windows-1252/ISO-8859-1 # characters in otherwise UTF-8 documents. # # Note that \x81, \x8d, \x8f, \x90, and \x9d are undefined in # Windows-1252. WINDOWS_1252_TO_UTF8 = { 0x80 : b'\xe2\x82\xac', # € 0x82 : b'\xe2\x80\x9a', # ‚ 0x83 : b'\xc6\x92', # ƒ 0x84 : b'\xe2\x80\x9e', # „ 0x85 : b'\xe2\x80\xa6', # … 0x86 : b'\xe2\x80\xa0', # † 0x87 : b'\xe2\x80\xa1', # ‡ 0x88 : b'\xcb\x86', # ˆ 0x89 : b'\xe2\x80\xb0', # ‰ 0x8a : b'\xc5\xa0', # Š 0x8b : b'\xe2\x80\xb9', # ‹ 0x8c : b'\xc5\x92', # Œ 0x8e : b'\xc5\xbd', # Ž 0x91 : b'\xe2\x80\x98', # ‘ 0x92 : b'\xe2\x80\x99', # ’ 0x93 : b'\xe2\x80\x9c', # “ 0x94 : b'\xe2\x80\x9d', # ” 0x95 : b'\xe2\x80\xa2', # • 0x96 : b'\xe2\x80\x93', # – 0x97 : b'\xe2\x80\x94', # — 0x98 : b'\xcb\x9c', # ˜ 0x99 : b'\xe2\x84\xa2', # ™ 0x9a : b'\xc5\xa1', # š 0x9b : b'\xe2\x80\xba', # › 0x9c : b'\xc5\x93', # œ 0x9e : b'\xc5\xbe', # ž 0x9f : b'\xc5\xb8', # Ÿ 0xa0 : b'\xc2\xa0', # 0xa1 : b'\xc2\xa1', # ¡ 0xa2 : b'\xc2\xa2', # ¢ 0xa3 : b'\xc2\xa3', # £ 0xa4 : b'\xc2\xa4', # ¤ 0xa5 : b'\xc2\xa5', # ¥ 0xa6 : b'\xc2\xa6', # ¦ 0xa7 : b'\xc2\xa7', # § 0xa8 : b'\xc2\xa8', # ¨ 0xa9 : b'\xc2\xa9', # © 0xaa : b'\xc2\xaa', # ª 0xab : b'\xc2\xab', # « 0xac : b'\xc2\xac', # ¬ 0xad : b'\xc2\xad', # 0xae : b'\xc2\xae', # ® 0xaf : b'\xc2\xaf', # ¯ 0xb0 : b'\xc2\xb0', # ° 0xb1 : b'\xc2\xb1', # ± 0xb2 : b'\xc2\xb2', # ² 0xb3 : b'\xc2\xb3', # ³ 0xb4 : b'\xc2\xb4', # ´ 0xb5 : b'\xc2\xb5', # µ 0xb6 : b'\xc2\xb6', # ¶ 0xb7 : b'\xc2\xb7', # · 0xb8 : b'\xc2\xb8', # ¸ 0xb9 : b'\xc2\xb9', # ¹ 0xba : b'\xc2\xba', # º 0xbb : b'\xc2\xbb', # » 0xbc : b'\xc2\xbc', # ¼ 0xbd : b'\xc2\xbd', # ½ 0xbe : b'\xc2\xbe', # ¾ 0xbf : b'\xc2\xbf', # ¿ 0xc0 : b'\xc3\x80', # À 0xc1 : b'\xc3\x81', # Á 0xc2 : b'\xc3\x82', #  0xc3 : b'\xc3\x83', # à 0xc4 : b'\xc3\x84', # Ä 0xc5 : b'\xc3\x85', # Å 0xc6 : b'\xc3\x86', # Æ 0xc7 : b'\xc3\x87', # Ç 0xc8 : b'\xc3\x88', # È 0xc9 : b'\xc3\x89', # É 0xca : b'\xc3\x8a', # Ê 0xcb : b'\xc3\x8b', # Ë 0xcc : b'\xc3\x8c', # Ì 0xcd : b'\xc3\x8d', # Í 0xce : b'\xc3\x8e', # Î 0xcf : b'\xc3\x8f', # Ï 0xd0 : b'\xc3\x90', # Ð 0xd1 : b'\xc3\x91', # Ñ 0xd2 : b'\xc3\x92', # Ò 0xd3 : b'\xc3\x93', # Ó 0xd4 : b'\xc3\x94', # Ô 0xd5 : b'\xc3\x95', # Õ 0xd6 : b'\xc3\x96', # Ö 0xd7 : b'\xc3\x97', # × 0xd8 : b'\xc3\x98', # Ø 0xd9 : b'\xc3\x99', # Ù 0xda : b'\xc3\x9a', # Ú 0xdb : b'\xc3\x9b', # Û 0xdc : b'\xc3\x9c', # Ü 0xdd : b'\xc3\x9d', # Ý 0xde : b'\xc3\x9e', # Þ 0xdf : b'\xc3\x9f', # ß 0xe0 : b'\xc3\xa0', # à 0xe1 : b'\xa1', # á 0xe2 : b'\xc3\xa2', # â 0xe3 : b'\xc3\xa3', # ã 0xe4 : b'\xc3\xa4', # ä 0xe5 : b'\xc3\xa5', # å 0xe6 : b'\xc3\xa6', # æ 0xe7 : b'\xc3\xa7', # ç 0xe8 : b'\xc3\xa8', # è 0xe9 : b'\xc3\xa9', # é 0xea : b'\xc3\xaa', # ê 0xeb : b'\xc3\xab', # ë 0xec : b'\xc3\xac', # ì 0xed : b'\xc3\xad', # í 0xee : b'\xc3\xae', # î 0xef : b'\xc3\xaf', # ï 0xf0 : b'\xc3\xb0', # ð 0xf1 : b'\xc3\xb1', # ñ 0xf2 : b'\xc3\xb2', # ò 0xf3 : b'\xc3\xb3', # ó 0xf4 : b'\xc3\xb4', # ô 0xf5 : b'\xc3\xb5', # õ 0xf6 : b'\xc3\xb6', # ö 0xf7 : b'\xc3\xb7', # ÷ 0xf8 : b'\xc3\xb8', # ø 0xf9 : b'\xc3\xb9', # ù 0xfa : b'\xc3\xba', # ú 0xfb : b'\xc3\xbb', # û 0xfc : b'\xc3\xbc', # ü 0xfd : b'\xc3\xbd', # ý 0xfe : b'\xc3\xbe', # þ } MULTIBYTE_MARKERS_AND_SIZES = [ (0xc2, 0xdf, 2), # 2-byte characters start with a byte C2-DF (0xe0, 0xef, 3), # 3-byte characters start with E0-EF (0xf0, 0xf4, 4), # 4-byte characters start with F0-F4 ] FIRST_MULTIBYTE_MARKER = MULTIBYTE_MARKERS_AND_SIZES[0][0] LAST_MULTIBYTE_MARKER = MULTIBYTE_MARKERS_AND_SIZES[-1][1] @classmethod def detwingle(cls, in_bytes, main_encoding="utf8", embedded_encoding="windows-1252"): """Fix characters from one encoding embedded in some other encoding. Currently the only situation supported is Windows-1252 (or its subset ISO-8859-1), embedded in UTF-8. :param in_bytes: A bytestring that you suspect contains characters from multiple encodings. Note that this _must_ be a bytestring. If you've already converted the document to Unicode, you're too late. :param main_encoding: The primary encoding of `in_bytes`. :param embedded_encoding: The encoding that was used to embed characters in the main document. :return: A bytestring in which `embedded_encoding` characters have been converted to their `main_encoding` equivalents. """ if embedded_encoding.replace('_', '-').lower() not in ( 'windows-1252', 'windows_1252'): raise NotImplementedError( "Windows-1252 and ISO-8859-1 are the only currently supported " "embedded encodings.") if main_encoding.lower() not in ('utf8', 'utf-8'): raise NotImplementedError( "UTF-8 is the only currently supported main encoding.") byte_chunks = [] chunk_start = 0 pos = 0 while pos < len(in_bytes): byte = in_bytes[pos] if not isinstance(byte, int): # Python 2.x byte = ord(byte) if (byte >= cls.FIRST_MULTIBYTE_MARKER and byte <= cls.LAST_MULTIBYTE_MARKER): # This is the start of a UTF-8 multibyte character. Skip # to the end. for start, end, size in cls.MULTIBYTE_MARKERS_AND_SIZES: if byte >= start and byte <= end: pos += size break elif byte >= 0x80 and byte in cls.WINDOWS_1252_TO_UTF8: # We found a Windows-1252 character! # Save the string up to this point as a chunk. byte_chunks.append(in_bytes[chunk_start:pos]) # Now translate the Windows-1252 character into UTF-8 # and add it as another, one-byte chunk. byte_chunks.append(cls.WINDOWS_1252_TO_UTF8[byte]) pos += 1 chunk_start = pos else: # Go on to the next character. pos += 1 if chunk_start == 0: # The string is unchanged. return in_bytes else: # Store the final chunk. byte_chunks.append(in_bytes[chunk_start:]) return b''.join(byte_chunks) PK z�Z�c�r � � __init__.pynu �[��� """Beautiful Soup Elixir and Tonic - "The Screen-Scraper's Friend". http://www.crummy.com/software/BeautifulSoup/ Beautiful Soup uses a pluggable XML or HTML parser to parse a (possibly invalid) document into a tree representation. Beautiful Soup provides methods and Pythonic idioms that make it easy to navigate, search, and modify the parse tree. Beautiful Soup works with Python 3.6 and up. It works better if lxml and/or html5lib is installed. For more than you ever wanted to know about Beautiful Soup, see the documentation: http://www.crummy.com/software/BeautifulSoup/bs4/doc/ """ __author__ = "Leonard Richardson (leonardr@segfault.org)" __version__ = "4.12.3" __copyright__ = "Copyright (c) 2004-2024 Leonard Richardson" # Use of this source code is governed by the MIT license. __license__ = "MIT" __all__ = ['BeautifulSoup'] from collections import Counter import os import re import sys import traceback import warnings # The very first thing we do is give a useful error if someone is # running this code under Python 2. if sys.version_info.major < 3: raise ImportError('You are trying to use a Python 3-specific version of Beautiful Soup under Python 2. This will not work. The final version of Beautiful Soup to support Python 2 was 4.9.3.') from .builder import ( builder_registry, ParserRejectedMarkup, XMLParsedAsHTMLWarning, HTMLParserTreeBuilder ) from .dammit import UnicodeDammit from .element import ( CData, Comment, CSS, DEFAULT_OUTPUT_ENCODING, Declaration, Doctype, NavigableString, PageElement, ProcessingInstruction, PYTHON_SPECIFIC_ENCODINGS, ResultSet, Script, Stylesheet, SoupStrainer, Tag, TemplateString, ) # Define some custom warnings. class GuessedAtParserWarning(UserWarning): """The warning issued when BeautifulSoup has to guess what parser to use -- probably because no parser was specified in the constructor. """ class MarkupResemblesLocatorWarning(UserWarning): """The warning issued when BeautifulSoup is given 'markup' that actually looks like a resource locator -- a URL or a path to a file on disk. """ class BeautifulSoup(Tag): """A data structure representing a parsed HTML or XML document. Most of the methods you'll call on a BeautifulSoup object are inherited from PageElement or Tag. Internally, this class defines the basic interface called by the tree builders when converting an HTML/XML document into a data structure. The interface abstracts away the differences between parsers. To write a new tree builder, you'll need to understand these methods as a whole. These methods will be called by the BeautifulSoup constructor: * reset() * feed(markup) The tree builder may call these methods from its feed() implementation: * handle_starttag(name, attrs) # See note about return value * handle_endtag(name) * handle_data(data) # Appends to the current data node * endData(containerClass) # Ends the current data node No matter how complicated the underlying parser is, you should be able to build a tree using 'start tag' events, 'end tag' events, 'data' events, and "done with data" events. If you encounter an empty-element tag (aka a self-closing tag, like HTML's <br> tag), call handle_starttag and then handle_endtag. """ # Since BeautifulSoup subclasses Tag, it's possible to treat it as # a Tag with a .name. This name makes it clear the BeautifulSoup # object isn't a real markup tag. ROOT_TAG_NAME = '[document]' # If the end-user gives no indication which tree builder they # want, look for one with these features. DEFAULT_BUILDER_FEATURES = ['html', 'fast'] # A string containing all ASCII whitespace characters, used in # endData() to detect data chunks that seem 'empty'. ASCII_SPACES = '\x20\x0a\x09\x0c\x0d' NO_PARSER_SPECIFIED_WARNING = "No parser was explicitly specified, so I'm using the best available %(markup_type)s parser for this system (\"%(parser)s\"). This usually isn't a problem, but if you run this code on another system, or in a different virtual environment, it may use a different parser and behave differently.\n\nThe code that caused this warning is on line %(line_number)s of the file %(filename)s. To get rid of this warning, pass the additional argument 'features=\"%(parser)s\"' to the BeautifulSoup constructor.\n" def __init__(self, markup="", features=None, builder=None, parse_only=None, from_encoding=None, exclude_encodings=None, element_classes=None, **kwargs): """Constructor. :param markup: A string or a file-like object representing markup to be parsed. :param features: Desirable features of the parser to be used. This may be the name of a specific parser ("lxml", "lxml-xml", "html.parser", or "html5lib") or it may be the type of markup to be used ("html", "html5", "xml"). It's recommended that you name a specific parser, so that Beautiful Soup gives you the same results across platforms and virtual environments. :param builder: A TreeBuilder subclass to instantiate (or instance to use) instead of looking one up based on `features`. You only need to use this if you've implemented a custom TreeBuilder. :param parse_only: A SoupStrainer. Only parts of the document matching the SoupStrainer will be considered. This is useful when parsing part of a document that would otherwise be too large to fit into memory. :param from_encoding: A string indicating the encoding of the document to be parsed. Pass this in if Beautiful Soup is guessing wrongly about the document's encoding. :param exclude_encodings: A list of strings indicating encodings known to be wrong. Pass this in if you don't know the document's encoding but you know Beautiful Soup's guess is wrong. :param element_classes: A dictionary mapping BeautifulSoup classes like Tag and NavigableString, to other classes you'd like to be instantiated instead as the parse tree is built. This is useful for subclassing Tag or NavigableString to modify default behavior. :param kwargs: For backwards compatibility purposes, the constructor accepts certain keyword arguments used in Beautiful Soup 3. None of these arguments do anything in Beautiful Soup 4; they will result in a warning and then be ignored. Apart from this, any keyword arguments passed into the BeautifulSoup constructor are propagated to the TreeBuilder constructor. This makes it possible to configure a TreeBuilder by passing in arguments, not just by saying which one to use. """ if 'convertEntities' in kwargs: del kwargs['convertEntities'] warnings.warn( "BS4 does not respect the convertEntities argument to the " "BeautifulSoup constructor. Entities are always converted " "to Unicode characters.") if 'markupMassage' in kwargs: del kwargs['markupMassage'] warnings.warn( "BS4 does not respect the markupMassage argument to the " "BeautifulSoup constructor. The tree builder is responsible " "for any necessary markup massage.") if 'smartQuotesTo' in kwargs: del kwargs['smartQuotesTo'] warnings.warn( "BS4 does not respect the smartQuotesTo argument to the " "BeautifulSoup constructor. Smart quotes are always converted " "to Unicode characters.") if 'selfClosingTags' in kwargs: del kwargs['selfClosingTags'] warnings.warn( "BS4 does not respect the selfClosingTags argument to the " "BeautifulSoup constructor. The tree builder is responsible " "for understanding self-closing tags.") if 'isHTML' in kwargs: del kwargs['isHTML'] warnings.warn( "BS4 does not respect the isHTML argument to the " "BeautifulSoup constructor. Suggest you use " "features='lxml' for HTML and features='lxml-xml' for " "XML.") def deprecated_argument(old_name, new_name): if old_name in kwargs: warnings.warn( 'The "%s" argument to the BeautifulSoup constructor ' 'has been renamed to "%s."' % (old_name, new_name), DeprecationWarning, stacklevel=3 ) return kwargs.pop(old_name) return None parse_only = parse_only or deprecated_argument( "parseOnlyThese", "parse_only") from_encoding = from_encoding or deprecated_argument( "fromEncoding", "from_encoding") if from_encoding and isinstance(markup, str): warnings.warn("You provided Unicode markup but also provided a value for from_encoding. Your from_encoding will be ignored.") from_encoding = None self.element_classes = element_classes or dict() # We need this information to track whether or not the builder # was specified well enough that we can omit the 'you need to # specify a parser' warning. original_builder = builder original_features = features if isinstance(builder, type): # A builder class was passed in; it needs to be instantiated. builder_class = builder builder = None elif builder is None: if isinstance(features, str): features = [features] if features is None or len(features) == 0: features = self.DEFAULT_BUILDER_FEATURES builder_class = builder_registry.lookup(*features) if builder_class is None: raise FeatureNotFound( "Couldn't find a tree builder with the features you " "requested: %s. Do you need to install a parser library?" % ",".join(features)) # At this point either we have a TreeBuilder instance in # builder, or we have a builder_class that we can instantiate # with the remaining **kwargs. if builder is None: builder = builder_class(**kwargs) if not original_builder and not ( original_features == builder.NAME or original_features in builder.ALTERNATE_NAMES ) and markup: # The user did not tell us which TreeBuilder to use, # and we had to guess. Issue a warning. if builder.is_xml: markup_type = "XML" else: markup_type = "HTML" # This code adapted from warnings.py so that we get the same line # of code as our warnings.warn() call gets, even if the answer is wrong # (as it may be in a multithreading situation). caller = None try: caller = sys._getframe(1) except ValueError: pass if caller: globals = caller.f_globals line_number = caller.f_lineno else: globals = sys.__dict__ line_number= 1 filename = globals.get('__file__') if filename: fnl = filename.lower() if fnl.endswith((".pyc", ".pyo")): filename = filename[:-1] if filename: # If there is no filename at all, the user is most likely in a REPL, # and the warning is not necessary. values = dict( filename=filename, line_number=line_number, parser=builder.NAME, markup_type=markup_type ) warnings.warn( self.NO_PARSER_SPECIFIED_WARNING % values, GuessedAtParserWarning, stacklevel=2 ) else: if kwargs: warnings.warn("Keyword arguments to the BeautifulSoup constructor will be ignored. These would normally be passed into the TreeBuilder constructor, but a TreeBuilder instance was passed in as `builder`.") self.builder = builder self.is_xml = builder.is_xml self.known_xml = self.is_xml self._namespaces = dict() self.parse_only = parse_only if hasattr(markup, 'read'): # It's a file-type object. markup = markup.read() elif len(markup) <= 256 and ( (isinstance(markup, bytes) and not b'<' in markup) or (isinstance(markup, str) and not '<' in markup) ): # Issue warnings for a couple beginner problems # involving passing non-markup to Beautiful Soup. # Beautiful Soup will still parse the input as markup, # since that is sometimes the intended behavior. if not self._markup_is_url(markup): self._markup_resembles_filename(markup) rejections = [] success = False for (self.markup, self.original_encoding, self.declared_html_encoding, self.contains_replacement_characters) in ( self.builder.prepare_markup( markup, from_encoding, exclude_encodings=exclude_encodings)): self.reset() self.builder.initialize_soup(self) try: self._feed() success = True break except ParserRejectedMarkup as e: rejections.append(e) pass if not success: other_exceptions = [str(e) for e in rejections] raise ParserRejectedMarkup( "The markup you provided was rejected by the parser. Trying a different parser or a different encoding may help.\n\nOriginal exception(s) from parser:\n " + "\n ".join(other_exceptions) ) # Clear out the markup and remove the builder's circular # reference to this object. self.markup = None self.builder.soup = None def _clone(self): """Create a new BeautifulSoup object with the same TreeBuilder, but not associated with any markup. This is the first step of the deepcopy process. """ clone = type(self)("", None, self.builder) # Keep track of the encoding of the original document, # since we won't be parsing it again. clone.original_encoding = self.original_encoding return clone def __getstate__(self): # Frequently a tree builder can't be pickled. d = dict(self.__dict__) if 'builder' in d and d['builder'] is not None and not self.builder.picklable: d['builder'] = type(self.builder) # Store the contents as a Unicode string. d['contents'] = [] d['markup'] = self.decode() # If _most_recent_element is present, it's a Tag object left # over from initial parse. It might not be picklable and we # don't need it. if '_most_recent_element' in d: del d['_most_recent_element'] return d def __setstate__(self, state): # If necessary, restore the TreeBuilder by looking it up. self.__dict__ = state if isinstance(self.builder, type): self.builder = self.builder() elif not self.builder: # We don't know which builder was used to build this # parse tree, so use a default we know is always available. self.builder = HTMLParserTreeBuilder() self.builder.soup = self self.reset() self._feed() return state @classmethod def _decode_markup(cls, markup): """Ensure `markup` is bytes so it's safe to send into warnings.warn. TODO: warnings.warn had this problem back in 2010 but it might not anymore. """ if isinstance(markup, bytes): decoded = markup.decode('utf-8', 'replace') else: decoded = markup return decoded @classmethod def _markup_is_url(cls, markup): """Error-handling method to raise a warning if incoming markup looks like a URL. :param markup: A string. :return: Whether or not the markup resembles a URL closely enough to justify a warning. """ if isinstance(markup, bytes): space = b' ' cant_start_with = (b"http:", b"https:") elif isinstance(markup, str): space = ' ' cant_start_with = ("http:", "https:") else: return False if any(markup.startswith(prefix) for prefix in cant_start_with): if not space in markup: warnings.warn( 'The input looks more like a URL than markup. You may want to use' ' an HTTP client like requests to get the document behind' ' the URL, and feed that document to Beautiful Soup.', MarkupResemblesLocatorWarning, stacklevel=3 ) return True return False @classmethod def _markup_resembles_filename(cls, markup): """Error-handling method to raise a warning if incoming markup resembles a filename. :param markup: A bytestring or string. :return: Whether or not the markup resembles a filename closely enough to justify a warning. """ path_characters = '/\\' extensions = ['.html', '.htm', '.xml', '.xhtml', '.txt'] if isinstance(markup, bytes): path_characters = path_characters.encode("utf8") extensions = [x.encode('utf8') for x in extensions] filelike = False if any(x in markup for x in path_characters): filelike = True else: lower = markup.lower() if any(lower.endswith(ext) for ext in extensions): filelike = True if filelike: warnings.warn( 'The input looks more like a filename than markup. You may' ' want to open this file and pass the filehandle into' ' Beautiful Soup.', MarkupResemblesLocatorWarning, stacklevel=3 ) return True return False def _feed(self): """Internal method that parses previously set markup, creating a large number of Tag and NavigableString objects. """ # Convert the document to Unicode. self.builder.reset() self.builder.feed(self.markup) # Close out any unfinished strings and close all the open tags. self.endData() while self.currentTag.name != self.ROOT_TAG_NAME: self.popTag() def reset(self): """Reset this object to a state as though it had never parsed any markup. """ Tag.__init__(self, self, self.builder, self.ROOT_TAG_NAME) self.hidden = 1 self.builder.reset() self.current_data = [] self.currentTag = None self.tagStack = [] self.open_tag_counter = Counter() self.preserve_whitespace_tag_stack = [] self.string_container_stack = [] self._most_recent_element = None self.pushTag(self) def new_tag(self, name, namespace=None, nsprefix=None, attrs={}, sourceline=None, sourcepos=None, **kwattrs): """Create a new Tag associated with this BeautifulSoup object. :param name: The name of the new Tag. :param namespace: The URI of the new Tag's XML namespace, if any. :param prefix: The prefix for the new Tag's XML namespace, if any. :param attrs: A dictionary of this Tag's attribute values; can be used instead of `kwattrs` for attributes like 'class' that are reserved words in Python. :param sourceline: The line number where this tag was (purportedly) found in its source document. :param sourcepos: The character position within `sourceline` where this tag was (purportedly) found. :param kwattrs: Keyword arguments for the new Tag's attribute values. """ kwattrs.update(attrs) return self.element_classes.get(Tag, Tag)( None, self.builder, name, namespace, nsprefix, kwattrs, sourceline=sourceline, sourcepos=sourcepos ) def string_container(self, base_class=None): container = base_class or NavigableString # There may be a general override of NavigableString. container = self.element_classes.get( container, container ) # On top of that, we may be inside a tag that needs a special # container class. if self.string_container_stack and container is NavigableString: container = self.builder.string_containers.get( self.string_container_stack[-1].name, container ) return container def new_string(self, s, subclass=None): """Create a new NavigableString associated with this BeautifulSoup object. """ container = self.string_container(subclass) return container(s) def insert_before(self, *args): """This method is part of the PageElement API, but `BeautifulSoup` doesn't implement it because there is nothing before or after it in the parse tree. """ raise NotImplementedError("BeautifulSoup objects don't support insert_before().") def insert_after(self, *args): """This method is part of the PageElement API, but `BeautifulSoup` doesn't implement it because there is nothing before or after it in the parse tree. """ raise NotImplementedError("BeautifulSoup objects don't support insert_after().") def popTag(self): """Internal method called by _popToTag when a tag is closed.""" tag = self.tagStack.pop() if tag.name in self.open_tag_counter: self.open_tag_counter[tag.name] -= 1 if self.preserve_whitespace_tag_stack and tag == self.preserve_whitespace_tag_stack[-1]: self.preserve_whitespace_tag_stack.pop() if self.string_container_stack and tag == self.string_container_stack[-1]: self.string_container_stack.pop() #print("Pop", tag.name) if self.tagStack: self.currentTag = self.tagStack[-1] return self.currentTag def pushTag(self, tag): """Internal method called by handle_starttag when a tag is opened.""" #print("Push", tag.name) if self.currentTag is not None: self.currentTag.contents.append(tag) self.tagStack.append(tag) self.currentTag = self.tagStack[-1] if tag.name != self.ROOT_TAG_NAME: self.open_tag_counter[tag.name] += 1 if tag.name in self.builder.preserve_whitespace_tags: self.preserve_whitespace_tag_stack.append(tag) if tag.name in self.builder.string_containers: self.string_container_stack.append(tag) def endData(self, containerClass=None): """Method called by the TreeBuilder when the end of a data segment occurs. """ if self.current_data: current_data = ''.join(self.current_data) # If whitespace is not preserved, and this string contains # nothing but ASCII spaces, replace it with a single space # or newline. if not self.preserve_whitespace_tag_stack: strippable = True for i in current_data: if i not in self.ASCII_SPACES: strippable = False break if strippable: if '\n' in current_data: current_data = '\n' else: current_data = ' ' # Reset the data collector. self.current_data = [] # Should we add this string to the tree at all? if self.parse_only and len(self.tagStack) <= 1 and \ (not self.parse_only.text or \ not self.parse_only.search(current_data)): return containerClass = self.string_container(containerClass) o = containerClass(current_data) self.object_was_parsed(o) def object_was_parsed(self, o, parent=None, most_recent_element=None): """Method called by the TreeBuilder to integrate an object into the parse tree.""" if parent is None: parent = self.currentTag if most_recent_element is not None: previous_element = most_recent_element else: previous_element = self._most_recent_element next_element = previous_sibling = next_sibling = None if isinstance(o, Tag): next_element = o.next_element next_sibling = o.next_sibling previous_sibling = o.previous_sibling if previous_element is None: previous_element = o.previous_element fix = parent.next_element is not None o.setup(parent, previous_element, next_element, previous_sibling, next_sibling) self._most_recent_element = o parent.contents.append(o) # Check if we are inserting into an already parsed node. if fix: self._linkage_fixer(parent) def _linkage_fixer(self, el): """Make sure linkage of this fragment is sound.""" first = el.contents[0] child = el.contents[-1] descendant = child if child is first and el.parent is not None: # Parent should be linked to first child el.next_element = child # We are no longer linked to whatever this element is prev_el = child.previous_element if prev_el is not None and prev_el is not el: prev_el.next_element = None # First child should be linked to the parent, and no previous siblings. child.previous_element = el child.previous_sibling = None # We have no sibling as we've been appended as the last. child.next_sibling = None # This index is a tag, dig deeper for a "last descendant" if isinstance(child, Tag) and child.contents: descendant = child._last_descendant(False) # As the final step, link last descendant. It should be linked # to the parent's next sibling (if found), else walk up the chain # and find a parent with a sibling. It should have no next sibling. descendant.next_element = None descendant.next_sibling = None target = el while True: if target is None: break elif target.next_sibling is not None: descendant.next_element = target.next_sibling target.next_sibling.previous_element = child break target = target.parent def _popToTag(self, name, nsprefix=None, inclusivePop=True): """Pops the tag stack up to and including the most recent instance of the given tag. If there are no open tags with the given name, nothing will be popped. :param name: Pop up to the most recent tag with this name. :param nsprefix: The namespace prefix that goes with `name`. :param inclusivePop: It this is false, pops the tag stack up to but *not* including the most recent instqance of the given tag. """ #print("Popping to %s" % name) if name == self.ROOT_TAG_NAME: # The BeautifulSoup object itself can never be popped. return most_recently_popped = None stack_size = len(self.tagStack) for i in range(stack_size - 1, 0, -1): if not self.open_tag_counter.get(name): break t = self.tagStack[i] if (name == t.name and nsprefix == t.prefix): if inclusivePop: most_recently_popped = self.popTag() break most_recently_popped = self.popTag() return most_recently_popped def handle_starttag(self, name, namespace, nsprefix, attrs, sourceline=None, sourcepos=None, namespaces=None): """Called by the tree builder when a new tag is encountered. :param name: Name of the tag. :param nsprefix: Namespace prefix for the tag. :param attrs: A dictionary of attribute values. :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 namespaces: A dictionary of all namespace prefix mappings currently in scope in the document. If this method returns None, the tag was rejected by an active SoupStrainer. You should proceed as if the tag had not occurred in the document. For instance, if this was a self-closing tag, don't call handle_endtag. """ # print("Start tag %s: %s" % (name, attrs)) self.endData() if (self.parse_only and len(self.tagStack) <= 1 and (self.parse_only.text or not self.parse_only.search_tag(name, attrs))): return None tag = self.element_classes.get(Tag, Tag)( self, self.builder, name, namespace, nsprefix, attrs, self.currentTag, self._most_recent_element, sourceline=sourceline, sourcepos=sourcepos, namespaces=namespaces ) if tag is None: return tag if self._most_recent_element is not None: self._most_recent_element.next_element = tag self._most_recent_element = tag self.pushTag(tag) return tag def handle_endtag(self, name, nsprefix=None): """Called by the tree builder when an ending tag is encountered. :param name: Name of the tag. :param nsprefix: Namespace prefix for the tag. """ #print("End tag: " + name) self.endData() self._popToTag(name, nsprefix) def handle_data(self, data): """Called by the tree builder when a chunk of textual data is encountered.""" self.current_data.append(data) def decode(self, pretty_print=False, eventual_encoding=DEFAULT_OUTPUT_ENCODING, formatter="minimal", iterator=None): """Returns a string or Unicode representation of the parse tree as an HTML or XML document. :param pretty_print: If this is True, indentation will be used to make the document more readable. :param eventual_encoding: The encoding of the final document. If this is None, the document will be a Unicode string. """ if self.is_xml: # Print the XML declaration encoding_part = '' if eventual_encoding in PYTHON_SPECIFIC_ENCODINGS: # This is a special Python encoding; it can't actually # go into an XML document because it means nothing # outside of Python. eventual_encoding = None if eventual_encoding != None: encoding_part = ' encoding="%s"' % eventual_encoding prefix = '<?xml version="1.0"%s?>\n' % encoding_part else: prefix = '' if not pretty_print: indent_level = None else: indent_level = 0 return prefix + super(BeautifulSoup, self).decode( indent_level, eventual_encoding, formatter, iterator) # Aliases to make it easier to get started quickly, e.g. 'from bs4 import _soup' _s = BeautifulSoup _soup = BeautifulSoup class BeautifulStoneSoup(BeautifulSoup): """Deprecated interface to an XML parser.""" def __init__(self, *args, **kwargs): kwargs['features'] = 'xml' warnings.warn( 'The BeautifulStoneSoup class is deprecated. Instead of using ' 'it, pass features="xml" into the BeautifulSoup constructor.', DeprecationWarning, stacklevel=2 ) super(BeautifulStoneSoup, self).__init__(*args, **kwargs) class StopParsing(Exception): """Exception raised by a TreeBuilder if it's unable to continue parsing.""" pass class FeatureNotFound(ValueError): """Exception raised by the BeautifulSoup constructor if no parser with the requested features is found. """ pass #If this file is run as a script, act as an HTML pretty-printer. if __name__ == '__main__': import sys soup = BeautifulSoup(sys.stdin) print((soup.prettify())) PK z�ZMa �I I tests/test_element.pynu �[��� PK z�Z��w�g g � tests/test_docs.pynu �[��� PK z�Z��U~< < 7 tests/test_fuzz.pynu �[��� PK z�Z��_9 9 6 �) tests/__pycache__/test_navigablestring.cpython-310.pycnu �[��� PK z�Z �8N N * T= tests/__pycache__/test_css.cpython-310.pycnu �[��� PK z�Z*D�8�" �" * Ë tests/__pycache__/test_tag.cpython-310.pycnu �[��� PK z�Z|� �6 6 2 � tests/__pycache__/test_pageelement.cpython-310.pycnu �[��� PK z�Z�ޯв в * n� tests/__pycache__/__init__.cpython-310.pycnu �[��� PK z�ZK M� � 0 �� tests/__pycache__/test_formatter.cpython-310.pycnu �[��� PK z�Z@S�(8 8 7 x� tests/__pycache__/test_builder_registry.cpython-310.pycnu �[��� PK z�Z��Q� � 1 � tests/__pycache__/test_htmlparser.cpython-310.pycnu �[��� PK z�Zz����� �� + I� tests/__pycache__/test_tree.cpython-310.pycnu �[��� PK z�Z�9��� � / Y� tests/__pycache__/test_html5lib.cpython-310.pycnu �[��� PK z�Z}U�u� � + �� tests/__pycache__/test_docs.cpython-310.pycnu �[��� PK z�Z+ef�@ @ + �� tests/__pycache__/test_fuzz.cpython-310.pycnu �[��� PK z�Zi*uQ� � . ;� tests/__pycache__/test_element.cpython-310.pycnu �[��� PK z�ZAp���0 �0 - L� tests/__pycache__/test_dammit.cpython-310.pycnu �[��� PK z�Z}% A� � + y� tests/__pycache__/test_lxml.cpython-310.pycnu �[��� PK z�Z����� � . � tests/__pycache__/test_builder.cpython-310.pycnu �[��� PK z�Z v|�K �K + � tests/__pycache__/test_soup.cpython-310.pycnu �[��� PK z�Z�a� �M �M ~f tests/test_soup.pynu �[��� PK z�Z�jT�� � e� tests/test_tree.pynu �[��� PK z�Z �Tf�7 �7 �p tests/test_pageelement.pynu �[��� PK z�Zl�:[ [ �� tests/test_builder.pynu �[��� PK z�ZJ"O� � S� tests/test_navigablestring.pynu �[��� PK z�Z% �m N y� tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-5703933063462912.testcasenu �[��� PK z�Zx�� � N �� tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-5375146639360000.testcasenu �[��� PK z�Z�O )| | N W� tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-6600557255327744.testcasenu �[��� PK z�Z ϥ�g g B Q� tests/fuzz/crash-ffbdfa8a2b26f13537b68d3794b0478a4090ee4a.testcasenu �[��� PK z�Z�A� N *� tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-4818336571064320.testcasenu �[��� PK z�Z���J N �� tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-6241471367348224.testcasenu �[��� PK z�Z�XD#'� '� N P� tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-5984173902397440.testcasenu �[��� PK z�Zk� N �� tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-4670634698080256.testcasenu �[��� PK z�Z���{� � N �� tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-6450958476902400.testcasenu �[��� PK z�Z Ή��, �, N ڮ tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-5492400320282624.testcasenu �[��� PK z�Z�t~b�( �( N F� tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-6124268085182464.testcasenu �[��� PK z�ZH�7T L L N P tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-5167584867909632.testcasenu �[��� PK z�Z��n N �Q tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-4999465949331456.testcasenu �[��� PK z�Z9����; �; N wR tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-5000587759190016.testcasenu �[��� PK z�Z�LbF/ / N � tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-6306874195312640.testcasenu �[��� PK z�Z�!]�# # N �� tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-5843991618256896.testcasenu �[��� PK z�Z?��� N 6� tests/fuzz/clusterfuzz-testcase-minimized-bs4_fuzzer-5270998950477824.testcasenu �[��� PK z�Z�:�9/ / B �� tests/fuzz/crash-0d306a50c8ed8bcd0785b67000fcd5dea1d33f08.testcasenu �[��� PK z�Z1o��C C a� tests/test_css.pynu �[��� PK z�Z�JD�� � !� tests/test_html5lib.pynu �[��� PK z�Z��x��% �% � tests/test_tag.pynu �[��� PK z�Z>U��[< [< �% tests/test_dammit.pynu �[��� PK z�Z_�͍� � Yb tests/test_lxml.pynu �[��� PK z�ZK_~94 4 n� tests/test_formatter.pynu �[��� PK z�ZΑ�M� � � tests/test_builder_registry.pynu �[��� PK z�Z?��p p 1� tests/test_htmlparser.pynu �[��� PK z�Z�~V�� � � tests/__init__.pynu �[��� PK z�ZVL�5 2{ diagnose.pynu �[��� PK z�Z\/�}�' �' ) �� builder/__pycache__/_lxml.cpython-310.pycnu �[��� PK z�Z0���\& \& / �� builder/__pycache__/_htmlparser.cpython-310.pycnu �[��� PK z�Z�GC3K 3K , c� builder/__pycache__/__init__.cpython-310.pycnu �[��� PK z�Z�5��_1 _1 - �1 builder/__pycache__/_html5lib.cpython-310.pycnu �[��� PK z�ZޣCZK: K: �c builder/_htmlparser.pynu �[��� PK z�Z�9�ʪJ �J ?� builder/_html5lib.pynu �[��� PK z�Z�!g�d: d: -� builder/_lxml.pynu �[��� PK z�Z%�1��_ �_ �# builder/__init__.pynu �[��� PK z�ZZg�*` *` $ � __pycache__/__init__.cpython-310.pycnu �[��� PK z�Z��& �& �� __pycache__/css.cpython-310.pycnu �[��� PK z�Z�RI�Z Z % � __pycache__/formatter.cpython-310.pycnu �[��� PK z�Z�69�� � # \& __pycache__/element.cpython-310.pycnu �[��� PK z�Z�/�;�k �k " �4 __pycache__/dammit.cpython-310.pycnu �[��� PK z�Z� r' $ `� __pycache__/diagnose.cpython-310.pycnu �[��� PK z�Z?kF]' ]' �� css.pynu �[��� PK z�ZO�{�j �j S� element.pynu �[��� PK z�Zu9 :R formatter.pynu �[��� PK z�Zi�LƠ Ơ �n dammit.pynu �[��� PK z�Z�c�r � � � __init__.pynu �[��� PK H H � �
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.04 |
proxy
|
phpinfo
|
Settings