from thordata import ThordataClient

# Initialize the client
client = ThordataClient(
    scraper_token="your_scraper_token",
    public_token="your_public_token",  # Optional, for task APIs
    public_key="your_public_key"        # Optional, for task APIs
)

# Make a request through the proxy network
response = client.get("https://httpbin.org/ip")
print(response.json())
# {'origin': '123.45.67.89'}  # Residential IP

import os
from dotenv import load_dotenv
from thordata import ThordataClient

load_dotenv()

client = ThordataClient(
    scraper_token=os.getenv("THORDATA_SCRAPER_TOKEN"),
    public_token=os.getenv("THORDATA_PUBLIC_TOKEN"),
    public_key=os.getenv("THORDATA_PUBLIC_KEY"),
)

from thordata import ThordataClient

client = ThordataClient(scraper_token="your_token")

# GET request through proxy
response = client.get("https://example.com")
print(response.text)

# POST request through proxy
response = client.post("https://httpbin.org/post", json={"key": "value"})
print(response.json())

from thordata import ThordataClient, ProxyConfig

client = ThordataClient(scraper_token="your_token")

# Create a proxy config with geo-targeting
config = ProxyConfig(
    username="your_username",
    password="your_password",
    country="us",           # Target country
    state="california",     # Target state
    city="los_angeles",     # Target city
)

response = client.get("https://httpbin.org/ip", proxy_config=config)
print(response.json())

from thordata import ThordataClient, StickySession

client = ThordataClient(scraper_token="your_token")

# Create a sticky session (same IP for 10 minutes)
session = StickySession(
    username="your_username",
    password="your_password",
    country="gb",
    duration_minutes=10,
)

# All requests use the same IP
for i in range(5):
    response = client.get("https://httpbin.org/ip", proxy_config=session)
    print(f"Request {i+1}: {response.json()['origin']}")

from thordata import ProxyConfig, ProxyProduct

proxy = ProxyConfig(
    username="your_username",
    password="your_password",
    product=ProxyProduct.RESIDENTIAL,
    country="us",
)

response = requests.get(
    "http://httpbin.org/ip",
    proxies=proxy.to_proxies_dict(),
)
print(response.json())

proxy = ProxyConfig(
    username="your_username",
    password="your_password",
    product=ProxyProduct.DATACENTER,
)

proxy = ProxyConfig(
    username="your_username",
    password="your_password",
    product=ProxyProduct.MOBILE,
    country="gb",
)

from thordata import StaticISPProxy

proxy = StaticISPProxy(
    host="your_static_ip_address",  # Your purchased IP
    username="your_username",
    password="your_password",
)

response = requests.get(
    "http://httpbin.org/ip",
    proxies=proxy.to_proxies_dict(),
)
# Returns your purchased static IP

from thordata import ThordataClient, Engine

client = ThordataClient(scraper_token="your_token")

# Google search
results = client.serp_search(
    query="python programming",
    engine=Engine.GOOGLE,
    num=10
)

# Print organic results
for result in results.get("organic", []):
    print(f"{result['title']}: {result['link']}")

from thordata import ThordataClient

client = ThordataClient(scraper_token="YOUR_SCRAPER_TOKEN")

# Recommended: use dedicated engines for Google verticals when available
news = client.serp_search(
    query="pizza",
    engine="google_news",
    country="us",
    language="en",
    num=10,
    so=1,  # 0=relevance, 1=date (Google News)
)

# Alternative: use Google generic engine + tbm via `search_type`
# Note: `search_type` maps to Google tbm and is mainly intended for engine="google".
results = client.serp_search(
    query="pizza",
    engine="google",
    num=10,
    country="us",
    language="en",
    search_type="news",  # tbm=nws (Google generic engine)
    ibp="some_ibp_value",
    lsig="some_lsig_value",
)

from thordata import ThordataClient, SerpRequest

client = ThordataClient(scraper_token="your_token")

