PyPI - scrapling - Versions diffs - 0.2.8__py3-none-any.whl → 0.2.91__py3-none-any.whl - Mend

scrapling 0.2.8py3-none-any.whl → 0.2.91py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (37) hide show

scrapling/__init__.py +4 -4
scrapling/core/_types.py +2 -0
scrapling/core/custom_types.py +88 -6
scrapling/core/storage_adaptors.py +5 -6
scrapling/core/translator.py +2 -2
scrapling/core/utils.py +29 -27
scrapling/defaults.py +2 -1
scrapling/engines/camo.py +124 -24
scrapling/engines/constants.py +4 -4
scrapling/engines/pw.py +195 -91
scrapling/engines/static.py +91 -48
scrapling/engines/toolbelt/__init__.py +3 -3
scrapling/engines/toolbelt/custom.py +16 -22
scrapling/engines/toolbelt/fingerprints.py +3 -3
scrapling/engines/toolbelt/navigation.py +21 -8
scrapling/fetchers.py +231 -16
scrapling/parser.py +50 -22
{scrapling-0.2.8.dist-info → scrapling-0.2.91.dist-info}/METADATA +33 -18
scrapling-0.2.91.dist-info/RECORD +47 -0
tests/fetchers/async/__init__.py +0 -0
tests/fetchers/async/test_camoufox.py +95 -0
tests/fetchers/async/test_httpx.py +83 -0
tests/fetchers/async/test_playwright.py +99 -0
tests/fetchers/sync/__init__.py +0 -0
tests/fetchers/sync/test_camoufox.py +68 -0
tests/fetchers/sync/test_httpx.py +82 -0
tests/fetchers/sync/test_playwright.py +87 -0
tests/fetchers/test_utils.py +90 -122
tests/parser/test_automatch.py +64 -9
tests/parser/test_general.py +260 -218
scrapling-0.2.8.dist-info/RECORD +0 -42
tests/fetchers/test_camoufox.py +0 -65
tests/fetchers/test_httpx.py +0 -68
tests/fetchers/test_playwright.py +0 -77
{scrapling-0.2.8.dist-info → scrapling-0.2.91.dist-info}/LICENSE +0 -0
{scrapling-0.2.8.dist-info → scrapling-0.2.91.dist-info}/WHEEL +0 -0
{scrapling-0.2.8.dist-info → scrapling-0.2.91.dist-info}/top_level.txt +0 -0

tests/parser/test_general.py CHANGED Viewed

@@ -1,288 +1,330 @@
 import pickle
-import unittest
+import time
+import pytest
 from cssselect import SelectorError, SelectorSyntaxError
 from scrapling import Adaptor
-class TestParser(unittest.TestCase):
-    def setUp(self):
-        self.html = '''
-        <html>
-        <head>
-            <title>Complex Web Page</title>
-            <style>
-                .hidden { display: none; }
-            </style>
-        </head>
-        <body>
-            <header>
-                <nav>
-                    <ul>
-                        <li><a href="#home">Home</a></li>
-                        <li><a href="#about">About</a></li>
-                        <li><a href="#contact">Contact</a></li>
-                    </ul>
-                </nav>
-            </header>
-            <main>
-                <section id="products" schema='{"jsonable": "data"}'>
-                    <h2>Products</h2>
-                    <div class="product-list">
-                        <article class="product" data-id="1">
-                            <h3>Product 1</h3>
-                            <p class="description">This is product 1</p>
-                            <span class="price">$10.99</span>
-                            <div class="hidden stock">In stock: 5</div>
-                        </article>
-                        <article class="product" data-id="2">
-                            <h3>Product 2</h3>
-                            <p class="description">This is product 2</p>
-                            <span class="price">$20.99</span>
-                            <div class="hidden stock">In stock: 3</div>
-                        </article>
-                        <article class="product" data-id="3">
-                            <h3>Product 3</h3>
-                            <p class="description">This is product 3</p>
-                            <span class="price">$15.99</span>
-                            <div class="hidden stock">Out of stock</div>
-                        </article>
+@pytest.fixture
+def html_content():
+    return '''
+    <html>
+    <head>
+        <title>Complex Web Page</title>
+        <style>
+            .hidden { display: none; }
+        </style>
+    </head>
+    <body>
+        <header>
+            <nav>
+                <ul>
+                    <li><a href="#home">Home</a></li>
+                    <li><a href="#about">About</a></li>
+                    <li><a href="#contact">Contact</a></li>
+                </ul>
+            </nav>
+        </header>
+        <main>
+            <section id="products" schema='{"jsonable": "data"}'>
+                <h2>Products</h2>
+                <div class="product-list">
+                    <article class="product" data-id="1">
+                        <h3>Product 1</h3>
+                        <p class="description">This is product 1</p>
+                        <span class="price">$10.99</span>
+                        <div class="hidden stock">In stock: 5</div>
+                    </article>
+                    <article class="product" data-id="2">
+                        <h3>Product 2</h3>
+                        <p class="description">This is product 2</p>
+                        <span class="price">$20.99</span>
+                        <div class="hidden stock">In stock: 3</div>
+                    </article>
+                    <article class="product" data-id="3">
+                        <h3>Product 3</h3>
+                        <p class="description">This is product 3</p>
+                        <span class="price">$15.99</span>
+                        <div class="hidden stock">Out of stock</div>
+                    </article>
+                </div>
+            </section>
+            <section id="reviews">
+                <h2>Customer Reviews</h2>
+                <div class="review-list">
+                    <div class="review" data-rating="5">
+                        <p class="review-text">Great product!</p>
+                        <span class="reviewer">John Doe</span>
                     </div>
