scrapling 0.2.98__py3-none-any.whl → 0.3__py3-none-any.whl

scrapling-0.2.98.dist-info/RECORD

@@ -1,49 +0,0 @@
-scrapling/__init__.py,sha256=S-SWj9O2r0Tu8Z-mPxDJ-z3h5k-bBfhFOETaCY4A9dc,1510
-scrapling/cli.py,sha256=7yTsMhVAqqS8Z27T5dFKrR9_X8vuFjBlwYgAF22W7T8,1292
-scrapling/defaults.py,sha256=MAn2MMLBFvoe4i3u_qlp6YEvGUiCjNPPDux1cFCdpsU,866
-scrapling/fetchers.py,sha256=xwVCjAg0VCXwhB2igSLQvb0D0bOPGfg5WNtxgE7m-W0,34987
-scrapling/parser.py,sha256=1xS1UjCm1GVnKcVAtup9rSE1xuYPxXOgJe-8LJE5gUk,53956
-scrapling/py.typed,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-scrapling/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-scrapling/core/_types.py,sha256=dKVi_dUxdxNtTr7sj7ySkHXDfrsmjFTfpCQeO5tGuBY,670
-scrapling/core/custom_types.py,sha256=EWGx5t5scHEB1SMsitzc8duskq-5f-Qaj40IWkNTRzM,12947
-scrapling/core/mixins.py,sha256=sozbpaGL1_O_x3U-ABM5aYWpnxpCLfdbcA9SG3P7weY,3532
-scrapling/core/storage_adaptors.py,sha256=gZbUpHtLOL7o_oZbES_o40r39zShxTeTM8YK6dXA5Zo,6214
-scrapling/core/translator.py,sha256=3a2VX9KR-q-GzwT1OgGDv1UlzIkvBggkQXUdiMyL-4c,5277
-scrapling/core/utils.py,sha256=KX88B3tV1-SgCAr69TUN3LfmsTDcLnEhYJiPuWd31yA,3704
-scrapling/engines/__init__.py,sha256=zA7tzqcDXP0hllwmjVewNHWipIA4JSU9mRG4J-cud0c,267
-scrapling/engines/camo.py,sha256=oYKA0l3EpOcQW2APRj5FEmslqtp9A8i_ZljqlKvIDeI,16129
-scrapling/engines/constants.py,sha256=Gb_nXFoBB4ujJkd05SKkenMe1UDiRYQA3dkmA3DunLg,3723
-scrapling/engines/pw.py,sha256=cZraIBWd9ulEGEdhETIGmpevi62CN9JGcUU1OIDdxkA,21369
-scrapling/engines/static.py,sha256=EjdaR0beqWfEKKavT7vlBnozoayQaVpqeVtaOuzd384,9306
-scrapling/engines/toolbelt/__init__.py,sha256=VQDdYm1zY9Apno6d8UrULk29vUjllZrQqD8mXL1E2Fc,402
-scrapling/engines/toolbelt/custom.py,sha256=_-baGB8oOOHogbaddtGsq_K_01ccOjOkGA6tOKk28hM,12811
-scrapling/engines/toolbelt/fingerprints.py,sha256=Zzoqq3p6X_8D7eTxACz3z96cBZWWK61iKOGo2sZUtlg,2924
-scrapling/engines/toolbelt/navigation.py,sha256=fMjDgicqy2MoZZll2h5EvrrxkL6yNrC09v8isTpwAt0,4565
-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_utils.py,sha256=ANFu-4FFhtyGFGIwJksUO2M2tTTcKU2M_t6F2aav8lM,4967
-tests/fetchers/async/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/fetchers/async/test_camoufox.py,sha256=BANJ0TVqEdsjkYlsyU-q_spfaMsqTLOBQU8LUDurL9I,3685
-tests/fetchers/async/test_httpx.py,sha256=6WgsvqV1-rYTjZ9na5x-wt49C3Ur9D99HXBFbewO0gc,3888
-tests/fetchers/async/test_playwright.py,sha256=rr_3vB9LWclbl7PBNMH2MNU6CsirvJAIx_LsI9mLil0,4106
-tests/fetchers/sync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/fetchers/sync/test_camoufox.py,sha256=IcDXPAWSSJnYT6psDFKSbCeym5n7hCrMPYQEghaOX3A,3165
-tests/fetchers/sync/test_httpx.py,sha256=xItYWjnDOIswKJzua2tDq8Oy43nTeFl0O1bci7lzGmg,3615
-tests/fetchers/sync/test_playwright.py,sha256=MEyDRaMyxDIWupG7f_xz0f0jd9Cpbd5rXCPz6qUy8cs,3818
-tests/parser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/parser/test_automatch.py,sha256=SxsNdExE8zz8AcPRQFBUjZ3Q_1-tPOd9dzVvMSZpOYQ,4908
-tests/parser/test_general.py,sha256=dyfOsc8lleoY4AxcfDUBUaD1i95xecfYuTUhKBsYjwo,12100
-scrapling-0.2.98.dist-info/LICENSE,sha256=XHgu8DRuT7_g3Hb9Q18YGg8eShp6axPBacbnQxT_WWQ,1499
-scrapling-0.2.98.dist-info/METADATA,sha256=Un_ROxrGIvk_8w-ECQbwKAcJzYyx3MTWS1DHt9FRqdI,69718
-scrapling-0.2.98.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-scrapling-0.2.98.dist-info/entry_points.txt,sha256=DHyt2Blxy0P5OE2HRcP95Wz9_xo2ERCDcNqrJjYS3o8,49
-scrapling-0.2.98.dist-info/top_level.txt,sha256=ub7FkOEXeYmmYTUxd4pCrwXfBfAMIpZ1sCGmXCc14tI,16
-scrapling-0.2.98.dist-info/RECORD,,

