channel3-sdk 2.11.0__py3-none-any.whl

channel3_sdk/resources/products.py

@@ -0,0 +1,206 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+
+import httpx
+
+from ..types import RedirectMode, product_retrieve_params
+from .._types import Body, Omit, Query, Headers, NotGiven, SequenceNotStr, omit, not_given
+from .._utils import maybe_transform, async_maybe_transform
+from .._compat import cached_property
+from .._resource import SyncAPIResource, AsyncAPIResource
+from .._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from .._base_client import make_request_options
+from ..types.redirect_mode import RedirectMode
+from ..types.product_detail import ProductDetail
+
+__all__ = ["ProductsResource", "AsyncProductsResource"]
+
+
+class ProductsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> ProductsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/channel3-ai/sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return ProductsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ProductsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/channel3-ai/sdk-python#with_streaming_response
+        """
+        return ProductsResourceWithStreamingResponse(self)
+
+    def retrieve(
+        self,
+        product_id: str,
+        *,
+        redirect_mode: Optional[RedirectMode] | Omit = omit,
+        website_ids: Optional[SequenceNotStr[str]] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ProductDetail:
+        """
+        Get detailed information about a specific product by its ID.
+
+        Args:
+          redirect_mode: "price" redirects to the product page with the lowest price "commission"
+              redirects to the product page with the highest commission rate "brand" redirects
+              to the brand's product page
+
+          website_ids: Optional list of website IDs to constrain the buy URL to, relevant if multiple
+              merchants exist
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not product_id:
+            raise ValueError(f"Expected a non-empty value for `product_id` but received {product_id!r}")
+        return self._get(
+            f"/v0/products/{product_id}",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "redirect_mode": redirect_mode,
+                        "website_ids": website_ids,
+                    },
+                    product_retrieve_params.ProductRetrieveParams,
+                ),
+            ),
+            cast_to=ProductDetail,
+        )
+
+
+class AsyncProductsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncProductsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/channel3-ai/sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncProductsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncProductsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/channel3-ai/sdk-python#with_streaming_response
+        """
+        return AsyncProductsResourceWithStreamingResponse(self)
+
+    async def retrieve(
+        self,
+        product_id: str,
+        *,
+        redirect_mode: Optional[RedirectMode] | Omit = omit,
+        website_ids: Optional[SequenceNotStr[str]] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> ProductDetail:
+        """
+        Get detailed information about a specific product by its ID.
+
+        Args:
+          redirect_mode: "price" redirects to the product page with the lowest price "commission"
+              redirects to the product page with the highest commission rate "brand" redirects
+              to the brand's product page
+
+          website_ids: Optional list of website IDs to constrain the buy URL to, relevant if multiple
+              merchants exist
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not product_id:
+            raise ValueError(f"Expected a non-empty value for `product_id` but received {product_id!r}")
+        return await self._get(
+            f"/v0/products/{product_id}",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {
+                        "redirect_mode": redirect_mode,
+                        "website_ids": website_ids,
+                    },
+                    product_retrieve_params.ProductRetrieveParams,
+                ),
+            ),
+            cast_to=ProductDetail,
+        )
+
+
+class ProductsResourceWithRawResponse:
+    def __init__(self, products: ProductsResource) -> None:
+        self._products = products
+
+        self.retrieve = to_raw_response_wrapper(
+            products.retrieve,
+        )
+
+
+class AsyncProductsResourceWithRawResponse:
+    def __init__(self, products: AsyncProductsResource) -> None:
+        self._products = products
+
+        self.retrieve = async_to_raw_response_wrapper(
+            products.retrieve,
+        )
+
+
+class ProductsResourceWithStreamingResponse:
+    def __init__(self, products: ProductsResource) -> None:
+        self._products = products
+
+        self.retrieve = to_streamed_response_wrapper(
+            products.retrieve,
+        )
+
+
+class AsyncProductsResourceWithStreamingResponse:
+    def __init__(self, products: AsyncProductsResource) -> None:
+        self._products = products
+
+        self.retrieve = async_to_streamed_response_wrapper(
+            products.retrieve,
+        )

channel3_sdk/resources/search.py