-                </section>
-                <section id="reviews">
-                    <h2>Customer Reviews</h2>
-                    <div class="review-list">
-                        <div class="review" data-rating="5">
-                            <p class="review-text">Great product!</p>
-                            <span class="reviewer">John Doe</span>
-                        </div>
-                        <div class="review" data-rating="4">
-                            <p class="review-text">Good value for money.</p>
-                            <span class="reviewer">Jane Smith</span>
-                        </div>
+                    <div class="review" data-rating="4">
+                        <p class="review-text">Good value for money.</p>
+                        <span class="reviewer">Jane Smith</span>
                     </div>
-                </section>
-            </main>
-            <footer>
-                <p>&copy; 2024 Our Company</p>
-            </footer>
-            <script id="page-data" type="application/json">
-                {"lastUpdated": "2024-09-22T10:30:00Z", "totalProducts": 3}
-            </script>
-        </body>
-        </html>
-        '''
-        self.page = Adaptor(self.html, auto_match=False, debug=False)
-    def test_css_selector(self):
-        """Test Selecting elements with complex CSS selectors"""
-        elements = self.page.css('main #products .product-list article.product')
-        self.assertEqual(len(elements), 3)
-        in_stock_products = self.page.css(
+                </div>
+            </section>
+        </main>
+        <footer>
+            <p>&copy; 2024 Our Company</p>
+        </footer>
+        <script id="page-data" type="application/json">
+            {"lastUpdated": "2024-09-22T10:30:00Z", "totalProducts": 3}
+        </script>
+    </body>
+    </html>
+    '''
+@pytest.fixture
+def page(html_content):
+    return Adaptor(html_content, auto_match=False)
+# CSS Selector Tests
+class TestCSSSelectors:
+    def test_basic_product_selection(self, page):
+        """Test selecting all product elements"""
+        elements = page.css('main #products .product-list article.product')
+        assert len(elements) == 3
+    def test_in_stock_product_selection(self, page):
+        """Test selecting in-stock products"""
+        in_stock_products = page.css(
             'main #products .product-list article.product:not(:contains("Out of stock"))')
