webextract-sdk 0.1.0__py3-none-any.whl

webextract/__init__.py

@@ -0,0 +1,20 @@
+"""WebExtract: web page to clean Markdown + fixed-schema JSON for AI agents (https://webextract.dev)."""
+from ._client import (
+    DEFAULT_BASE_URL, ENV_API_KEY, AsyncWebExtract, ResponseMeta, WebExtract, WebExtractResponse, __version__, error_from_response,
+)
+from ._errors import (
+    PAYMENT_HINTS, TARGET_FETCH_CODES, AuthenticationError, ConnectionError, InvalidRequestError, PaymentRequiredError,
+    RateLimitError, TargetFetchError, WebExtractError,
+)
+
+TOOL_DESCRIPTIONS = {
+    "extract_url": "Fetch a public web page (robots.txt respected) and return clean Markdown plus fixed-schema JSON: article metadata, product/price (with price_detail when available; a missing price is never reported as 0), and tables. Paid per call (USDC on Base and 6 other chains via x402, or prepaid credits); free tier 50 calls/day per IP.",
+    "page_markdown": "Fetch a public web page (robots.txt respected) and return clean Markdown only. Cheaper than extract_url. Use it when you only need the text.",
+    "url": "Public http(s) URL of the page to read",
+}
+
+__all__ = [
+    "WebExtract", "AsyncWebExtract", "ENV_API_KEY", "WebExtractResponse", "ResponseMeta", "DEFAULT_BASE_URL", "__version__",
+    "error_from_response", "WebExtractError", "PaymentRequiredError", "TargetFetchError", "InvalidRequestError",
+    "AuthenticationError", "RateLimitError", "ConnectionError", "PAYMENT_HINTS", "TARGET_FETCH_CODES", "TOOL_DESCRIPTIONS",
+]

webextract/_client.py

