getanyapi 0.1.0__tar.gz → 0.7.0__tar.gz

{getanyapi-0.1.0 → getanyapi-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: getanyapi
-Version: 0.1.0
+Version: 0.7.0
 Summary: Official typed Python SDK for AnyAPI: any API, one wallet, USD, no subscriptions.
 Project-URL: Homepage, https://getanyapi.com
 Project-URL: Documentation, https://getanyapi.com/docs
@@ -44,8 +44,9 @@ from getanyapi import AnyAPI
 
 client = AnyAPI()  # reads ANYAPI_API_KEY from the environment
 res = client.reddit.search(query="mechanical keyboard")
-for post in res.output.posts:
-    print(post.title, post.score)
+if res.output.found:
+    for post in res.output.data.posts:
+        print(post.title, post.score)
 print("charged", res.cost_usd, "USD")
 ```
 
@@ -82,9 +83,22 @@ except ResultNotFoundError:
 ```
 
 `ResultNotFoundError` subclasses `NotFoundError`, so `except NotFoundError` catches both an
-HTTP 404 and an empty result; catch `ResultNotFoundError` to handle only empty results. A few
-SKUs (e.g. `reddit.search`) return their data object directly as `output` with no `found`
-wrapper; `unwrap` returns it as-is and never raises for those.
+HTTP 404 and an empty result; catch `ResultNotFoundError` to handle only empty results. If a
+future committed schema uses a bare output, generated typing returns its data object directly
+rather than relying on a hard-coded SKU list.
+
+## Discovery
+
+```python
+apis = client.catalog(category="search")
+matches = client.search(query="web search", platform="google", limit=10)
+api = client.describe(matches.results[0].slug)
+print(api.pricing.from_offer, api.pricing.failover_max_usd, api.input_schema)
+```
+
+Sync and async clients expose the same category-only `catalog`, dedicated ranked `search`, and
+schema-bearing `describe` methods. Prices are nested USD flat/linear offers, lanes are
+anonymous, and provider is always `"AnyAPI"`.
 
 ## Pagination
 
@@ -115,17 +129,17 @@ res = client.google.search(
 
 ## Errors and retries
 
-| Class | HTTP | Meaning |
-| --- | --- | --- |
-| `BadRequestError` | 400 | Input failed validation |
-| `AuthenticationError` | 401 | Missing or invalid API key |
-| `InsufficientBalanceError` | 402 | Wallet balance or per-key cap exceeded |
-| `NotFoundError` | 404 | Slug or resource does not exist |
-| `ResultNotFoundError` | - | `unwrap` on an empty found-data result |
-| `RateLimitedError` | 429 | Too many requests (retried automatically) |
-| `UpstreamError` | 502 | An upstream backend failed |
-| `ConnectionError` | 0 | Network or transport failure (retried) |
-| `TimeoutError` | 0 | Request exceeded its timeout (not retried) |
+| Class                      | HTTP | Meaning                                    |
+| -------------------------- | ---- | ------------------------------------------ |
+| `BadRequestError`          | 400  | Input failed validation                    |
+| `AuthenticationError`      | 401  | Missing or invalid API key                 |
+| `InsufficientBalanceError` | 402  | Wallet balance or per-key cap exceeded     |
+| `NotFoundError`            | 404  | Slug or resource does not exist            |
+| `ResultNotFoundError`      | -    | `unwrap` on an empty found-data result     |
+| `RateLimitedError`         | 429  | Too many requests (retried automatically)  |
+| `UpstreamError`            | 502  | An upstream backend failed                 |
+| `ConnectionError`          | 0    | Network or transport failure (retried)     |
+| `TimeoutError`             | 0    | Request exceeded its timeout (not retried) |
 
 All extend `AnyAPIError` (with `.status` and `.request_id`). Retries cover only 429 and network
 failures, with jittered exponential backoff honoring `Retry-After`. Default `max_retries` is 2
@@ -143,7 +157,7 @@ result = agent_signup(label="my-agent")
 client = AnyAPI(api_key=result.secret)
 ```
 
-The key ships with a small starter credit and a per-key spend cap; a human funds it by claiming
+The key ships with a small starter balance and a per-key spend cap; a human funds it by claiming
 it at `result.claim_url`.
 
 ## Docs

{getanyapi-0.1.0 → getanyapi-0.7.0}/README.md

@@ -15,8 +15,9 @@ from getanyapi import AnyAPI
 
 client = AnyAPI()  # reads ANYAPI_API_KEY from the environment
 res = client.reddit.search(query="mechanical keyboard")
-for post in res.output.posts:
-    print(post.title, post.score)
+if res.output.found:
+    for post in res.output.data.posts:
+        print(post.title, post.score)
 print("charged", res.cost_usd, "USD")
 ```
 
@@ -53,9 +54,22 @@ except ResultNotFoundError:
 ```
 
 `ResultNotFoundError` subclasses `NotFoundError`, so `except NotFoundError` catches both an
-HTTP 404 and an empty result; catch `ResultNotFoundError` to handle only empty results. A few
-SKUs (e.g. `reddit.search`) return their data object directly as `output` with no `found`
-wrapper; `unwrap` returns it as-is and never raises for those.
+HTTP 404 and an empty result; catch `ResultNotFoundError` to handle only empty results. If a
+future committed schema uses a bare output, generated typing returns its data object directly
+rather than relying on a hard-coded SKU list.
+
+## Discovery
+
+```python
+apis = client.catalog(category="search")
+matches = client.search(query="web search", platform="google", limit=10)
+api = client.describe(matches.results[0].slug)
+print(api.pricing.from_offer, api.pricing.failover_max_usd, api.input_schema)
+```
+
+Sync and async clients expose the same category-only `catalog`, dedicated ranked `search`, and
+schema-bearing `describe` methods. Prices are nested USD flat/linear offers, lanes are
+anonymous, and provider is always `"AnyAPI"`.
 
 ## Pagination
 
@@ -86,17 +100,17 @@ res = client.google.search(
 
 ## Errors and retries
 
-| Class | HTTP | Meaning |
-| --- | --- | --- |
-| `BadRequestError` | 400 | Input failed validation |
-| `AuthenticationError` | 401 | Missing or invalid API key |
-| `InsufficientBalanceError` | 402 | Wallet balance or per-key cap exceeded |
-| `NotFoundError` | 404 | Slug or resource does not exist |
-| `ResultNotFoundError` | - | `unwrap` on an empty found-data result |
-| `RateLimitedError` | 429 | Too many requests (retried automatically) |
-| `UpstreamError` | 502 | An upstream backend failed |
-| `ConnectionError` | 0 | Network or transport failure (retried) |
-| `TimeoutError` | 0 | Request exceeded its timeout (not retried) |
+| Class                      | HTTP | Meaning                                    |
+| -------------------------- | ---- | ------------------------------------------ |
+| `BadRequestError`          | 400  | Input failed validation                    |
+| `AuthenticationError`      | 401  | Missing or invalid API key                 |
+| `InsufficientBalanceError` | 402  | Wallet balance or per-key cap exceeded     |
+| `NotFoundError`            | 404  | Slug or resource does not exist            |
+| `ResultNotFoundError`      | -    | `unwrap` on an empty found-data result     |
+| `RateLimitedError`         | 429  | Too many requests (retried automatically)  |
+| `UpstreamError`            | 502  | An upstream backend failed                 |
+| `ConnectionError`          | 0    | Network or transport failure (retried)     |
+| `TimeoutError`             | 0    | Request exceeded its timeout (not retried) |
 
 All extend `AnyAPIError` (with `.status` and `.request_id`). Retries cover only 429 and network
 failures, with jittered exponential backoff honoring `Retry-After`. Default `max_retries` is 2
@@ -114,7 +128,7 @@ result = agent_signup(label="my-agent")
 client = AnyAPI(api_key=result.secret)
 ```
 
-The key ships with a small starter credit and a per-key spend cap; a human funds it by claiming
+The key ships with a small starter balance and a per-key spend cap; a human funds it by claiming
 it at `result.claim_url`.
 
 ## Docs

{getanyapi-0.1.0 → getanyapi-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "getanyapi"
-version = "0.1.0"
+version = "0.7.0"
 description = "Official typed Python SDK for AnyAPI: any API, one wallet, USD, no subscriptions."
 readme = "README.md"
 requires-python = ">=3.10"

{getanyapi-0.1.0 → getanyapi-0.7.0}/src/getanyapi/__init__.py

@@ -32,15 +32,24 @@ from .types import (
     Balance,
     BareRunResult,
     CatalogEntry,
+    CatalogSearchResult,
+    CatalogSearchResults,
+    DiscoveryLane,
+    DiscoveryPricing,
+    FlatPricingOffer,
+    HighlightField,
+    LaneHealth,
+    LinearPricingOffer,
     Output,
     OutputFound,
     OutputNotFound,
+    PricingOffer,
     RequestOptions,
     RunResult,
     unwrap,
 )
 
-__version__ = "0.0.0"
+__version__ = "0.7.0"
 
 __all__ = [
     # clients + top-level functions
@@ -57,6 +66,15 @@ __all__ = [
     "Balance",
     "AccountProfile",
     "CatalogEntry",
+    "FlatPricingOffer",
+    "LinearPricingOffer",
+    "PricingOffer",
+    "DiscoveryPricing",
+    "LaneHealth",
+    "DiscoveryLane",
+    "HighlightField",
+    "CatalogSearchResult",
+    "CatalogSearchResults",
     "RequestOptions",
     "AgentSignupResult",
     # pagination

getanyapi-0.7.0/src/getanyapi/_account.py

@@ -0,0 +1,144 @@
+"""Account, catalog, and agent-signup request/response mapping (SPEC 2.7, 3.7).
+
+Pure functions that build the HTTP request pieces and map raw JSON bodies into
+the public models. The sync and async clients share these so the wire mapping
+lives in one place. Discovery bodies are validated against the customer-safe
+nested USD contract before any public model is returned.
+"""
+
+from __future__ import annotations
+
+from typing import Any, cast
+
+from ._errors import AnyAPIError, error_for_status
+from ._transport import as_dict, error_message
+from .types import (
+    AccountProfile,
+    AgentSignupResult,
+    Balance,
+    CatalogEntry,
+    CatalogSearchResults,
+)
+
+__all__ = [
+    "balance_path",
+    "me_path",
+    "catalog_request",
+    "search_request",
+    "describe_path",
+    "signup_request",
+    "parse_balance",
+    "parse_me",
+    "parse_catalog",
+    "parse_describe",
+    "parse_search",
+    "parse_signup",
+    "map_error",
+]
+
+balance_path = "/v1/balance"
+me_path = "/v1/me"
+
+
+def catalog_request(category: str | None) -> tuple[str, dict[str, str]]:
+    """Path and query params for ``catalog()`` (GET /v1/apis)."""
+    params: dict[str, str] = {}
+    if category is not None:
+        params["category"] = category
+    return "/v1/apis", params
+
+
+def search_request(
+    query: str,
+    category: str | None,
+    platform: str | None,
+    limit: int | None,
+) -> tuple[str, dict[str, str]]:
+    """Path and query params for dedicated ranked discovery search."""
+    params = {"q": query}
+    if category is not None:
+        params["category"] = category
+    if platform is not None:
+        params["platform"] = platform
+    if limit is not None:
+        params["limit"] = str(limit)
+    return "/catalog/search", params
+
+
+def describe_path(slug: str) -> str:
+    return f"/v1/apis/{slug}"
+
+
+def signup_request(sponsor_email: str | None, label: str | None) -> dict[str, Any]:
+    """JSON body for ``agent_signup()`` (POST /agent/signup, no auth)."""
+    body: dict[str, Any] = {}
+    if sponsor_email is not None:
+        body["sponsorEmail"] = sponsor_email
+    if label is not None:
+        body["label"] = label
+    return body
+
+
+def parse_balance(body: Any) -> Balance:
+    return Balance.model_validate(body)
+
+
+def parse_me(body: Any) -> AccountProfile:
+    """Map /v1/me, dropping clerkUserId and signupGrantApplied (SPEC 2.7)."""
+    return AccountProfile.model_validate(body)
+
+
+def _reject_internal_keys(value: object, path: str) -> None:
+    if isinstance(value, list):
+        for index, item in enumerate(cast("list[object]", value)):
+            _reject_internal_keys(item, f"{path}[{index}]")
+        return
+    if not isinstance(value, dict):
+        return
+    for key, item in cast("dict[object, object]", value).items():
+        if isinstance(key, str) and "credit" in key.lower():
+            raise ValueError(f"malformed discovery response: {path}.{key}")
+        _reject_internal_keys(item, f"{path}.{key}")
+
+
+def _require_exact_keys(value: dict[str, object], allowed: set[str], path: str) -> None:
+    unexpected = set(value) - allowed
+    if unexpected:
+        key = sorted(unexpected)[0]
+        raise ValueError(f"malformed discovery response: {path}.{key}")
+
+
+def parse_catalog(body: object) -> list[CatalogEntry]:
+    """Map {apis:[...]} into CatalogEntry[] (SPEC 2.7)."""
+    _reject_internal_keys(body, "catalog")
+    envelope = as_dict(body)
+    _require_exact_keys(envelope, {"apis"}, "catalog")
+    raw = envelope.get("apis")
+    if not isinstance(raw, list):
+        raise ValueError("malformed discovery response: catalog.apis")
+    apis: list[object] = list(cast("list[object]", raw))
+    return [CatalogEntry.model_validate(item, strict=True) for item in apis]
+
+
+def parse_describe(body: object) -> CatalogEntry:
+    """Map a single /v1/apis/{slug} entry into one CatalogEntry."""
+    _reject_internal_keys(body, "api")
+    entry = CatalogEntry.model_validate(body, strict=True)
+    if entry.input_schema is None or entry.output_schema is None:
+        raise ValueError("malformed discovery response: detail schemas are required")
+    return entry
+
+
+def parse_search(body: object) -> CatalogSearchResults:
+    """Validate the dedicated search result envelope."""
+    _reject_internal_keys(body, "search")
+    return CatalogSearchResults.model_validate(body, strict=True)
+
+
+def parse_signup(body: Any) -> AgentSignupResult:
+    return AgentSignupResult.model_validate(body)
+
+
+def map_error(status: int, body: object, request_id: str | None) -> AnyAPIError:
+    """Map a non-2xx account/catalog response to the frozen error hierarchy."""
+    return error_for_status(status, error_message(body, status), request_id=request_id)

{getanyapi-0.1.0 → getanyapi-0.7.0}/src/getanyapi/_async_client.py

@@ -30,6 +30,7 @@ from .types import (
     AccountProfile,
     Balance,
     CatalogEntry,
+    CatalogSearchResults,
     RequestOptions,
     RunResult,
 )
@@ -42,9 +43,7 @@ _DEFAULT_BASE_URL = "https://api.getanyapi.com"
 def _resolve_api_key(api_key: str | None) -> str:
     key = api_key if api_key is not None else os.environ.get("ANYAPI_API_KEY")
     if not key:
-        raise AnyAPIError(
-            "no API key: pass api_key= or set ANYAPI_API_KEY", status=0
-        )
+        raise AnyAPIError("no API key: pass api_key= or set ANYAPI_API_KEY", status=0)
     return key
 
 
@@ -129,9 +128,7 @@ class AsyncAnyAPI:
                     continue
                 raise
             except httpx.TimeoutException as exc:
-                raise TimeoutError(
-                    str(exc) or "request timed out", status=0
-                ) from exc
+                raise TimeoutError(str(exc) or "request timed out", status=0) from exc
             except httpx.HTTPError as exc:
                 if retry.can_retry:
                     await asyncio.sleep(retry.next_delay(None))
@@ -162,17 +159,13 @@ class AsyncAnyAPI:
 
     # -- account + catalog ------------------------------------------------
 
-    async def _get(
-        self, path: str, params: dict[str, str] | None = None
-    ) -> object:
+    async def _get(self, path: str, params: dict[str, str] | None = None) -> object:
         url = f"{self._base_url}{path}"
         headers = {
             "Authorization": f"Bearer {self._api_key}",
             "Accept": "application/json",
         }
-        response = await self._http.get(
-            url, params=params or {}, headers=headers
-        )
+        response = await self._http.get(url, params=params or {}, headers=headers)
         return self._json_or_raise(response)
 
     def _json_or_raise(self, response: httpx.Response) -> object:
@@ -192,12 +185,21 @@ class AsyncAnyAPI:
     async def me(self) -> AccountProfile:
         return _account.parse_me(await self._get(_account.me_path))
 
-    async def catalog(
-        self, *, query: str | None = None, category: str | None = None
-    ) -> list[CatalogEntry]:
-        path, params = _account.catalog_request(query, category)
+    async def catalog(self, *, category: str | None = None) -> list[CatalogEntry]:
+        path, params = _account.catalog_request(category)
         return _account.parse_catalog(await self._get(path, params))
 
+    async def search(
+        self,
+        *,
+        query: str,
+        category: str | None = None,
+        platform: str | None = None,
+        limit: int | None = None,
+    ) -> CatalogSearchResults:
+        path, params = _account.search_request(query, category, platform, limit)
+        return _account.parse_search(await self._get(path, params))
+
     async def describe(self, slug: str) -> CatalogEntry:
         body = await self._get(_account.describe_path(slug))
         return _account.parse_describe(body)

{getanyapi-0.1.0 → getanyapi-0.7.0}/src/getanyapi/_client.py

@@ -49,6 +49,7 @@ from .types import (
     AgentSignupResult,
     Balance,
     CatalogEntry,
+    CatalogSearchResults,
     RequestOptions,
     RunResult,
 )
@@ -71,9 +72,7 @@ def lookup_namespace(name: str) -> tuple[str, str, str] | None:
 def _resolve_api_key(api_key: str | None) -> str:
     key = api_key if api_key is not None else os.environ.get("ANYAPI_API_KEY")
     if not key:
-        raise AnyAPIError(
-            "no API key: pass api_key= or set ANYAPI_API_KEY", status=0
-        )
+        raise AnyAPIError("no API key: pass api_key= or set ANYAPI_API_KEY", status=0)
     return key
 
 
@@ -164,9 +163,7 @@ class AnyAPI:
                     continue
                 raise
             except httpx.TimeoutException as exc:
-                raise TimeoutError(
-                    str(exc) or "request timed out", status=0
-                ) from exc
+                raise TimeoutError(str(exc) or "request timed out", status=0) from exc
             except httpx.HTTPError as exc:
                 if retry.can_retry:
                     _transport.sleep(retry.next_delay(None))
@@ -223,12 +220,21 @@ class AnyAPI:
     def me(self) -> AccountProfile:
         return _account.parse_me(self._get(_account.me_path))
 
-    def catalog(
-        self, *, query: str | None = None, category: str | None = None
-    ) -> list[CatalogEntry]:
-        path, params = _account.catalog_request(query, category)
+    def catalog(self, *, category: str | None = None) -> list[CatalogEntry]:
+        path, params = _account.catalog_request(category)
         return _account.parse_catalog(self._get(path, params))
 
+    def search(
+        self,
+        *,
+        query: str,
+        category: str | None = None,
+        platform: str | None = None,
+        limit: int | None = None,
+    ) -> CatalogSearchResults:
+        path, params = _account.search_request(query, category, platform, limit)
+        return _account.parse_search(self._get(path, params))
+
     def describe(self, slug: str) -> CatalogEntry:
         return _account.parse_describe(self._get(_account.describe_path(slug)))
 

{getanyapi-0.1.0 → getanyapi-0.7.0}/src/getanyapi/platforms/__init__.py

@@ -13,6 +13,7 @@ REGISTRY: dict[str, tuple[str, str, str]] = {
     "airbnb": ("airbnb", "AirbnbNamespace", "AsyncAirbnbNamespace"),
     "alibaba": ("alibaba", "AlibabaNamespace", "AsyncAlibabaNamespace"),
     "amazon": ("amazon", "AmazonNamespace", "AsyncAmazonNamespace"),
+    "apollo": ("apollo", "ApolloNamespace", "AsyncApolloNamespace"),
     "appstore": ("appstore", "AppstoreNamespace", "AsyncAppstoreNamespace"),
     "bluesky": ("bluesky", "BlueskyNamespace", "AsyncBlueskyNamespace"),
     "booking": ("booking", "BookingNamespace", "AsyncBookingNamespace"),
@@ -23,6 +24,7 @@ REGISTRY: dict[str, tuple[str, str, str]] = {
     ),
     "congress": ("congress", "CongressNamespace", "AsyncCongressNamespace"),
     "dexscreener": ("dexscreener", "DexscreenerNamespace", "AsyncDexscreenerNamespace"),
+    "douyin": ("douyin", "DouyinNamespace", "AsyncDouyinNamespace"),
     "ebay": ("ebay", "EbayNamespace", "AsyncEbayNamespace"),
     "email": ("email", "EmailNamespace", "AsyncEmailNamespace"),
     "facebook": ("facebook", "FacebookNamespace", "AsyncFacebookNamespace"),
@@ -61,6 +63,7 @@ REGISTRY: dict[str, tuple[str, str, str]] = {
     "rednote": ("rednote", "RednoteNamespace", "AsyncRednoteNamespace"),
     "sec": ("sec", "SecNamespace", "AsyncSecNamespace"),
     "semrush": ("semrush", "SemrushNamespace", "AsyncSemrushNamespace"),
+    "seo": ("seo", "SeoNamespace", "AsyncSeoNamespace"),
     "snapchat": ("snapchat", "SnapchatNamespace", "AsyncSnapchatNamespace"),
     "social": ("social", "SocialNamespace", "AsyncSocialNamespace"),
     "spotify": ("spotify", "SpotifyNamespace", "AsyncSpotifyNamespace"),
@@ -75,6 +78,7 @@ REGISTRY: dict[str, tuple[str, str, str]] = {
     "upwork": ("upwork", "UpworkNamespace", "AsyncUpworkNamespace"),
     "walmart": ("walmart", "WalmartNamespace", "AsyncWalmartNamespace"),
     "web": ("web", "WebNamespace", "AsyncWebNamespace"),
+    "weibo": ("weibo", "WeiboNamespace", "AsyncWeiboNamespace"),
     "whatsapp": ("whatsapp", "WhatsappNamespace", "AsyncWhatsappNamespace"),
     "yahoo_finance": (
         "yahoo_finance",
@@ -83,6 +87,7 @@ REGISTRY: dict[str, tuple[str, str, str]] = {
     ),
     "yelp": ("yelp", "YelpNamespace", "AsyncYelpNamespace"),
     "youtube": ("youtube", "YoutubeNamespace", "AsyncYoutubeNamespace"),
+    "zhihu": ("zhihu", "ZhihuNamespace", "AsyncZhihuNamespace"),
     "zillow": ("zillow", "ZillowNamespace", "AsyncZillowNamespace"),
 }