thordata-sdk 0.2.2__tar.gz → 0.2.4__tar.gz

{thordata_sdk-0.2.2 → thordata_sdk-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: thordata_sdk
-Version: 0.2.2
+Version: 0.2.4
 Summary: The official Python SDK for Thordata Proxy & Scraper Infrastructure.
 Home-page: https://github.com/Thordata/thordata-python-sdk
 Author: Thordata Developer Team
@@ -22,20 +22,6 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: requests>=2.25.0
-Requires-Dist: aiohttp>=3.8.0
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license
-Dynamic: license-file
-Dynamic: project-url
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
 
 # Thordata Python SDK
 

{thordata_sdk-0.2.2 → thordata_sdk-0.2.4}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='thordata_sdk',
-    version='0.2.2',  # Bump version due to breaking auth changes
+    version='0.2.4',  # Bump version due to breaking auth changes
     packages=find_packages(include=['thordata_sdk', 'thordata_sdk.*']),
     install_requires=[
         'requests>=2.25.0',  # Standard synchronous HTTP

{thordata_sdk-0.2.2 → thordata_sdk-0.2.4}/thordata_sdk/__init__.py

@@ -1,8 +1,9 @@
 # Expose main clients
 from .client import ThordataClient
 from .async_client import AsyncThordataClient
+from .enums import Engine, GoogleSearchType
 
 # Version of the thordata-sdk package
-__version__ = "0.2.2"
+__version__ = "0.2.4"
 
 __all__ = ["ThordataClient", "AsyncThordataClient"]

{thordata_sdk-0.2.2 → thordata_sdk-0.2.4}/thordata_sdk/async_client.py

@@ -1,7 +1,12 @@
 import aiohttp
 import logging
 import json
-from typing import Optional, Dict, Any
+import base64
+from typing import Optional, Dict, Any, Union
+
+# 复用我们刚刚写好的逻辑和枚举
+from .enums import Engine
+from .parameters import normalize_serp_params
 
 logger = logging.getLogger(__name__)
 
@@ -9,11 +14,6 @@ logger = logging.getLogger(__name__)
 class AsyncThordataClient:
     """
     Thordata Asynchronous Client (built on aiohttp).
-    Designed for high-concurrency and low-latency data collection tasks.
-
-    Usage:
-        async with AsyncThordataClient(...) as client:
-            await client.get("http://example.com")
     """
 
     def __init__(
@@ -24,22 +24,19 @@ class AsyncThordataClient:
         proxy_host: str = "gate.thordata.com",
         proxy_port: int = 22225
     ):
-        """
-        Initialize the asynchronous client.
-        """
         self.scraper_token = scraper_token
         self.public_token = public_token
         self.public_key = public_key
 
-        # Proxy Authentication
         self.proxy_auth = aiohttp.BasicAuth(login=scraper_token, password='')
         self.proxy_url = f"http://{proxy_host}:{proxy_port}"
 
-        # API Endpoints
         self.base_url = "https://scraperapi.thordata.com"
+        self.universal_url = "https://universalapi.thordata.com"
         self.api_url = "https://api.thordata.com/api/web-scraper-api"
 
         self.SERP_API_URL = f"{self.base_url}/request"
+        self.UNIVERSAL_API_URL = f"{self.universal_url}/request"
         self.SCRAPER_BUILDER_URL = f"{self.base_url}/builder"
         self.SCRAPER_STATUS_URL = f"{self.api_url}/tasks-status"
         self.SCRAPER_DOWNLOAD_URL = f"{self.api_url}/tasks-download"
@@ -55,21 +52,14 @@ class AsyncThordataClient:
         await self.close()
 
     async def close(self):
-        """Close the underlying aiohttp session."""
         if self._session and not self._session.closed:
             await self._session.close()
             self._session = None
 
-    # --- Proxy Usage ---
-
+    # --- Proxy (Unchanged) ---
     async def get(self, url: str, **kwargs) -> aiohttp.ClientResponse:
-        """
-        Send an asynchronous GET request through the Thordata Proxy.
-        """
         if self._session is None:
             raise RuntimeError("Client session not initialized.")
-
-        logger.debug(f"Async Proxy Request: {url}")
         try:
             return await self._session.get(
                 url,
@@ -81,43 +71,37 @@ class AsyncThordataClient:
             logger.error(f"Async Request failed: {e}")
             raise
 
-    # --- SERP API ---
-
+    # --- SERP (Optimized) ---
     async def serp_search(
-        self, query: str, engine: str = "google", num: int = 10, **kwargs
+        self, 
+        query: str, 
+        engine: Union[Engine, str] = Engine.GOOGLE, 
+        num: int = 10, 
+        **kwargs
     ) -> Dict[str, Any]:
-        """Async SERP search."""
+        """
+        Execute a real-time SERP search (Async).
+        """
         if self._session is None:
             raise RuntimeError("Client session not initialized.")
 
-        payload = {
-            "q": query,
-            "num": str(num),
-            "json": "1",
-            "engine": engine.lower(),
-            **kwargs
-        }
-        if engine.lower() == 'yandex':
-            payload['text'] = payload.pop('q')
-            if 'url' not in payload:
-                payload['url'] = "yandex.com"
-        elif 'url' not in payload:
-            if engine == 'google':
-                payload['url'] = "google.com"
-            elif engine == 'bing':
-                payload['url'] = "bing.com"
+        # 1. 转换枚举
+        engine_str = engine.value if isinstance(engine, Engine) else engine.lower()
+
+        # 2. 调用 parameters.py 复用逻辑 (Don't Repeat Yourself!)
+        payload = normalize_serp_params(engine_str, query, num=num, **kwargs)
 
         headers = {
             "Authorization": f"Bearer {self.scraper_token}",
             "Content-Type": "application/x-www-form-urlencoded"
         }
 
+        # 3. 发送请求
         async with self._session.post(
             self.SERP_API_URL, data=payload, headers=headers
         ) as response:
             response.raise_for_status()
             data = await response.json()
-            # Handle double-encoding
             if isinstance(data, str):
                 try:
                     data = json.loads(data)
@@ -125,17 +109,80 @@ class AsyncThordataClient:
                     pass
             return data
 
-    # --- Web Scraper API ---
+    # --- Universal (Unchanged) ---
+    async def universal_scrape(
+        self,
+        url: str,
+        js_render: bool = False,
+        output_format: str = "HTML",
+        country: str = None,
+        block_resources: bool = False
+    ) -> Union[str, bytes]:
+        if self._session is None:
+            raise RuntimeError("Client session not initialized.")
+
+        headers = {
+            "Authorization": f"Bearer {self.scraper_token}",
+            "Content-Type": "application/x-www-form-urlencoded"
+        }
+
+        payload = {
+            "url": url,
+            "js_render": "True" if js_render else "False",
+            "type": output_format.lower(),
+            "block_resources": "True" if block_resources else "False"
+        }
+        if country:
+            payload["country"] = country
+
+        async with self._session.post(
+            self.UNIVERSAL_API_URL, data=payload, headers=headers
+        ) as response:
+            response.raise_for_status()
 
+            try:
+                resp_json = await response.json()
+            except Exception:
+                if output_format.upper() == "PNG":
+                    return await response.read()
+                return await response.text()
+
+            if isinstance(resp_json, dict) and resp_json.get("code") \
+                    and resp_json.get("code") != 200:
+                raise Exception(f"Universal API Error: {resp_json}")
+
+            if "html" in resp_json:
+                return resp_json["html"]
+
+            if "png" in resp_json:
+                png_str = resp_json["png"]
+                if not png_str:
+                    raise Exception("API returned empty PNG data")
+
+                # 🛠️ FIX: 移除 Data URI Scheme 前缀
+                if "," in png_str:
+                    png_str = png_str.split(",", 1)[1]
+
+                png_str = png_str.replace("\n", "").replace("\r", "")
+                missing_padding = len(png_str) % 4
+                if missing_padding:
+                    png_str += '=' * (4 - missing_padding)
+                return base64.b64decode(png_str)
+
+            return str(resp_json)
+
+    # --- Web Scraper (Optimized) ---
     async def create_scraper_task(
         self,
         file_name: str,
         spider_id: str,
+        spider_name: str,
         individual_params: Dict[str, Any],
-        spider_name: str = "youtube.com",
         universal_params: Dict[str, Any] = None
     ) -> str:
-        """Create an async scraping task."""
+        """
+        Create an Asynchronous Web Scraper Task.
+        """
         if self._session is None:
             raise RuntimeError("Client session not initialized.")
 
@@ -144,6 +191,7 @@ class AsyncThordataClient:
             "Content-Type": "application/x-www-form-urlencoded"
         }
 
+        # 简化 Payload 构建，移除不必要的检查
         payload = {
             "file_name": file_name,
             "spider_id": spider_id,
@@ -163,8 +211,8 @@ class AsyncThordataClient:
                 raise Exception(f"Creation failed: {data}")
             return data["data"]["task_id"]
 
+    # --- Status & Result (Unchanged) ---
     async def get_task_status(self, task_id: str) -> str:
-        """Check task status."""
         headers = {
             "token": self.public_token,
             "key": self.public_key,
@@ -183,7 +231,6 @@ class AsyncThordataClient:
             return "Unknown"
 
     async def get_task_result(self, task_id: str, file_type: str = "json") -> str:
-        """Get download link."""
         headers = {
             "token": self.public_token,
             "key": self.public_key,

{thordata_sdk-0.2.2 → thordata_sdk-0.2.4}/thordata_sdk/client.py

@@ -1,7 +1,11 @@
 import requests
 import logging
 import json
-from typing import Dict, Any
+import base64
+from typing import Dict, Any, Union, Optional
+
+from .enums import Engine
+from .parameters import normalize_serp_params
 
 # Configure a library-specific logger
 logger = logging.getLogger(__name__)
@@ -14,7 +18,8 @@ class ThordataClient:
     Handles authentication for:
     1. Proxy Network (HTTP/HTTPS)
     2. SERP API (Real-time Search)
-    3. Web Scraper API (Async Task Management)
+    3. Universal Scraping API (Single Page)
+    4. Web Scraper API (Async Task Management)
     """
 
     def __init__(
@@ -39,16 +44,18 @@ class ThordataClient:
         self.public_token = public_token
         self.public_key = public_key
 
-        # Proxy Configuration (User: Scraper Token, Pass: Empty)
+        # Proxy Configuration
         self.proxy_url = (
             f"http://{self.scraper_token}:@{proxy_host}:{proxy_port}"
         )
 
         # API Endpoints
         self.base_url = "https://scraperapi.thordata.com"
+        self.universal_url = "https://universalapi.thordata.com"
         self.api_url = "https://api.thordata.com/api/web-scraper-api"
 
         self.SERP_API_URL = f"{self.base_url}/request"
+        self.UNIVERSAL_API_URL = f"{self.universal_url}/request"
         self.SCRAPER_BUILDER_URL = f"{self.base_url}/builder"
         self.SCRAPER_STATUS_URL = f"{self.api_url}/tasks-status"
         self.SCRAPER_DOWNLOAD_URL = f"{self.api_url}/tasks-download"
@@ -62,51 +69,39 @@ class ThordataClient:
     def get(self, url: str, **kwargs) -> requests.Response:
         """
         Send a GET request through the Thordata Proxy Network.
-
-        Args:
-            url (str): The target URL.
-            **kwargs: Additional arguments passed to requests.get().
-
-        Returns:
-            requests.Response: The HTTP response.
         """
         logger.debug(f"Proxy Request: {url}")
         kwargs.setdefault("timeout", 30)
         return self.session.get(url, **kwargs)
 
     def serp_search(
-        self, query: str, engine: str = "google", num: int = 10, **kwargs
+        self, 
+        query: str, 
+        engine: Union[Engine, str] = Engine.GOOGLE, # 既可以是枚举，也可以是字符串
+        num: int = 10, 
+        **kwargs # 这里接收所有额外参数 (比如 type="maps")
     ) -> Dict[str, Any]:
         """
         Execute a real-time SERP search.
+        
+        Args:
+            query: Keywords
+            engine: 'google', 'bing', 'yandex' etc.
+            num: Number of results (default 10)
+            **kwargs: Extra parameters (e.g., type="shopping", location="London")
         """
-        payload = {
-            "q": query,
-            "num": str(num),
-            "json": "1",
-            "engine": engine.lower(),
-            **kwargs
-        }
+        # 兼容处理：如果用户传的是枚举对象，取它的值；如果是字符串，转小写
+        engine_str = engine.value if isinstance(engine, Engine) else engine.lower()
 
-        # Engine-specific parameter adjustments
-        if engine.lower() == 'yandex':
-            payload['text'] = payload.pop('q')
-            if 'url' not in payload:
-                payload['url'] = "yandex.com"
-        elif 'url' not in payload:
-            if engine == 'google':
-                payload['url'] = "google.com"
-            elif engine == 'bing':
-                payload['url'] = "bing.com"
-            elif engine == 'duckduckgo':
-                payload['url'] = "duckduckgo.com"
+        # 调用 parameters.py 里的逻辑
+        payload = normalize_serp_params(engine_str, query, num=num, **kwargs)
 
         headers = {
             "Authorization": f"Bearer {self.scraper_token}",
             "Content-Type": "application/x-www-form-urlencoded"
         }
 
-        logger.info(f"SERP Search: {engine} - {query}")
+        logger.info(f"SERP Search: {engine_str} - {query}")
         try:
             response = self.session.post(
                 self.SERP_API_URL,
@@ -115,35 +110,114 @@ class ThordataClient:
                 timeout=60
             )
             response.raise_for_status()
+            
             data = response.json()
-
-            # Handle potential double-encoded JSON strings
             if isinstance(data, str):
-                try:
-                    data = json.loads(data)
-                except json.JSONDecodeError:
-                    pass
+                try: data = json.loads(data)
+                except: pass
             return data
         except Exception as e:
             logger.error(f"SERP Request Failed: {e}")
             raise
 
+
+    def universal_scrape(
+        self,
+        url: str,
+        js_render: bool = False,
+        output_format: str = "HTML",
+        country: str = None,
+        block_resources: bool = False
+    ) -> Union[str, bytes]:
+        """
+        Unlock target pages via the Universal Scraping API.
+        """
+        headers = {
+            "Authorization": f"Bearer {self.scraper_token}",
+            "Content-Type": "application/x-www-form-urlencoded"
+        }
+
+        payload = {
+            "url": url,
+            "js_render": "True" if js_render else "False",
+            "type": output_format.lower(),
+            "block_resources": "True" if block_resources else "False"
+        }
+        if country:
+            payload["country"] = country
+
+        logger.info(f"Universal Scrape: {url}")
+
+        try:
+            response = self.session.post(
+                self.UNIVERSAL_API_URL,
+                data=payload,
+                headers=headers,
+                timeout=60
+            )
+            response.raise_for_status()
+
+            # Parse JSON wrapper
+            try:
+                resp_json = response.json()
+            except json.JSONDecodeError:
+                # Fallback for raw response
+                if output_format.upper() == "PNG":
+                    return response.content
+                return response.text
+
+            # Check API errors
+            if isinstance(resp_json, dict) and resp_json.get("code") \
+                    and resp_json.get("code") != 200:
+                raise Exception(f"Universal API Error: {resp_json}")
+
+            # Extract HTML
+            if "html" in resp_json:
+                return resp_json["html"]
+
+            # Extract PNG
+            if "png" in resp_json:
+                png_str = resp_json["png"]
+                if not png_str:
+                    raise Exception("API returned empty PNG data")
+
+                # 🛠️ FIX: 移除 Data URI Scheme 前缀 (data:image/png;base64,)
+                if "," in png_str:
+                    png_str = png_str.split(",", 1)[1]
+
+                # Base64 解码 (处理 padding)
+                png_str = png_str.replace("\n", "").replace("\r", "")
+                missing_padding = len(png_str) % 4
+                if missing_padding:
+                    png_str += '=' * (4 - missing_padding)
+
+                return base64.b64decode(png_str)
+
+            return str(resp_json)
+
+        except Exception as e:
+            logger.error(f"Universal Scrape Failed: {e}")
+            raise
+
     def create_scraper_task(
         self,
         file_name: str,
-        spider_id: str,
-        individual_params: Dict[str, Any],
-        spider_name: str = "youtube.com",
+        spider_id: str,     # 必须传，用户从仪表板获取
+        spider_name: str,   # 必须传，例如 "youtube.com"
+        individual_params: Dict[str, Any], # 用户把具体的参数打包在这个字典里传进来
         universal_params: Dict[str, Any] = None
     ) -> str:
         """
-        Create an Asynchronous Web Scraper Task.
+        Create a generic Web Scraper Task.
+        
+        Note: Check the Thordata Dashboard to get the correct 'spider_id' and 'spider_name'.
         """
         headers = {
             "Authorization": f"Bearer {self.scraper_token}",
             "Content-Type": "application/x-www-form-urlencoded"
         }
 
+        # 直接打包发送，不替用户做太多复杂的校验，保证兼容性
         payload = {
             "spider_name": spider_name,
             "spider_id": spider_id,
@@ -154,7 +228,7 @@ class ThordataClient:
         if universal_params:
             payload["spider_universal"] = json.dumps(universal_params)
 
-        logger.info(f"Creating Scraper Task: {spider_id}")
+        logger.info(f"Creating Scraper Task: {spider_name} (ID: {spider_id})")
         try:
             response = self.session.post(
                 self.SCRAPER_BUILDER_URL,
@@ -174,7 +248,6 @@ class ThordataClient:
     def get_task_status(self, task_id: str) -> str:
         """
         Check the status of a task.
-        Returns: 'Running', 'Ready', 'Failed', or 'Unknown'.
         """
         headers = {
             "token": self.public_token,

thordata_sdk-0.2.4/thordata_sdk/enums.py

@@ -0,0 +1,20 @@
+# thordata_sdk/enums.py
+from enum import Enum
+
+class Engine(str, Enum):
+    """SERP 核心支持的四大引擎"""
+    GOOGLE = "google"
+    BING = "bing"
+    YANDEX = "yandex"
+    DUCKDUCKGO = "duckduckgo"
+    BAIDU = "baidu"
+
+class GoogleSearchType(str, Enum):
+    """Google 搜索的常见子类型 (参考你的截图)"""
+    SEARCH = "search"      # 默认网页搜索
+    MAPS = "maps"          # 地图
+    SHOPPING = "shopping"  # 购物
+    NEWS = "news"          # 新闻
+    IMAGES = "images"      # 图片
+    VIDEOS = "videos"      # 视频
+    # 其他冷门的先不写，用户可以通过字符串传参

thordata_sdk-0.2.4/thordata_sdk/parameters.py

@@ -0,0 +1,41 @@
+# thordata_sdk/parameters.py
+from typing import Dict, Any
+
+def normalize_serp_params(engine: str, query: str, **kwargs) -> Dict[str, Any]:
+    """
+    统一不同搜索引擎的参数差异。
+    """
+    # 1. 基础参数
+    payload = {
+        "num": str(kwargs.get("num", 10)),
+        "json": "1",
+        "engine": engine,
+    }
+
+    # 2. 处理查询关键词 (Yandex 用 text，其他用 q)
+    if engine == "yandex":
+        payload["text"] = query
+        # 如果用户没传 url，给个默认的
+        if "url" not in kwargs:
+            payload["url"] = "yandex.com"
+    else:
+        payload["q"] = query
+        
+        # 3. 处理默认 URL (如果用户没传)
+        if "url" not in kwargs:
+            defaults = {
+                "google": "google.com",
+                "bing": "bing.com",
+                "duckduckgo": "duckduckgo.com",
+                "baidu": "baidu.com"
+            }
+            if engine in defaults:
+                payload["url"] = defaults[engine]
+
+    # 4. 把用户传入的其他所有参数（比如 type="shopping", google_domain="google.co.uk"）都透传进去
+    # 这样你就不用去定义那几十种类型了，用户传啥就是啥
+    for k, v in kwargs.items():
+        if k not in ["num", "engine", "q", "text"]: # 避免覆盖
+            payload[k] = v
+
+    return payload

{thordata_sdk-0.2.2 → thordata_sdk-0.2.4}/thordata_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
-Name: thordata_sdk
-Version: 0.2.2
+Metadata-Version: 2.1
+Name: thordata-sdk
+Version: 0.2.4
 Summary: The official Python SDK for Thordata Proxy & Scraper Infrastructure.
 Home-page: https://github.com/Thordata/thordata-python-sdk
 Author: Thordata Developer Team
@@ -22,20 +22,6 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: requests>=2.25.0
-Requires-Dist: aiohttp>=3.8.0
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license
-Dynamic: license-file
-Dynamic: project-url
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
 
 # Thordata Python SDK
 

{thordata_sdk-0.2.2 → thordata_sdk-0.2.4}/thordata_sdk.egg-info/SOURCES.txt

@@ -1,11 +1,11 @@
 LICENSE
 README.md
 setup.py
-tests/test_async_client.py
-tests/test_client.py
 thordata_sdk/__init__.py
 thordata_sdk/async_client.py
 thordata_sdk/client.py
+thordata_sdk/enums.py
+thordata_sdk/parameters.py
 thordata_sdk.egg-info/PKG-INFO
 thordata_sdk.egg-info/SOURCES.txt
 thordata_sdk.egg-info/dependency_links.txt

thordata_sdk-0.2.2/tests/test_async_client.py

@@ -1,59 +0,0 @@
-import pytest
-import aiohttp
-from aioresponses import aioresponses
-from thordata_sdk import AsyncThordataClient
-
-# Mark all tests in this module as async
-pytestmark = pytest.mark.asyncio
-
-# Mock Credentials
-TEST_SCRAPER = "async_scraper_token"
-TEST_PUB_TOKEN = "async_public_token"
-TEST_PUB_KEY = "async_key"
-TEST_HOST = "gate.thordata.com"
-TEST_PORT = 22225
-
-@pytest.fixture
-async def async_client():
-    """Fixture for AsyncThordataClient with context management."""
-    client = AsyncThordataClient(
-        scraper_token=TEST_SCRAPER,
-        public_token=TEST_PUB_TOKEN,
-        public_key=TEST_PUB_KEY,
-        proxy_host=TEST_HOST,
-        proxy_port=TEST_PORT
-    )
-    async with client: 
-        yield client
-
-async def test_async_client_initialization(async_client):
-    """Test async client properties."""
-    expected_url = f"http://{TEST_HOST}:{TEST_PORT}"
-
-    assert async_client.proxy_url == expected_url
-    assert isinstance(async_client.proxy_auth, aiohttp.BasicAuth)
-    assert async_client.proxy_auth.login == TEST_SCRAPER
-
-async def test_async_successful_request(async_client):
-    """Test successful async proxy request."""
-    mock_url = "http://example.com/async_test"
-    mock_data = {"status": "async_ok"}
-
-    with aioresponses() as m:
-        m.get(mock_url, status=200, payload=mock_data)
-        
-        response = await async_client.get(mock_url)
-        
-        assert response.status == 200
-        data = await response.json()
-        assert data == mock_data
-
-async def test_async_http_error_handling(async_client):
-    """Test async HTTP error."""
-    error_url = "http://example.com/async_error"
-
-    with aioresponses() as m:
-        m.get(error_url, status=401)
-
-        response = await async_client.get(error_url)
-        assert response.status == 401

thordata_sdk-0.2.2/tests/test_client.py

@@ -1,53 +0,0 @@
-import requests
-import requests_mock
-import pytest
-from thordata_sdk.client import ThordataClient
-
-# Mock Credentials
-TEST_SCRAPER = "mock_scraper_token"
-TEST_PUB_TOKEN = "mock_public_token"
-TEST_PUB_KEY = "mock_public_key"
-TEST_HOST = "gate.thordata.com" 
-TEST_PORT = 22225
-
-@pytest.fixture
-def client():
-    """Fixture to create a ThordataClient instance."""
-    return ThordataClient(
-        scraper_token=TEST_SCRAPER, 
-        public_token=TEST_PUB_TOKEN, 
-        public_key=TEST_PUB_KEY,
-        proxy_host=TEST_HOST,
-        proxy_port=TEST_PORT
-    )
-
-def test_client_initialization(client):
-    """Test client initialization and proxy URL construction."""
-    expected_url = f"http://{TEST_SCRAPER}:@{TEST_HOST}:{TEST_PORT}" 
-    
-    # Verify proxy configuration in session
-    assert client.session.proxies["http"] == expected_url
-    assert client.session.proxies["https"] == expected_url
-
-def test_successful_request(client):
-    """Test a successful proxy request (200 OK)."""
-    mock_url = "http://example.com/test"
-    mock_data = {"status": "ok"}
-
-    with requests_mock.Mocker() as m:
-        m.get(mock_url, status_code=200, json=mock_data)
-        
-        response = client.get(mock_url)
-        
-        assert response.status_code == 200
-        assert response.json() == mock_data
-
-def test_http_error_handling(client):
-    """Test handling of HTTP errors (e.g., 403 Forbidden)."""
-    error_url = "http://example.com/error"
-    
-    with requests_mock.Mocker() as m:
-        m.get(error_url, status_code=403)
-        
-        response = client.get(error_url)
-        assert response.status_code == 403