tests/__init__.py

@@ -1 +0,0 @@
-"""Package for test project."""

tests/fetchers/__init__.py

@@ -1 +0,0 @@
-# Because I'm too lazy to mock requests :)

tests/fetchers/async/test_camoufox.py

@@ -1,95 +0,0 @@
-import pytest
-import pytest_httpbin
-
-from scrapling import StealthyFetcher
-
-
-@pytest_httpbin.use_class_based_httpbin
-@pytest.mark.asyncio
-class TestStealthyFetcher:
-    @pytest.fixture(scope="class")
-    def fetcher(self):
-        return StealthyFetcher(auto_match=False)
-
-    @pytest.fixture(scope="class")
-    def urls(self, httpbin):
-        url = httpbin.url
-        return {
-            'status_200': f'{url}/status/200',
-            'status_404': f'{url}/status/404',
-            'status_501': f'{url}/status/501',
-            'basic_url': f'{url}/get',
-            'html_url': f'{url}/html',
-            'delayed_url': f'{url}/delay/10',  # 10 Seconds delay response
-            'cookies_url': f"{url}/cookies/set/test/value"
-        }
-
-    async def test_basic_fetch(self, fetcher, urls):
-        """Test doing basic fetch request with multiple statuses"""
-        assert (await fetcher.async_fetch(urls['status_200'])).status == 200
-        assert (await fetcher.async_fetch(urls['status_404'])).status == 404
-        assert (await fetcher.async_fetch(urls['status_501'])).status == 501
-
-    async def test_networkidle(self, fetcher, urls):
-        """Test if waiting for `networkidle` make page does not finish loading or not"""
-        assert (await fetcher.async_fetch(urls['basic_url'], network_idle=True)).status == 200
-
-    async def test_blocking_resources(self, fetcher, urls):
-        """Test if blocking resources make page does not finish loading or not"""
-        assert (await fetcher.async_fetch(urls['basic_url'], block_images=True)).status == 200
-        assert (await fetcher.async_fetch(urls['basic_url'], disable_resources=True)).status == 200
-
-    async def test_waiting_selector(self, fetcher, urls):
-        """Test if waiting for a selector make page does not finish loading or not"""
-        assert (await fetcher.async_fetch(urls['html_url'], wait_selector='h1')).status == 200
-        assert (await fetcher.async_fetch(
-            urls['html_url'],
-            wait_selector='h1',
-            wait_selector_state='visible'
-        )).status == 200
-
-    async def test_cookies_loading(self, fetcher, urls):
-        """Test if cookies are set after the request"""
-        response = await fetcher.async_fetch(urls['cookies_url'])
-        assert response.cookies == {'test': 'value'}
-
-    async def test_automation(self, fetcher, urls):
-        """Test if automation break the code or not"""
-
-        async def scroll_page(page):
-            await page.mouse.wheel(10, 0)
-            await page.mouse.move(100, 400)
-            await page.mouse.up()
-            return page
-
-        assert (await fetcher.async_fetch(urls['html_url'], page_action=scroll_page)).status == 200
-
-    async def test_properties(self, fetcher, urls):
-        """Test if different arguments breaks the code or not"""
-        assert (await fetcher.async_fetch(
-            urls['html_url'],
-            block_webrtc=True,
-            allow_webgl=True
-        )).status == 200
-
-        assert (await fetcher.async_fetch(
-            urls['html_url'],
-            block_webrtc=False,
-            allow_webgl=True
-        )).status == 200
-
-        assert (await fetcher.async_fetch(
-            urls['html_url'],
-            block_webrtc=True,
-            allow_webgl=False
-        )).status == 200
-
-        assert (await fetcher.async_fetch(
-            urls['html_url'],
-            extra_headers={'ayo': ''},
-            os_randomize=True
-        )).status == 200
-
-    async def test_infinite_timeout(self, fetcher, urls):
-        """Test if infinite timeout breaks the code or not"""
-        assert (await fetcher.async_fetch(urls['delayed_url'], timeout=None)).status == 200

