paddle-python-sdk 0.1.0__py3-none-any.whl

paddle_billing/Entities/Business.py

@@ -0,0 +1,38 @@
+from __future__  import annotations
+from dataclasses import dataclass
+from datetime    import datetime
+
+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
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 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_billing/Entities/Collections/AddressCollection.py

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

paddle_billing/Entities/Collections/AdjustmentCollection.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from paddle_billing.Entities.Collections.Collection import Collection
+from paddle_billing.Entities.Collections.Paginator  import Paginator
+
+
+class AdjustmentCollection(Collection):
+    @classmethod
+    def from_list(cls, items_data: list, paginator: Paginator | None = None) -> AdjustmentCollection:
+        from paddle_billing.Entities.Adjustment import Adjustment
+
+        items: list[Adjustment] = [Adjustment.from_dict(item) for item in items_data]
+
+        return AdjustmentCollection(items, paginator)
+
+
+    def __next__(self):
+        return super().__next__()

paddle_billing/Entities/Collections/BusinessCollection.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from paddle_billing.Entities.Collections.Collection import Collection
+from paddle_billing.Entities.Collections.Paginator  import Paginator
+
+
+class BusinessCollection(Collection):
+    @classmethod
+    def from_list(cls, items_data: list, paginator: Paginator | None = None) -> BusinessCollection:
+        from paddle_billing.Entities.Business import Business
+
+        items: list[Business] = [Business.from_dict(item) for item in items_data]
+
+        return BusinessCollection(items, paginator)
+
+
+    def __next__(self):
+        return super().__next__()

paddle_billing/Entities/Collections/Collection.py

@@ -0,0 +1,47 @@
+from abc             import ABC, abstractmethod
+from collections.abc import Iterator
+
+from paddle_billing.Entities.Collections.Paginator import Paginator
+
+
+class Collection(ABC, Iterator):
+    def __init__(self, items, paginator: Paginator | None = None):
+        self.items     = items
+        self.paginator = paginator
+        self._pointer  = 0
+
+
+    @abstractmethod
+    def from_list(self, data, paginator: Paginator | None = None):
+        pass
+
+
+    def __iter__(self):
+        self._pointer = 0
+
+        return self
+
+
+    def __next__(self):
+        if self._pointer < len(self.items):
+            result         = self.items[self._pointer]
+            self._pointer += 1
+
+            return result
+
+        if self.paginator and self.paginator.has_more:
+            new_collection = self.paginator.next_page()
+            self.items.extend(new_collection.items)  # Append new items
+            self.paginator = new_collection.paginator
+
+            return self.__next__()  # Continue iteration with new items
+
+        raise StopIteration
+
+
+    def current(self):
+        return self.items[self._pointer]
+
+
+    def key(self):
+        return getattr(self.items[self._pointer], 'id', self._pointer)

paddle_billing/Entities/Collections/CreditBalanceCollection.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from paddle_billing.Entities.Collections.Collection import Collection
+from paddle_billing.Entities.Collections.Paginator  import Paginator
+
+
+class CreditBalanceCollection(Collection):
+    @classmethod
+    def from_list(cls, items_data: list, paginator: Paginator | None = None) -> CreditBalanceCollection:
+        from paddle_billing.Entities.CreditBalance import CreditBalance
+
+        items: list[CreditBalance] = [CreditBalance.from_dict(item) for item in items_data]
+
+        return CreditBalanceCollection(items, paginator)
+
+
+    def __next__(self):
+        return super().__next__()

paddle_billing/Entities/Collections/CustomerCollection.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from paddle_billing.Entities.Collections.Collection import Collection
+from paddle_billing.Entities.Collections.Paginator  import Paginator
+
+
+class CustomerCollection(Collection):
+    @classmethod
+    def from_list(cls, items_data: list, paginator: Paginator | None = None) -> CustomerCollection:
+        from paddle_billing.Entities.Customer import Customer
+
+        items: list[Customer] = [Customer.from_dict(item) for item in items_data]
+
+        return CustomerCollection(items, paginator)
+
+
+    def __next__(self):
+        return super().__next__()

