scrapeit-sdk 0.1.0__tar.gz

scrapeit_sdk-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.egg-info/
+.pytest_cache/
+.venv/
+build/
+dist/

scrapeit_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.5
+Name: scrapeit-sdk
+Version: 0.1.0
+Summary: Official Python SDK for the ScrapeIt Web Scraping API and product APIs.
+Project-URL: Documentation, https://docs.scrapeit.io/guide/sdks
+License-Expression: MIT
+Keywords: amazon,google-maps,google-serp,scrapeit,scraping-api,web-scraping
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: httpx<1,>=0.27
+Provides-Extra: dev
+Requires-Dist: datamodel-code-generator==0.83.0; extra == 'dev'
+Requires-Dist: pytest==9.1.1; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# ScrapeIt Python SDK
+
+Official Python client for the [ScrapeIt](https://scrapeit.io) Web Scraping API and product APIs
+(Google SERP, Google Maps, Amazon, Website Crawler and more). Sync and async clients on `httpx`,
+request types generated from the ScrapeIt OpenAPI document.
+
+```bash
+pip install scrapeit-sdk
+```
+
+```python
+from scrapeit import Scrapeit, ScrapeitError
+
+client = Scrapeit()  # reads SCRAPEIT_API_KEY, or pass Scrapeit("YOUR_API_KEY")
+
+page = client.scrape(url="https://example.com", jsRendering=True)
+print(page["data"])
+
+results = client.google_search(q="coffee near me", gl="us")
+```
+
+```python
+import asyncio
+from scrapeit import AsyncScrapeit
+
+async def main() -> None:
+    async with AsyncScrapeit() as client:
+        job = await client.scrape_async(url="https://example.com")
+        done = await client.wait_for_async_scrape(job["data"]["id"])
+        print(done["data"]["status"])
+
+asyncio.run(main())
+```
+
+Every method returns the API envelope `{"data": ..., "meta": ...}` and raises `ScrapeitError` with
+the stable API error `code` (for example `INSUFFICIENT_CREDITS`). 429, 500 and 503 responses are
+retried automatically with `Retry-After`.
+
+Documentation: <https://docs.scrapeit.io/guide/sdks>

scrapeit_sdk-0.1.0/README.md

@@ -0,0 +1,39 @@
+# ScrapeIt Python SDK
+
+Official Python client for the [ScrapeIt](https://scrapeit.io) Web Scraping API and product APIs
+(Google SERP, Google Maps, Amazon, Website Crawler and more). Sync and async clients on `httpx`,
+request types generated from the ScrapeIt OpenAPI document.
+
+```bash
+pip install scrapeit-sdk
+```
+
+```python
+from scrapeit import Scrapeit, ScrapeitError
+
+client = Scrapeit()  # reads SCRAPEIT_API_KEY, or pass Scrapeit("YOUR_API_KEY")
+
+page = client.scrape(url="https://example.com", jsRendering=True)
+print(page["data"])
+
+results = client.google_search(q="coffee near me", gl="us")
+```
+
+```python
+import asyncio
+from scrapeit import AsyncScrapeit
+
+async def main() -> None:
+    async with AsyncScrapeit() as client:
+        job = await client.scrape_async(url="https://example.com")
+        done = await client.wait_for_async_scrape(job["data"]["id"])
+        print(done["data"]["status"])
+
+asyncio.run(main())
+```
+
+Every method returns the API envelope `{"data": ..., "meta": ...}` and raises `ScrapeitError` with
+the stable API error `code` (for example `INSUFFICIENT_CREDITS`). 429, 500 and 503 responses are
+retried automatically with `Retry-After`.
+
+Documentation: <https://docs.scrapeit.io/guide/sdks>

scrapeit_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,52 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "scrapeit-sdk"
+dynamic = ["version"]
+description = "Official Python SDK for the ScrapeIt Web Scraping API and product APIs."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.11"
+dependencies = ["httpx>=0.27,<1"]
+keywords = ["scrapeit", "web-scraping", "scraping-api", "google-serp", "google-maps", "amazon"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Typing :: Typed",
+  "Intended Audience :: Developers",
+]
+
+[project.urls]
+Documentation = "https://docs.scrapeit.io/guide/sdks"
+
+[project.optional-dependencies]
+# Pinned: the generator's output is committed and compared byte for byte by
+# tests/test_generated_models.py, so a different generator version is a different file.
+dev = ["datamodel-code-generator==0.83.0", "pytest==9.1.1"]
+
+[tool.hatch.version]
+path = "src/scrapeit/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/scrapeit"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+# Read by `python -m datamodel_code_generator` run from this directory (pnpm sdk:generate and the
+# drift guard). The input is the SDK subset written by sdks/scripts/generate-sdks.mjs.
+[tool.datamodel-codegen]
+input = "../openapi.sdk.json"
+input-file-type = "openapi"
+output = "src/scrapeit/_generated/models.py"
+output-model-type = "typing.TypedDict"
+openapi-scopes = ["schemas", "paths", "parameters"]
+target-python-version = "3.11"
+# Builtin formatting keeps the output independent of black/isort versions installed alongside.
+formatters = ["builtin"]
+disable-timestamp = true
+use-schema-description = true
+use-field-description = true
+enum-field-as-literal = "all"
+custom-file-header = "# GENERATED FILE — do not edit by hand.\n# Source: sdks/openapi.sdk.json (subset of docs/api/openapi.yml). Regenerate: pnpm sdk:generate"

scrapeit_sdk-0.1.0/src/scrapeit/__init__.py

@@ -0,0 +1,24 @@
+"""Official Python SDK for the ScrapeIt Web Scraping API and product APIs."""
+
+from ._client import (
+    API_KEY_ENVIRONMENT_VARIABLE,
+    DEFAULT_BASE_URL,
+    AsyncScrapeit,
+    Envelope,
+    Scrapeit,
+)
+from ._errors import ScrapeitError, SdkErrorCode
+from ._generated import models
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "API_KEY_ENVIRONMENT_VARIABLE",
+    "DEFAULT_BASE_URL",
+    "AsyncScrapeit",
+    "Envelope",
+    "Scrapeit",
+    "ScrapeitError",
+    "SdkErrorCode",
+    "models",
+]

scrapeit_sdk-0.1.0/src/scrapeit/_client.py

@@ -0,0 +1,450 @@
+from __future__ import annotations
+
+import asyncio
+import os
+import time
+from abc import ABC, abstractmethod
+from collections.abc import Awaitable, Callable, Mapping
+from datetime import datetime, timezone
+from email.utils import parsedate_to_datetime
+from types import TracebackType
+from typing import Any, Generic, Literal, TypeVar, Unpack
+from urllib.parse import quote
+
+import httpx
+
+from ._errors import ScrapeitError, SdkErrorCode
+from ._generated import models
+
+DEFAULT_BASE_URL = "https://api.scrapeit.io"
+API_KEY_ENVIRONMENT_VARIABLE = "SCRAPEIT_API_KEY"
+
+# Above the API's own ceiling for a synchronous scrape (`timeoutMs` up to 180 s), so the server, not
+# the client, reports a slow target.
+DEFAULT_TIMEOUT_SECONDS = 200.0
+DEFAULT_MAX_RETRIES = 2
+INITIAL_RETRY_DELAY_SECONDS = 1.0
+# One API rate-limit window: a longer Retry-After is better surfaced to the caller than slept on.
+MAX_RETRY_DELAY_SECONDS = 60.0
+DEFAULT_POLL_INTERVAL_SECONDS = 2.0
+DEFAULT_WAIT_TIMEOUT_SECONDS = 600.0
+
+# Statuses retried automatically: the platform did not run, or did not charge, the request. 429 is a
+# rate limit or a busy concurrency slot (rejected before any work is queued), 503 a draining or
+# unavailable API, 500 an internal failure (platform failures are never charged). 502 and 504 are
+# NOT retried: a target block page after the last proxy attempt (502) and a timed-out scrape whose
+# late result is still recorded (504) can be billable, and a blind resend would be charged again.
+RETRYABLE_STATUSES = frozenset({429, 500, 503})
+TERMINAL_JOB_STATUSES = frozenset({"finished", "failed", "stopped", "skipped"})
+
+HttpMethod = Literal["GET", "POST", "DELETE"]
+Envelope = dict[str, Any]
+"""The API success envelope ``{"data": ..., "meta": ...}``, as returned."""
+
+_ResultT = TypeVar("_ResultT")
+
+
+def _resolve_api_key(api_key: str | None) -> str:
+    resolved = api_key if api_key is not None else os.environ.get(API_KEY_ENVIRONMENT_VARIABLE)
+
+    if not resolved:
+        raise ScrapeitError(
+            code=SdkErrorCode.MISSING_API_KEY,
+            message=f"Pass api_key or set the {API_KEY_ENVIRONMENT_VARIABLE} environment variable.",
+        )
+
+    return resolved
+
+
+def _path_segment(value: str) -> str:
+    return quote(value, safe="")
+
+
+def _query(params: Mapping[str, Any] | None) -> dict[str, Any]:
+    # Lists go as repeated keys, which the API reads as a list (it also accepts a,b,c).
+    return {name: value for name, value in (params or {}).items() if value is not None}
+
+
+def retry_delay_seconds(retry_after: str | None, attempt: int) -> float:
+    """Retry-After (seconds or an HTTP date) when the API sends it, else exponential backoff."""
+    backoff = min(INITIAL_RETRY_DELAY_SECONDS * 2.0**attempt, MAX_RETRY_DELAY_SECONDS)
+
+    if retry_after is None:
+        return backoff
+
+    try:
+        delay = float(retry_after)
+    except ValueError:
+        try:
+            delay = (parsedate_to_datetime(retry_after) - datetime.now(timezone.utc)).total_seconds()
+        except (TypeError, ValueError):
+            return backoff
+
+    return min(max(delay, 0.0), MAX_RETRY_DELAY_SECONDS)
+
+
+def _parse_success(response: httpx.Response) -> Envelope:
+    try:
+        payload = response.json()
+    except ValueError:
+        payload = None
+
+    if not isinstance(payload, dict) or "data" not in payload:
+        raise ScrapeitError(
+            code=SdkErrorCode.INVALID_RESPONSE,
+            message="The API response is not a { data, meta } JSON envelope.",
+            status=response.status_code,
+        )
+
+    return payload
+
+
+def _api_error(response: httpx.Response) -> ScrapeitError:
+    try:
+        payload = response.json()
+    except ValueError:
+        payload = None
+
+    error = payload.get("error") if isinstance(payload, dict) else None
+    error = error if isinstance(error, dict) else {}
+    code = error.get("code")
+    message = error.get("message")
+    correlation_id = error.get("correlation_id")
+
+    return ScrapeitError(
+        code=code if isinstance(code, str) else SdkErrorCode.INVALID_RESPONSE,
+        message=message
+        if isinstance(message, str)
+        else f"ScrapeIt API responded with HTTP {response.status_code}.",
+        status=response.status_code,
+        details=error.get("details"),
+        correlation_id=correlation_id if isinstance(correlation_id, str) else None,
+    )
+
+
+def _transport_error(error: httpx.TransportError, timeout: float | None) -> ScrapeitError:
+    # Not retried: the request may have reached the API, and a resent scrape is charged again.
+    if isinstance(error, httpx.TimeoutException):
+        return ScrapeitError(
+            code=SdkErrorCode.REQUEST_TIMEOUT, message=f"No response within {timeout} s."
+        )
+
+    return ScrapeitError(
+        code=SdkErrorCode.NETWORK_ERROR, message="The request did not reach the ScrapeIt API."
+    )
+
+
+def _job_status(job: Envelope) -> str:
+    data = job.get("data")
+    status = data.get("status") if isinstance(data, dict) else None
+
+    if not isinstance(status, str):
+        raise ScrapeitError(
+            code=SdkErrorCode.INVALID_RESPONSE,
+            message="The API response carries no job status.",
+        )
+
+    return status
+
+
+def _wait_timeout_error(job: Envelope) -> ScrapeitError:
+    data = job["data"]
+
+    return ScrapeitError(
+        code=SdkErrorCode.WAIT_TIMEOUT,
+        message="The job did not reach a terminal status in time; it keeps running.",
+        details={"job_id": data.get("id"), "status": data.get("status")},
+    )
+
+
+class _Methods(ABC, Generic[_ResultT]):
+    """The API surface, written once for both clients: ``_ResultT`` is ``Envelope`` for
+    :class:`Scrapeit` and ``Awaitable[Envelope]`` for :class:`AsyncScrapeit`."""
+
+    def __init__(self) -> None:
+        self.google_maps = _GoogleMaps(self)
+        self.amazon = _Amazon(self)
+        self.crawler = _Crawler(self)
+        self.jobs = _Jobs(self)
+
+    @abstractmethod
+    def request(
+        self,
+        method: HttpMethod,
+        path: str,
+        *,
+        params: Mapping[str, Any] | None = None,
+        json: Any = None,
+    ) -> _ResultT:
+        """Any endpoint of the API (Zillow, Allegro, Apartments.com, batch scraping…), with the same
+        authentication, retries and error handling as the named methods."""
+
+    @abstractmethod
+    def _wait_for_terminal_status(
+        self, read_job: Callable[[], _ResultT], poll_interval: float, timeout: float
+    ) -> _ResultT: ...
+
+    def scrape(self, **params: Unpack[models.ScrapeWebDto]) -> _ResultT:
+        """Synchronous Web Scraping API request: returns when the page is scraped."""
+        return self.request("POST", "/api/v1/scrape/web", json=params)
+
+    def scrape_async(self, **params: Unpack[models.CreateAsyncWebScrapeDto]) -> _ResultT:
+        """Starts a background Web Scraping API request (optionally with ``webhookUrl``) and returns
+        the job at once; follow it with :meth:`wait_for_async_scrape` or the webhook."""
+        return self.request("POST", "/api/v1/scrape/web/async", json=params)
+
+    def get_async_scrape(self, job_id: str) -> _ResultT:
+        return self.request("GET", f"/api/v1/scrape/web/async/{_path_segment(job_id)}")
+
+    def wait_for_async_scrape(
+        self,
+        job_id: str,
+        *,
+        poll_interval: float = DEFAULT_POLL_INTERVAL_SECONDS,
+        timeout: float = DEFAULT_WAIT_TIMEOUT_SECONDS,
+    ) -> _ResultT:
+        """Polls an async scrape until it is finished, failed, stopped or skipped."""
+        return self._wait_for_terminal_status(
+            lambda: self.get_async_scrape(job_id), poll_interval, timeout
+        )
+
+    def google_search(
+        self, **params: Unpack[models.ApiV1ScrapeGoogleSearchGetParametersQuery]
+    ) -> _ResultT:
+        return self.request("GET", "/api/v1/scrape/google/search", params=params)
+
+    def usage(self) -> _ResultT:
+        """Credits, concurrency and usage of the organization the API key belongs to."""
+        return self.request("GET", "/api/v1/usage/me")
+
+
+class _GoogleMaps(Generic[_ResultT]):
+    def __init__(self, client: _Methods[_ResultT]) -> None:
+        self._client = client
+
+    def search(
+        self, **params: Unpack[models.ApiV1ScrapeGoogleMapsSearchGetParametersQuery]
+    ) -> _ResultT:
+        return self._client.request("GET", "/api/v1/scrape/google/maps/search", params=params)
+
+    def place(
+        self, **params: Unpack[models.ApiV1ScrapeGoogleMapsPlaceGetParametersQuery]
+    ) -> _ResultT:
+        return self._client.request("GET", "/api/v1/scrape/google/maps/place", params=params)
+
+
+class _Amazon(Generic[_ResultT]):
+    def __init__(self, client: _Methods[_ResultT]) -> None:
+        self._client = client
+
+    def search(self, **params: Unpack[models.ApiV1ScrapeAmazonSearchGetParametersQuery]) -> _ResultT:
+        return self._client.request("GET", "/api/v1/scrape/amazon/search", params=params)
+
+    def product(
+        self, **params: Unpack[models.ApiV1ScrapeAmazonProductGetParametersQuery]
+    ) -> _ResultT:
+        return self._client.request("GET", "/api/v1/scrape/amazon/product", params=params)
+
+
+class _Crawler(Generic[_ResultT]):
+    def __init__(self, client: _Methods[_ResultT]) -> None:
+        self._client = client
+
+    def start(self, **params: Unpack[models.CreateCrawlerJobDto]) -> _ResultT:
+        return self._client.request("POST", "/api/v1/scrapers/crawler/jobs", json=params)
+
+    def status(self, job_id: str) -> _ResultT:
+        return self._client.request("GET", f"/api/v1/scrapers/jobs/{_path_segment(job_id)}")
+
+    def results(
+        self, job_id: str, **params: Unpack[models.ApiV1ScrapersJobsJobIdResultsGetParametersQuery]
+    ) -> _ResultT:
+        return self._client.request(
+            "GET", f"/api/v1/scrapers/jobs/{_path_segment(job_id)}/results", params=params
+        )
+
+    def wait(
+        self,
+        job_id: str,
+        *,
+        poll_interval: float = DEFAULT_POLL_INTERVAL_SECONDS,
+        timeout: float = DEFAULT_WAIT_TIMEOUT_SECONDS,
+    ) -> _ResultT:
+        return self._client._wait_for_terminal_status(
+            lambda: self.status(job_id), poll_interval, timeout
+        )
+
+
+class _Jobs(Generic[_ResultT]):
+    def __init__(self, client: _Methods[_ResultT]) -> None:
+        self._client = client
+
+    def get(self, job_id: str) -> _ResultT:
+        return self._client.request("GET", f"/api/v1/jobs/{_path_segment(job_id)}")
+
+
+class Scrapeit(_Methods[Envelope]):
+    """Synchronous ScrapeIt API client. Methods return the ``{"data", "meta"}`` envelope and raise
+    :class:`ScrapeitError` carrying the API error ``code``.
+
+    Pass ``http_client`` to reuse your own ``httpx.Client`` (proxies, transports, tests); ``timeout``
+    then comes from that client.
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        timeout: float = DEFAULT_TIMEOUT_SECONDS,
+        http_client: httpx.Client | None = None,
+    ) -> None:
+        super().__init__()
+        self._headers = {"x-api-key": _resolve_api_key(api_key), "accept": "application/json"}
+        self._base_url = base_url.rstrip("/")
+        self._max_retries = max_retries
+        self._timeout = timeout
+        self._http = http_client if http_client is not None else httpx.Client(timeout=timeout)
+
+    def request(
+        self,
+        method: HttpMethod,
+        path: str,
+        *,
+        params: Mapping[str, Any] | None = None,
+        json: Any = None,
+    ) -> Envelope:
+        attempt = 0
+
+        while True:
+            try:
+                response = self._http.request(
+                    method,
+                    f"{self._base_url}{path}",
+                    params=_query(params),
+                    json=json,
+                    headers=self._headers,
+                )
+            except httpx.TransportError as error:
+                raise _transport_error(error, self._timeout) from error
+
+            if response.is_success:
+                return _parse_success(response)
+
+            if attempt >= self._max_retries or response.status_code not in RETRYABLE_STATUSES:
+                raise _api_error(response)
+
+            time.sleep(retry_delay_seconds(response.headers.get("retry-after"), attempt))
+            attempt += 1
+
+    def _wait_for_terminal_status(
+        self, read_job: Callable[[], Envelope], poll_interval: float, timeout: float
+    ) -> Envelope:
+        deadline = time.monotonic() + timeout
+
+        while True:
+            job = read_job()
+
+            if _job_status(job) in TERMINAL_JOB_STATUSES:
+                return job
+
+            if time.monotonic() + poll_interval > deadline:
+                raise _wait_timeout_error(job)
+
+            time.sleep(poll_interval)
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> Scrapeit:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        self.close()
+
+
+class AsyncScrapeit(_Methods[Awaitable[Envelope]]):
+    """Asynchronous ScrapeIt API client (``await`` every method); same surface as :class:`Scrapeit`."""
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        timeout: float = DEFAULT_TIMEOUT_SECONDS,
+        http_client: httpx.AsyncClient | None = None,
+    ) -> None:
+        super().__init__()
+        self._headers = {"x-api-key": _resolve_api_key(api_key), "accept": "application/json"}
+        self._base_url = base_url.rstrip("/")
+        self._max_retries = max_retries
+        self._timeout = timeout
+        self._http = http_client if http_client is not None else httpx.AsyncClient(timeout=timeout)
+
+    async def request(
+        self,
+        method: HttpMethod,
+        path: str,
+        *,
+        params: Mapping[str, Any] | None = None,
+        json: Any = None,
+    ) -> Envelope:
+        attempt = 0
+
+        while True:
+            try:
+                response = await self._http.request(
+                    method,
+                    f"{self._base_url}{path}",
+                    params=_query(params),
+                    json=json,
+                    headers=self._headers,
+                )
+            except httpx.TransportError as error:
+                raise _transport_error(error, self._timeout) from error
+
+            if response.is_success:
+                return _parse_success(response)
+
+            if attempt >= self._max_retries or response.status_code not in RETRYABLE_STATUSES:
+                raise _api_error(response)
+
+            await asyncio.sleep(retry_delay_seconds(response.headers.get("retry-after"), attempt))
+            attempt += 1
+
+    async def _wait_for_terminal_status(
+        self, read_job: Callable[[], Awaitable[Envelope]], poll_interval: float, timeout: float
+    ) -> Envelope:
+        deadline = time.monotonic() + timeout
+
+        while True:
+            job = await read_job()
+
+            if _job_status(job) in TERMINAL_JOB_STATUSES:
+                return job
+
+            if time.monotonic() + poll_interval > deadline:
+                raise _wait_timeout_error(job)
+
+            await asyncio.sleep(poll_interval)
+
+    async def aclose(self) -> None:
+        await self._http.aclose()
+
+    async def __aenter__(self) -> AsyncScrapeit:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        await self.aclose()

scrapeit_sdk-0.1.0/src/scrapeit/_errors.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class SdkErrorCode:
+    """Codes the SDK raises itself, when there is no ``{ error }`` body from the API to take one from."""
+
+    MISSING_API_KEY = "MISSING_API_KEY"
+    """No API key was passed and ``SCRAPEIT_API_KEY`` is not set."""
+    NETWORK_ERROR = "NETWORK_ERROR"
+    """The request never got a response (DNS, connection refused, reset)."""
+    REQUEST_TIMEOUT = "REQUEST_TIMEOUT"
+    """No response arrived within the client ``timeout``."""
+    INVALID_RESPONSE = "INVALID_RESPONSE"
+    """The API answered with a body that is not the ``{ data, meta }`` / ``{ error }`` JSON envelope."""
+    WAIT_TIMEOUT = "WAIT_TIMEOUT"
+    """A ``wait…`` helper gave up before the job reached a terminal status."""
+
+
+class ScrapeitError(Exception):
+    """Any failed ScrapeIt call.
+
+    ``code`` is the stable machine-readable code from the API ``{ error }`` envelope (for example
+    ``INSUFFICIENT_CREDITS``, ``CONCURRENCY_LIMIT_EXCEEDED``) or one of :class:`SdkErrorCode`; branch on
+    it, not on the message.
+    """
+
+    def __init__(
+        self,
+        *,
+        code: str,
+        message: str,
+        status: int | None = None,
+        details: Any = None,
+        correlation_id: str | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.code = code
+        self.message = message
+        self.status = status
+        """HTTP status of the API response; ``None`` when no response arrived."""
+        self.details = details
+        self.correlation_id = correlation_id
+        """Quote it in support requests: it finds the request in ScrapeIt logs."""
+
+    def __repr__(self) -> str:
+        return f"ScrapeitError(code={self.code!r}, status={self.status!r}, message={self.message!r})"

scrapeit_sdk-0.1.0/src/scrapeit/_generated/__init__.py

@@ -0,0 +1 @@
+# GENERATED package: models.py is written by `pnpm sdk:generate` (datamodel-code-generator).