tests/fetchers/async/test_httpx.py

@@ -1,83 +0,0 @@
-import pytest
-import pytest_httpbin
-
-from scrapling.fetchers import AsyncFetcher
-
-
-@pytest_httpbin.use_class_based_httpbin
-@pytest.mark.asyncio
-class TestAsyncFetcher:
-    @pytest.fixture(scope="class")
-    def fetcher(self):
-        return AsyncFetcher(auto_match=True)
-
-    @pytest.fixture(scope="class")
-    def urls(self, httpbin):
-        return {
-            'status_200': f'{httpbin.url}/status/200',
-            'status_404': f'{httpbin.url}/status/404',
-            'status_501': f'{httpbin.url}/status/501',
-            'basic_url': f'{httpbin.url}/get',
-            'post_url': f'{httpbin.url}/post',
-            'put_url': f'{httpbin.url}/put',
-            'delete_url': f'{httpbin.url}/delete',
-            'html_url': f'{httpbin.url}/html'
-        }
-
-    async def test_basic_get(self, fetcher, urls):
-        """Test doing basic get request with multiple statuses"""
-        assert (await fetcher.get(urls['status_200'])).status == 200
-        assert (await fetcher.get(urls['status_404'])).status == 404
-        assert (await fetcher.get(urls['status_501'])).status == 501
-
-    async def test_get_properties(self, fetcher, urls):
-        """Test if different arguments with GET request breaks the code or not"""
-        assert (await fetcher.get(urls['status_200'], stealthy_headers=True)).status == 200
-        assert (await fetcher.get(urls['status_200'], follow_redirects=True)).status == 200
-        assert (await fetcher.get(urls['status_200'], timeout=None)).status == 200
-        assert (await fetcher.get(
-            urls['status_200'],
-            stealthy_headers=True,
-            follow_redirects=True,
-            timeout=None
-        )).status == 200
-
-    async def test_post_properties(self, fetcher, urls):
-        """Test if different arguments with POST request breaks the code or not"""
-        assert (await fetcher.post(urls['post_url'], data={'key': 'value'})).status == 200
-        assert (await fetcher.post(urls['post_url'], data={'key': 'value'}, stealthy_headers=True)).status == 200
-        assert (await fetcher.post(urls['post_url'], data={'key': 'value'}, follow_redirects=True)).status == 200
-        assert (await fetcher.post(urls['post_url'], data={'key': 'value'}, timeout=None)).status == 200
-        assert (await fetcher.post(
-            urls['post_url'],
-            data={'key': 'value'},
-            stealthy_headers=True,
-            follow_redirects=True,
-            timeout=None
-        )).status == 200
-
-    async def test_put_properties(self, fetcher, urls):
-        """Test if different arguments with PUT request breaks the code or not"""
-        assert (await fetcher.put(urls['put_url'], data={'key': 'value'})).status in [200, 405]
-        assert (await fetcher.put(urls['put_url'], data={'key': 'value'}, stealthy_headers=True)).status in [200, 405]
-        assert (await fetcher.put(urls['put_url'], data={'key': 'value'}, follow_redirects=True)).status in [200, 405]
-        assert (await fetcher.put(urls['put_url'], data={'key': 'value'}, timeout=None)).status in [200, 405]
-        assert (await fetcher.put(
-            urls['put_url'],
-            data={'key': 'value'},
-            stealthy_headers=True,
-            follow_redirects=True,
-            timeout=None
-        )).status in [200, 405]
-
-    async def test_delete_properties(self, fetcher, urls):
-        """Test if different arguments with DELETE request breaks the code or not"""
-        assert (await fetcher.delete(urls['delete_url'], stealthy_headers=True)).status == 200
-        assert (await fetcher.delete(urls['delete_url'], follow_redirects=True)).status == 200
-        assert (await fetcher.delete(urls['delete_url'], timeout=None)).status == 200
-        assert (await fetcher.delete(
-            urls['delete_url'],
-            stealthy_headers=True,
-            follow_redirects=True,
-            timeout=None
-        )).status == 200

