@scrypted/arlo 0.11.24 → 0.11.26

package/venv/lib/python3.10/site-packages/bs4/tests/test_htmlparser.py

@@ -0,0 +1,161 @@
+"""Tests to ensure that the html.parser tree builder generates good
+trees."""
+
+import pickle
+import pytest
+from bs4.builder._htmlparser import (
+    _DuplicateAttributeHandler,
+    BeautifulSoupHTMLParser,
+    HTMLParserTreeBuilder,
+)
+from bs4.exceptions import ParserRejectedMarkup
+from typing import Any
+from . import HTMLTreeBuilderSmokeTest
+
+
+class TestHTMLParserTreeBuilder(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):
+                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 &amp;# 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 None is soup.p.sourceline
+        assert None is soup.p.sourcepos
+
+    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: _DuplicateAttributeHandler, expected: Any
+        ) -> None:
+            soup = self.soup(markup, on_duplicate_attribute=on_duplicate_attribute)
+            assert soup.a is not None
+            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 (
+            ("&RightArrowLeftArrow;", "\u21c4", b"&rlarr;"),
+            ("&models;", "\u22a7", b"&models;"),
+            ("&Nfr;", "\U0001d511", b"&Nfr;"),
+            ("&ngeqq;", "\u2267\u0338", b"&ngeqq;"),
+            ("&not;", "\xac", b"&not;"),
+            ("&Not;", "\u2aec", b"&Not;"),
+            ("&quot;", '"', b'"'),
+            ("&there4;", "\u2234", b"&there4;"),
+            ("&Therefore;", "\u2234", b"&there4;"),
+            ("&therefore;", "\u2234", b"&there4;"),
+            ("&fjlig;", "fj", b"fj"),
+            ("&sqcup;", "\u2294", b"&sqcup;"),
+            ("&sqcups;", "\u2294\ufe00", b"&sqcups;"),
+            ("&apos;", "'", b"'"),
+            ("&verbar;", "|", 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
+
+    def test_invalid_html_entity(self):
+        # The html.parser treebuilder can't distinguish between an invalid
+        # HTML entity with a semicolon and an invalid HTML entity with no
+        # semicolon.
+        markup = "<p>a &nosuchentity b</p>"
+        soup = self.soup(markup)
+        assert "<p>a &amp;nosuchentity b</p>" == soup.p.decode()
+
+        markup = "<p>a &nosuchentity; b</p>"
+        soup = self.soup(markup)
+        assert "<p>a &amp;nosuchentity b</p>" == soup.p.decode()

package/venv/lib/python3.10/site-packages/bs4/tests/test_lxml.py

@@ -0,0 +1,196 @@
+"""Tests to ensure that the lxml tree builder generates good trees."""
+
+import pickle
+import pytest
+import warnings
+from . import LXML_PRESENT, LXML_VERSION
+
+if LXML_PRESENT:
+    from bs4.builder._lxml import LXMLTreeBuilder, LXMLTreeBuilderForXML
+
+from bs4 import (
+    BeautifulStoneSoup,
+)
+from . import (
+    HTMLTreeBuilderSmokeTest,
+    XMLTreeBuilderSmokeTest,
+    SOUP_SIEVE_PRESENT,
+)
+
+
+@pytest.mark.skipif(
+    not LXML_PRESENT,
+    reason="lxml seems not to be present, not testing its tree builder.",
+)
+class TestLXMLTreeBuilder(HTMLTreeBuilderSmokeTest):
+    """See ``HTMLTreeBuilderSmokeTest``."""
+
+    @property
+    def default_builder(self):
+        return LXMLTreeBuilder
+
+    def test_out_of_range_entity(self):
+        self.assert_soup("<p>foo&#10000000000000;bar</p>", "<p>foobar</p>")
+        self.assert_soup("<p>foo&#x10000000000000;bar</p>", "<p>foobar</p>")
+        self.assert_soup("<p>foo&#1000000000;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 "&#147;", 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 "The BeautifulStoneSoup class was 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.
+        #
+        # However, for consistency with other parsers, Tag.sourceline
+        # and Tag.sourcepos are always set to None, rather than being
+        # available as an alias for find().
+        soup = self.soup(
+            "\n   <p>\n\n<sourceline>\n<b>text</b></sourceline><sourcepos></p>",
+            store_line_numbers=True,
+        )
+        assert None is soup.p.sourceline
+        assert None is soup.p.sourcepos
+
+
+@pytest.mark.skipif(
+    not LXML_PRESENT,
+    reason="lxml seems not to be present, not testing its XML tree builder.",
+)
+class TestLXMLXMLTreeBuilder(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)

package/venv/lib/python3.10/site-packages/bs4/tests/test_navigablestring.py

@@ -0,0 +1,144 @@
+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.string
+        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.string
+        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 is 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)
+        )