@@ -0,0 +1,279 @@
+"""Sync and async clients for https://api.webextract.dev. The package never handles private keys:
+x402 signing happens inside the ``payment_client`` you pass (e.g. ``x402HttpxClient``)."""
+from __future__ import annotations
+
+import base64
+import json
+import os
+from dataclasses import dataclass
+from typing import Any, Dict, Generic, Literal, Optional, TypeVar
+from urllib.parse import urlsplit
+
+import httpx
+
+from ._errors import (
+    AuthenticationError, ConnectionError, InvalidRequestError, PaymentRequiredError, RateLimitError,
+    TargetFetchError, TARGET_FETCH_CODES, WebExtractError,
+)
+
+__version__ = "0.1.0"
+ENV_API_KEY = "WEBEXTRACT_API_KEY"
+DEFAULT_BASE_URL = "https://api.webextract.dev"
+Billing = Literal["key", "free", "x402", "x402-testnet"]
+T = TypeVar("T")
+_PROTECTED = {"authorization", "x-billing", "payment-signature", "x-payment"}
+
+
+@dataclass
+class ResponseMeta:
+    status: int
+    billing: str
+    free_remaining: Optional[int]
+    credits_charged: Optional[float]
+    credits_remaining: Optional[float]
+    sandbox: bool
+    payment_response: Optional[Dict[str, Any]]
+
+
+@dataclass
+class WebExtractResponse(Generic[T]):
+    data: T
+    meta: ResponseMeta
+
+
+def _num(v: Optional[str]) -> Optional[float]:
+    if v is None or not v.strip():
+        return None
+    try:
+        return float(v)
+    except ValueError:
+        return None
+
+
+def _b64json(v: Optional[str]) -> Optional[Dict[str, Any]]:
+    if not v:
+        return None
+    try:
+        o = json.loads(base64.b64decode(v))
+        return o if isinstance(o, dict) else None
+    except Exception:
+        return None
+
+
+def _check_url(url: str) -> str:
+    if not isinstance(url, str) or not url.strip():
+        raise InvalidRequestError("url is required", status=0, code="missing_url", charged=False)
+    u = url.strip()
+    parts = urlsplit(u)
+    if parts.scheme not in ("http", "https") or not parts.netloc:
+        raise InvalidRequestError("url must be an absolute http(s) URL", status=0, code="invalid_url", charged=False)
+    return u
+
+
+def error_from_response(res: Any) -> WebExtractError:
+    """Map an error response (httpx or requests) to a WebExtractError subclass."""
+    status = res.status_code
+    try:
+        body = res.json()
+    except Exception:
+        body = None
+    if not isinstance(body, dict):
+        body = None
+    code = (body or {}).get("error") if isinstance((body or {}).get("error"), str) else f"http_{status}"
+    message = (body or {}).get("message") or (res.text[:200] if body is None and res.text else f"HTTP {status}")
+    charged = (body or {}).get("charged") if isinstance((body or {}).get("charged"), bool) else False
+    if status == 402:
+        reason = res.headers.get("x-payment-reason") or (body or {}).get("reason") or ("no_credits" if code == "no_credits" else "x402_required")
+        pr = _b64json(res.headers.get("payment-required"))
+        accepts = pr.get("accepts") if isinstance(pr, dict) and isinstance(pr.get("accepts"), list) else []
+        networks = list(dict.fromkeys(a.get("network") for a in accepts if isinstance(a, dict) and a.get("network")))
+        if not networks:
+            networks = list(((body or {}).get("x402") or {}).get("networks") or [])
+        fr = _num(res.headers.get("x-free-remaining"))
+        return PaymentRequiredError(
+            message, status=status, code="payment_required" if code == "http_402" else code, charged=False,
+            retryable=reason == "settlement_failed", body=body, reason=reason, payment_required=pr, networks=networks,
+            buy_url=((body or {}).get("stripe") or {}).get("buy_url") or (body or {}).get("buy"),
+            free_remaining=int(fr) if fr is not None else None)
+    if code in TARGET_FETCH_CODES or status == 451:
+        return TargetFetchError(message, status=status, code=code, charged=False, retryable=code == "fetch_failed", body=body)
+    if status == 400:
+        return InvalidRequestError(message, status=status, code=code, charged=False, body=body)
+    if status == 401:
+        return AuthenticationError(message, status=status, code=code, charged=False, body=body)
+    if status == 429:
+        return RateLimitError(message, status=status, code=code, charged=False, retryable=True, body=body,
+                              retry_after=_num(res.headers.get("retry-after")))
+    return WebExtractError(message, status=status, code=code, charged=charged, retryable=status >= 500, body=body)
+
+
+class _Base:
+    def __init__(self, *, api_key: Optional[str], billing: Optional[Billing], payment_client: Any,
+                 http_client: Any, base_url: Optional[str], timeout: float,
+                 headers: Optional[Dict[str, str]], settlement_retries: int = 1) -> None:
+        if api_key is not None and (not isinstance(api_key, str) or not api_key.strip()):
+            raise TypeError("api_key must be a non-empty string")
+        if api_key is None and payment_client is None and billing in (None, "key"):
+            # Fallback only: an explicit api_key wins; with payment_client or a non-key billing the env var is ignored.
+            env_key = os.environ.get(ENV_API_KEY, "").strip()
+            api_key = env_key or None
+        if api_key and payment_client is not None:
+            raise TypeError("pass either api_key or payment_client, not both (a Bearer key always wins on the server)")
+        self.billing: str = billing or ("key" if api_key else "x402" if payment_client is not None else "free")
+        if self.billing == "key" and not api_key:
+            raise TypeError(f'billing "key" needs api_key (or the {ENV_API_KEY} environment variable)')
+        if self.billing in ("x402", "x402-testnet") and payment_client is None:
+            raise TypeError(f'billing "{self.billing}" needs payment_client (e.g. x402HttpxClient from the x402 SDK)')
+        if self.billing != "key" and api_key:
+            raise TypeError(f'billing "{self.billing}" cannot be combined with api_key')
+        if self.billing not in ("key", "free", "x402", "x402-testnet"):
+            raise TypeError(f"unknown billing {self.billing!r}")
+        self._api_key = api_key
+        self.base_url = (base_url or DEFAULT_BASE_URL).rstrip("/")
+        self.timeout = timeout
+        if not isinstance(settlement_retries, int) or settlement_retries < 0:
+            raise TypeError("settlement_retries must be an int >= 0")
+        self.settlement_retries = settlement_retries
+        self._extra = {k: v for k, v in (headers or {}).items() if k.lower() not in _PROTECTED}
+        self._transport_client = payment_client if payment_client is not None else http_client
+
+    def __repr__(self) -> str:  # never show the key
+        return f"{type(self).__name__}(base_url={self.base_url!r}, billing={self.billing!r})"
+
+    def _headers(self, billing_header: bool = True) -> Dict[str, str]:
+        h = {"accept": "application/json", "user-agent": f"webextract-python/{__version__}", **self._extra}
+        if self._api_key:
+            h["authorization"] = f"Bearer {self._api_key}"
+        if billing_header and self.billing in ("free", "x402-testnet"):
+            h["x-billing"] = self.billing
+        return h
+
+    def _should_retry(self, e: WebExtractError, attempt: int) -> bool:
+        # settlement_failed = payment verified but not settled; the API says "not charged, retry with a new payment".
+        # Only this reason is retried automatically; the payment client signs a fresh payload on the new request.
+        return isinstance(e, PaymentRequiredError) and e.reason == "settlement_failed" and attempt < self.settlement_retries
+
+    def _parse(self, res: Any) -> WebExtractResponse[Dict[str, Any]]:
+        if 200 <= res.status_code < 300:
+            try:
+                data = res.json()
+            except Exception:
+                data = None
+            if not isinstance(data, dict):
+                raise WebExtractError("response was not JSON", status=res.status_code, code="invalid_response", body=res.text[:500])
+            fr = _num(res.headers.get("x-free-remaining"))
+            return WebExtractResponse(data=data, meta=ResponseMeta(
+                status=res.status_code, billing=self.billing, free_remaining=int(fr) if fr is not None else None,
+                credits_charged=_num(res.headers.get("x-credits-charged")),
+                credits_remaining=_num(res.headers.get("x-credits-remaining")),
+                sandbox=res.headers.get("x-sandbox") == "true",
+                payment_response=_b64json(res.headers.get("payment-response"))))
+        raise error_from_response(res)
+
+
+def _wrap_exc(e: Exception) -> ConnectionError:
+    timed_out = isinstance(e, httpx.TimeoutException) or "Timeout" in type(e).__name__
+    msg = "request timed out" if timed_out else f"request failed before a response: {type(e).__name__}: {e}"
+    err = ConnectionError(msg, status=0, code="timeout" if timed_out else "connection_error", charged=None, retryable=True)
+    err.__cause__ = e
+    return err
+
+
+class WebExtract(_Base):
+    """Synchronous client. ``payment_client`` may be any object with a requests/httpx-style
+    ``get(url, params=, headers=, timeout=)``, e.g. the ``requests.Session`` returned by
+    ``x402.http.clients.x402_requests(x402_client)`` (the x402 SDK has no sync httpx client).
+
+    >>> WebExtract().markdown("https://example.com").data["markdown"]  # free tier (X-Billing: free)
+    """
+
+    def __init__(self, *, api_key: Optional[str] = None, billing: Optional[Billing] = None,
+                 payment_client: Any = None, http_client: Optional[httpx.Client] = None,
+                 base_url: Optional[str] = None, timeout: float = 60.0, headers: Optional[Dict[str, str]] = None,
+                 settlement_retries: int = 1) -> None:
+        super().__init__(api_key=api_key, billing=billing, payment_client=payment_client, http_client=http_client,
+                         base_url=base_url, timeout=timeout, headers=headers, settlement_retries=settlement_retries)
+        self._owned = self._transport_client is None
+        self._http: httpx.Client = self._transport_client or httpx.Client(timeout=timeout)
+
+    def extract(self, url: str) -> WebExtractResponse[Dict[str, Any]]:
+        """GET /v1/extract: Markdown + fixed-schema JSON. $0.005 or 1 credit."""
+        return self._get("/v1/extract", {"url": _check_url(url)})
+
+    def markdown(self, url: str) -> WebExtractResponse[Dict[str, Any]]:
+        """GET /v1/markdown: Markdown only. $0.002 or 0.4 credit."""
+        return self._get("/v1/markdown", {"url": _check_url(url)})
+
+    def balance(self) -> Dict[str, Any]:
+        """GET /v1/balance: credits, or free calls left today for this IP. Never charged."""
+        return self._get("/v1/balance", None, billing_header=False).data
+
+    def _get(self, path: str, params: Optional[Dict[str, str]], billing_header: bool = True) -> WebExtractResponse[Dict[str, Any]]:
+        attempt = 0
+        while True:
+            try:
+                res = self._http.get(self.base_url + path, params=params, headers=self._headers(billing_header), timeout=self.timeout)
+            except Exception as e:
+                raise _wrap_exc(e) from e
+            try:
+                return self._parse(res)
+            except WebExtractError as e:
+                if not self._should_retry(e, attempt):
+                    raise
+                attempt += 1
+
+    def close(self) -> None:
+        if self._owned:
+            self._http.close()
+
+    def __enter__(self) -> "WebExtract":
+        return self
+
+    def __exit__(self, *a: Any) -> None:
+        self.close()
+
+
+class AsyncWebExtract(_Base):
+    """Async client. For x402 pass ``payment_client=x402HttpxClient(x402_client)`` from the official x402 SDK."""
+
+    def __init__(self, *, api_key: Optional[str] = None, billing: Optional[Billing] = None,
+                 payment_client: Optional[httpx.AsyncClient] = None, http_client: Optional[httpx.AsyncClient] = None,
+                 base_url: Optional[str] = None, timeout: float = 60.0, headers: Optional[Dict[str, str]] = None,
+                 settlement_retries: int = 1) -> None:
+        super().__init__(api_key=api_key, billing=billing, payment_client=payment_client, http_client=http_client,
+                         base_url=base_url, timeout=timeout, headers=headers, settlement_retries=settlement_retries)
+        self._owned = self._transport_client is None
+        self._http: httpx.AsyncClient = self._transport_client or httpx.AsyncClient(timeout=timeout)
+
+    async def extract(self, url: str) -> WebExtractResponse[Dict[str, Any]]:
+        return await self._get("/v1/extract", {"url": _check_url(url)})
+
+    async def markdown(self, url: str) -> WebExtractResponse[Dict[str, Any]]:
+        return await self._get("/v1/markdown", {"url": _check_url(url)})
+
+    async def balance(self) -> Dict[str, Any]:
+        return (await self._get("/v1/balance", None, billing_header=False)).data
+
+    async def _get(self, path: str, params: Optional[Dict[str, str]], billing_header: bool = True) -> WebExtractResponse[Dict[str, Any]]:
+        attempt = 0
+        while True:
+            try:
+                res = await self._http.get(self.base_url + path, params=params, headers=self._headers(billing_header), timeout=self.timeout)
+            except Exception as e:
+                raise _wrap_exc(e) from e
+            try:
+                return self._parse(res)
+            except WebExtractError as e:
+                if not self._should_retry(e, attempt):
+                    raise
+                attempt += 1
+
+    async def aclose(self) -> None:
+        if self._owned:
+            await self._http.aclose()
+
+    async def __aenter__(self) -> "AsyncWebExtract":
+        return self
+
+    async def __aexit__(self, *a: Any) -> None:
+        await self.aclose()