tests/fetchers/async/test_playwright.py

@@ -1,99 +0,0 @@
-import pytest
-import pytest_httpbin
-
-from scrapling import PlayWrightFetcher
-
-
-@pytest_httpbin.use_class_based_httpbin
-class TestPlayWrightFetcherAsync:
-    @pytest.fixture
-    def fetcher(self):
-        return PlayWrightFetcher(auto_match=False)
-
-    @pytest.fixture
-    def urls(self, httpbin):
-        return {
-            'status_200': f'{httpbin.url}/status/200',
-            'status_404': f'{httpbin.url}/status/404',
-            'status_501': f'{httpbin.url}/status/501',
-            'basic_url': f'{httpbin.url}/get',
-            'html_url': f'{httpbin.url}/html',
-            'delayed_url': f'{httpbin.url}/delay/10',
-            'cookies_url': f"{httpbin.url}/cookies/set/test/value"
-        }
-
-    @pytest.mark.asyncio
-    async def test_basic_fetch(self, fetcher, urls):
-        """Test doing basic fetch request with multiple statuses"""
-        response = await fetcher.async_fetch(urls['status_200'])
-        assert response.status == 200
-
-    @pytest.mark.asyncio
-    async def test_networkidle(self, fetcher, urls):
-        """Test if waiting for `networkidle` make page does not finish loading or not"""
-        response = await fetcher.async_fetch(urls['basic_url'], network_idle=True)
-        assert response.status == 200
-
-    @pytest.mark.asyncio
-    async def test_blocking_resources(self, fetcher, urls):
-        """Test if blocking resources make page does not finish loading or not"""
-        response = await fetcher.async_fetch(urls['basic_url'], disable_resources=True)
-        assert response.status == 200
-
-    @pytest.mark.asyncio
-    async def test_waiting_selector(self, fetcher, urls):
-        """Test if waiting for a selector make page does not finish loading or not"""
-        response1 = await fetcher.async_fetch(urls['html_url'], wait_selector='h1')
-        assert response1.status == 200
-
-        response2 = await fetcher.async_fetch(urls['html_url'], wait_selector='h1', wait_selector_state='visible')
-        assert response2.status == 200
-
-    @pytest.mark.asyncio
-    async def test_cookies_loading(self, fetcher, urls):
-        """Test if cookies are set after the request"""
-        response = await fetcher.async_fetch(urls['cookies_url'])
-        assert response.cookies == {'test': 'value'}
-
-    @pytest.mark.asyncio
-    async def test_automation(self, fetcher, urls):
-        """Test if automation break the code or not"""
-        async def scroll_page(page):
-            await page.mouse.wheel(10, 0)
-            await page.mouse.move(100, 400)
-            await page.mouse.up()
-            return page
-
-        response = await fetcher.async_fetch(urls['html_url'], page_action=scroll_page)
-        assert response.status == 200
-
-    @pytest.mark.parametrize("kwargs", [
-        {"disable_webgl": True, "hide_canvas": False},
-        {"disable_webgl": False, "hide_canvas": True},
-        # {"stealth": True}, # causes issues with Github Actions
-        {"useragent": 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:131.0) Gecko/20100101 Firefox/131.0'},
-        {"extra_headers": {'ayo': ''}}
-    ])
-    @pytest.mark.asyncio
-    async def test_properties(self, fetcher, urls, kwargs):
-        """Test if different arguments breaks the code or not"""
-        response = await fetcher.async_fetch(urls['html_url'], **kwargs)
-        assert response.status == 200
-
-    @pytest.mark.asyncio
-    async def test_cdp_url_invalid(self, fetcher, urls):
-        """Test if invalid CDP URLs raise appropriate exceptions"""
-        with pytest.raises(ValueError):
-            await fetcher.async_fetch(urls['html_url'], cdp_url='blahblah')
-
-        with pytest.raises(ValueError):
-            await fetcher.async_fetch(urls['html_url'], cdp_url='blahblah', nstbrowser_mode=True)
-
-        with pytest.raises(Exception):
-            await fetcher.async_fetch(urls['html_url'], cdp_url='ws://blahblah')
-
-    @pytest.mark.asyncio
-    async def test_infinite_timeout(self, fetcher, urls):
-        """Test if infinite timeout breaks the code or not"""
-        response = await fetcher.async_fetch(urls['delayed_url'], timeout=None)
-        assert response.status == 200

