thordata-sdk 1.3.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

thordata/types/task.py

@@ -0,0 +1,144 @@
+"""
+Web Scraper Task types.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any
+
+from .common import CommonSettings, ThordataBaseConfig
+
+
+class TaskStatus(str, Enum):
+    PENDING = "pending"
+    RUNNING = "running"
+    READY = "ready"
+    SUCCESS = "success"
+    FINISHED = "finished"
+    FAILED = "failed"
+    ERROR = "error"
+    CANCELLED = "cancelled"
+    UNKNOWN = "unknown"
+
+    @classmethod
+    def is_terminal(cls, status: TaskStatus) -> bool:
+        return status in {
+            cls.READY,
+            cls.SUCCESS,
+            cls.FINISHED,
+            cls.FAILED,
+            cls.ERROR,
+            cls.CANCELLED,
+        }
+
+    @classmethod
+    def is_success(cls, status: TaskStatus) -> bool:
+        return status in {cls.READY, cls.SUCCESS, cls.FINISHED}
+
+    @classmethod
+    def is_failure(cls, status: TaskStatus) -> bool:
+        return status in {cls.FAILED, cls.ERROR}
+
+
+class DataFormat(str, Enum):
+    JSON = "json"
+    CSV = "csv"
+    XLSX = "xlsx"
+
+
+@dataclass
+class ScraperTaskConfig(ThordataBaseConfig):
+    file_name: str
+    spider_id: str
+    spider_name: str
+    parameters: dict[str, Any]
+    universal_params: dict[str, Any] | None = None
+    include_errors: bool = True
+
+    def to_payload(self) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "file_name": self.file_name,
+            "spider_id": self.spider_id,
+            "spider_name": self.spider_name,
+            "spider_parameters": json.dumps([self.parameters]),
+            "spider_errors": "true" if self.include_errors else "false",
+        }
+        if self.universal_params:
+            payload["spider_universal"] = json.dumps(self.universal_params)
+        return payload
+
+
+@dataclass
+class VideoTaskConfig(ThordataBaseConfig):
+    file_name: str
+    spider_id: str
+    spider_name: str
+    parameters: dict[str, Any]
+    common_settings: CommonSettings
+    include_errors: bool = True
+
+    def to_payload(self) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "file_name": self.file_name,
+            "spider_id": self.spider_id,
+            "spider_name": self.spider_name,
+            "spider_parameters": json.dumps([self.parameters]),
+            "spider_errors": "true" if self.include_errors else "false",
+            # v2.0 Doc explicitly requires 'spider_universal' key for video tasks too sometimes,
+            # but usually it's passed as 'common_settings' or 'spider_universal'.
+            # Sticking to original models.py key logic for now to ensure stability.
+            "spider_universal": self.common_settings.to_json(),
+        }
+        # Note: If API expects 'common_settings' key specifically, adjust here.
+        # Based on v2 context, video builder often uses spider_universal.
+        return payload
+
+
+@dataclass
+class TaskStatusResponse:
+    task_id: str
+    status: str
+    progress: int | None = None
+    message: str | None = None
+
+    def is_complete(self) -> bool:
+        terminal_statuses = {
+            "ready",
+            "success",
+            "finished",
+            "failed",
+            "error",
+            "cancelled",
+        }
+        return self.status.lower() in terminal_statuses
+
+    def is_success(self) -> bool:
+        return self.status.lower() in {"ready", "success", "finished"}
+
+
+@dataclass
+class UsageStatistics:
+    total_usage_traffic: float
+    traffic_balance: float
+    query_days: int
+    range_usage_traffic: float
+    data: list[dict[str, Any]]
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> UsageStatistics:
+        return cls(
+            total_usage_traffic=float(data.get("total_usage_traffic", 0)),
+            traffic_balance=float(data.get("traffic_balance", 0)),
+            query_days=int(data.get("query_days", 0)),
+            range_usage_traffic=float(data.get("range_usage_traffic", 0)),
+            data=data.get("data", []),
+        )
+
+    def total_usage_gb(self) -> float:
+        return self.total_usage_traffic / (1024 * 1024)
+
+    def balance_gb(self) -> float:
+        return self.traffic_balance / (1024 * 1024)

thordata/types/universal.py

@@ -0,0 +1,66 @@
+"""
+Universal Scraping (Web Unlocker) types.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from typing import Any
+
+from .common import ThordataBaseConfig
+
+
+@dataclass
+class UniversalScrapeRequest(ThordataBaseConfig):
+    url: str
+    js_render: bool = False
+    output_format: str = "html"  # 'html' or 'png'
+    country: str | None = None
+    block_resources: str | None = None  # 'script,image'
+    clean_content: str | None = None  # 'js,css'
+    wait: int | None = None  # ms
+    wait_for: str | None = None  # selector
+
+    # Headers/Cookies must be serialized to JSON in payload
+    headers: list[dict[str, str]] | None = None
+    cookies: list[dict[str, str]] | None = None
+
+    extra_params: dict[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        valid_formats = {"html", "png"}
+        if self.output_format.lower() not in valid_formats:
+            raise ValueError(
+                f"Invalid output_format: {self.output_format}. Must be one of: {valid_formats}"
+            )
+
+        if self.wait is not None and (self.wait < 0 or self.wait > 100000):
+            raise ValueError("wait must be between 0 and 100000 milliseconds")
+
+    def to_payload(self) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "url": self.url,
+            "js_render": "True" if self.js_render else "False",
+            "type": self.output_format.lower(),
+        }
+
+        if self.country:
+            payload["country"] = self.country.lower()
+        if self.block_resources:
+            payload["block_resources"] = self.block_resources
+        if self.clean_content:
+            payload["clean_content"] = self.clean_content
+        if self.wait is not None:
+            payload["wait"] = str(self.wait)
+        if self.wait_for:
+            payload["wait_for"] = self.wait_for
+
+        # Serialize complex objects as JSON strings
+        if self.headers:
+            payload["headers"] = json.dumps(self.headers)
+        if self.cookies:
+            payload["cookies"] = json.dumps(self.cookies)
+
+        payload.update(self.extra_params)
+        return payload