@@ -0,0 +1,231 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+
+import httpx
+
+from ..types import search_perform_params
+from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from .._utils import maybe_transform, async_maybe_transform
+from .._compat import cached_property
+from .._resource import SyncAPIResource, AsyncAPIResource
+from .._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from .._base_client import make_request_options
+from ..types.search_config_param import SearchConfigParam
+from ..types.search_filters_param import SearchFiltersParam
+from ..types.search_perform_response import SearchPerformResponse
+
+__all__ = ["SearchResource", "AsyncSearchResource"]
+
+
+class SearchResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> SearchResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/channel3-ai/sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return SearchResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> SearchResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/channel3-ai/sdk-python#with_streaming_response
+        """
+        return SearchResourceWithStreamingResponse(self)
+
+    def perform(
+        self,
+        *,
+        base64_image: Optional[str] | Omit = omit,
+        config: SearchConfigParam | Omit = omit,
+        context: Optional[str] | Omit = omit,
+        filters: SearchFiltersParam | Omit = omit,
+        image_url: Optional[str] | Omit = omit,
+        limit: Optional[int] | Omit = omit,
+        query: Optional[str] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SearchPerformResponse:
+        """
+        Search for products.
+
+        Args:
+          base64_image: Base64 encoded image
+
+          config: Optional configuration
+
+          context: Optional customer information to personalize search results
+
+          filters: Optional filters. Search will only consider products that match all of the
+              filters.
+
+          image_url: Image URL
+
+          limit: Optional limit on the number of results. Default is 20, max is 30.
+
+          query: Search query
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._post(
+            "/v0/search",
+            body=maybe_transform(
+                {
+                    "base64_image": base64_image,
+                    "config": config,
+                    "context": context,
+                    "filters": filters,
+                    "image_url": image_url,
+                    "limit": limit,
+                    "query": query,
+                },
+                search_perform_params.SearchPerformParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SearchPerformResponse,
+        )
+
+
+class AsyncSearchResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncSearchResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/channel3-ai/sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncSearchResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncSearchResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/channel3-ai/sdk-python#with_streaming_response
+        """
+        return AsyncSearchResourceWithStreamingResponse(self)
+
+    async def perform(
+        self,
+        *,
+        base64_image: Optional[str] | Omit = omit,
+        config: SearchConfigParam | Omit = omit,
+        context: Optional[str] | Omit = omit,
+        filters: SearchFiltersParam | Omit = omit,
+        image_url: Optional[str] | Omit = omit,
+        limit: Optional[int] | Omit = omit,
+        query: Optional[str] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> SearchPerformResponse:
+        """
+        Search for products.
+
+        Args:
+          base64_image: Base64 encoded image
+
+          config: Optional configuration
+
+          context: Optional customer information to personalize search results
+
+          filters: Optional filters. Search will only consider products that match all of the
+              filters.
+
+          image_url: Image URL
+
+          limit: Optional limit on the number of results. Default is 20, max is 30.
+
+          query: Search query
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._post(
+            "/v0/search",
+            body=await async_maybe_transform(
+                {
+                    "base64_image": base64_image,
+                    "config": config,
+                    "context": context,
+                    "filters": filters,
+                    "image_url": image_url,
+                    "limit": limit,
+                    "query": query,
+                },
+                search_perform_params.SearchPerformParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SearchPerformResponse,
+        )
+
+
+class SearchResourceWithRawResponse:
+    def __init__(self, search: SearchResource) -> None:
+        self._search = search
+
+        self.perform = to_raw_response_wrapper(
+            search.perform,
+        )
+
+
+class AsyncSearchResourceWithRawResponse:
+    def __init__(self, search: AsyncSearchResource) -> None:
+        self._search = search
+
+        self.perform = async_to_raw_response_wrapper(
+            search.perform,
+        )
+
+
+class SearchResourceWithStreamingResponse:
+    def __init__(self, search: SearchResource) -> None:
+        self._search = search
+
+        self.perform = to_streamed_response_wrapper(
+            search.perform,
+        )
+
+
+class AsyncSearchResourceWithStreamingResponse:
+    def __init__(self, search: AsyncSearchResource) -> None:
+        self._search = search
+
+        self.perform = async_to_streamed_response_wrapper(
+            search.perform,
+        )

channel3_sdk/resources/websites.py

@@ -0,0 +1,171 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+
+import httpx
+
+from ..types import website_find_params
+from .._types import Body, Query, Headers, NotGiven, not_given
+from .._utils import maybe_transform, async_maybe_transform
+from .._compat import cached_property
+from .._resource import SyncAPIResource, AsyncAPIResource
+from .._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from .._base_client import make_request_options
+from ..types.website import Website
+
+__all__ = ["WebsitesResource", "AsyncWebsitesResource"]
+
+
+class WebsitesResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> WebsitesResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/channel3-ai/sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return WebsitesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> WebsitesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/channel3-ai/sdk-python#with_streaming_response
+        """
+        return WebsitesResourceWithStreamingResponse(self)
+
+    def find(
+        self,
+        *,
+        query: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Optional[Website]:
+        """
+        Find a website by URL.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._get(
+            "/v0/websites",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform({"query": query}, website_find_params.WebsiteFindParams),
+            ),
+            cast_to=Website,
+        )
+
+
+class AsyncWebsitesResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncWebsitesResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/channel3-ai/sdk-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncWebsitesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncWebsitesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/channel3-ai/sdk-python#with_streaming_response
+        """
+        return AsyncWebsitesResourceWithStreamingResponse(self)
+
+    async def find(
+        self,
+        *,
+        query: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> Optional[Website]:
+        """
+        Find a website by URL.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._get(
+            "/v0/websites",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform({"query": query}, website_find_params.WebsiteFindParams),
+            ),
+            cast_to=Website,
+        )
+
+
+class WebsitesResourceWithRawResponse:
+    def __init__(self, websites: WebsitesResource) -> None:
+        self._websites = websites
+
+        self.find = to_raw_response_wrapper(
+            websites.find,
+        )
+
+
+class AsyncWebsitesResourceWithRawResponse:
+    def __init__(self, websites: AsyncWebsitesResource) -> None:
+        self._websites = websites
+
+        self.find = async_to_raw_response_wrapper(
+            websites.find,
+        )
+
+
+class WebsitesResourceWithStreamingResponse:
+    def __init__(self, websites: WebsitesResource) -> None:
+        self._websites = websites
+
+        self.find = to_streamed_response_wrapper(
+            websites.find,
+        )
+
+
+class AsyncWebsitesResourceWithStreamingResponse:
+    def __init__(self, websites: AsyncWebsitesResource) -> None:
+        self._websites = websites
+
+        self.find = async_to_streamed_response_wrapper(
+            websites.find,
+        )