# Create a detailed search request
request = SerpRequest(
    query="best laptops 2024",
    engine="google_shopping",
    num=20,
    country="us",
    language="en",
    safe_search=True,
    device="mobile",
    # Shopping-specific params can be passed via extra_params
    # e.g. min_price=500, max_price=1500, sort_by=1, shoprs="..."
)

results = client.serp_search_advanced(request)

from thordata import ThordataClient, Engine

client = ThordataClient(scraper_token="your_token")

# Google
google_results = client.serp_search("AI news", engine=Engine.GOOGLE)

# Bing
bing_results = client.serp_search("AI news", engine=Engine.BING)

# Yandex (Russian search engine)
yandex_results = client.serp_search("AI news", engine=Engine.YANDEX)

# DuckDuckGo
ddg_results = client.serp_search("AI news", engine=Engine.DUCKDUCKGO)

results = client.serp_search(
    query="python web scraping best practices",
    engine=Engine.GOOGLE,
    country="us",
    language="en",
    num=10,
    time_filter="week",      # Last week
    safe_search=True,        # Adult content filter
)

results = client.serp_search(
    query="iPhone 15",
    engine="google_shopping",
    country="us",
    language="en",
    num=20,
    # Shopping parameters are passed through kwargs
    min_price=500,
    max_price=1500,
    sort_by=1,
    free_shipping=True,
    on_sale=True,
    small_business=True,
    direct_link=True,
    shoprs="FILTER_ID_HERE",
)
shopping_items = results.get("shopping_results", [])

results = client.serp_search(
    query="pizza near me",
    engine=Engine.GOOGLE,
    search_type="local",
    google_domain="google.com",
    country="us",
    language="en",
    location="San Francisco",
    uule="w+CAIQICIFU2FuIEZyYW5jaXNjbw",  # Example value
    start=0,  # Local only accepts 0, 20, 40...
)
local_results = results.get("local_results", results.get("organic", []))

results = client.serp_search(
    query="python async tutorial",
    engine=Engine.GOOGLE,
    search_type="videos",   # tbm=vid
    country="us",
    language="en",
    languages_filter="lang_en|lang_fr",
    location="United States",
    uule="ENCODED_LOCATION_HERE",
    num=10,
    time_filter="month",
    safe_search=True,
    filter_duplicates=True,
)
video_results = results.get("video_results", results.get("organic", []))

results = client.serp_search(
    query="AI regulation",
    engine="google_news",
    country="us",
    language="en",
    topic_token="YOUR_TOPIC_TOKEN",
    publication_token="YOUR_PUBLICATION_TOKEN",
    section_token="YOUR_SECTION_TOKEN",
    story_token="YOUR_STORY_TOKEN",
    so=1,  # 0=relevance, 1=date
)
news_results = results.get("news_results", results.get("organic", []))

from thordata import ThordataClient

client = ThordataClient(scraper_token="your_token")

# Get HTML content
html = client.universal_scrape(
    url="https://example.com",
    js_render=True,  # Enable JavaScript rendering
)
print(html[:500])

from thordata import ThordataClient, UniversalScrapeRequest

client = ThordataClient(scraper_token="your_token")

request = UniversalScrapeRequest(
    url="https://example.com",
    js_render=True,
    output_format="html",
    country="us",
    block_resources="image,font",  # Speed up by blocking resources
    clean_content="js,css",        # Remove JS/CSS from output
    wait=5000,                     # Wait 5 seconds after load
    wait_for=".content-loaded",    # Wait for CSS selector
    headers=[
        {"name": "Accept-Language", "value": "en-US"}
    ],
    cookies=[
        {"name": "session", "value": "abc123"}
    ],
)

html = client.universal_scrape_advanced(request)

from thordata import ThordataClient

client = ThordataClient(scraper_token="your_token")

# Get PNG screenshot
png_bytes = client.universal_scrape(
    url="https://example.com",
    js_render=True,
    output_format="png",
)

