getanyapi 0.1.0__py3-none-any.whl

getanyapi/platforms/upwork.py

@@ -0,0 +1,119 @@
+# Generated - do not edit. Regenerate with: pnpm generate
+"""Generated namespace module for the upwork platform."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import NotRequired, Required, TypedDict, Unpack
+
+from ..types import RequestOptions, RunResult
+
+if TYPE_CHECKING:
+    from .._async_client import AsyncAnyAPI
+    from .._client import AnyAPI
+
+
+class UpworkJobsInput(TypedDict, total=False):
+    """Input for Upwork Jobs."""
+
+    limit: NotRequired[int]
+    """Maximum number of results to return (1-25, default 25). You are billed per result returned, so a lower limit costs less. Range: 1 to 25."""
+    query: Required[str]
+    """Keywords to search Upwork jobs for (e.g. react developer)."""
+    sort: NotRequired[str]
+    """Sort order for listings: newest or relevance (e.g. newest). Default: newest."""
+
+
+class UpworkJobsData(BaseModel):
+    items: list[UpworkJobsItem] = Field(
+        description="Job records: title, description, budget or hourly rate, required skills, posted date, and client details."
+    )
+
+
+class UpworkJobsItem(BaseModel):
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    budget: str | None = Field(
+        default=None, description="Fixed budget or hourly range."
+    )
+    client_location: str | None = Field(default=None, alias="clientLocation")
+    client_rating: float | None = Field(default=None, alias="clientRating")
+    client_total_spent: float | None = Field(
+        default=None,
+        alias="clientTotalSpent",
+        description="Client lifetime spend (USD).",
+    )
+    description: str | None = Field(
+        default=None, description="Present whenever the upstream returns this record."
+    )
+    experience_level: str | None = Field(default=None, alias="experienceLevel")
+    job_id: str = Field(alias="jobId", description="Upwork job identifier.")
+    job_type: str | None = Field(
+        default=None, alias="jobType", description="Fixed or Hourly."
+    )
+    payment_verified: bool | None = Field(
+        default=None,
+        alias="paymentVerified",
+        description="Whether the client's payment method is verified; null when Upwork reports it as unknown.",
+    )
+    posted_at: str | None = Field(
+        default=None, alias="postedAt", description="ISO 8601 posting date."
+    )
+    proposals: int | None = Field(
+        default=None, description="Number of proposals submitted."
+    )
+    tags: list[str] | None = Field(default=None, description="Skill tags.")
+    title: str
+    url: str = Field(description="Upwork job posting URL.")
+
+
+class UpworkNamespace:
+    """Typed methods for this platform. Attached lazily to the client."""
+
+    def __init__(self, client: "AnyAPI") -> None:
+        self._client = client
+
+    def jobs(
+        self, *, options: RequestOptions | None = None, **input: Unpack[UpworkJobsInput]
+    ) -> RunResult[UpworkJobsData]:
+        """Upwork Jobs
+
+        Search Upwork job postings by keyword - up to 25 fresh listings per request
+        with transparent per-request USD pricing.
+
+        Price: $0.0033 per result.
+
+        Example:
+            res = client.upwork.jobs(limit=10, query="web developer")
+        """
+        raw = self._client._run_raw(  # pyright: ignore[reportPrivateUsage]
+            "upwork.jobs", dict(input), options
+        )
+        return RunResult[UpworkJobsData].model_validate(raw)
+
+
+class AsyncUpworkNamespace:
+    """Typed methods for this platform. Attached lazily to the client."""
+
+    def __init__(self, client: "AsyncAnyAPI") -> None:
+        self._client = client
+
+    async def jobs(
+        self, *, options: RequestOptions | None = None, **input: Unpack[UpworkJobsInput]
+    ) -> RunResult[UpworkJobsData]:
+        """Upwork Jobs
+
+        Search Upwork job postings by keyword - up to 25 fresh listings per request
+        with transparent per-request USD pricing.
+
+        Price: $0.0033 per result.
+
+        Example:
+            res = client.upwork.jobs(limit=10, query="web developer")
+        """
+        raw = await self._client._arun_raw(  # pyright: ignore[reportPrivateUsage]
+            "upwork.jobs", dict(input), options
+        )
+        return RunResult[UpworkJobsData].model_validate(raw)

getanyapi/platforms/walmart.py

@@ -0,0 +1,93 @@
+# Generated - do not edit. Regenerate with: pnpm generate
+"""Generated namespace module for the walmart platform."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import Required, TypedDict, Unpack
+
+from ..types import RequestOptions, RunResult
+
+if TYPE_CHECKING:
+    from .._async_client import AsyncAnyAPI
+    from .._client import AnyAPI
+
+
+class WalmartProductInput(TypedDict, total=False):
+    """Input for Walmart Product."""
+
+    url: Required[str]
+    """Walmart product page URL."""
+
+
+class WalmartProductData(BaseModel):
+    items: list[WalmartProductItem] = Field(
+        description="Product detail records: title, price, availability, rating, review count, images, and specifications."
+    )
+
+
+class WalmartProductItem(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    title: str
+    url: str
+
+
+class WalmartNamespace:
+    """Typed methods for this platform. Attached lazily to the client."""
+
+    def __init__(self, client: "AnyAPI") -> None:
+        self._client = client
+
+    def product(
+        self,
+        *,
+        options: RequestOptions | None = None,
+        **input: Unpack[WalmartProductInput],
+    ) -> RunResult[WalmartProductData]:
+        """Walmart Product
+
+        Fetch a Walmart product page by URL and get full product details - title,
+        price, availability, ratings, images, and specs - in one normalized,
+        flat-priced response.
+
+        Price: $0.00368 per result.
+
+        Example:
+            res = client.walmart.product(url="https://www.walmart.com/ip/Apple-AirPods-Pro-2/5689919121")
+        """
+        raw = self._client._run_raw(  # pyright: ignore[reportPrivateUsage]
+            "walmart.product", dict(input), options
+        )
+        return RunResult[WalmartProductData].model_validate(raw)
+
+
+class AsyncWalmartNamespace:
+    """Typed methods for this platform. Attached lazily to the client."""
+
+    def __init__(self, client: "AsyncAnyAPI") -> None:
+        self._client = client
+
+    async def product(
+        self,
+        *,
+        options: RequestOptions | None = None,
+        **input: Unpack[WalmartProductInput],
+    ) -> RunResult[WalmartProductData]:
+        """Walmart Product
+
+        Fetch a Walmart product page by URL and get full product details - title,
+        price, availability, ratings, images, and specs - in one normalized,
+        flat-priced response.
+
+        Price: $0.00368 per result.
+
+        Example:
+            res = client.walmart.product(url="https://www.walmart.com/ip/Apple-AirPods-Pro-2/5689919121")
+        """
+        raw = await self._client._arun_raw(  # pyright: ignore[reportPrivateUsage]
+            "walmart.product", dict(input), options
+        )
+        return RunResult[WalmartProductData].model_validate(raw)

getanyapi/platforms/web.py

@@ -0,0 +1,264 @@
+# Generated - do not edit. Regenerate with: pnpm generate
+"""Generated namespace module for the web platform."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import NotRequired, Required, TypedDict, Unpack
+
+from ..types import RequestOptions, RunResult
+
+if TYPE_CHECKING:
+    from .._async_client import AsyncAnyAPI
+    from .._client import AnyAPI
+
+
+class WebCrawlInput(TypedDict, total=False):
+    """Input for Website Crawl."""
+
+    limit: NotRequired[int]
+    """Maximum number of results to return (1-10, default 10). You are billed per result returned, so a lower limit costs less. Range: 1 to 10."""
+    url: Required[str]
+    """The website URL or domain to crawl."""
+
+
+class WebMapInput(TypedDict, total=False):
+    """Input for Web Map."""
+
+    limit: NotRequired[int]
+    """Maximum number of links to return. Default: 100."""
+    search: NotRequired[str]
+    """Optional term that orders the returned links by relevance."""
+    url: Required[str]
+    """The base URL of the site to map into a list of links."""
+
+
+class WebScrapeInput(TypedDict, total=False):
+    """Input for Web Scrape."""
+
+    url: Required[str]
+    """The URL of the page to scrape."""
+
+
+class WebScreenshotInput(TypedDict, total=False):
+    """Input for Website Screenshot."""
+
+    url: Required[str]
+    """The full URL of the page to capture."""
+    viewportWidth: NotRequired[int]
+    """Browser viewport width in pixels (e.g. 1280). Default: 1280."""
+
+
+class WebCrawlData(BaseModel):
+    items: list[WebCrawlItem] = Field(
+        description="Crawled page records: URL, page title, and extracted text content for each page."
+    )
+
+
+class WebCrawlItem(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    domain: str
+    text: str
+
+
+class WebMapData(BaseModel):
+    results: list[WebMapResult]
+
+
+class WebMapResult(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    description: str
+    title: str
+    url: str
+
+
+class WebScrapeData(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    description: str
+    markdown: str
+    title: str
+    url: str
+
+
+class WebScreenshotData(BaseModel):
+    items: list[WebScreenshotItem] = Field(
+        description="Screenshot records: the requested page URL and a link to the captured image."
+    )
+
+
+class WebScreenshotItem(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    image: str | None = Field(
+        default=None, description="Present whenever the upstream returns this record."
+    )
+    url: str
+
+
+class WebNamespace:
+    """Typed methods for this platform. Attached lazily to the client."""
+
+    def __init__(self, client: "AnyAPI") -> None:
+        self._client = client
+
+    def crawl(
+        self, *, options: RequestOptions | None = None, **input: Unpack[WebCrawlInput]
+    ) -> RunResult[WebCrawlData]:
+        """Website Crawl
+
+        Crawl a website and get clean text content from up to 10 pages in one
+        normalized response - ideal for feeding sites into LLMs and search indexes.
+
+        Price: $0.0015 per request plus $0.003 per result.
+
+        Example:
+            res = client.web.crawl(limit=3, url="https://example.com")
+        """
+        raw = self._client._run_raw(  # pyright: ignore[reportPrivateUsage]
+            "web.crawl", dict(input), options
+        )
+        return RunResult[WebCrawlData].model_validate(raw)
+
+    def map(
+        self, *, options: RequestOptions | None = None, **input: Unpack[WebMapInput]
+    ) -> RunResult[WebMapData]:
+        """Web Map
+
+        Map an entire website into a clean list of its URLs (with titles and
+        descriptions) in a single call. Billed per request in real dollars.
+
+        Price: $0.0009 per request.
+
+        Example:
+            res = client.web.map(url="https://example.com")
+        """
+        raw = self._client._run_raw(  # pyright: ignore[reportPrivateUsage]
+            "web.map", dict(input), options
+        )
+        return RunResult[WebMapData].model_validate(raw)
+
+    def scrape(
+        self, *, options: RequestOptions | None = None, **input: Unpack[WebScrapeInput]
+    ) -> RunResult[WebScrapeData]:
+        """Web Scrape
+
+        Scrape any web page and get its main content back as clean Markdown plus
+        title and metadata. One call, billed per request in real dollars.
+
+        Price: $0.0009 per request.
+
+        Example:
+            res = client.web.scrape(url="https://example.com")
+        """
+        raw = self._client._run_raw(  # pyright: ignore[reportPrivateUsage]
+            "web.scrape", dict(input), options
+        )
+        return RunResult[WebScrapeData].model_validate(raw)
+
+    def screenshot(
+        self,
+        *,
+        options: RequestOptions | None = None,
+        **input: Unpack[WebScreenshotInput],
+    ) -> RunResult[WebScreenshotData]:
+        """Website Screenshot
+
+        Capture a real-browser screenshot of any web page URL, with transparent
+        per-request USD pricing.
+
+        Price: $0.00158 per result.
+
+        Example:
+            res = client.web.screenshot(url="https://example.com")
+        """
+        raw = self._client._run_raw(  # pyright: ignore[reportPrivateUsage]
+            "web.screenshot", dict(input), options
+        )
+        return RunResult[WebScreenshotData].model_validate(raw)
+
+
+class AsyncWebNamespace:
+    """Typed methods for this platform. Attached lazily to the client."""
+
+    def __init__(self, client: "AsyncAnyAPI") -> None:
+        self._client = client
+
+    async def crawl(
+        self, *, options: RequestOptions | None = None, **input: Unpack[WebCrawlInput]
+    ) -> RunResult[WebCrawlData]:
+        """Website Crawl
+
+        Crawl a website and get clean text content from up to 10 pages in one
+        normalized response - ideal for feeding sites into LLMs and search indexes.
+
+        Price: $0.0015 per request plus $0.003 per result.
+
+        Example:
+            res = client.web.crawl(limit=3, url="https://example.com")
+        """
+        raw = await self._client._arun_raw(  # pyright: ignore[reportPrivateUsage]
+            "web.crawl", dict(input), options
+        )
+        return RunResult[WebCrawlData].model_validate(raw)
+
+    async def map(
+        self, *, options: RequestOptions | None = None, **input: Unpack[WebMapInput]
+    ) -> RunResult[WebMapData]:
+        """Web Map
+
+        Map an entire website into a clean list of its URLs (with titles and
+        descriptions) in a single call. Billed per request in real dollars.
+
+        Price: $0.0009 per request.
+
+        Example:
+            res = client.web.map(url="https://example.com")
+        """
+        raw = await self._client._arun_raw(  # pyright: ignore[reportPrivateUsage]
+            "web.map", dict(input), options
+        )
+        return RunResult[WebMapData].model_validate(raw)
+
+    async def scrape(
+        self, *, options: RequestOptions | None = None, **input: Unpack[WebScrapeInput]
+    ) -> RunResult[WebScrapeData]:
+        """Web Scrape
+
+        Scrape any web page and get its main content back as clean Markdown plus
+        title and metadata. One call, billed per request in real dollars.
+
+        Price: $0.0009 per request.
+
+        Example:
+            res = client.web.scrape(url="https://example.com")
+        """
+        raw = await self._client._arun_raw(  # pyright: ignore[reportPrivateUsage]
+            "web.scrape", dict(input), options
+        )
+        return RunResult[WebScrapeData].model_validate(raw)
+
+    async def screenshot(
+        self,
+        *,
+        options: RequestOptions | None = None,
+        **input: Unpack[WebScreenshotInput],
+    ) -> RunResult[WebScreenshotData]:
+        """Website Screenshot
+
+        Capture a real-browser screenshot of any web page URL, with transparent
+        per-request USD pricing.
+
+        Price: $0.00158 per result.
+
+        Example:
+            res = client.web.screenshot(url="https://example.com")
+        """
+        raw = await self._client._arun_raw(  # pyright: ignore[reportPrivateUsage]
+            "web.screenshot", dict(input), options
+        )
+        return RunResult[WebScreenshotData].model_validate(raw)

getanyapi/platforms/whatsapp.py

@@ -0,0 +1,91 @@
+# Generated - do not edit. Regenerate with: pnpm generate
+"""Generated namespace module for the whatsapp platform."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import Required, TypedDict, Unpack
+
+from ..types import RequestOptions, RunResult
+
+if TYPE_CHECKING:
+    from .._async_client import AsyncAnyAPI
+    from .._client import AnyAPI
+
+
+class WhatsappValidateInput(TypedDict, total=False):
+    """Input for WhatsApp Number Validator."""
+
+    phone: Required[str]
+    """The phone number to check, in international format."""
+
+
+class WhatsappValidateData(BaseModel):
+    items: list[WhatsappValidateItem] = Field(
+        description="Validation records: the phone number with its WhatsApp registration status."
+    )
+
+
+class WhatsappValidateItem(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    phone: str
+    status: str
+
+
+class WhatsappNamespace:
+    """Typed methods for this platform. Attached lazily to the client."""
+
+    def __init__(self, client: "AnyAPI") -> None:
+        self._client = client
+
+    def validate(
+        self,
+        *,
+        options: RequestOptions | None = None,
+        **input: Unpack[WhatsappValidateInput],
+    ) -> RunResult[WhatsappValidateData]:
+        """WhatsApp Number Validator
+
+        Check whether a phone number is registered on WhatsApp, with transparent
+        per-request USD pricing.
+
+        Price: $0.0035 per request plus $0.001 per result.
+
+        Example:
+            res = client.whatsapp.validate(phone="+14155552671")
+        """
+        raw = self._client._run_raw(  # pyright: ignore[reportPrivateUsage]
+            "whatsapp.validate", dict(input), options
+        )
+        return RunResult[WhatsappValidateData].model_validate(raw)
+
+
+class AsyncWhatsappNamespace:
+    """Typed methods for this platform. Attached lazily to the client."""
+
+    def __init__(self, client: "AsyncAnyAPI") -> None:
+        self._client = client
+
+    async def validate(
+        self,
+        *,
+        options: RequestOptions | None = None,
+        **input: Unpack[WhatsappValidateInput],
+    ) -> RunResult[WhatsappValidateData]:
+        """WhatsApp Number Validator
+
+        Check whether a phone number is registered on WhatsApp, with transparent
+        per-request USD pricing.
+
+        Price: $0.0035 per request plus $0.001 per result.
+
+        Example:
+            res = client.whatsapp.validate(phone="+14155552671")
+        """
+        raw = await self._client._arun_raw(  # pyright: ignore[reportPrivateUsage]
+            "whatsapp.validate", dict(input), options
+        )
+        return RunResult[WhatsappValidateData].model_validate(raw)

getanyapi/platforms/yahoo_finance.py

@@ -0,0 +1,95 @@
+# Generated - do not edit. Regenerate with: pnpm generate
+"""Generated namespace module for the yahoo_finance platform."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import Required, TypedDict, Unpack
+
+from ..types import RequestOptions, RunResult
+
+if TYPE_CHECKING:
+    from .._async_client import AsyncAnyAPI
+    from .._client import AnyAPI
+
+
+class YahooFinanceQuoteInput(TypedDict, total=False):
+    """Input for Yahoo Finance Quote."""
+
+    ticker: Required[str]
+    """The ticker symbol to look up."""
+
+
+class YahooFinanceQuoteData(BaseModel):
+    items: list[YahooFinanceQuoteItem] = Field(
+        description="Quote records for the ticker: current price, market cap, volume, day range, and key financial stats."
+    )
+
+
+class YahooFinanceQuoteItem(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    name: str | None = Field(
+        default=None, description="Present whenever the upstream returns this record."
+    )
+    price: float
+
+
+class YahooFinanceNamespace:
+    """Typed methods for this platform. Attached lazily to the client."""
+
+    def __init__(self, client: "AnyAPI") -> None:
+        self._client = client
+
+    def quote(
+        self,
+        *,
+        options: RequestOptions | None = None,
+        **input: Unpack[YahooFinanceQuoteInput],
+    ) -> RunResult[YahooFinanceQuoteData]:
+        """Yahoo Finance Quote
+
+        Look up a stock or ETF by ticker symbol and get its Yahoo Finance quote -
+        price, market cap, volume, and key stats - as normalized JSON with
+        transparent per-request USD pricing.
+
+        Price: $0.00005 per request plus $0.0009 per result.
+
+        Example:
+            res = client.yahoo_finance.quote(ticker="AAPL")
+        """
+        raw = self._client._run_raw(  # pyright: ignore[reportPrivateUsage]
+            "yahoo_finance.quote", dict(input), options
+        )
+        return RunResult[YahooFinanceQuoteData].model_validate(raw)
+
+
+class AsyncYahooFinanceNamespace:
+    """Typed methods for this platform. Attached lazily to the client."""
+
+    def __init__(self, client: "AsyncAnyAPI") -> None:
+        self._client = client
+
+    async def quote(
+        self,
+        *,
+        options: RequestOptions | None = None,
+        **input: Unpack[YahooFinanceQuoteInput],
+    ) -> RunResult[YahooFinanceQuoteData]:
+        """Yahoo Finance Quote
+
+        Look up a stock or ETF by ticker symbol and get its Yahoo Finance quote -
+        price, market cap, volume, and key stats - as normalized JSON with
+        transparent per-request USD pricing.
+
+        Price: $0.00005 per request plus $0.0009 per result.
+
+        Example:
+            res = client.yahoo_finance.quote(ticker="AAPL")
+        """
+        raw = await self._client._arun_raw(  # pyright: ignore[reportPrivateUsage]
+            "yahoo_finance.quote", dict(input), options
+        )
+        return RunResult[YahooFinanceQuoteData].model_validate(raw)