paddle_billing/Entities/Collections/DiscountCollection.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from paddle_billing.Entities.Collections.Collection import Collection
+from paddle_billing.Entities.Collections.Paginator  import Paginator
+
+
+class DiscountCollection(Collection):
+    @classmethod
+    def from_list(cls, items_data: list, paginator: Paginator | None = None) -> DiscountCollection:
+        from paddle_billing.Entities.Discount import Discount
+
+        items: list[Discount] = [Discount.from_dict(item) for item in items_data]
+
+        return DiscountCollection(items, paginator)
+
+
+    def __next__(self):
+        return super().__next__()

paddle_billing/Entities/Collections/EventCollection.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from paddle_billing.Entities.Collections.Collection import Collection
+from paddle_billing.Entities.Collections.Paginator  import Paginator
+
+
+class EventCollection(Collection):
+    @classmethod
+    def from_list(cls, items_data: list, paginator: Paginator | None = None) -> EventCollection:
+        from paddle_billing.Entities.Event import Event
+
+        items: list[Event] = [Event.from_dict(item) for item in items_data]
+
+        return EventCollection(items, paginator)
+
+
+    def __next__(self):
+        return super().__next__()

paddle_billing/Entities/Collections/EventTypeCollection.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from paddle_billing.Entities.Collections.Collection import Collection
+from paddle_billing.Entities.Collections.Paginator  import Paginator
+
+
+class EventTypeCollection(Collection):
+    @classmethod
+    def from_list(cls, items_data: list, paginator: Paginator | None = None) -> EventTypeCollection:
+        from paddle_billing.Entities.EventType import EventType
+
+        items: list[EventType] = [EventType.from_dict(item) for item in items_data]
+
+        return EventTypeCollection(items, paginator)
+
+
+    def __next__(self):
+        return super().__next__()

paddle_billing/Entities/Collections/NotificationCollection.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from paddle_billing.Entities.Collections.Collection import Collection
+from paddle_billing.Entities.Collections.Paginator  import Paginator
+
+
+class NotificationCollection(Collection):
+    @classmethod
+    def from_list(cls, items_data: list, paginator: Paginator | None = None) -> NotificationCollection:
+        from paddle_billing.Entities.Notification import Notification
+
+        items: list[Notification] = [Notification.from_dict(item) for item in items_data]
+
+        return NotificationCollection(items, paginator)
+
+
+    def __next__(self):
+        return super().__next__()

paddle_billing/Entities/Collections/NotificationLogCollection.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from paddle_billing.Entities.Collections.Collection import Collection
+from paddle_billing.Entities.Collections.Paginator  import Paginator
+
+
+class NotificationLogCollection(Collection):
+    @classmethod
+    def from_list(cls, items_data: list, paginator: Paginator | None = None) -> NotificationLogCollection:
+        from paddle_billing.Entities.NotificationLog import NotificationLog
+
+        items: list[NotificationLog] = [NotificationLog.from_dict(item) for item in items_data]
+
+        return NotificationLogCollection(items, paginator)
+
+
+    def __next__(self):
+        return super().__next__()

paddle_billing/Entities/Collections/NotificationSettingCollection.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from paddle_billing.Entities.Collections.Collection import Collection
+from paddle_billing.Entities.Collections.Paginator  import Paginator
+
+
+class NotificationSettingCollection(Collection):
+    @classmethod
+    def from_list(cls, items_data: list, paginator: Paginator | None = None) -> NotificationSettingCollection:
+        from paddle_billing.Entities.Notification import Notification
+
+        items: list[Notification] = [Notification.from_dict(item) for item in items_data]
+
+        return NotificationSettingCollection(items, paginator)
+
+
+    def __next__(self):
+        return super().__next__()

paddle_billing/Entities/Collections/Paginator.py

@@ -0,0 +1,29 @@
+from paddle_billing.ResponseParser       import ResponseParser
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from paddle_billing.Client               import Client
+    from paddle_billing.Entities.Collections import Collection
+    from paddle_billing.Entities.Shared      import Pagination
+
+
+class Paginator:
+    def __init__(self, client: 'Client', pagination: 'Pagination', mapper):
+        self._client     = client
+        self._pagination = pagination
+        self._mapper     = mapper
+
+
+    @property
+    def has_more(self) -> bool:
+        return self._pagination.has_more
+
+
+    def next_page(self) -> 'Collection':
+        response        = self._client.get_raw(self._pagination.next)
+        response_parser = ResponseParser(response)
+
+        return self._mapper.from_list(
+            response_parser.get_data(),
+            Paginator(self._client, response_parser.get_pagination(), self._mapper)
+        )