# Save to file
with open("screenshot.png", "wb") as f:
    f.write(png_bytes)

from thordata import ThordataClient

client = ThordataClient(
    scraper_token="your_token",
    public_token="your_public_token",
    public_key="your_public_key",
)

# Create a scraping task
task_id = client.create_scraper_task(
    file_name="youtube_channel_data",
    spider_id="youtube_video-post_by-url",  # From Dashboard
    spider_name="youtube.com",
    parameters={
        "url": "https://www.youtube.com/@PewDiePie/videos",
        "num_of_posts": "50"
    }
)
print(f"Task created: {task_id}")

# Wait for completion (with timeout)
status = client.wait_for_task(task_id, max_wait=300)
print(f"Task status: {status}")

# Get results
if status in ("ready", "success"):
    download_url = client.get_task_result(task_id)
    print(f"Download: {download_url}")

import asyncio
from thordata import AsyncThordataClient

async def main():
    async with AsyncThordataClient(
        scraper_token="your_token",
        public_token="your_public_token",
        public_key="your_public_key",
    ) as client:
        
        # Concurrent proxy requests
        urls = [
            "https://httpbin.org/ip",
            "https://httpbin.org/headers",
            "https://httpbin.org/user-agent",
        ]
        
        tasks = [client.get(url) for url in urls]
        responses = await asyncio.gather(*tasks)
        
        for resp in responses:
            print(await resp.json())

asyncio.run(main())

import asyncio
from thordata import AsyncThordataClient, Engine

async def search_multiple():
    async with AsyncThordataClient(scraper_token="your_token") as client:
        queries = ["python", "javascript", "rust", "go"]
        
        tasks = [
            client.serp_search(q, engine=Engine.GOOGLE)
            for q in queries
        ]
        
        results = await asyncio.gather(*tasks)
        
        for query, result in zip(queries, results):
            count = len(result.get("organic", []))
            print(f"{query}: {count} results")

asyncio.run(search_multiple())

from thordata import ThordataClient, ProxyType

client = ThordataClient(
    scraper_token="your_token",
    public_token="your_public_token",
    public_key="your_public_key",
)

# List all supported countries
countries = client.list_countries(proxy_type=ProxyType.RESIDENTIAL)
print(f"Supported countries: {len(countries)}")

# List states for a country
states = client.list_states("US")
for state in states[:5]:
    print(f"  {state['state_code']}: {state['state_name']}")

# List cities
cities = client.list_cities("US", state_code="california")
print(f"Cities in California: {len(cities)}")

# List ASNs (for ISP targeting)
asns = client.list_asn("US")
for asn in asns[:5]:
    print(f"  {asn['asn_code']}: {asn['asn_name']}")

from thordata import (
    ThordataClient,
    ThordataError,
    ThordataAuthError,
    ThordataRateLimitError,
    ThordataNetworkError,
    ThordataTimeoutError,
)

client = ThordataClient(scraper_token="your_token")

try:
    result = client.serp_search("test query")
except ThordataAuthError as e:
    print(f"Authentication failed: {e}")
    print(f"Check your token. Status code: {e.status_code}")
except ThordataRateLimitError as e:
    print(f"Rate limited: {e}")
    if e.retry_after:
        print(f"Retry after {e.retry_after} seconds")
except ThordataTimeoutError as e:
    print(f"Request timed out: {e}")
except ThordataNetworkError as e:
    print(f"Network error: {e}")
except ThordataError as e:
    print(f"General error: {e}")

from thordata import ThordataClient, RetryConfig

# Custom retry configuration
retry_config = RetryConfig(
    max_retries=5,           # Maximum retry attempts
    backoff_factor=2.0,      # Exponential backoff multiplier
    max_backoff=120.0,       # Maximum wait between retries
    jitter=True,             # Add randomness to prevent thundering herd
)

client = ThordataClient(
    scraper_token="your_token",
    retry_config=retry_config,
)

# Requests will automatically retry on transient failures
response = client.get("https://example.com")