-        self.assertEqual(len(in_stock_products), 2)
+        assert len(in_stock_products) == 2
-    def test_xpath_selector(self):
-        """Test Selecting elements with Complex XPath selectors"""
-        reviews = self.page.xpath(
+# XPath Selector Tests
+class TestXPathSelectors:
+    def test_high_rating_reviews(self, page):
+        """Test selecting reviews with high ratings"""
+        reviews = page.xpath(
             '//section[@id="reviews"]//div[contains(@class, "review") and @data-rating >= 4]'
         )
-        self.assertEqual(len(reviews), 2)
+        assert len(reviews) == 2
-        high_priced_products = self.page.xpath(
+    def test_high_priced_products(self, page):
+        """Test selecting products above a certain price"""
+        high_priced_products = page.xpath(
             '//article[contains(@class, "product")]'
             '[number(translate(substring-after(.//span[@class="price"], "$"), ",", "")) > 15]'
         )
-        self.assertEqual(len(high_priced_products), 2)
+        assert len(high_priced_products) == 2
+# Text Matching Tests
+class TestTextMatching:
+    def test_regex_multiple_matches(self, page):
+        """Test finding multiple matches with regex"""
+        stock_info = page.find_by_regex(r'In stock: \d+', first_match=False)
+        assert len(stock_info) == 2
-    def test_find_by_text(self):
-        """Test Selecting elements with Text matching"""
-        stock_info = self.page.find_by_regex(r'In stock: \d+', first_match=False)
-        self.assertEqual(len(stock_info), 2)
+    def test_regex_first_match(self, page):
+        """Test finding the first match with regex"""
+        stock_info = page.find_by_regex(r'In stock: \d+', first_match=True, case_sensitive=True)
+        assert stock_info.text == 'In stock: 5'
-        stock_info = self.page.find_by_regex(r'In stock: \d+', first_match=True, case_sensitive=True)
-        self.assertEqual(stock_info.text, 'In stock: 5')
+    def test_partial_text_match(self, page):
+        """Test finding elements with partial text match"""
+        stock_info = page.find_by_text(r'In stock:', partial=True, first_match=False)
+        assert len(stock_info) == 2
-        stock_info = self.page.find_by_text(r'In stock:', partial=True, first_match=False)
-        self.assertEqual(len(stock_info), 2)
+    def test_exact_text_match(self, page):
+        """Test finding elements with exact text match"""
+        out_of_stock = page.find_by_text('Out of stock', partial=False, first_match=False)
+        assert len(out_of_stock) == 1
-        out_of_stock = self.page.find_by_text('Out of stock', partial=False, first_match=False)
-        self.assertEqual(len(out_of_stock), 1)
-    def test_find_similar_elements(self):
-        """Test Finding similar elements of an element"""
-        first_product = self.page.css_first('.product')
+# Similar Elements Tests
+class TestSimilarElements:
+    def test_finding_similar_products(self, page):
+        """Test finding similar product elements"""
+        first_product = page.css_first('.product')
         similar_products = first_product.find_similar()
-        self.assertEqual(len(similar_products), 2)
+        assert len(similar_products) == 2
-        first_review = self.page.find('div', class_='review')
+    def test_finding_similar_reviews(self, page):
+        """Test finding similar review elements with additional filtering"""
+        first_review = page.find('div', class_='review')
         similar_high_rated_reviews = [
             review
             for review in first_review.find_similar()
             if int(review.attrib.get('data-rating', 0)) >= 4
         ]
-        self.assertEqual(len(similar_high_rated_reviews), 1)
+        assert len(similar_high_rated_reviews) == 1
-    def test_expected_errors(self):
-        """Test errors that should raised if it does"""
-        with self.assertRaises(ValueError):
+# Error Handling Tests
+class TestErrorHandling:
+    def test_invalid_adaptor_initialization(self):
+        """Test various invalid Adaptor initializations"""
+        # No arguments
+        with pytest.raises(ValueError):
             _ = Adaptor(auto_match=False)
-        with self.assertRaises(TypeError):
+        # Invalid argument types
+        with pytest.raises(TypeError):
             _ = Adaptor(root="ayo", auto_match=False)
-        with self.assertRaises(TypeError):
+        with pytest.raises(TypeError):
             _ = Adaptor(text=1, auto_match=False)
-        with self.assertRaises(TypeError):
+        with pytest.raises(TypeError):
             _ = Adaptor(body=1, auto_match=False)
-        with self.assertRaises(ValueError):
-            _ = Adaptor(self.html, storage=object, auto_match=True)
-    def test_pickleable(self):
-        """Test that objects aren't pickleable"""
-        table = self.page.css('.product-list')[0]
-        with self.assertRaises(TypeError):  # Adaptors
-            pickle.dumps(table)
-        with self.assertRaises(TypeError):  # Adaptor
-            pickle.dumps(table[0])
-    def test_overridden(self):
-        """Test overridden functions"""
-        table = self.page.css('.product-list')[0]
-        self.assertTrue(issubclass(type(table.__str__()), str))
-        self.assertTrue(issubclass(type(table.__repr__()), str))
-        self.assertTrue(issubclass(type(table.attrib.__str__()), str))
-        self.assertTrue(issubclass(type(table.attrib.__repr__()), str))
-    def test_bad_selector(self):
-        """Test object can handle bad selector"""
-        with self.assertRaises((SelectorError, SelectorSyntaxError,)):
-            self.page.css('4 ayo')
+    def test_invalid_storage(self, page, html_content):
+        """Test invalid storage parameter"""
+        with pytest.raises(ValueError):
+            _ = Adaptor(html_content, storage=object, auto_match=True)
-        with self.assertRaises((SelectorError, SelectorSyntaxError,)):
-            self.page.xpath('4 ayo')
+    def test_bad_selectors(self, page):
+        """Test handling of invalid selectors"""
+        with pytest.raises((SelectorError, SelectorSyntaxError)):
+            page.css('4 ayo')
-    def test_selectors_generation(self):
-        """Try to create selectors for all elements in the page"""
-        def _traverse(element: Adaptor):
-            self.assertTrue(type(element.generate_css_selector) is str)
-            self.assertTrue(type(element.generate_xpath_selector) is str)
-            for branch in element.children:
-                _traverse(branch)
+        with pytest.raises((SelectorError, SelectorSyntaxError)):
+            page.xpath('4 ayo')
-        _traverse(self.page)
-    def test_getting_all_text(self):
-        """Test getting all text"""
-        self.assertNotEqual(self.page.get_all_text(), '')
-    def test_element_navigation(self):
-        """Test moving in the page from selected element"""
-        table = self.page.css('.product-list')[0]
+# Pickling and Object Representation Tests
+class TestPicklingAndRepresentation:
+    def test_unpickleable_objects(self, page):
+        """Test that Adaptor objects cannot be pickled"""
+        table = page.css('.product-list')[0]
+        with pytest.raises(TypeError):
+            pickle.dumps(table)
-        self.assertIsNot(table.path, [])
-        self.assertNotEqual(table.html_content, '')
-        self.assertNotEqual(table.prettify(), '')
+        with pytest.raises(TypeError):
+            pickle.dumps(table[0])
+    def test_string_representations(self, page):
+        """Test custom string representations of objects"""
+        table = page.css('.product-list')[0]
+        assert issubclass(type(table.__str__()), str)
+        assert issubclass(type(table.__repr__()), str)
+        assert issubclass(type(table.attrib.__str__()), str)
+        assert issubclass(type(table.attrib.__repr__()), str)
+# Navigation and Traversal Tests
+class TestElementNavigation:
+    def test_basic_navigation_properties(self, page):
+        """Test basic navigation properties of elements"""
+        table = page.css('.product-list')[0]
+        assert table.path is not None
+        assert table.html_content != ''
+        assert table.prettify() != ''
+    def test_parent_and_sibling_navigation(self, page):
+        """Test parent and sibling navigation"""
+        table = page.css('.product-list')[0]
         parent = table.parent
-        self.assertEqual(parent.attrib['id'], 'products')
-        children = table.children
-        self.assertEqual(len(children), 3)
+        assert parent.attrib['id'] == 'products'
         parent_siblings = parent.siblings
-        self.assertEqual(len(parent_siblings), 1)
+        assert len(parent_siblings) == 1
+    def test_child_navigation(self, page):
+        """Test child navigation"""
+        table = page.css('.product-list')[0]
+        children = table.children
+        assert len(children) == 3
-        child = table.find({'data-id': "1"})
+    def test_next_and_previous_navigation(self, page):
+        """Test next and previous element navigation"""
+        child = page.css('.product-list')[0].find({'data-id': "1"})
         next_element = child.next
-        self.assertEqual(next_element.attrib['data-id'], '2')
+        assert next_element.attrib['data-id'] == '2'
         prev_element = next_element.previous
-        self.assertEqual(prev_element.tag, child.tag)
+        assert prev_element.tag == child.tag
-        all_prices = self.page.css('.price')
+    def test_ancestor_finding(self, page):
+        """Test finding ancestors of elements"""
+        all_prices = page.css('.price')
         products_with_prices = [
             price.find_ancestor(lambda p: p.has_class('product'))
             for price in all_prices
         ]
-        self.assertEqual(len(products_with_prices), 3)
-    def test_empty_return(self):
-        """Test cases where functions shouldn't have results"""
-        test_html = """
-        <html>
-            <span id="a"><a></a><!--comment--></span>
-            <span id="b"><!--comment--><a></a></span>
-        </html>"""
-        soup = Adaptor(test_html, auto_match=False, keep_comments=False)
-        html_tag = soup.css('html')[0]
-        self.assertEqual(html_tag.path, [])
-        self.assertEqual(html_tag.siblings, [])
-        self.assertEqual(html_tag.parent, None)
-        self.assertEqual(html_tag.find_ancestor(lambda e: e), None)
-        self.assertEqual(soup.css('#a a')[0].next, None)
-        self.assertEqual(soup.css('#b a')[0].previous, None)
-    def test_text_to_json(self):
-        """Test converting text to json"""
-        script_content = self.page.css('#page-data::text')[0]
-        self.assertTrue(issubclass(type(script_content.sort()), str))
+        assert len(products_with_prices) == 3
+# JSON and Attribute Tests
+class TestJSONAndAttributes:
+    def test_json_conversion(self, page):
+        """Test converting content to JSON"""
+        script_content = page.css('#page-data::text')[0]
+        assert issubclass(type(script_content.sort()), str)
         page_data = script_content.json()
-        self.assertEqual(page_data['totalProducts'], 3)
-        self.assertTrue('lastUpdated' in page_data)
-    def test_regex_on_text(self):
-        """Test doing regex on a selected text"""
-        element = self.page.css('[data-id="1"] .price')[0]
-        match = element.re_first(r'[\.\d]+')
-        self.assertEqual(match, '10.99')
-        match = element.text.re(r'(\d+)', replace_entities=False)
-        self.assertEqual(len(match), 2)
-    def test_attribute_operations(self):
-        """Test operations on elements attributes"""
-        products = self.page.css('.product')
+        assert page_data['totalProducts'] == 3
+        assert 'lastUpdated' in page_data
+    def test_attribute_operations(self, page):
+        """Test various attribute-related operations"""
+        # Product ID extraction
+        products = page.css('.product')
         product_ids = [product.attrib['data-id'] for product in products]
-        self.assertEqual(product_ids, ['1', '2', '3'])
-        self.assertTrue('data-id' in products[0].attrib)
+        assert product_ids == ['1', '2', '3']
+        assert 'data-id' in products[0].attrib
-        reviews = self.page.css('.review')
+        # Review rating calculations
+        reviews = page.css('.review')
         review_ratings = [int(review.attrib['data-rating']) for review in reviews]
-        self.assertEqual(sum(review_ratings) / len(review_ratings), 4.5)
+        assert sum(review_ratings) / len(review_ratings) == 4.5
+        # Attribute searching
         key_value = list(products[0].attrib.search_values('1', partial=False))
-        self.assertEqual(list(key_value[0].keys()), ['data-id'])
+        assert list(key_value[0].keys()) == ['data-id']
         key_value = list(products[0].attrib.search_values('1', partial=True))
-        self.assertEqual(list(key_value[0].keys()), ['data-id'])
+        assert list(key_value[0].keys()) == ['data-id']
+        # JSON attribute conversion
+        attr_json = page.css_first('#products').attrib['schema'].json()
+        assert attr_json == {'jsonable': 'data'}
+        assert isinstance(page.css('#products')[0].attrib.json_string, bytes)
+# Performance Test
+def test_large_html_parsing_performance():
+    """Test parsing and selecting performance on large HTML"""
+    large_html = '<html><body>' + '<div class="item">' * 5000 + '</div>' * 5000 + '</body></html>'
+    start_time = time.time()
+    parsed = Adaptor(large_html, auto_match=False)
+    elements = parsed.css('.item')
+    end_time = time.time()
+    assert len(elements) == 5000
+    # Converting 5000 elements to a class and doing operations on them will take time
+    # Based on my tests with 100 runs, 1 loop each Scrapling (given the extra work/features) takes 10.4ms on average
+    assert end_time - start_time < 0.5  # Locally I test on 0.1 but on GitHub actions with browsers and threading sometimes closing adds fractions of seconds
+# Selector Generation Test
+def test_selectors_generation(page):
+    """Try to create selectors for all elements in the page"""
-        attr_json = self.page.css_first('#products').attrib['schema'].json()
-        self.assertEqual(attr_json, {'jsonable': 'data'})
-        self.assertEqual(type(self.page.css('#products')[0].attrib.json_string), bytes)
+    def _traverse(element: Adaptor):
+        assert isinstance(element.generate_css_selector, str)
+        assert isinstance(element.generate_xpath_selector, str)
+        for branch in element.children:
+            _traverse(branch)
-    def test_performance(self):
-        """Test parsing and selecting speed"""
-        import time
-        large_html = '<html><body>' + '<div class="item">' * 5000 + '</div>' * 5000 + '</body></html>'
+    _traverse(page)
-        start_time = time.time()
-        parsed = Adaptor(large_html, auto_match=False, debug=False)
-        elements = parsed.css('.item')
-        end_time = time.time()
-        self.assertEqual(len(elements), 5000)
-        # Converting 5000 elements to a class and doing operations on them will take time
-        # Based on my tests with 100 runs, 1 loop each Scrapling (given the extra work/features) takes 10.4ms on average
-        self.assertLess(end_time - start_time, 0.5)  # Locally I test on 0.1 but on GitHub actions with browsers and threading sometimes closing adds fractions of seconds
+# Miscellaneous Tests
+def test_getting_all_text(page):
+    """Test getting all text from the page"""
+    assert page.get_all_text() != ''
-# Use `coverage run -m unittest --verbose tests/test_parser_functions.py` instead for the coverage report
-# if __name__ == '__main__':
-#     unittest.main(verbosity=2)
+def test_regex_on_text(page):
+    """Test regex operations on text"""
+    element = page.css('[data-id="1"] .price')[0]
+    match = element.re_first(r'[\.\d]+')
+    assert match == '10.99'
+    match = element.text.re(r'(\d+)', replace_entities=False)
+    assert len(match) == 2

scrapling-0.2.8.dist-info/RECORD DELETED Viewed

@@ -1,42 +0,0 @@
-scrapling/__init__.py,sha256=0-gw4uqckCs7ikl6sHiB5c6y0AelpgefqJkBmSd7j1k,469
-scrapling/defaults.py,sha256=qO6zAS7k5_QXvbjuoBv87fUMqASGMuM2dVry9J9auv0,287
-scrapling/fetchers.py,sha256=iw1wEuFg14akJYpSg9webfBjAL341Pnofn4IkWahGlE,17486
-scrapling/parser.py,sha256=suXggr39GimLnnLm9ivM1CQ40AoDwGke2sgnWszqFqk,54331
-scrapling/py.typed,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-scrapling/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-scrapling/core/_types.py,sha256=__HJ2JTk5vx5eg_7HAJmDjaHrMDIaoxNG8fadLLyKV8,566
-scrapling/core/custom_types.py,sha256=8GCgcZL-IT5lP6titxL-RPCiItQSuJZjSlFIGCDxoSs,8402
-scrapling/core/mixins.py,sha256=sozbpaGL1_O_x3U-ABM5aYWpnxpCLfdbcA9SG3P7weY,3532
-scrapling/core/storage_adaptors.py,sha256=Q2-G7oDqoIqlIBEmnUsKwSzM2lNGNUPKtTbMjTV9178,6218
-scrapling/core/translator.py,sha256=WN_xPyYrD1MjLPv8Ar8zHNTPC_iYsW29kkjET4hbFI0,5228
-scrapling/core/utils.py,sha256=RajDRSPkVmszjpwNy8NIz8ZlUxPox8j2rSractr7Q9s,3779
-scrapling/engines/__init__.py,sha256=zA7tzqcDXP0hllwmjVewNHWipIA4JSU9mRG4J-cud0c,267
-scrapling/engines/camo.py,sha256=fmpGMW5T7we5cQC8muyvVo_A27yAqc5csm7dO_2jHiE,8446
-scrapling/engines/constants.py,sha256=WTn-X4kFIDWjXTiqOT0tm4XT5pijcdohFyZ0Af2C5Xc,3723
-scrapling/engines/pw.py,sha256=kWbkHm2vnQYeGuJnicKlAL1HrBKuXoFtyRMNFXLs4VY,13962
-scrapling/engines/static.py,sha256=h629IjT78YbhjFYBVSli53lKiYrG3929TAaZ7TA-j-Y,8022
-scrapling/engines/toolbelt/__init__.py,sha256=0tSsxMH5ALOMPXrLkr8mTH7LWg9QfIse4Ij9vUFgYjY,391
-scrapling/engines/toolbelt/custom.py,sha256=tab_wJmN6onvu2U8tDXeJ9jn6A47jTkmxSBoc-w8dIk,12789
-scrapling/engines/toolbelt/fingerprints.py,sha256=Y3FW8uqxxeNK3v6vBVvki8VjeG5oRxSwim4Q2Hv_cRk,2917
-scrapling/engines/toolbelt/navigation.py,sha256=Okpl4ynlLn2cUpSiaaoXDSOdDOXhvxNOOGphE_HXc5k,4016
-scrapling/engines/toolbelt/bypasses/navigator_plugins.js,sha256=tbnnk3nCXB6QEQnOhDlu3n-s7lnUTAkrUsjP6FDQIQg,2104
-scrapling/engines/toolbelt/bypasses/notification_permission.js,sha256=poPM3o5WYgEX-EdiUfDCllpWfc3Umvw4jr2u6O6elus,237
-scrapling/engines/toolbelt/bypasses/pdf_viewer.js,sha256=mKjjSuP1-BOGC_2WhRYHJo_LP7lTBi2KXmP_zsHO_tI,173
-scrapling/engines/toolbelt/bypasses/playwright_fingerprint.js,sha256=3RP1AE_XZRvpupeV_i-WSNVqRxyUy0qd8rQV8j_4j3U,221
-scrapling/engines/toolbelt/bypasses/screen_props.js,sha256=fZEuHMQ1-fYuxxUMoQXUvVWYUkPUbblkfMfpiLvBY7w,599
-scrapling/engines/toolbelt/bypasses/webdriver_fully.js,sha256=hdJw4clRAJQqIdq5gIFC_eC-x7C1i2ab01KV5ylmOBs,728
-scrapling/engines/toolbelt/bypasses/window_chrome.js,sha256=D7hqzNGGDorh8JVlvm2YIv7Bk2CoVkG55MDIdyqhT1w,6808
-tests/__init__.py,sha256=YHFB5ftzgLQVh6gbPfbYcY4yOS9DOBp5dBa6I-qtm8U,32
-tests/fetchers/__init__.py,sha256=6H4NgARhyTcGGd3dNCKQJ8kUFdrAEMSScQL7Ga_vU3c,43
-tests/fetchers/test_camoufox.py,sha256=-1v_0mXeBcAVW932nkFws1HIDCodGbpNYniSnVMHeeU,3116
-tests/fetchers/test_httpx.py,sha256=rrw9q4KdDAHpQVa4sTmw278Yv1OlwY_SKPbpBPLVN7c,3508
-tests/fetchers/test_playwright.py,sha256=xwhRmlw7WBrtqyilZsoMHkHpyAx7iXQ-YexDMJURTao,3702
-tests/fetchers/test_utils.py,sha256=FPPJkBrqgYxdGeWwapH8Vj8zyfYVLiTE1qSLu8eBWik,5728
-tests/parser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/parser/test_automatch.py,sha256=BeeYJi3cYCghbiZmi57z4bqcGPaoUA8GAm7MALBBkkk,2486
-tests/parser/test_general.py,sha256=sPbwQRka9Mh8MDz2Sto8Rwg78t0SWWxELgzhTVPEplE,11785
-scrapling-0.2.8.dist-info/LICENSE,sha256=XHgu8DRuT7_g3Hb9Q18YGg8eShp6axPBacbnQxT_WWQ,1499
-scrapling-0.2.8.dist-info/METADATA,sha256=0As--zWykpljObaw8DZQJr6udpHm4NyRN-dfUOUrhBc,66605
-scrapling-0.2.8.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-scrapling-0.2.8.dist-info/top_level.txt,sha256=ub7FkOEXeYmmYTUxd4pCrwXfBfAMIpZ1sCGmXCc14tI,16
-scrapling-0.2.8.dist-info/RECORD,,

scrapling 0.2.8__py3-none-any.whl → 0.2.91__py3-none-any.whl

scrapling 0.2.8py3-none-any.whl → 0.2.91py3-none-any.whl