tests/fetchers/sync/test_camoufox.py

@@ -1,68 +0,0 @@
-import pytest
-import pytest_httpbin
-
-from scrapling import StealthyFetcher
-
-
-@pytest_httpbin.use_class_based_httpbin
-class TestStealthyFetcher:
-    @pytest.fixture(scope="class")
-    def fetcher(self):
-        """Fixture to create a StealthyFetcher instance for the entire test class"""
-        return StealthyFetcher(auto_match=False)
-
-    @pytest.fixture(autouse=True)
-    def setup_urls(self, httpbin):
-        """Fixture to set up URLs for testing"""
-        self.status_200 = f'{httpbin.url}/status/200'
-        self.status_404 = f'{httpbin.url}/status/404'
-        self.status_501 = f'{httpbin.url}/status/501'
-        self.basic_url = f'{httpbin.url}/get'
-        self.html_url = f'{httpbin.url}/html'
-        self.delayed_url = f'{httpbin.url}/delay/10'  # 10 Seconds delay response
-        self.cookies_url = f"{httpbin.url}/cookies/set/test/value"
-
-    def test_basic_fetch(self, fetcher):
-        """Test doing basic fetch request with multiple statuses"""
-        assert fetcher.fetch(self.status_200).status == 200
-        assert fetcher.fetch(self.status_404).status == 404
-        assert fetcher.fetch(self.status_501).status == 501
-
-    def test_networkidle(self, fetcher):
-        """Test if waiting for `networkidle` make page does not finish loading or not"""
-        assert fetcher.fetch(self.basic_url, network_idle=True).status == 200
-
-    def test_blocking_resources(self, fetcher):
-        """Test if blocking resources make page does not finish loading or not"""
-        assert fetcher.fetch(self.basic_url, block_images=True).status == 200
-        assert fetcher.fetch(self.basic_url, disable_resources=True).status == 200
-
-    def test_waiting_selector(self, fetcher):
-        """Test if waiting for a selector make page does not finish loading or not"""
-        assert fetcher.fetch(self.html_url, wait_selector='h1').status == 200
-        assert fetcher.fetch(self.html_url, wait_selector='h1', wait_selector_state='visible').status == 200
-
-    def test_cookies_loading(self, fetcher):
-        """Test if cookies are set after the request"""
-        assert fetcher.fetch(self.cookies_url).cookies == {'test': 'value'}
-
-    def test_automation(self, fetcher):
-        """Test if automation break the code or not"""
-        def scroll_page(page):
-            page.mouse.wheel(10, 0)
-            page.mouse.move(100, 400)
-            page.mouse.up()
-            return page
-
-        assert fetcher.fetch(self.html_url, page_action=scroll_page).status == 200
-
-    def test_properties(self, fetcher):
-        """Test if different arguments breaks the code or not"""
-        assert fetcher.fetch(self.html_url, block_webrtc=True, allow_webgl=True).status == 200
-        assert fetcher.fetch(self.html_url, block_webrtc=False, allow_webgl=True).status == 200
-        assert fetcher.fetch(self.html_url, block_webrtc=True, allow_webgl=False).status == 200
-        assert fetcher.fetch(self.html_url, extra_headers={'ayo': ''}, os_randomize=True).status == 200
-
-    def test_infinite_timeout(self, fetcher):
-        """Test if infinite timeout breaks the code or not"""
-        assert fetcher.fetch(self.delayed_url, timeout=None).status == 200

