paddle-python-sdk 1.14.1__tar.gz → 1.16.0__tar.gz

paddle_python_sdk-1.16.0/PKG-INFO

@@ -0,0 +1,224 @@
+Metadata-Version: 2.4
+Name: paddle-python-sdk
+Version: 1.16.0
+Summary: Paddle's Python SDK for Paddle Billing
+Home-page: https://developer.paddle.com/api-reference/overview
+Author: Paddle and contributors
+Author-email: team-dx@paddle.com
+License: Apache-2.0
+Keywords: paddle,sdk,python
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.31
+Requires-Dist: urllib3>=1.26.18
+Provides-Extra: dev
+Requires-Dist: pytest<9.2.0,>=7.4.4; extra == "dev"
+Requires-Dist: pytest-cov<7.2,>=4.1; extra == "dev"
+Requires-Dist: requests-mock~=1.12.1; extra == "dev"
+Requires-Dist: setuptools>=69.0.3; extra == "dev"
+Requires-Dist: pre-commit>=3.8.0; extra == "dev"
+Requires-Dist: black>=24.8.0; extra == "dev"
+Requires-Dist: flake8>=7.1.1; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+[![Build Status](https://img.shields.io/github/actions/workflow/status/PaddleHQ/paddle-python-sdk/publish_to_pypi.yml)](https://github.com/PaddleHQ/paddle-python-sdk/actions/?query=branch%3Amain)
+[![PyPI](https://img.shields.io/pypi/v/paddle-python-sdk.svg)](https://pypi.python.org/pypi/paddle-python-sdk)
+[![PyPI pyversions](https://img.shields.io/pypi/pyversions/paddle-python-sdk.svg)](https://pypi.python.org/pypi/paddle-python-sdk/)
+[![License: Apache 2.0](https://img.shields.io/github/license/PaddleHQ/paddle-python-sdk)](http://www.apache.org/licenses/LICENSE-2.0)
+
+
+# paddle-python-sdk
+[Paddle Billing](https://developer.paddle.com/?utm_source=dx&utm_medium=paddle-python-sdk) is the developer-first merchant of record, designed for modern SaaS, AI, mobile app, and digital product businesses. We take care of payments, tax, subscriptions, and metrics with one unified API that does it all.
+
+This is a [Python](https://www.python.org/) SDK that you can use to integrate Paddle Billing with applications written in Python.
+
+For working with Paddle in your frontend, use [Paddle.js](https://developer.paddle.com/paddlejs/overview?utm_source=dx&utm_medium=paddle-python-sdk). You can open checkouts, securely collect payment information, build pricing pages, and integrate with Paddle Retain.
+
+> **Important:** This package works with Paddle Billing. It does not support Paddle Classic. To work with Paddle Classic, see: [Paddle Classic dev docs](https://classic.paddle.com/?utm_source=dx&utm_medium=paddle-python-sdk)
+
+
+## Table of contents
+- [Requirements](#Requirements)
+- [Install](#Install)
+- [Usage](#Usage)
+- [Examples](#Examples)
+- [Resources](#Resources)
+
+## Requirements
+Python>=3.11 (for native type hinting, StrEnum, trailing commas, f-strings)
+
+**Project dependencies** (automatically installed by pip):
+- requests>=2.31
+- urllib3>=2.1.0
+
+
+## Install
+Because `paddle-python-sdk` is [available on PyPi](https://pypi.org/project/paddle-python-sdk/), installation is as simple as running the following `pip` command: 
+
+`pip install paddle-python-sdk`
+
+
+
+## Usage
+To authenticate, you'll need an API key. You can create and manage API keys in **Paddle > Developer tools > Authentication**.
+
+Pass your API key while initializing a new Paddle client:
+``` python
+from paddle_billing import Client
+
+paddle = Client('PADDLE_API_SECRET_KEY')
+```
+
+You can pass your Paddle API secret key into the SDK from an environment variable:
+``` python
+from os             import getenv
+from paddle_billing import Client
+
+paddle = Client(getenv('PADDLE_API_SECRET_KEY'))
+```
+
+You can also pass an environment to work with Paddle's sandbox:
+``` python
+from paddle_billing import Client, Environment, Options
+
+paddle = Client('PADDLE_API_SECRET_KEY', options=Options(Environment.SANDBOX))
+```
+
+Keep in mind that API keys are separate for your sandbox and live accounts, so you'll need to generate keys for each environment.
+
+
+
+## Examples
+There are examples included in the [examples folder](https://github.com/PaddleHQ/paddle-python-sdk/tree/main/examples). To prevent leaking errors we recommend encapsulating Paddle operations inside Try/Except blocks. For brevity, most of the examples below do not do this.
+
+### List entities
+You can list supported entities with the `list()` method in the resource. It returns an iterator to help when working with multiple pages.
+``` python
+from paddle_billing import Client
+
+paddle = Client('PADDLE_API_SECRET_KEY')
+
+products = paddle.products.list()
+
+# list() returns an iterable, so pagination is automatically handled
+for product in products:
+    print(f"Product's id: {product.id}")
+```
+
+### Get an entity
+You can get an entity with the `get()` method in the resource. It accepts the `id` of the entity to get. The entity is returned.
+``` python
+from paddle_billing import Client
+
+paddle = Client('PADDLE_API_SECRET_KEY')
+
+product = paddle.products.get('PRODUCT_ID')
+```
+
+### Create an entity
+You can create a supported entity with the `create()` method in the resource. It accepts the resource's corresponding `CreateOperation` e.g. `CreateProduct`. The created entity is returned.
+
+``` python
+from paddle_billing                               import Client
+from paddle_billing.Entities.Shared.TaxCategory   import TaxCategory
+from paddle_billing.Resources.Products.Operations import CreateProduct
+
+paddle = Client('PADDLE_API_SECRET_KEY')
+
+created_product = paddle.products.create(CreateProduct(
+    name         = 'My Product',
+    tax_category = TaxCategory.Standard,
+))
+```
+
+### Update an entity
+You can update a supported entity with the `update()` method in the resource. It accepts the `id` of the entity to update and the corresponding `UpdateOperation` e.g. `UpdateProduct`. The updated entity is returned.
+``` python
+from paddle_billing                        import Client
+from paddle_billing.Resources.Products.Operations import UpdateProduct
+
+paddle = Client('PADDLE_API_SECRET_KEY')
+
+# Update the name of the product
+updated_product = paddle.products.update('PRODUCT_ID', UpdateProduct(
+    name = 'My Improved Product'
+))
+```
+
+Where operations require more than one `id`, the `update()` method accepts multiple arguments. For example, to update an address for a customer, pass the `customerId` and the `addressId`:
+``` python
+updated_address = paddle.addresses.update(
+    'CUSTOMER_ID',
+    'ADDRESS_ID',
+    operation_goes_here,
+)
+```
+
+### Delete an entity
+You can delete an entity with the `delete()` method in the resource. It accepts the `id` of the entity to delete. The deleted entity is returned.
+``` python
+from paddle_billing import Client
+
+paddle = Client('PADDLE_API_SECRET_KEY')
+
+deleted_product = paddle.products.delete('PRODUCT_ID')
+```
+
+### Error Handling
+
+If a request fails, Paddle raises an `ApiError` that contains the same information as [errors returned by the API](https://developer.paddle.com/api-reference/about/errors?utm_source=dx&utm_medium=paddle-python-sdk). You can use the `code` attribute to search an error in [the error reference](https://developer.paddle.com/errors/overview?utm_source=dx&utm_medium=paddle-python-sdk) and to handle the error in your app. Validation errors also return an array of `errors` that tell you which fields failed validation. The `retry_after` property will be set for `too_many_requests` errors.
+
+This example shows how to handle an error with the code `conflict`:
+
+```python
+from paddle_billing.Exceptions.ApiError import ApiError
+
+try:
+    # Call functions from the SDK
+except ApiError as error:
+    # error.error_code will always follow the error code defined in our documentation
+    if error.error_code == 'conflict':
+        # Handle Conflict error
+```
+
+## Resources
+
+### Webhook signature verification
+The SDK includes a helper class to verify webhook signatures sent by Notifications from Paddle.
+
+``` python
+from paddle_billing.Notifications import Secret, Verifier
+
+integrity_check = Verifier().verify(request, Secret('WEBHOOK_SECRET_KEY'))
+```
+
+The `verify()` method currently accepts any request object matching the `paddle_billing.Notifications.Requests.Request` protocol, and supports popular frameworks such as Flask and Django.
+
+Time drift max variance can be adjusted by passing `seconds` to `Verifier()` _(default: 5 seconds)_:
+
+```python
+integrity_check = Verifier(seconds).verify(request, Secret('WEBHOOK_SECRET_KEY'))
+```
+
+## Learn more
+- [Paddle API reference](https://developer.paddle.com/api-reference/overview?utm_source=dx&utm_medium=paddle-python-sdk)
+- [Sign up for Paddle Billing](https://login.paddle.com/signup?utm_source=dx&utm_medium=paddle-python-sdk)

paddle_python_sdk-1.16.0/examples/catalog_management.py

@@ -0,0 +1,176 @@
+from logging import getLogger
+from os import getenv
+from sys import exit  # You should use classes/functions that returns instead of exits
+
+from paddle_billing import Client, Environment, Options
+
+from paddle_billing.Entities.Shared import (
+    CountryCode,
+    CurrencyCode,
+    CustomData,
+    Duration,
+    Money,
+    PriceQuantity,
+    PriceTrialPeriod,
+    UnitPriceOverride,
+    Interval,
+    Status,
+    TaxCategory,
+)
+
+from paddle_billing.Exceptions.ApiError import ApiError
+
+from paddle_billing.Resources.Prices.Operations import CreatePrice, UpdatePrice, PriceIncludes
+from paddle_billing.Resources.Products.Operations import CreateProduct, UpdateProduct, ProductIncludes, ListProducts
+
+log = getLogger("my_app")
+
+# Verify your Paddle API key was provided by a PADDLE_SECRET_API_KEY environment variable
+# It is strongly advised that you do not include secrets in your source code
+# Use environment variables, and/or secrets management like Vault to obtain your secrets
+api_key: str = getenv("PADDLE_SECRET_API_KEY", None)
+if not api_key:
+    raise ValueError("You must provide the PADDLE_SECRET_API_KEY in your environment variables")
+
+# Determine the environment, defaulting to sandbox
+environment = Environment(getenv("PADDLE_ENVIRONMENT", "sandbox"))
+
+# Initialize the Paddle client
+paddle = Client(api_key, options=Options(environment), logger=log)
+
+
+# ┌───
+# │ Create Product │
+# └────────────────┘
+try:
+    product = paddle.products.create(
+        CreateProduct(
+            name="Kitten Service",
+            tax_category=TaxCategory.Standard,
+            description="Simply an awesome product",
+            image_url="https://placekitten.com/200/300",
+            custom_data=CustomData({"foo": "bar"}),
+        )
+    )
+except ApiError as error:
+    print(error)
+    exit(1)
+
+print(f"Created product '{product.id}': {product.description}")
+
+
+# ┌───
+# │ Update Product │
+# └────────────────┘
+try:
+    product = paddle.products.update(
+        product.id,
+        UpdateProduct(
+            name="Bear Service",
+            image_url="https://placebear.com/200/300",
+            custom_data=CustomData({"beep": "boop"}),
+        ),
+    )
+except ApiError as error:
+    print(error)
+    exit(1)
+
+print(f"Updated product '{product.id}': {product.description}")
+
+
+# ┌───
+# │ Create Price │
+# └──────────────┘
+try:
+    price = paddle.prices.create(
+        CreatePrice(
+            description="Bear Hug",
+            product_id=product.id,
+            unit_price=Money("1000", CurrencyCode.GBP),
+            trial_period=PriceTrialPeriod(Interval.Week, 1),
+            billing_cycle=Duration(Interval.Year, 1),
+            quantity=PriceQuantity(1, 1),
+            custom_data=CustomData({"foo": "bar"}),
+            unit_price_overrides=[
+                UnitPriceOverride(
+                    [CountryCode.CA, CountryCode.US],
+                    Money("5000", CurrencyCode.USD),
+                ),
+            ],
+        )
+    )
+except ApiError as error:
+    print(error)
+    exit(1)
+
+print(f"Created price '{price.id}': {price.description}")
+
+
+# ┌───
+# │ Update Price │
+# └──────────────┘
+try:
+    price = paddle.prices.update(
+        price.id,
+        UpdatePrice(
+            description="One-off Bear Hug",
+            unit_price=Money("500", CurrencyCode.GBP),
+            custom_data=CustomData({"beep": "boop"}),
+        ),
+    )
+except ApiError as error:
+    print(error)
+    exit(1)
+
+print(f"Updated price '{price.id}': {price.description}")
+
+
+# ┌───
+# │ Get Product with Prices │
+# └─────────────────────────┘
+try:
+    product = paddle.products.get(product.id, [ProductIncludes.Prices])
+except ApiError as error:
+    print(error)
+    exit(1)
+
+print(f"product.prices={product.prices}")
+print(f"Read product '{product.id}' with prices " + ", ".join([str(price.id) for price in product.prices]))
+
+
+# ┌───
+# │ Get Price with Product │
+# └────────────────────────┘
+try:
+    price = paddle.prices.get(price.id, [PriceIncludes.Product])
+except ApiError as error:
+    print(error)
+    exit(1)
+
+print(f"Read price '{price.id}' with product {price.product.id if price.product else 'MISSING PRODUCT'}")
+
+
+# ┌───
+# │ Get Products │
+# └──────────────┘
+try:
+    products = paddle.products.list(
+        ListProducts(
+            includes=[ProductIncludes.Prices],
+            statuses=[Status.Active],
+        )
+    )
+except ApiError as error:
+    print(error)
+    exit(1)
+
+
+# ┌───
+# │ Iterate Products and Prices │
+# └─────────────────────────────┘
+for product in products:
+    print(f"Product: {product.name}")
+    print("-" * len(product.name))
+    for price in product.prices:
+        print(f"Price: {price.name} - {price.description}")
+    print()

paddle_python_sdk-1.16.0/paddle_billing/Client.py

@@ -0,0 +1,226 @@
+from json import dumps as json_dumps
+from logging import Logger, getLogger
+from requests import Response, RequestException, Session
+from requests.adapters import HTTPAdapter
+from typing import Any
+from urllib3.util.retry import Retry
+from urllib.parse import urljoin, urlencode
+from uuid import uuid4
+from paddle_billing.Json import PayloadEncoder
+
+from paddle_billing.Operation import Operation
+from paddle_billing.HasParameters import HasParameters
+from paddle_billing.Options import Options
+from paddle_billing.ResponseParser import ResponseParser
+
+from paddle_billing.Logger.NullHandler import NullHandler
+
+from paddle_billing.Resources.Addresses.AddressesClient import AddressesClient
+from paddle_billing.Resources.Adjustments.AdjustmentsClient import AdjustmentsClient
+from paddle_billing.Resources.Businesses.BusinessesClient import BusinessesClient
+from paddle_billing.Resources.CheckoutDomains.CheckoutDomainsClient import CheckoutDomainsClient
+from paddle_billing.Resources.ClientTokens.ClientTokensClient import ClientTokensClient
+from paddle_billing.Resources.Countries.CountriesClient import CountriesClient
+from paddle_billing.Resources.Currencies.CurrenciesClient import CurrenciesClient
+from paddle_billing.Resources.Customers.CustomersClient import CustomersClient
+from paddle_billing.Resources.CustomerPortalSessions.CustomerPortalSessionsClient import CustomerPortalSessionsClient
+from paddle_billing.Resources.DiscountGroups.DiscountGroupsClient import DiscountGroupsClient
+from paddle_billing.Resources.Discounts.DiscountsClient import DiscountsClient
+from paddle_billing.Resources.Events.EventsClient import EventsClient
+from paddle_billing.Resources.EventTypes.EventTypesClient import EventTypesClient
+from paddle_billing.Resources.IPAddresses.IPAddressesClient import IPAddressesClient
+from paddle_billing.Resources.Notifications.NotificationsClient import NotificationsClient
+from paddle_billing.Resources.NotificationLogs.NotificationLogsClient import NotificationLogsClient
+from paddle_billing.Resources.NotificationSettings.NotificationSettingsClient import NotificationSettingsClient
+from paddle_billing.Resources.PaymentMethods.PaymentMethodsClient import PaymentMethodsClient
+from paddle_billing.Resources.Prices.PricesClient import PricesClient
+from paddle_billing.Resources.PricingPreviews.PricingPreviewsClient import PricingPreviewsClient
+from paddle_billing.Resources.Products.ProductsClient import ProductsClient
+from paddle_billing.Resources.Reports.ReportsClient import ReportsClient
+from paddle_billing.Resources.Simulations.SimulationsClient import SimulationsClient
+from paddle_billing.Resources.SimulationRuns.SimulationRunsClient import SimulationRunsClient
+from paddle_billing.Resources.SimulationRunEvents.SimulationRunEventsClient import SimulationRunEventsClient
+from paddle_billing.Resources.SimulationTypes.SimulationTypesClient import SimulationTypesClient
+from paddle_billing.Resources.Subscriptions.SubscriptionsClient import SubscriptionsClient
+from paddle_billing.Resources.Metrics.MetricsClient import MetricsClient
+from paddle_billing.Resources.Transactions.TransactionsClient import TransactionsClient
+from paddle_billing.Resources.Verifications.VerificationsClient import VerificationsClient
+
+
+class Client:
+    """
+    Client for making API requests using Python's requests library.
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        options: Options | None = None,
+        http_client: Session | None = None,
+        logger: Logger | None = None,
+        retry_count: int = 3,
+        use_api_version: int = 1,
+        timeout: float = 60.0,
+    ):
+        self.__api_key = api_key
+        self.retry_count = retry_count
+        self.transaction_id = None
+        self.use_api_version = use_api_version
+        self.options = options if options else Options()
+        self.log = logger if logger else Client.null_logger()
+        self.client = http_client if http_client else self.build_request_session()
+        self.timeout = timeout
+        self.payload = None  # Used by pytest
+        self.status_code = None  # Used by pytest
+
+        # Initialize the various clients
+        self.addresses = AddressesClient(self)
+        self.adjustments = AdjustmentsClient(self)
+        self.businesses = BusinessesClient(self)
+        self.checkout_domains = CheckoutDomainsClient(self)
+        self.client_tokens = ClientTokensClient(self)
+        self.countries = CountriesClient(self)
+        self.currencies = CurrenciesClient(self)
+        self.customers = CustomersClient(self)
+        self.customer_portal_sessions = CustomerPortalSessionsClient(self)
+        self.discounts = DiscountsClient(self)
+        self.discount_groups = DiscountGroupsClient(self)
+        self.events = EventsClient(self)
+        self.event_types = EventTypesClient(self)
+        self.notifications = NotificationsClient(self)
+        self.notification_logs = NotificationLogsClient(self)
+        self.notification_settings = NotificationSettingsClient(self)
+        self.payment_methods = PaymentMethodsClient(self)
+        self.prices = PricesClient(self)
+        self.pricing_previews = PricingPreviewsClient(self)
+        self.products = ProductsClient(self)
+        self.reports = ReportsClient(self)
+        self.simulations = SimulationsClient(self)
+        self.simulation_runs = SimulationRunsClient(self)
+        self.simulation_run_events = SimulationRunEventsClient(self)
+        self.simulation_types = SimulationTypesClient(self)
+        self.subscriptions = SubscriptionsClient(self)
+        self.transactions = TransactionsClient(self)
+        self.verifications = VerificationsClient(self)
+        self.ip_addresses = IPAddressesClient(self)
+        self.metrics = MetricsClient(self)
+
+    @staticmethod
+    def null_logger() -> Logger:
+        """
+        Create a logger instance that logs everything to nowhere
+        """
+
+        null_logger = getLogger("null_logger")
+        if not null_logger.handlers:
+            null_logger.addHandler(NullHandler())
+
+        return null_logger
+
+    def logging_hook(self, response, *args, **kwargs):
+        """
+        Requests logs were redirected here and to our custom logger which filters out sensitive data
+        """
+
+        self.log.info(f"Request: {response.request.method} {response.request.url}")
+        self.log.debug(f"Response: {response.status_code} {response.text}")
+
+    @staticmethod
+    def serialize_json_payload(payload: dict[str, Any] | Operation) -> str:
+        json_payload = json_dumps(payload, cls=PayloadEncoder)
+        final_json = json_payload if json_payload != "[]" else "{}"
+
+        return final_json
+
+    def _make_request(
+        self,
+        method: str,
+        url: str,
+        payload: dict[str, Any] | Operation | None = None,
+    ) -> Response:
+        """
+        Makes an actual API call to Paddle
+        """
+        # Parse and update URL with base URL components if necessary
+        if isinstance(url, str):
+            url = urljoin(self.options.environment.base_url, url)
+
+        self.client.headers.update(
+            {"X-Transaction-ID": str(self.transaction_id) if self.transaction_id else str(uuid4())}
+        )
+
+        self.payload = self.serialize_json_payload(payload) if payload else None
+        try:
+            # We use data= instead of json= because we manually serialize data into JSON
+            response = self.client.request(method.upper(), url, data=self.payload, timeout=self.timeout)
+            self.status_code = response.status_code
+            response.raise_for_status()
+
+            return response
+        except RequestException as e:
+            api_error = None
+            if e.response is not None:
+                self.status_code = e.response.status_code
+                response_parser = ResponseParser(e.response)
+                api_error = response_parser.get_error()
+
+            if self.log:
+                self.log.error(f"Request failed: {e}.{' ' + api_error.detail if api_error is not None else ''}")
+
+            if api_error is not None:
+                raise api_error
+
+            raise
+
+    @staticmethod
+    def format_uri_parameters(uri: str, parameters: HasParameters | dict[str, str]) -> str:
+        if isinstance(parameters, HasParameters):
+            parameters = parameters.get_parameters()
+
+        query = urlencode(parameters)
+        uri += "&" if "?" in uri else "?"
+        uri += query
+
+        return uri
+
+    def get_raw(self, url: str, parameters: HasParameters | dict[str, str] | None = None) -> Response:
+        url = Client.format_uri_parameters(url, parameters) if parameters else url
+
+        return self._make_request("GET", url, None)
+
+    def post_raw(
+        self,
+        url: str,
+        payload: dict[str, str] | Operation | None = None,
+        parameters: HasParameters | dict[str, str] | None = None,
+    ) -> Response:
+        url = Client.format_uri_parameters(url, parameters) if parameters else url
+
+        return self._make_request("POST", url, payload)
+
+    def patch_raw(self, url: str, payload: dict[str, str] | Operation | None) -> Response:
+        return self._make_request("PATCH", url, payload)
+
+    def delete_raw(self, url: str) -> Response:
+        return self._make_request("DELETE", url)
+
+    def build_request_session(self) -> Session:
+        session = Session()
+        session.headers.update(
+            {
+                "Authorization": f"Bearer {self.__api_key}",
+                "Content-Type": "application/json",
+                "Paddle-Version": str(self.use_api_version),
+                "User-Agent": "PaddleSDK/python 1.16.0",
+            }
+        )
+
+        # Configure retries
+        retries = Retry(total=self.retry_count, backoff_factor=1, status_forcelist=[429, 500, 502, 503, 504])
+        session.mount("https://", HTTPAdapter(max_retries=retries))
+
+        # Handle logging
+        if self.log:
+            session.hooks["response"] = self.logging_hook
+
+        return session

paddle_python_sdk-1.16.0/paddle_billing/Entities/CheckoutDomain.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.CheckoutDomains import CheckoutDomainPaymentMethodVerification, CheckoutDomainStatus
+
+
+@dataclass
+class CheckoutDomain(Entity):
+    id: str
+    domain: str
+    status: CheckoutDomainStatus
+    payment_method_verification: CheckoutDomainPaymentMethodVerification
+    created_at: datetime
+    updated_at: datetime
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> CheckoutDomain:
+        return CheckoutDomain(
+            id=data["id"],
+            domain=data["domain"],
+            status=CheckoutDomainStatus(data["status"]),
+            payment_method_verification=CheckoutDomainPaymentMethodVerification.from_dict(
+                data["payment_method_verification"]
+            ),
+            created_at=datetime.fromisoformat(data["created_at"]),
+            updated_at=datetime.fromisoformat(data["updated_at"]),
+        )

paddle_python_sdk-1.16.0/paddle_billing/Entities/CheckoutDomains/CheckoutDomainApplePayVerification.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+
+from paddle_billing.Entities.CheckoutDomains.CheckoutDomainPaymentMethodVerificationStatus import (
+    CheckoutDomainPaymentMethodVerificationStatus,
+)
+
+
+@dataclass
+class CheckoutDomainApplePayVerification:
+    status: CheckoutDomainPaymentMethodVerificationStatus
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> CheckoutDomainApplePayVerification:
+        return CheckoutDomainApplePayVerification(
+            status=CheckoutDomainPaymentMethodVerificationStatus(data["status"]),
+        )

paddle_python_sdk-1.16.0/paddle_billing/Entities/CheckoutDomains/CheckoutDomainPaymentMethod.py

@@ -0,0 +1,5 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum, PaddleStrEnumMeta
+
+
+class CheckoutDomainPaymentMethod(PaddleStrEnum, metaclass=PaddleStrEnumMeta):
+    ApplePay: "CheckoutDomainPaymentMethod" = "apple_pay"