paddle_billing/Entities/Collections/PriceCollection.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from paddle_billing.Entities.Collections.Collection import Collection
+from paddle_billing.Entities.Collections.Paginator  import Paginator
+
+
+class PriceCollection(Collection):
+    @classmethod
+    def from_list(cls, items_data: list, paginator: Paginator | None = None) -> PriceCollection:
+        from paddle_billing.Entities.Price import Price
+
+        items: list[Price] = [Price.from_dict(item) for item in items_data]
+
+        return PriceCollection(items, paginator)
+
+
+    def __next__(self):
+        return super().__next__()

paddle_billing/Entities/Collections/ProductCollection.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from paddle_billing.Entities.Collections.Collection import Collection
+from paddle_billing.Entities.Collections.Paginator  import Paginator
+
+
+class ProductCollection(Collection):
+    @classmethod
+    def from_list(cls, items_data: list, paginator: Paginator | None = None) -> ProductCollection:
+        from paddle_billing.Entities.Product import Product
+
+        items: list[Product] = [Product.from_dict(item) for item in items_data]
+
+        return ProductCollection(items, paginator)
+
+
+    def __next__(self):
+        return super().__next__()

paddle_billing/Entities/Collections/ReportCollection.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from paddle_billing.Entities.Collections.Collection import Collection
+from paddle_billing.Entities.Collections.Paginator  import Paginator
+
+
+class ReportCollection(Collection):
+    @classmethod
+    def from_list(cls, items_data: list, paginator: Paginator | None = None) -> ReportCollection:
+        from paddle_billing.Entities.Report import Report
+
+        items: list[Report] = [Report.from_dict(item) for item in items_data]
+
+        return ReportCollection(items, paginator)
+
+
+    def __next__(self):
+        return super().__next__()

paddle_billing/Entities/Collections/SubscriptionCollection.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from paddle_billing.Entities.Collections.Collection import Collection
+from paddle_billing.Entities.Collections.Paginator  import Paginator
+
+
+class SubscriptionCollection(Collection):
+    @classmethod
+    def from_list(cls, items_data: list, paginator: Paginator | None = None) -> SubscriptionCollection:
+        from paddle_billing.Entities.Subscription import Subscription
+
+        items: list[Subscription] = [Subscription.from_dict(item) for item in items_data]
+
+        return SubscriptionCollection(items, paginator)
+
+
+    def __next__(self):
+        return super().__next__()

paddle_billing/Entities/Collections/SubscriptionPreviewCollection.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from paddle_billing.Entities.Collections.Collection import Collection
+from paddle_billing.Entities.Collections.Paginator  import Paginator
+
+
+class SubscriptionPreviewCollection(Collection):
+    @classmethod
+    def from_list(cls, items_data: list, paginator: Paginator | None = None) -> SubscriptionPreviewCollection:
+        from paddle_billing.Entities.SubscriptionPreview import SubscriptionPreview
+
+        items: list[SubscriptionPreview] = [SubscriptionPreview.from_dict(item) for item in items_data]
+
+        return SubscriptionPreviewCollection(items, paginator)
+
+
+    def __next__(self):
+        return super().__next__()

paddle_billing/Entities/Collections/TransactionCollection.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from paddle_billing.Entities.Collections.Collection import Collection
+from paddle_billing.Entities.Collections.Paginator  import Paginator
+
+
+class TransactionCollection(Collection):
+    @classmethod
+    def from_list(cls, items_data: list, paginator: Paginator | None = None) -> TransactionCollection:
+        from paddle_billing.Entities.Transaction import Transaction
+
+        items: list[Transaction] = [Transaction.from_dict(item) for item in items_data]
+
+        return TransactionCollection(items, paginator)
+
+
+    def __next__(self):
+        return super().__next__()

