paddle-python-sdk 1.6.0__tar.gz → 1.7.0__tar.gz

paddle_python_sdk-1.7.0/PKG-INFO

@@ -0,0 +1,208 @@
+Metadata-Version: 2.4
+Name: paddle-python-sdk
+Version: 1.7.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<8.4.0,>=7.4.4; extra == "dev"
+Requires-Dist: pytest-cov<6.1,>=4.1; extra == "dev"
+Requires-Dist: requests-mock~=1.11.0; 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://www.paddle.com/billing?utm_source=dx&utm_medium=paddle-python-sdk) is a complete digital product sales and subscription management platform, designed for modern software businesses. It helps you increase your revenue, retain customers, and scale your operations.
+
+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 API reference](https://developer.paddle.com/classic/api-reference/1384a288aca7a-api-reference?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')
+```
+
+
+## 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.7.0/paddle_billing/Client.py

@@ -0,0 +1,213 @@
+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.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.Transactions.TransactionsClient import TransactionsClient
+
+
+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.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.ip_addresses = IPAddressesClient(self)
+
+    @staticmethod
+    def null_logger() -> Logger:
+        """
+        Create a logger instance that logs everything to nowhere
+        """
+
+        null_logger = getLogger("null_logger")
+        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.7.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.7.0/paddle_billing/Entities/Address.py

@@ -0,0 +1,44 @@
+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.Shared import CountryCode, CustomData, ImportMeta, Status
+
+
+@dataclass
+class Address(Entity):
+    id: str
+    customer_id: str
+    description: str | None
+    first_line: str | None
+    second_line: str | None
+    city: str | None
+    postal_code: str | None
+    region: str | None
+    country_code: CountryCode
+    custom_data: CustomData | None
+    status: Status
+    created_at: datetime
+    updated_at: datetime
+    import_meta: ImportMeta | None
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> Address:
+        return Address(
+            id=data["id"],
+            customer_id=data["customer_id"],
+            description=data.get("description"),
+            first_line=data.get("first_line"),
+            second_line=data.get("second_line"),
+            city=data.get("city"),
+            postal_code=data.get("postal_code"),
+            region=data.get("region"),
+            country_code=CountryCode(data["country_code"]),
+            status=Status(data["status"]),
+            created_at=datetime.fromisoformat(data["created_at"]),
+            updated_at=datetime.fromisoformat(data["updated_at"]),
+            custom_data=CustomData(data["custom_data"]) if data.get("custom_data") else None,
+            import_meta=ImportMeta.from_dict(data["import_meta"]) if data.get("import_meta") else None,
+        )

paddle_python_sdk-1.7.0/paddle_billing/Entities/Adjustment.py

@@ -0,0 +1,58 @@
+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.Adjustments import AdjustmentItem, AdjustmentTaxRatesUsed
+from paddle_billing.Entities.Shared import (
+    Action,
+    AdjustmentActionType,
+    AdjustmentStatus,
+    CurrencyCode,
+    PayoutTotalsAdjustment,
+    AdjustmentTotals,
+)
+
+
+@dataclass
+class Adjustment(Entity):
+    id: str
+    action: Action
+    transaction_id: str
+    subscription_id: str | None
+    customer_id: str
+    reason: str
+    credit_applied_to_balance: bool | None
+    currency_code: CurrencyCode
+    status: AdjustmentStatus
+    items: list[AdjustmentItem]
+    totals: AdjustmentTotals
+    payout_totals: PayoutTotalsAdjustment | None
+    created_at: datetime
+    updated_at: datetime | None
+    tax_rates_used: list[AdjustmentTaxRatesUsed]
+    type: AdjustmentActionType
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> Adjustment:
+        return Adjustment(
+            id=data["id"],
+            action=Action(data["action"]),
+            transaction_id=data["transaction_id"],
+            subscription_id=data.get("subscription_id"),
+            customer_id=data["customer_id"],
+            reason=data["reason"],
+            credit_applied_to_balance=data.get("credit_applied_to_balance"),
+            currency_code=CurrencyCode(data["currency_code"]),
+            status=AdjustmentStatus(data["status"]),
+            totals=AdjustmentTotals.from_dict(data["totals"]),
+            created_at=datetime.fromisoformat(data["created_at"]),
+            items=[AdjustmentItem.from_dict(item) for item in data["items"]],
+            payout_totals=(
+                PayoutTotalsAdjustment.from_dict(data["payout_totals"]) if data.get("payout_totals") else None
+            ),
+            updated_at=datetime.fromisoformat(data["updated_at"]) if data.get("updated_at") else None,
+            tax_rates_used=[AdjustmentTaxRatesUsed.from_dict(item) for item in data["tax_rates_used"]],
+            type=AdjustmentActionType(data["type"]),
+        )

paddle_python_sdk-1.7.0/paddle_billing/Entities/AdjustmentCreditNote.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+
+from paddle_billing.Entities.Entity import Entity
+
+
+@dataclass
+class AdjustmentCreditNote(Entity):
+    url: str
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> AdjustmentCreditNote:
+        return AdjustmentCreditNote(data["url"])

paddle_python_sdk-1.7.0/paddle_billing/Entities/Adjustments/AdjustmentCustomerBalance.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class AdjustmentCustomerBalance:
+    available: str
+    reserved: str
+    used: str
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> AdjustmentCustomerBalance:
+        return AdjustmentCustomerBalance(
+            available=data["available"],
+            reserved=data["reserved"],
+            used=data["used"],
+        )

paddle_python_sdk-1.7.0/paddle_billing/Entities/Adjustments/AdjustmentItem.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+
+from paddle_billing.Entities.Shared import AdjustmentItemTotals, AdjustmentType, Proration
+
+
+@dataclass
+class AdjustmentItem:
+    id: str
+    item_id: str
+    type: AdjustmentType
+    amount: str | None
+    proration: Proration | None
+    totals: AdjustmentItemTotals
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> AdjustmentItem:
+        return AdjustmentItem(
+            id=data["id"],
+            item_id=data["item_id"],
+            type=AdjustmentType(data["type"]),
+            amount=data.get("amount"),
+            proration=Proration.from_dict(data["proration"]) if data.get("proration") else None,
+            totals=AdjustmentItemTotals.from_dict(data["totals"]),
+        )

paddle_python_sdk-1.7.0/paddle_billing/Entities/Adjustments/AdjustmentTaxRatesUsed.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+
+from paddle_billing.Entities.Adjustments.AdjustmentTotals import AdjustmentTotals
+
+
+@dataclass
+class AdjustmentTaxRatesUsed:
+    tax_rate: str
+    totals: AdjustmentTotals
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> AdjustmentTaxRatesUsed:
+        return AdjustmentTaxRatesUsed(
+            tax_rate=data["tax_rate"],
+            totals=AdjustmentTotals.from_dict(data["totals"]),
+        )

paddle_python_sdk-1.7.0/paddle_billing/Entities/Adjustments/AdjustmentTotals.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class AdjustmentTotals:
+    subtotal: str
+    tax: str
+    total: str
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> AdjustmentTotals:
+        return AdjustmentTotals(
+            subtotal=data["subtotal"],
+            tax=data["tax"],
+            total=data["total"],
+        )

paddle_python_sdk-1.7.0/paddle_billing/Entities/Business.py

@@ -0,0 +1,38 @@
+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.Shared import Contacts, CustomData, ImportMeta, Status
+
+
+@dataclass
+class Business(Entity):
+    id: str
+    customer_id: str
+    name: str
+    company_number: str | None
+    tax_identifier: str | None
+    status: Status
+    contacts: list[Contacts]
+    created_at: datetime
+    updated_at: datetime
+    custom_data: CustomData | None = None
+    import_meta: ImportMeta | None = None
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> Business:
+        return Business(
+            id=data["id"],
+            customer_id=data["customer_id"],
+            name=data["name"],
+            company_number=data.get("company_number"),
+            tax_identifier=data.get("tax_identifier"),
+            status=Status(data["status"]),
+            created_at=datetime.fromisoformat(data["created_at"]),
+            updated_at=datetime.fromisoformat(data["updated_at"]),
+            contacts=[Contacts.from_dict(contact) for contact in data["contacts"]],
+            custom_data=CustomData(data["custom_data"]) if data.get("custom_data") else None,
+            import_meta=ImportMeta.from_dict(data["import_meta"]) if data.get("import_meta") else None,
+        )

paddle_python_sdk-1.7.0/paddle_billing/Entities/Collections/AddressCollection.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+from typing import Any
+
+from paddle_billing.Entities.Address import Address
+from paddle_billing.Entities.Collections.Collection import Collection
+from paddle_billing.Entities.Collections.Paginator import Paginator
+
+
+class AddressCollection(Collection[Address]):
+    @classmethod
+    def from_list(cls, items_data: list[dict[str, Any]], paginator: Paginator | None = None) -> AddressCollection:
+        items: list[Address] = [Address.from_dict(item) for item in items_data]
+
+        return AddressCollection(items, paginator)