tests/fetchers/sync/test_httpx.py

@@ -1,82 +0,0 @@
-import pytest
-import pytest_httpbin
-
-from scrapling import Fetcher
-
-
-@pytest_httpbin.use_class_based_httpbin
-class TestFetcher:
-    @pytest.fixture(scope="class")
-    def fetcher(self):
-        """Fixture to create a Fetcher instance for the entire test class"""
-        return Fetcher(auto_match=False)
-
-    @pytest.fixture(autouse=True)
-    def setup_urls(self, httpbin):
-        """Fixture to set up URLs for testing"""
-        self.status_200 = f'{httpbin.url}/status/200'
-        self.status_404 = f'{httpbin.url}/status/404'
-        self.status_501 = f'{httpbin.url}/status/501'
-        self.basic_url = f'{httpbin.url}/get'
-        self.post_url = f'{httpbin.url}/post'
-        self.put_url = f'{httpbin.url}/put'
-        self.delete_url = f'{httpbin.url}/delete'
-        self.html_url = f'{httpbin.url}/html'
-
-    def test_basic_get(self, fetcher):
-        """Test doing basic get request with multiple statuses"""
-        assert fetcher.get(self.status_200).status == 200
-        assert fetcher.get(self.status_404).status == 404
-        assert fetcher.get(self.status_501).status == 501
-
-    def test_get_properties(self, fetcher):
-        """Test if different arguments with GET request breaks the code or not"""
-        assert fetcher.get(self.status_200, stealthy_headers=True).status == 200
-        assert fetcher.get(self.status_200, follow_redirects=True).status == 200
-        assert fetcher.get(self.status_200, timeout=None).status == 200
-        assert fetcher.get(
-            self.status_200,
-            stealthy_headers=True,
-            follow_redirects=True,
-            timeout=None
-        ).status == 200
-
-    def test_post_properties(self, fetcher):
-        """Test if different arguments with POST request breaks the code or not"""
-        assert fetcher.post(self.post_url, data={'key': 'value'}).status == 200
-        assert fetcher.post(self.post_url, data={'key': 'value'}, stealthy_headers=True).status == 200
-        assert fetcher.post(self.post_url, data={'key': 'value'}, follow_redirects=True).status == 200
-        assert fetcher.post(self.post_url, data={'key': 'value'}, timeout=None).status == 200
-        assert fetcher.post(
-            self.post_url,
-            data={'key': 'value'},
-            stealthy_headers=True,
-            follow_redirects=True,
-            timeout=None
-        ).status == 200
-
-    def test_put_properties(self, fetcher):
-        """Test if different arguments with PUT request breaks the code or not"""
-        assert fetcher.put(self.put_url, data={'key': 'value'}).status == 200
-        assert fetcher.put(self.put_url, data={'key': 'value'}, stealthy_headers=True).status == 200
-        assert fetcher.put(self.put_url, data={'key': 'value'}, follow_redirects=True).status == 200
-        assert fetcher.put(self.put_url, data={'key': 'value'}, timeout=None).status == 200
-        assert fetcher.put(
-            self.put_url,
-            data={'key': 'value'},
-            stealthy_headers=True,
-            follow_redirects=True,
-            timeout=None
-        ).status == 200
-
-    def test_delete_properties(self, fetcher):
-        """Test if different arguments with DELETE request breaks the code or not"""
-        assert fetcher.delete(self.delete_url, stealthy_headers=True).status == 200
-        assert fetcher.delete(self.delete_url, follow_redirects=True).status == 200
-        assert fetcher.delete(self.delete_url, timeout=None).status == 200
-        assert fetcher.delete(
-            self.delete_url,
-            stealthy_headers=True,
-            follow_redirects=True,
-            timeout=None
-        ).status == 200