paddle_billing/Entities/Collections/TransactionPreviewCollection.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from paddle_billing.Entities.Collections.Collection import Collection
+from paddle_billing.Entities.Collections.Paginator  import Paginator
+
+
+class TransactionPreviewCollection(Collection):
+    @classmethod
+    def from_list(cls, items_data: list, paginator: Paginator | None = None) -> TransactionPreviewCollection:
+        from paddle_billing.Entities.TransactionPreview import TransactionPreview
+
+        items: list[TransactionPreview] = [TransactionPreview.from_dict(item) for item in items_data]
+
+        return TransactionPreviewCollection(items, paginator)
+
+
+    def __next__(self):
+        return super().__next__()

paddle_billing/Entities/Collections/TransactionsDataCollection.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from paddle_billing.Entities.Collections.Collection import Collection
+from paddle_billing.Entities.Collections.Paginator  import Paginator
+
+
+class TransactionsDataCollection(Collection):
+    @classmethod
+    def from_list(cls, items_data: list, paginator: Paginator | None = None) -> TransactionsDataCollection:
+        from paddle_billing.Entities.TransactionData import TransactionData
+
+        items: list[TransactionData] = [TransactionData.from_dict(item) for item in items_data]
+
+        return TransactionsDataCollection(items, paginator)
+
+
+    def __next__(self):
+        return super().__next__()

paddle_billing/Entities/Collections/__init__.py

@@ -0,0 +1,21 @@
+from paddle_billing.Entities.Collections.AddressCollection             import AddressCollection
+from paddle_billing.Entities.Collections.AdjustmentCollection          import AdjustmentCollection
+from paddle_billing.Entities.Collections.BusinessCollection            import BusinessCollection
+from paddle_billing.Entities.Collections.Collection                    import Collection
+from paddle_billing.Entities.Collections.CreditBalanceCollection       import CreditBalanceCollection
+from paddle_billing.Entities.Collections.CustomerCollection            import CustomerCollection
+from paddle_billing.Entities.Collections.DiscountCollection            import DiscountCollection
+from paddle_billing.Entities.Collections.EventCollection               import EventCollection
+from paddle_billing.Entities.Collections.EventTypeCollection           import EventTypeCollection
+from paddle_billing.Entities.Collections.NotificationCollection        import NotificationCollection
+from paddle_billing.Entities.Collections.NotificationLogCollection     import NotificationLogCollection
+from paddle_billing.Entities.Collections.NotificationSettingCollection import NotificationSettingCollection
+from paddle_billing.Entities.Collections.Paginator                     import Paginator
+from paddle_billing.Entities.Collections.PriceCollection               import PriceCollection
+from paddle_billing.Entities.Collections.ProductCollection             import ProductCollection
+from paddle_billing.Entities.Collections.ReportCollection              import ReportCollection
+from paddle_billing.Entities.Collections.SubscriptionCollection        import SubscriptionCollection
+from paddle_billing.Entities.Collections.SubscriptionPreviewCollection import SubscriptionPreviewCollection
+from paddle_billing.Entities.Collections.TransactionCollection         import TransactionCollection
+from paddle_billing.Entities.Collections.TransactionPreviewCollection  import TransactionPreviewCollection
+from paddle_billing.Entities.Collections.TransactionsDataCollection    import TransactionsDataCollection

paddle_billing/Entities/CreditBalance.py

@@ -0,0 +1,22 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Entity      import Entity
+from paddle_billing.Entities.Shared      import CurrencyCode
+from paddle_billing.Entities.Adjustments import AdjustmentCustomerBalance
+
+
+@dataclass
+class CreditBalance(Entity):
+    customer_id:   str
+    currency_code: CurrencyCode
+    balance:       AdjustmentCustomerBalance
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> CreditBalance:
+        return CreditBalance(
+            customer_id   = data['customer_id'],
+            currency_code = CurrencyCode(data['currency_code']),
+            balance       = AdjustmentCustomerBalance.from_dict(data['balance']),
+        )

paddle_billing/Entities/Customer.py