webextract/_errors.py

@@ -0,0 +1,82 @@
+"""Error classes. Every error raised by the client is a WebExtractError (or subclass)."""
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+TARGET_FETCH_CODES = frozenset({
+    "upstream_error", "blocked_by_site", "robots_disallowed", "dns_failed", "fetch_failed", "too_large", "unsupported_type",
+})
+
+PAYMENT_HINTS: Dict[str, str] = {
+    "x402_required": 'No API key, payment or free opt-in. Use billing="free" (50 calls/day per IP), an api_key (https://webextract.dev/#pricing), or a payment_client from the x402 SDK.',
+    "x402_requested": "x402 requested. Pass a payment_client (e.g. x402HttpxClient) so one of the PAYMENT-REQUIRED options can be signed.",
+    "free_limit_reached": "Free daily limit (50 calls/day per IP, shared with MCP) is used up. Buy credits at https://webextract.dev/#pricing or pay per call via x402 (USDC on Base and 6 other chains).",
+    "invalid_payment": "The x402 payment was rejected. Check the signer, network and USDC balance, then retry with a new payment.",
+    "unsupported_network": "The payment used a network/asset this endpoint does not accept. See `networks`.",
+    "settlement_failed": "Payment verified but settlement did not complete. Not charged. Retry with a freshly signed payment.",
+    "no_credits": "API key has no credits left. Top up at https://webextract.dev/#pricing.",
+}
+
+
+class WebExtractError(Exception):
+    """Base error. ``charged`` is False whenever the API says so (failed fetches are never billed)."""
+
+    def __init__(self, message: str, *, status: int, code: str, charged: Optional[bool] = None,
+                 retryable: bool = False, body: Any = None) -> None:
+        super().__init__(message)
+        self.message = message
+        self.status = status
+        self.code = code
+        self.charged = charged
+        self.retryable = retryable
+        self.body = body
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Compact, model-friendly description (used by the LangChain tools)."""
+        return {"error": self.code, "status": self.status, "message": self.message,
+                "charged": self.charged, "retryable": self.retryable}
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}(status={self.status}, code={self.code!r}, message={self.message!r})"
+
+
+class PaymentRequiredError(WebExtractError):
+    """HTTP 402. ``reason`` explains why; ``payment_required`` is the decoded PAYMENT-REQUIRED header."""
+
+    def __init__(self, message: str, *, reason: str, payment_required: Optional[Dict[str, Any]],
+                 networks: List[str], buy_url: Optional[str], free_remaining: Optional[int], **kw: Any) -> None:
+        super().__init__(message, **kw)
+        self.reason = reason
+        self.payment_required = payment_required
+        self.networks = networks
+        self.buy_url = buy_url
+        self.free_remaining = free_remaining
+        self.hint = PAYMENT_HINTS.get(reason, "Payment required.")
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {**super().to_dict(), "reason": self.reason, "hint": self.hint, "networks": self.networks,
+                "buy_url": self.buy_url, "free_remaining": self.free_remaining}
+
+
+class TargetFetchError(WebExtractError):
+    """The target page could not be fetched (robots.txt, HTTP error, blocked, DNS, timeout, size, type). Never charged."""
+
+
+class InvalidRequestError(WebExtractError):
+    """400: missing/invalid url, private host, invalid billing mode. Never charged."""
+
+
+class AuthenticationError(WebExtractError):
+    """401: unknown API key."""
+
+
+class RateLimitError(WebExtractError):
+    """429: rate limited (e.g. sandbox per-IP limits)."""
+
+    def __init__(self, message: str, *, retry_after: Optional[float], **kw: Any) -> None:
+        super().__init__(message, **kw)
+        self.retry_after = retry_after
+
+
+class ConnectionError(WebExtractError):  # noqa: A001 - deliberate, namespaced as webextract.ConnectionError
+    """No HTTP response (network error, timeout, or the payment client raised before sending)."""

webextract_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,96 @@
+Metadata-Version: 2.5
+Name: webextract-sdk
+Version: 0.1.0
+Summary: Thin client for the WebExtract API: web page to clean Markdown + fixed-schema JSON for AI agents. Prepaid key, free tier, or pay per call with x402.
+Project-URL: Homepage, https://webextract.dev
+Project-URL: Documentation, https://webextract.dev/docs
+Project-URL: Source, https://github.com/nyx464664816-stack/webextract
+Project-URL: Issues, https://github.com/nyx464664816-stack/webextract/issues
+Author: TAINCHENG, L.L.C.
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai-agents,extraction,llm,markdown,mcp,web-scraping,webextract,x402
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: httpx<1,>=0.27
+Provides-Extra: x402
+Requires-Dist: x402[evm,httpx]<3,>=2.25; extra == 'x402'
+Description-Content-Type: text/markdown
+
+# webextract-sdk (Python)
+
+Thin client for the [WebExtract](https://webextract.dev) API: a public web page in, clean Markdown plus fixed-schema JSON out (article metadata, product and price, tables). It's built for AI agents.
+
+```bash
+pip install webextract-sdk            # core (httpx only)
+pip install "webextract-sdk[x402]"    # + the official x402 SDK, for pay-per-call
+```
+
+The PyPI name is `webextract-sdk`; the import name is `webextract` (`from webextract import WebExtract`).
+
+## Billing: pick one
+
+| Mode | How | Cost |
+|---|---|---|
+| Free tier (default) | `WebExtract()` sends `X-Billing: free` (when `WEBEXTRACT_API_KEY` is not set) | 50 calls/day per IP (shared with MCP) |
+| Prepaid credits | `WebExtract(api_key="lx_...")` or env `WEBEXTRACT_API_KEY` → `Authorization: Bearer` | `/v1/extract` 1 credit, `/v1/markdown` 0.4 credit. Buy at https://webextract.dev/#pricing |
+| x402 pay per call | `AsyncWebExtract(payment_client=x402HttpxClient(...))` | `/v1/extract` $0.005, `/v1/markdown` $0.002 in USDC on Base and 6 other chains |
+| x402 sandbox | add `billing="x402-testnet"` | Base Sepolia **test** USDC only. Nothing real is charged |
+
+**This package never handles private keys.** With x402, signing happens inside the client you build with the official `x402` SDK.
+
+```python
+from webextract import WebExtract, PaymentRequiredError, TargetFetchError
+
+with WebExtract() as we:                      # free tier
+    r = we.extract("https://web-scraping.dev/product/1")
+    print(r.data["product"], r.meta.free_remaining)
+```
+
+### x402 (async, official SDK)
+
+```python
+import asyncio, os
+from eth_account import Account
+from x402 import x402Client
+from x402.http.clients import x402HttpxClient
+from x402.mechanisms.evm.exact import ExactEvmScheme
+from webextract import AsyncWebExtract
+
+async def main():
+    signer = Account.from_key(os.environ["X402_PRIVATE_KEY"])    # your key, your process
+    xc = x402Client(); xc.register("eip155:8453", ExactEvmScheme(signer=signer))
+    async with x402HttpxClient(xc, timeout=60) as pay:
+        we = AsyncWebExtract(payment_client=pay)                 # billing="x402"
+        r = await we.markdown("https://example.com")
+        print(r.meta.payment_response)                           # settlement receipt (tx hash)
+asyncio.run(main())
+```
+
+**`WEBEXTRACT_API_KEY`**: if `api_key` isn't passed, the client reads this environment variable. An explicit `api_key` always wins. The variable is ignored when `payment_client` is given or `billing` is anything other than `"key"`, so it never causes the "api_key + payment_client" error.
+
+**`settlement_retries`** (default `1`): a 402 `settlement_failed` (payment verified, not settled, **not charged**) is retried once, and the payment client signs a fresh payment. Other errors are never retried.
+
+For a sync client, pass the `requests.Session` from `x402.http.clients.x402_requests(xc)` as `payment_client=`. The x402 SDK has no sync httpx client.
+
+## Errors
+
+Every error is a `WebExtractError` with `status`, `code`, `message`, `charged`, `retryable`, `body`.
+
+| Class | When | Notes |
+|---|---|---|
+| `PaymentRequiredError` | HTTP 402 | `.reason` is one of `x402_required`, `x402_requested`, `free_limit_reached`, `invalid_payment`, `unsupported_network`, `settlement_failed` (retryable), `no_credits`. Also has `.networks`, `.payment_required` (decoded header), `.buy_url`, `.free_remaining`, `.hint` |
+| `TargetFetchError` | target page failed: `upstream_error`, `blocked_by_site` (422), `robots_disallowed` (451), `dns_failed`, `fetch_failed`, `too_large`, `unsupported_type` | never charged |
+| `InvalidRequestError` | 400 (`missing_url`, `invalid_url`, `forbidden_host`, ...) or client-side URL check | never charged |
+| `AuthenticationError` | 401 `invalid_api_key` | |
+| `RateLimitError` | 429 (sandbox limits) | `.retry_after` |
+| `ConnectionError` | no response: network error, timeout, or the payment client raised | `code` is `timeout` or `connection_error` |
+
+## Response fields
+
+The responses are the API JSON as-is (`schema_version` "1.0"). Fields added on 2026-10-21 (`content_source`, `product.price_detail`, `product_unresolved`) may be missing on older deployments, so read them with `.get()`. A missing price is never reported as `0`. `price_detail.unresolved.reason` says why it's missing.
+
+License: MIT © TAINCHENG, L.L.C.

webextract_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+webextract/__init__.py,sha256=X0YKasEcjbuAb76U645SI-HsOvdqaga_vmSALmFWgzk,1430
+webextract/_client.py,sha256=kZgJcBmkpqDaBr__QIc3g98c-r_VYgg6OL3oEZwpsqU,13767
+webextract/_errors.py,sha256=pH7hqJRRbQt4P_9bbTDJpaD-t9n-oQfv6B7EaLbTEZQ,4037
+webextract/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+webextract_sdk-0.1.0.dist-info/METADATA,sha256=vSPuraeK5vrR_1MUKthyI6_LeEBgwQ-xaTFOUBsbrNk,5308
+webextract_sdk-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+webextract_sdk-0.1.0.dist-info/licenses/LICENSE,sha256=hXkDs6G0olq1DFC3W5VBplfPxLDpKDauCGXAhOEOdUM,1074
+webextract_sdk-0.1.0.dist-info/RECORD,,

webextract_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

webextract_sdk-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TAINCHENG, L.L.C.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.