channel3_sdk/types/__init__.py

@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .brand import Brand as Brand
+from .price import Price as Price
+from .product import Product as Product
+from .variant import Variant as Variant
+from .website import Website as Website
+from .subscription import Subscription as Subscription
+from .price_history import PriceHistory as PriceHistory
+from .redirect_mode import RedirectMode as RedirectMode
+from .product_detail import ProductDetail as ProductDetail
+from .brand_find_params import BrandFindParams as BrandFindParams
+from .availability_status import AvailabilityStatus as AvailabilityStatus
+from .search_config_param import SearchConfigParam as SearchConfigParam
+from .website_find_params import WebsiteFindParams as WebsiteFindParams
+from .search_filters_param import SearchFiltersParam as SearchFiltersParam
+from .search_perform_params import SearchPerformParams as SearchPerformParams
+from .paginated_subscriptions import PaginatedSubscriptions as PaginatedSubscriptions
+from .product_retrieve_params import ProductRetrieveParams as ProductRetrieveParams
+from .search_perform_response import SearchPerformResponse as SearchPerformResponse
+from .enrich_enrich_url_params import EnrichEnrichURLParams as EnrichEnrichURLParams
+from .search_filter_price_param import SearchFilterPriceParam as SearchFilterPriceParam
+from .price_tracking_stop_params import PriceTrackingStopParams as PriceTrackingStopParams
+from .price_tracking_start_params import PriceTrackingStartParams as PriceTrackingStartParams
+from .price_tracking_get_history_params import PriceTrackingGetHistoryParams as PriceTrackingGetHistoryParams
+from .price_tracking_list_subscriptions_params import (
+    PriceTrackingListSubscriptionsParams as PriceTrackingListSubscriptionsParams,
+)

channel3_sdk/types/availability_status.py

@@ -0,0 +1,9 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal, TypeAlias
+
+__all__ = ["AvailabilityStatus"]
+
+AvailabilityStatus: TypeAlias = Literal[
+    "InStock", "LimitedAvailability", "PreOrder", "BackOrder", "SoldOut", "OutOfStock", "Discontinued", "Unknown"
+]

channel3_sdk/types/brand.py

@@ -0,0 +1,20 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from .._models import BaseModel
+
+__all__ = ["Brand"]
+
+
+class Brand(BaseModel):
+    id: str
+
+    name: str
+
+    best_commission_rate: Optional[float] = None
+    """The maximum commission rate for the brand, as a percentage"""
+
+    description: Optional[str] = None
+
+    logo_url: Optional[str] = None

channel3_sdk/types/brand_find_params.py

@@ -0,0 +1,11 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+__all__ = ["BrandFindParams"]
+
+
+class BrandFindParams(TypedDict, total=False):
+    query: Required[str]

channel3_sdk/types/enrich_enrich_url_params.py

@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+__all__ = ["EnrichEnrichURLParams"]
+
+
+class EnrichEnrichURLParams(TypedDict, total=False):
+    url: Required[str]
+    """The URL of the product to enrich"""