thordata/unlimited.py

@@ -0,0 +1,169 @@
+"""
+Sync interface for Unlimited Residential Proxy management.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from ._utils import build_public_api_headers
+from .exceptions import raise_for_code
+
+if TYPE_CHECKING:
+    from .client import ThordataClient
+
+
+class UnlimitedNamespace:
+    """
+    Namespace for Unlimited Residential Proxy operations.
+    """
+
+    def __init__(self, client: ThordataClient):
+        self._client = client
+        # Base URL for unlimited endpoints (usually same as public API base)
+        # We can reuse _locations_base_url logic to find the API root
+        # locations_base: .../api/locations -> root: .../api
+        self._api_base = client._locations_base_url.replace("/locations", "")
+
+    def list_servers(self) -> list[dict[str, Any]]:
+        """
+        Get the list of unlimited proxy servers.
+
+        Returns:
+            List of server objects.
+        """
+        self._client._require_public_credentials()
+        params = {
+            "token": self._client.public_token,
+            "key": self._client.public_key,
+        }
+        response = self._client._api_request_with_retry(
+            "GET", f"{self._api_base}/unlimited/server-list", params=params
+        )
+        response.raise_for_status()
+        data = response.json()
+        if data.get("code") != 200:
+            raise_for_code("List servers failed", code=data.get("code"), payload=data)
+
+        # API returns { "data": [...] } OR { "data": { "list": [...] } } sometimes
+        # Assuming standard list return
+        return data.get("data") or []
+
+    def restart_server(self, plan_name: str) -> dict[str, Any]:
+        """Restart an unlimited proxy server."""
+        return self._post_action("/unlimited/restart-server", {"plan_name": plan_name})
+
+    def renew(self, plan_name: str, month: int) -> dict[str, Any]:
+        """Renew an unlimited plan."""
+        return self._post_action(
+            "/unlimited/renew", {"plan_name": plan_name, "month": str(month)}
+        )
+
+    def upgrade(self, plan_name: str, target_plan: str) -> dict[str, Any]:
+        """Upgrade an unlimited plan."""
+        return self._post_action(
+            "/unlimited/upgrade",
+            {"plan_name": plan_name, "target_plan": target_plan},
+        )
+
+    def list_bound_users(self, ip: str) -> list[dict[str, Any]]:
+        """List users bound to a specific unlimited server IP."""
+        data = self._post_action("/get_unlimited_servers_bind_user", {"ip": ip})
+        # Assuming data structure similar to other lists
+        return data.get("list") or [] if isinstance(data, dict) else []
+
+    def bind_user(self, ip: str, username: str) -> dict[str, Any]:
+        """Bind a sub-user to an unlimited server IP."""
+        return self._post_action(
+            "/add_unlimited_servers_bind_user", {"ip": ip, "username": username}
+        )
+
+    def unbind_user(self, ip: str, username: str) -> dict[str, Any]:
+        """Unbind a sub-user from an unlimited server IP."""
+        return self._post_action(
+            "/del_unlimited_servers_bind_user", {"ip": ip, "username": username}
+        )
+
+    def _post_action(self, endpoint: str, payload: dict[str, Any]) -> dict[str, Any]:
+        """Helper for POST actions."""
+        self._client._require_public_credentials()
+        headers = build_public_api_headers(
+            self._client.public_token or "", self._client.public_key or ""
+        )
+        response = self._client._api_request_with_retry(
+            "POST", f"{self._api_base}{endpoint}", data=payload, headers=headers
+        )
+        response.raise_for_status()
+        data = response.json()
+        if data.get("code") != 200:
+            raise_for_code(
+                f"Action {endpoint} failed", code=data.get("code"), payload=data
+            )
+        return data.get("data", {})
+
+    def get_server_monitor(
+        self,
+        ins_id: str,
+        region: str,
+        start_time: int,
+        end_time: int,
+        period: int = 300,
+    ) -> dict[str, Any]:
+        """
+        Get Unlimited Proxy Server monitor (CPU, Mem, TCP, Bandwidth).
+        """
+        self._client._require_public_credentials()
+        params = {
+            "token": self._client.public_token,
+            "key": self._client.public_key,
+            "ins_id": ins_id,
+            "region": region,
+            "start_time": str(start_time),
+            "end_time": str(end_time),
+            "period": str(period),
+        }
+        # Note: Endpoint is /api/unlimited/server-monitor
+        response = self._client._api_request_with_retry(
+            "GET", f"{self._api_base}/unlimited/server-monitor", params=params
+        )
+        response.raise_for_status()
+        data = response.json()
+        if data.get("code") != 200:
+            raise_for_code(
+                "Get server monitor failed", code=data.get("code"), payload=data
+            )
+        return data.get("data", {})
+
+    def get_balancing_monitor(
+        self,
+        ins_id: str,
+        region: str,
+        start_time: int,
+        end_time: int,
+        period: int = 300,
+    ) -> dict[str, Any]:
+        """
+        Get Unlimited Residential Proxy Load Balancing Machine Monitoring.
+        """
+        self._client._require_public_credentials()
+        params = {
+            "token": self._client.public_token,
+            "key": self._client.public_key,
+            "ins_id": ins_id,
+            "region": region,
+            "start_time": str(start_time),
+            "end_time": str(end_time),
+            "period": str(period),
+        }
+        response = self._client._api_request_with_retry(
+            "GET", f"{self._api_base}/unlimited/balancing-monitor", params=params
+        )
+        response.raise_for_status()
+        data = response.json()
+
+        # Note: This endpoint uses 'status_code' instead of 'code' in the root
+        code = data.get("status_code", data.get("code"))
+        if code != 200:
+            raise_for_code("Get balancing monitor failed", code=code, payload=data)
+
+        return data.get("payload", {})

{thordata_sdk-1.3.0.dist-info → thordata_sdk-1.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thordata-sdk
-Version: 1.3.0
+Version: 1.5.0
 Summary: The Official Python SDK for Thordata - AI Data Infrastructure & Proxy Network.
 Author-email: Thordata Developer Team <support@thordata.com>
 License: MIT
@@ -35,7 +35,7 @@ Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
 Requires-Dist: pytest-httpserver>=1.0.0; extra == "dev"
 Requires-Dist: python-dotenv>=1.0.0; extra == "dev"
-Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: black>=25.11.0; extra == "dev"
 Requires-Dist: ruff>=0.1.0; extra == "dev"
 Requires-Dist: mypy>=1.0.0; extra == "dev"
 Requires-Dist: types-requests>=2.28.0; extra == "dev"
@@ -63,14 +63,13 @@ Dynamic: license-file
 
 ## 📖 Introduction
 
-This SDK provides a robust, high-performance interface to Thordata's AI data infrastructure. It is designed for high-concurrency scraping, reliable proxy tunneling, and seamless data extraction.
+The **Thordata Python SDK v1.5.0** is a production-ready wrapper for Thordata's AI data infrastructure. It is architected for high reliability, strict type safety, and maximum performance.
 
-**Key Features:**
-*   **🚀 Production Ready:** Built on `urllib3` connection pooling for low-latency proxy requests.
-*   **⚡ Async Support:** Native `aiohttp` client for high-concurrency SERP/Universal scraping.
-*   **🛡️ Robust:** Handles TLS-in-TLS tunneling, retries, and error parsing automatically.
-*   **✨ Developer Experience:** Fully typed (`mypy` compatible) with intuitive IDE autocomplete.
-*   **🧩 Lazy Validation:** Only validate credentials for the features you actually use.
+**Why v1.5.0?**
+*   **🛡️ Bulletproof Networking**: Custom core handles `HTTP`, `HTTPS`, and `SOCKS5h` (Remote DNS) tunneling, solving common SSL/TLS handshake issues in complex network environments.
+*   **⚡ Async First**: First-class `asyncio` support with `aiohttp` for high-concurrency scraping (1000+ RPS).
+*   **🧩 100% API Coverage**: Every endpoint documented by Thordata (including Hourly Usage, Server Monitor, and Task Management) is implemented.
+*   **🤖 Type Safe**: Fully typed (`mypy` strict) for excellent IDE autocompletion and error checking.
 
 ---
 
@@ -84,72 +83,74 @@ pip install thordata-sdk
 
 ## 🔐 Configuration
 
-Set environment variables to avoid hardcoding credentials. You only need to set the variables for the features you use.
+Set environment variables to avoid hardcoding credentials.
 
 ```bash
-# [Required for SERP & Web Unlocker]
-export THORDATA_SCRAPER_TOKEN="your_token_here"
+# [Scraping APIs]
+export THORDATA_SCRAPER_TOKEN="your_scraper_token"
 
-# [Required for Proxy Network]
+# [Management APIs]
+export THORDATA_PUBLIC_TOKEN="your_public_token"
+export THORDATA_PUBLIC_KEY="your_public_key"
+
+# [Proxy Network]
 export THORDATA_RESIDENTIAL_USERNAME="your_username"
 export THORDATA_RESIDENTIAL_PASSWORD="your_password"
-export THORDATA_PROXY_HOST="vpnXXXX.pr.thordata.net"
-
-# [Required for Task Management]
-export THORDATA_PUBLIC_TOKEN="public_token"
-export THORDATA_PUBLIC_KEY="public_key"
+# Optional: Set upstream proxy for local dev (e.g., Clash)
+# export THORDATA_UPSTREAM_PROXY="http://127.0.0.1:7890"
 ```
 
 ---
 
 ## 🚀 Quick Start
 
-### 1. SERP Search (Google/Bing/Yandex)
+### 1. SERP Search (Google/Bing)
 
 ```python
 from thordata import ThordataClient, Engine
 
-client = ThordataClient()  # Loads THORDATA_SCRAPER_TOKEN from env
+client = ThordataClient() 
 
-# Simple Search
-print("Searching...")
-results = client.serp_search("latest AI trends", engine=Engine.GOOGLE_NEWS)
+# Search Google
+results = client.serp_search(
+    query="latest AI trends",
+    engine=Engine.GOOGLE,
+    num=10,
+    location="United States"
+)
 
-for news in results.get("news_results", [])[:3]:
-    print(f"- {news['title']} ({news['source']})")
+for item in results.get("organic", []):
+    print(f"{item['title']} - {item['link']}")
 ```
 
 ### 2. Universal Scrape (Web Unlocker)
 
-Bypass Cloudflare/Akamai and render JavaScript automatically.
+Automatically handles JS rendering, CAPTCHAs, and fingerprinting.
 
 ```python
 html = client.universal_scrape(
-    url="https://example.com/protected-page",
+    url="https://example.com",
     js_render=True,
-    wait_for=".content-loaded",
-    country="us"
+    country="us",
+    wait_for=".content-loaded"  # Smart waiting
 )
-print(f"Scraped {len(html)} bytes")
 ```
 
-### 3. High-Performance Proxy
+### 3. High-Performance Proxy Tunneling
 
-Use Thordata's residential IPs with automatic connection pooling.
+Use Thordata's residential IPs directly with `requests` (Sync) or `aiohttp` (Async). The SDK handles the complex authentication and rotation logic.
 
 ```python
 from thordata import ProxyConfig, ProxyProduct
 
-# Config is optional if env vars are set, but allows granular control
+# Config is optional if env vars are set
 proxy = ProxyConfig(
     product=ProxyProduct.RESIDENTIAL,
     country="jp",
-    city="tokyo",
-    session_id="session-001",
     session_duration=10  # Sticky IP for 10 mins
 )
 
-# Use the client to make requests (Reuses TCP connections)
+# The client automatically routes this through Thordata's network
 response = client.get("https://httpbin.org/ip", proxy_config=proxy)
 print(response.json())
 ```
@@ -158,9 +159,9 @@ print(response.json())
 
 ## ⚙️ Advanced Usage
 
-### Async Client (High Concurrency)
+### Async High-Concurrency
 
-For building AI agents or high-throughput spiders.
+Perfect for building high-throughput AI agents.
 
 ```python
 import asyncio
@@ -168,20 +169,17 @@ from thordata import AsyncThordataClient
 
 async def main():
     async with AsyncThordataClient() as client:
-        # Fire off multiple requests in parallel
-        tasks = [
-            client.serp_search(f"query {i}") 
-            for i in range(5)
-        ]
+        # Fire off 10 requests in parallel
+        tasks = [client.serp_search(f"query {i}") for i in range(10)]
         results = await asyncio.gather(*tasks)
         print(f"Completed {len(results)} searches")
 
 asyncio.run(main())
 ```
 
-### Web Scraper API (Task Management)
+### Task Management (Batch Scraping)
 
-Create and manage large-scale scraping tasks asynchronously.
+Handle large-scale scraping jobs asynchronously.
 
 ```python
 # 1. Create a task
@@ -192,13 +190,38 @@ task_id = client.create_scraper_task(
     parameters={"url": "https://example.com"}
 )
 
-# 2. Wait for completion (Polling)
-status = client.wait_for_task(task_id)
+# 2. Poll for completion (Helper method)
+status = client.wait_for_task(task_id, max_wait=600)
+
+# 3. Download results
+if status == "finished":
+    data_url = client.get_task_result(task_id)
+    print(f"Download: {data_url}")
+```
+
+---
+
+## 🛠️ Management APIs
+
+Manage your infrastructure programmatically.
+
+```python
+# Check Balance
+balance = client.get_traffic_balance()
 
-# 3. Get results
-if status == "ready":
-    url = client.get_task_result(task_id)
-    print(f"Download Data: {url}")
+# Manage Whitelist
+client.add_whitelist_ip("1.2.3.4")
+
+# Create Sub-users
+client.create_proxy_user("new_user", "pass123", traffic_limit=500)
+
+# Monitor Unlimited Proxies
+monitor = client.unlimited.get_server_monitor(
+    ins_id="ins-123", 
+    region="us", 
+    start_time=1700000000, 
+    end_time=1700003600
+)
 ```
 
 ---

thordata_sdk-1.5.0.dist-info/RECORD

@@ -0,0 +1,35 @@
+thordata/__init__.py,sha256=-2bXx3LckBWrJ_E5HqFTOj7sm45AgrOnSWV4QN6f-7U,2287
+thordata/_example_utils.py,sha256=T9QtVq9BHhubOShgtGp2GSusYYd-ZFUJFJAw7ubIsa4,2199
+thordata/_utils.py,sha256=Acr_6sHgdZXU7SQozd6FEYTZV6iHw__nlhpBTDwb66U,4917
+thordata/async_client.py,sha256=zN59ZQfFVCuAGnGcyj-C_S9MbHzb17QbUISm46n6gpY,39439
+thordata/async_unlimited.py,sha256=kzTksFkN21rDM21Pwy3hcayjfyGYNGGyGR3fRLtZC6I,4510
+thordata/client.py,sha256=eA6jav_aAw2CQdSyrg3P59rELKo13K5tHqmSjEw3L_8,56717
+thordata/demo.py,sha256=DojJRFqUm9XAMBkjmk03WGeiUdLCbXguMIwtMOzfN6M,3822
+thordata/enums.py,sha256=_pahGhcq9Eh2ptL_WiNU2WlqKrydV_6e4U9G4erV9-s,774
+thordata/exceptions.py,sha256=P9czrxkFhT439DxW3LE5W-koS595ObH4-mAQOfaDM18,9976
+thordata/models.py,sha256=wozvlpS-Uv1DgkM_CEKOvldQ2InicxhIN0QiezIXPE4,853
+thordata/retry.py,sha256=5kRwULl3X68Nx8PlSzr9benfyCL0nRSpVQXrwjWr45M,11456
+thordata/serp_engines.py,sha256=iuMWncelcGOskCHXFzpcPMMTL5qfiLkazHB1uj3zpZo,5985
+thordata/unlimited.py,sha256=RzrtwcotYlbOWuSLysDyI75IkMVL7ygdfE9HKNoe02M,6087
+thordata/core/__init__.py,sha256=EFT6mZpSdec_7uFUpSpDDHVwbTxy314uxJC_uprR6J4,500
+thordata/core/async_http_client.py,sha256=KKsmhXN6bWRTDFvqa0H-WRf4R-TWH8WSgpDBRv6TEvg,3052
+thordata/core/http_client.py,sha256=8lSwclmVweM-Go1qMW36zYnMKAUT_9RyDdPF7qMS4-Y,2280
+thordata/core/tunnel.py,sha256=rbM_4zGwY4FXqdxYmCOURQw2s1EuAWFBVBM-1joNjGI,8373
+thordata/tools/__init__.py,sha256=ROryBBlCfq9cydaKXEPtnevjhg6GdFioAjdnp2VTR0M,606
+thordata/tools/base.py,sha256=fHuCp53y8eB59DuCdA1wHcbMVmsd5ikL9KlT5m_jJn0,1006
+thordata/tools/code.py,sha256=opYMG7LdR90VjW5tn8wnRCwDT-zUC0uteMKW01TMPTI,580
+thordata/tools/ecommerce.py,sha256=u-s-RGMSAGifsMnyMrwtJ3yVDgu3n74bv8yyX6TbMNU,1560
+thordata/tools/search.py,sha256=toWMOnnfQXgafyndHs23Yn049vpPlGPHdZA7SpiJJTE,1724
+thordata/tools/social.py,sha256=VbujfbA5Man6Shsik4QYBpf9z2FJhhJkZLNKll09Ots,4886
+thordata/tools/video.py,sha256=WikUOYPSVtHdrS0Z7VVexlUPyFZRv9v7cerkpzzO5jU,2549
+thordata/types/__init__.py,sha256=hlLt5UCVm7QdeOCN5_YWXS4Vy8tJUhIp0XbWjAoQiQg,1357
+thordata/types/common.py,sha256=hkTZ1QtokpE1yT9BvTmYfQz9AUjeCIIPvjib2pnq_Ag,2818
+thordata/types/proxy.py,sha256=IU45wQHCBOIlbdcCN9veypAkDT0q9NIikLu674CudOU,10438
+thordata/types/serp.py,sha256=NO52I1NprjVBgKQe4o2xEp82a3Oy9wCBYG-2Q0oegnU,5817
+thordata/types/task.py,sha256=f5xGeH4BrE7sHIgWhRJuMr3iuPooxJlg7ztr8lwcSx8,4139
+thordata/types/universal.py,sha256=Kw8lf_2ElXIfylsNfVosLE1MvlEQkryv4fWEaQw6ecg,2161
+thordata_sdk-1.5.0.dist-info/licenses/LICENSE,sha256=bAxpWgQIzb-5jl3nhLdOwOJ_vlbHLtSG7yev2B7vioY,1088
+thordata_sdk-1.5.0.dist-info/METADATA,sha256=VqsfaJsguO-KSMOjWjPodO1nIa510qpjNBdVzCMHshQ,7026
+thordata_sdk-1.5.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+thordata_sdk-1.5.0.dist-info/top_level.txt,sha256=Z8R_07m0lXCCSb1hapL9_nxMtyO3rf_9wOvq4n9u2Hg,9
+thordata_sdk-1.5.0.dist-info/RECORD,,

{thordata_sdk-1.3.0.dist-info → thordata_sdk-1.5.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

thordata_sdk-1.3.0.dist-info/RECORD

@@ -1,16 +0,0 @@
-thordata/__init__.py,sha256=O9R2zY6qQXWIkQQ8Hcqqcwshymk4-2Bo_Pmm-Ma3SeI,3195
-thordata/_example_utils.py,sha256=T9QtVq9BHhubOShgtGp2GSusYYd-ZFUJFJAw7ubIsa4,2199
-thordata/_utils.py,sha256=Acr_6sHgdZXU7SQozd6FEYTZV6iHw__nlhpBTDwb66U,4917
-thordata/async_client.py,sha256=9swh6AoAgvLRavFzXaM1rUz9Zm66r7GKjThjfILLiSI,58082
-thordata/client.py,sha256=IvkPjm4v9ViiNMUM4uUbUOY3kNtJdw3mzSd3BT3yD0A,59039
-thordata/demo.py,sha256=HQzgaUM33bWD7mBQ6HEkK5K6zqFnSAHLvaam6BwPgFA,3762
-thordata/enums.py,sha256=MpZnS9_8sg2vtcFqM6UicB94cKZm5R1t83L3ejNSbLs,8502
-thordata/exceptions.py,sha256=P9czrxkFhT439DxW3LE5W-koS595ObH4-mAQOfaDM18,9976
-thordata/models.py,sha256=qtB7jE0v5zNEQfSpmOqdiacB5DgM2QfVR2PaYs-DisM,38206
-thordata/retry.py,sha256=5kRwULl3X68Nx8PlSzr9benfyCL0nRSpVQXrwjWr45M,11456
-thordata/serp_engines.py,sha256=iuMWncelcGOskCHXFzpcPMMTL5qfiLkazHB1uj3zpZo,5985
-thordata_sdk-1.3.0.dist-info/licenses/LICENSE,sha256=bAxpWgQIzb-5jl3nhLdOwOJ_vlbHLtSG7yev2B7vioY,1088
-thordata_sdk-1.3.0.dist-info/METADATA,sha256=x7p4JY94WCbvVmLiSaPDcUiKKiSw_4bRn3sLr1PRBPM,6600
-thordata_sdk-1.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-thordata_sdk-1.3.0.dist-info/top_level.txt,sha256=Z8R_07m0lXCCSb1hapL9_nxMtyO3rf_9wOvq4n9u2Hg,9
-thordata_sdk-1.3.0.dist-info/RECORD,,