tests/fetchers/sync/test_playwright.py

@@ -1,87 +0,0 @@
-import pytest
-import pytest_httpbin
-
-from scrapling import PlayWrightFetcher
-
-
-@pytest_httpbin.use_class_based_httpbin
-class TestPlayWrightFetcher:
-
-    @pytest.fixture(scope="class")
-    def fetcher(self):
-        """Fixture to create a StealthyFetcher instance for the entire test class"""
-        return PlayWrightFetcher(auto_match=False)
-
-    @pytest.fixture(autouse=True)
-    def setup_urls(self, httpbin):
-        """Fixture to set up URLs for testing"""
-        self.status_200 = f'{httpbin.url}/status/200'
-        self.status_404 = f'{httpbin.url}/status/404'
-        self.status_501 = f'{httpbin.url}/status/501'
-        self.basic_url = f'{httpbin.url}/get'
-        self.html_url = f'{httpbin.url}/html'
-        self.delayed_url = f'{httpbin.url}/delay/10'  # 10 Seconds delay response
-        self.cookies_url = f"{httpbin.url}/cookies/set/test/value"
-
-    def test_basic_fetch(self, fetcher):
-        """Test doing basic fetch request with multiple statuses"""
-        assert fetcher.fetch(self.status_200).status == 200
-        # There's a bug with playwright makes it crashes if a URL returns status code 4xx/5xx without body, let's disable this till they reply to my issue report
-        # assert fetcher.fetch(self.status_404).status == 404
-        # assert fetcher.fetch(self.status_501).status == 501
-
-    def test_networkidle(self, fetcher):
-        """Test if waiting for `networkidle` make page does not finish loading or not"""
-        assert fetcher.fetch(self.basic_url, network_idle=True).status == 200
-
-    def test_blocking_resources(self, fetcher):
-        """Test if blocking resources make page does not finish loading or not"""
-        assert fetcher.fetch(self.basic_url, disable_resources=True).status == 200
-
-    def test_waiting_selector(self, fetcher):
-        """Test if waiting for a selector make page does not finish loading or not"""
-        assert fetcher.fetch(self.html_url, wait_selector='h1').status == 200
-        assert fetcher.fetch(self.html_url, wait_selector='h1', wait_selector_state='visible').status == 200
-
-    def test_cookies_loading(self, fetcher):
-        """Test if cookies are set after the request"""
-        assert fetcher.fetch(self.cookies_url).cookies == {'test': 'value'}
-
-    def test_automation(self, fetcher):
-        """Test if automation break the code or not"""
-
-        def scroll_page(page):
-            page.mouse.wheel(10, 0)
-            page.mouse.move(100, 400)
-            page.mouse.up()
-            return page
-
-        assert fetcher.fetch(self.html_url, page_action=scroll_page).status == 200
-
-    @pytest.mark.parametrize("kwargs", [
-        {"disable_webgl": True, "hide_canvas": False},
-        {"disable_webgl": False, "hide_canvas": True},
-        # {"stealth": True}, # causes issues with Github Actions
-        {"useragent": 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:131.0) Gecko/20100101 Firefox/131.0'},
-        {"extra_headers": {'ayo': ''}}
-    ])
-    def test_properties(self, fetcher, kwargs):
-        """Test if different arguments breaks the code or not"""
-        response = fetcher.fetch(self.html_url, **kwargs)
-        assert response.status == 200
-
-    def test_cdp_url_invalid(self, fetcher):
-        """Test if invalid CDP URLs raise appropriate exceptions"""
-        with pytest.raises(ValueError):
-            fetcher.fetch(self.html_url, cdp_url='blahblah')
-
-        with pytest.raises(ValueError):
-            fetcher.fetch(self.html_url, cdp_url='blahblah', nstbrowser_mode=True)
-
-        with pytest.raises(Exception):
-            fetcher.fetch(self.html_url, cdp_url='ws://blahblah')
-
-    def test_infinite_timeout(self, fetcher, ):
-        """Test if infinite timeout breaks the code or not"""
-        response = fetcher.fetch(self.delayed_url, timeout=None)
-        assert response.status == 200