@@ -0,0 +1,36 @@
+from __future__  import annotations
+from dataclasses import dataclass
+from datetime    import datetime
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.Shared import CustomData, ImportMeta, Status
+
+
+@dataclass
+class Customer(Entity):
+    id:                str
+    name:              str | None
+    email:             str
+    marketing_consent: bool
+    status:            Status
+    locale:            str
+    created_at:        datetime
+    updated_at:        datetime
+    custom_data:       CustomData | None = None
+    import_meta:       ImportMeta | None = None
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> Customer:
+        return Customer(
+            id                = data['id'],
+            name              = data.get('name'),
+            email             = data['email'],
+            marketing_consent = data['marketing_consent'],
+            status            = Status(data['status']),
+            locale            = data['locale'],
+            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_billing/Entities/DateTime.py

@@ -0,0 +1,43 @@
+from datetime import datetime, timedelta, timezone
+
+
+class DateTime:
+    PADDLE_RFC3339_UTC    = '%Y-%m-%dT%H:%M:%S.%fZ'   # trailing Z for UTC
+    PADDLE_RFC3339_OFFSET = '%Y-%m-%dT%H:%M:%S.%f%z'  # actual timezone offset when not UTC
+    PADDLE_RFC3339        = PADDLE_RFC3339_UTC        # default to UTC
+
+
+    def __init__(self, datetime_str: str = 'now'):
+        if datetime_str == 'now':
+            self._datetime = datetime.now(timezone.utc)
+        else:
+            self._datetime = datetime.fromisoformat(datetime_str).replace(tzinfo=timezone.utc)
+
+
+    @property
+    def as_datetime(self):
+        return self._datetime
+
+
+    def format(self, fmt: str | None = None) -> str:
+        """Returns a RFC3339 formatted datetime string, and handles trailing Z"""
+        if self._datetime.tzinfo == timezone.utc or self._datetime.utcoffset() == timedelta(0):
+            return f"{self._datetime.strftime(fmt if fmt is not None else self.PADDLE_RFC3339)}"
+        else:
+            return f"{self._datetime.strftime(fmt if fmt is not None else self.PADDLE_RFC3339_OFFSET)}"
+
+
+    @classmethod
+    def from_datetime(cls, date: datetime | str):
+        if isinstance(date, str) and date == '0001-01-01T00:00:00Z':
+            return None
+
+        date_str = date if isinstance(date, str) else date.strftime(cls.PADDLE_RFC3339)
+        try:
+            return cls(date_str)
+        except Exception:
+            return None
+
+
+    def __str__(self):
+        return self.format()

paddle_billing/Entities/Discount.py

@@ -0,0 +1,51 @@
+from __future__  import annotations
+from .Entity     import Entity
+from dataclasses import dataclass
+from datetime    import datetime
+
+from paddle_billing.Entities.Discounts import DiscountStatus, DiscountType
+from paddle_billing.Entities.Shared    import CurrencyCode, ImportMeta
+
+
+@dataclass
+class Discount(Entity):
+    id:                          str
+    status:                      DiscountStatus
+    description:                 str
+    enabled_for_checkout:        bool
+    code:                        str | None
+    type:                        DiscountType
+    amount:                      str
+    currency_code:               CurrencyCode | None
+    recur:                       bool
+    maximum_recurring_intervals: int | None
+    usage_limit:                 int | None
+    restrict_to:                 list[str] | None
+    expires_at:                  datetime | None
+    times_used:                  int
+    created_at:                  datetime
+    updated_at:                  datetime
+    import_meta:                 ImportMeta | None
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> Discount:
+        return Discount(
+            id                          = data['id'],
+            status                      = DiscountStatus(data['status']),
+            description                 = data['description'],
+            enabled_for_checkout        = data['enabled_for_checkout'],
+            code                        = data.get('code'),
+            type                        = DiscountType(data['type']),
+            amount                      = data['amount'],
+            recur                       = data['recur'],
+            maximum_recurring_intervals = data.get('maximum_recurring_intervals'),
+            usage_limit                 = data.get('usage_limit'),
+            restrict_to                 = data.get('restrict_to'),
+            times_used                  = data['times_used'],
+            created_at                  = datetime.fromisoformat(data['created_at']),
+            updated_at                  = datetime.fromisoformat(data['updated_at']),
+            currency_code               = CurrencyCode(data['currency_code'])        if data.get('currency_code') else None,
+            expires_at                  = datetime.fromisoformat(data['expires_at']) if data.get('expires_at')    else None,
+            import_meta                 = ImportMeta.from_dict(data['import_meta'])  if data.get('import_meta')   else None,
+        )