checkout-intents 0.1.0__py3-none-any.whl

checkout_intents/resources/checkout_intents.py

@@ -0,0 +1,480 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Any, Iterable, cast
+
+import httpx
+
+from ..types import (
+    checkout_intent_create_params,
+    checkout_intent_confirm_params,
+    checkout_intent_add_payment_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.buyer_param import BuyerParam
+from ..types.checkout_intent import CheckoutIntent
+from ..types.payment_method_param import PaymentMethodParam
+from ..types.variant_selection_param import VariantSelectionParam
+
+__all__ = ["CheckoutIntentsResource", "AsyncCheckoutIntentsResource"]
+
+
+class CheckoutIntentsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> CheckoutIntentsResourceWithRawResponse:
+        """
+        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/rye-com/checkout-intents-python#accessing-raw-response-data-eg-headers
+        """
+        return CheckoutIntentsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> CheckoutIntentsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/rye-com/checkout-intents-python#with_streaming_response
+        """
+        return CheckoutIntentsResourceWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        buyer: BuyerParam,
+        product_url: str,
+        quantity: float,
+        variant_selections: Iterable[VariantSelectionParam] | 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,
+    ) -> CheckoutIntent:
+        """
+        Create a checkout intent with the given request body.
+
+        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 cast(
+            CheckoutIntent,
+            self._post(
+                "/api/v1/checkout-intents",
+                body=maybe_transform(
+                    {
+                        "buyer": buyer,
+                        "product_url": product_url,
+                        "quantity": quantity,
+                        "variant_selections": variant_selections,
+                    },
+                    checkout_intent_create_params.CheckoutIntentCreateParams,
+                ),
+                options=make_request_options(
+                    extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                ),
+                cast_to=cast(Any, CheckoutIntent),  # Union types cannot be passed in as arguments in the type system
+            ),
+        )
+
+    def retrieve(
+        self,
+        id: 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,
+    ) -> CheckoutIntent:
+        """
+        Retrieve a checkout intent by id
+
+        Returns checkout intent information if the lookup succeeds.
+
+        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
+        """
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return cast(
+            CheckoutIntent,
+            self._get(
+                f"/api/v1/checkout-intents/{id}",
+                options=make_request_options(
+                    extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                ),
+                cast_to=cast(Any, CheckoutIntent),  # Union types cannot be passed in as arguments in the type system
+            ),
+        )
+
+    def add_payment(
+        self,
+        id: str,
+        *,
+        payment_method: PaymentMethodParam,
+        # 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,
+    ) -> CheckoutIntent:
+        """
+        Add payment details to a checkout intent
+
+        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
+        """
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return cast(
+            CheckoutIntent,
+            self._post(
+                f"/api/v1/checkout-intents/{id}/payment",
+                body=maybe_transform(
+                    {"payment_method": payment_method},
+                    checkout_intent_add_payment_params.CheckoutIntentAddPaymentParams,
+                ),
+                options=make_request_options(
+                    extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                ),
+                cast_to=cast(Any, CheckoutIntent),  # Union types cannot be passed in as arguments in the type system
+            ),
+        )
+
+    def confirm(
+        self,
+        id: str,
+        *,
+        payment_method: PaymentMethodParam,
+        # 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,
+    ) -> CheckoutIntent:
+        """
+        Confirm a checkout intent with provided payment information
+
+        Confirm means we have buyer's name, address and payment info, so we can move
+        forward to place the order.
+
+        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
+        """
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return cast(
+            CheckoutIntent,
+            self._post(
+                f"/api/v1/checkout-intents/{id}/confirm",
+                body=maybe_transform(
+                    {"payment_method": payment_method}, checkout_intent_confirm_params.CheckoutIntentConfirmParams
+                ),
+                options=make_request_options(
+                    extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                ),
+                cast_to=cast(Any, CheckoutIntent),  # Union types cannot be passed in as arguments in the type system
+            ),
+        )
+
+
+class AsyncCheckoutIntentsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncCheckoutIntentsResourceWithRawResponse:
+        """
+        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/rye-com/checkout-intents-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncCheckoutIntentsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncCheckoutIntentsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/rye-com/checkout-intents-python#with_streaming_response
+        """
+        return AsyncCheckoutIntentsResourceWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        buyer: BuyerParam,
+        product_url: str,
+        quantity: float,
+        variant_selections: Iterable[VariantSelectionParam] | 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,
+    ) -> CheckoutIntent:
+        """
+        Create a checkout intent with the given request body.
+
+        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 cast(
+            CheckoutIntent,
+            await self._post(
+                "/api/v1/checkout-intents",
+                body=await async_maybe_transform(
+                    {
+                        "buyer": buyer,
+                        "product_url": product_url,
+                        "quantity": quantity,
+                        "variant_selections": variant_selections,
+                    },
+                    checkout_intent_create_params.CheckoutIntentCreateParams,
+                ),
+                options=make_request_options(
+                    extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                ),
+                cast_to=cast(Any, CheckoutIntent),  # Union types cannot be passed in as arguments in the type system
+            ),
+        )
+
+    async def retrieve(
+        self,
+        id: 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,
+    ) -> CheckoutIntent:
+        """
+        Retrieve a checkout intent by id
+
+        Returns checkout intent information if the lookup succeeds.
+
+        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
+        """
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return cast(
+            CheckoutIntent,
+            await self._get(
+                f"/api/v1/checkout-intents/{id}",
+                options=make_request_options(
+                    extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                ),
+                cast_to=cast(Any, CheckoutIntent),  # Union types cannot be passed in as arguments in the type system
+            ),
+        )
+
+    async def add_payment(
+        self,
+        id: str,
+        *,
+        payment_method: PaymentMethodParam,
+        # 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,
+    ) -> CheckoutIntent:
+        """
+        Add payment details to a checkout intent
+
+        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
+        """
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return cast(
+            CheckoutIntent,
+            await self._post(
+                f"/api/v1/checkout-intents/{id}/payment",
+                body=await async_maybe_transform(
+                    {"payment_method": payment_method},
+                    checkout_intent_add_payment_params.CheckoutIntentAddPaymentParams,
+                ),
+                options=make_request_options(
+                    extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                ),
+                cast_to=cast(Any, CheckoutIntent),  # Union types cannot be passed in as arguments in the type system
+            ),
+        )
+
+    async def confirm(
+        self,
+        id: str,
+        *,
+        payment_method: PaymentMethodParam,
+        # 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,
+    ) -> CheckoutIntent:
+        """
+        Confirm a checkout intent with provided payment information
+
+        Confirm means we have buyer's name, address and payment info, so we can move
+        forward to place the order.
+
+        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
+        """
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return cast(
+            CheckoutIntent,
+            await self._post(
+                f"/api/v1/checkout-intents/{id}/confirm",
+                body=await async_maybe_transform(
+                    {"payment_method": payment_method}, checkout_intent_confirm_params.CheckoutIntentConfirmParams
+                ),
+                options=make_request_options(
+                    extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                ),
+                cast_to=cast(Any, CheckoutIntent),  # Union types cannot be passed in as arguments in the type system
+            ),
+        )
+
+
+class CheckoutIntentsResourceWithRawResponse:
+    def __init__(self, checkout_intents: CheckoutIntentsResource) -> None:
+        self._checkout_intents = checkout_intents
+
+        self.create = to_raw_response_wrapper(
+            checkout_intents.create,
+        )
+        self.retrieve = to_raw_response_wrapper(
+            checkout_intents.retrieve,
+        )
+        self.add_payment = to_raw_response_wrapper(
+            checkout_intents.add_payment,
+        )
+        self.confirm = to_raw_response_wrapper(
+            checkout_intents.confirm,
+        )
+
+
+class AsyncCheckoutIntentsResourceWithRawResponse:
+    def __init__(self, checkout_intents: AsyncCheckoutIntentsResource) -> None:
+        self._checkout_intents = checkout_intents
+
+        self.create = async_to_raw_response_wrapper(
+            checkout_intents.create,
+        )
+        self.retrieve = async_to_raw_response_wrapper(
+            checkout_intents.retrieve,
+        )
+        self.add_payment = async_to_raw_response_wrapper(
+            checkout_intents.add_payment,
+        )
+        self.confirm = async_to_raw_response_wrapper(
+            checkout_intents.confirm,
+        )
+
+
+class CheckoutIntentsResourceWithStreamingResponse:
+    def __init__(self, checkout_intents: CheckoutIntentsResource) -> None:
+        self._checkout_intents = checkout_intents
+
+        self.create = to_streamed_response_wrapper(
+            checkout_intents.create,
+        )
+        self.retrieve = to_streamed_response_wrapper(
+            checkout_intents.retrieve,
+        )
+        self.add_payment = to_streamed_response_wrapper(
+            checkout_intents.add_payment,
+        )
+        self.confirm = to_streamed_response_wrapper(
+            checkout_intents.confirm,
+        )
+
+
+class AsyncCheckoutIntentsResourceWithStreamingResponse:
+    def __init__(self, checkout_intents: AsyncCheckoutIntentsResource) -> None:
+        self._checkout_intents = checkout_intents
+
+        self.create = async_to_streamed_response_wrapper(
+            checkout_intents.create,
+        )
+        self.retrieve = async_to_streamed_response_wrapper(
+            checkout_intents.retrieve,
+        )
+        self.add_payment = async_to_streamed_response_wrapper(
+            checkout_intents.add_payment,
+        )
+        self.confirm = async_to_streamed_response_wrapper(
+            checkout_intents.confirm,
+        )

checkout_intents/types/__init__.py

@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .buyer import Buyer as Buyer
+from .money import Money as Money
+from .offer import Offer as Offer
+from .buyer_param import BuyerParam as BuyerParam
+from .payment_method import PaymentMethod as PaymentMethod
+from .checkout_intent import CheckoutIntent as CheckoutIntent
+from .variant_selection import VariantSelection as VariantSelection
+from .base_checkout_intent import BaseCheckoutIntent as BaseCheckoutIntent
+from .payment_method_param import PaymentMethodParam as PaymentMethodParam
+from .brand_retrieve_response import BrandRetrieveResponse as BrandRetrieveResponse
+from .variant_selection_param import VariantSelectionParam as VariantSelectionParam
+from .checkout_intent_create_params import CheckoutIntentCreateParams as CheckoutIntentCreateParams
+from .checkout_intent_confirm_params import CheckoutIntentConfirmParams as CheckoutIntentConfirmParams
+from .checkout_intent_add_payment_params import CheckoutIntentAddPaymentParams as CheckoutIntentAddPaymentParams

checkout_intents/types/base_checkout_intent.py

@@ -0,0 +1,26 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from datetime import datetime
+
+from pydantic import Field as FieldInfo
+
+from .buyer import Buyer
+from .._models import BaseModel
+from .variant_selection import VariantSelection
+
+__all__ = ["BaseCheckoutIntent"]
+
+
+class BaseCheckoutIntent(BaseModel):
+    id: str
+
+    buyer: Buyer
+
+    created_at: datetime = FieldInfo(alias="createdAt")
+
+    product_url: str = FieldInfo(alias="productUrl")
+
+    quantity: float
+
+    variant_selections: Optional[List[VariantSelection]] = FieldInfo(alias="variantSelections", default=None)

checkout_intents/types/brand_retrieve_response.py

@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["BrandRetrieveResponse"]
+
+
+class BrandRetrieveResponse(BaseModel):
+    id: str
+    """A unique identifier for the brand."""
+
+    marketplace: Literal["AMAZON", "SHOPIFY", "UNKNOWN"]
+    """Indicates what ecommerce platform the brand uses."""
+
+    supported: bool
+    """
+    If `false`, then products from this brand cannot be purchased through the Sell
+    Anything API.
+    """

checkout_intents/types/buyer.py

@@ -0,0 +1,31 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["Buyer"]
+
+
+class Buyer(BaseModel):
+    address1: str
+
+    city: str
+
+    country: str
+
+    email: str
+
+    first_name: str = FieldInfo(alias="firstName")
+
+    last_name: str = FieldInfo(alias="lastName")
+
+    phone: str
+
+    postal_code: str = FieldInfo(alias="postalCode")
+
+    province: str
+
+    address2: Optional[str] = None

checkout_intents/types/buyer_param.py

@@ -0,0 +1,31 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, Annotated, TypedDict
+
+from .._utils import PropertyInfo
+
+__all__ = ["BuyerParam"]
+
+
+class BuyerParam(TypedDict, total=False):
+    address1: Required[str]
+
+    city: Required[str]
+
+    country: Required[str]
+
+    email: Required[str]
+
+    first_name: Required[Annotated[str, PropertyInfo(alias="firstName")]]
+
+    last_name: Required[Annotated[str, PropertyInfo(alias="lastName")]]
+
+    phone: Required[str]
+
+    postal_code: Required[Annotated[str, PropertyInfo(alias="postalCode")]]
+
+    province: Required[str]
+
+    address2: str

checkout_intents/types/checkout_intent.py

@@ -0,0 +1,83 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union, Optional
+from typing_extensions import Literal, TypeAlias
+
+from pydantic import Field as FieldInfo
+
+from .offer import Offer
+from .._models import BaseModel
+from .payment_method import PaymentMethod
+from .base_checkout_intent import BaseCheckoutIntent
+
+__all__ = [
+    "CheckoutIntent",
+    "RetrievingOfferCheckoutIntent",
+    "AwaitingConfirmationCheckoutIntent",
+    "PlacingOrderCheckoutIntent",
+    "CompletedCheckoutIntent",
+    "FailedCheckoutIntent",
+    "FailedCheckoutIntentFailureReason",
+]
+
+
+class RetrievingOfferCheckoutIntent(BaseCheckoutIntent):
+    state: Literal["retrieving_offer"]
+
+
+class AwaitingConfirmationCheckoutIntent(BaseCheckoutIntent):
+    offer: Offer
+
+    state: Literal["awaiting_confirmation"]
+
+
+class PlacingOrderCheckoutIntent(BaseCheckoutIntent):
+    offer: Offer
+
+    payment_method: PaymentMethod = FieldInfo(alias="paymentMethod")
+
+    state: Literal["placing_order"]
+
+
+class CompletedCheckoutIntent(BaseCheckoutIntent):
+    offer: Offer
+
+    payment_method: PaymentMethod = FieldInfo(alias="paymentMethod")
+
+    state: Literal["completed"]
+
+
+class FailedCheckoutIntentFailureReason(BaseModel):
+    code: Literal[
+        "checkout_intent_expired",
+        "payment_failed",
+        "insufficient_stock",
+        "product_out_of_stock",
+        "offer_retrieval_failed",
+        "order_placement_failed",
+        "developer_not_found",
+        "missing_shipping_method",
+        "unsupported_currency",
+        "unsupported_store_no_guest_checkout",
+    ]
+
+    message: str
+
+
+class FailedCheckoutIntent(BaseCheckoutIntent):
+    failure_reason: FailedCheckoutIntentFailureReason = FieldInfo(alias="failureReason")
+
+    state: Literal["failed"]
+
+    offer: Optional[Offer] = None
+
+    payment_method: Optional[PaymentMethod] = FieldInfo(alias="paymentMethod", default=None)
+
+
+CheckoutIntent: TypeAlias = Union[
+    RetrievingOfferCheckoutIntent,
+    AwaitingConfirmationCheckoutIntent,
+    PlacingOrderCheckoutIntent,
+    CompletedCheckoutIntent,
+    FailedCheckoutIntent,
+]