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

paddle_billing/Notifications/Entities/Customer.py

@@ -0,0 +1,36 @@
+from __future__  import annotations
+from dataclasses import dataclass
+from datetime    import datetime
+
+from paddle_billing.Notifications.Entities.Entity import Entity
+from paddle_billing.Notifications.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/Notifications/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/Notifications/Entities/Discount.py

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

paddle_billing/Notifications/Entities/Discounts/DiscountStatus.py

@@ -0,0 +1,8 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class DiscountStatus(PaddleStrEnum):
+    Active   = 'active'
+    Archived = 'archived'
+    Expired  = 'expired'
+    Used     = 'used'

paddle_billing/Notifications/Entities/Discounts/DiscountType.py

@@ -0,0 +1,7 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class DiscountType(PaddleStrEnum):
+    Flat        = 'flat'
+    FlatPerSeat = 'flat_per_seat'
+    Percentage  = 'percentage'

paddle_billing/Notifications/Entities/Discounts/__init__.py

@@ -0,0 +1,2 @@
+from paddle_billing.Notifications.Entities.Discounts.DiscountStatus import DiscountStatus
+from paddle_billing.Notifications.Entities.Discounts.DiscountType   import DiscountType

paddle_billing/Notifications/Entities/Entity.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+from abc        import ABC, abstractmethod
+
+
+class Entity(ABC):
+    @classmethod
+    @abstractmethod
+    def from_dict(cls, data: dict):
+        """
+        A static factory for the entity that conforms to the Paddle API.
+        """
+        pass

paddle_billing/Notifications/Entities/Payout.py

@@ -0,0 +1,24 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Notifications.Entities.Entity  import Entity
+from paddle_billing.Notifications.Entities.Payouts import PayoutStatus
+from paddle_billing.Notifications.Entities.Shared  import CurrencyCodePayouts
+
+
+@dataclass
+class Payout(Entity):
+    amount:        str
+    currency_code: CurrencyCodePayouts
+    id:            str
+    status:        PayoutStatus
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> Payout:
+        return Payout(
+            amount        = data['amount'],
+            id            = data['id'],
+            status        = PayoutStatus(data['status']),
+            currency_code = CurrencyCodePayouts(data['currency_code']),
+        )

paddle_billing/Notifications/Entities/Payouts/PayoutStatus.py

@@ -0,0 +1,6 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class PayoutStatus(PaddleStrEnum):
+    Unpaid = 'unpaid'
+    Paid   = 'paid'

paddle_billing/Notifications/Entities/Payouts/__init__.py

@@ -0,0 +1 @@
+from paddle_billing.Notifications.Entities.Payouts.PayoutStatus import PayoutStatus

paddle_billing/Notifications/Entities/Price.py

@@ -0,0 +1,66 @@
+from __future__  import annotations
+from dataclasses import dataclass
+from datetime    import datetime
+
+from paddle_billing.Notifications.Entities.Entity import Entity
+from paddle_billing.Notifications.Entities.Shared import (
+    CatalogType,
+    CustomData,
+    ImportMeta,
+    Money,
+    PriceQuantity,
+    Status,
+    TaxMode,
+    TimePeriod,
+    UnitPriceOverride,
+)
+
+from paddle_billing.Logger import get_logger
+log = get_logger()
+
+
+@dataclass
+class Price(Entity):
+    id:                   str
+    product_id:           str
+    name:                 str | None
+    description:          str
+    type:                 CatalogType | None
+    billing_cycle:        TimePeriod  | None
+    trial_period:         TimePeriod  | None
+    tax_mode:             TaxMode
+    unit_price:           Money
+    unit_price_overrides: list[UnitPriceOverride]
+    quantity:             PriceQuantity
+    status:               Status
+    custom_data:          CustomData | None
+    import_meta:          ImportMeta | None
+    created_at:           datetime   | None
+    updated_at:           datetime   | None
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> Price:
+        return Price(
+            id                   = data['id'],
+            product_id           = data['product_id'],
+            name                 = data.get('name'),
+            description          = data['description'],
+            unit_price           = Money.from_dict(data['unit_price']),
+            quantity             = PriceQuantity.from_dict(data['quantity']),
+            status               = Status(data['status']),
+            tax_mode             = TaxMode(data.get('tax_mode')),
+            unit_price_overrides = [UnitPriceOverride.from_dict(override) for override in data.get('unit_price_overrides', [])],
+            type                 = CatalogType(data.get('type'))               if data.get('type')          else None,
+            billing_cycle        = TimePeriod.from_dict(data['billing_cycle']) if data.get('billing_cycle') else None,
+            trial_period         = TimePeriod.from_dict(data['trial_period'])  if data.get('trial_period')  else None,
+            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,
+            created_at           = datetime.fromisoformat(data['created_at'])  if data.get('created_at')    else None,
+            updated_at           = datetime.fromisoformat(data['updated_at'])  if data.get('updated_at')    else None,
+        )
+
+
+
+# Prevents circular import
+from paddle_billing.Entities.Product import Product  # noqa E402

paddle_billing/Notifications/Entities/Product.py

@@ -0,0 +1,45 @@
+from __future__  import annotations
+from dataclasses import dataclass
+from datetime    import datetime
+
+from paddle_billing.Notifications.Entities.Entity import Entity
+from paddle_billing.Notifications.Entities.Shared import CatalogType, CustomData, ImportMeta, Status, TaxCategory
+
+
+@dataclass
+class Product(Entity):
+    id:           str
+    name:         str
+    status:       Status
+    tax_category: TaxCategory
+    description:  str         | None
+    image_url:    str         | None
+    custom_data:  CustomData  | None = None
+    import_meta:  ImportMeta  | None = None
+    prices:       list[Price] | None = None
+    type:         CatalogType | None = None
+    created_at:   datetime    | None = None
+    updated_at:   datetime    | None = None
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> Product:
+        return Product(
+            description  = data.get('description'),
+            id           = data['id'],
+            image_url    = data.get('image_url'),
+            name         = data['name'],
+            status       = Status(data['status']),
+            tax_category = TaxCategory(data['tax_category']),
+            prices       = [Price.from_dict(price) for price in data.get('prices', [])],
+            type         = CatalogType(data['type'])                  if data.get('type')        else None,
+            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,
+            created_at   = datetime.fromisoformat(data['created_at']) if data.get('created_at')  else None,
+            updated_at   = datetime.fromisoformat(data['updated_at']) if data.get('updated_at')  else None,
+        )
+
+
+
+# Prevents circular import
+from paddle_billing.Entities.Price  import Price  # noqa E402

paddle_billing/Notifications/Entities/Report.py

@@ -0,0 +1,32 @@
+from __future__  import annotations
+from dataclasses import dataclass
+from datetime    import datetime
+
+from paddle_billing.Notifications.Entities.Entity  import Entity
+from paddle_billing.Notifications.Entities.Reports import ReportFilter, ReportStatus, ReportType
+
+
+@dataclass
+class Report(Entity):
+    id:         str
+    status:     ReportStatus
+    rows:       int | None
+    type:       ReportType
+    filters:    list[ReportFilter]
+    expires_at: datetime | None
+    created_at: datetime
+    updated_at: datetime
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> Report:
+        return Report(
+            id         = data['id'],
+            status     = ReportStatus(data['status']),
+            rows       = data.get('rows'),
+            type       = ReportType(data['type']),
+            filters    = [ReportFilter.from_dict(a_filter) for a_filter in data.get('filters', [])],
+            expires_at = datetime.fromisoformat(data['expires_at']) if data.get('expires_at') else None,
+            created_at = datetime.fromisoformat(data['created_at']),
+            updated_at = datetime.fromisoformat(data['updated_at']),
+        )

paddle_billing/Notifications/Entities/Reports/ReportFilter.py

@@ -0,0 +1,20 @@
+from __future__  import annotations
+from dataclasses import asdict, dataclass
+
+from paddle_billing.Notifications.Entities.Reports import ReportFilterName, ReportFilterOperator
+
+
+@dataclass
+class ReportFilter:
+    name:     ReportFilterName
+    operator: ReportFilterOperator | None
+    value:    list | str
+
+
+    @staticmethod
+    def from_dict(data: dict) -> ReportFilter:
+        return ReportFilter(**data)
+
+
+    def get_parameters(self) -> dict:
+        return asdict(self)

paddle_billing/Notifications/Entities/Reports/ReportFilterName.py

@@ -0,0 +1,17 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class ReportFilterName(PaddleStrEnum):
+    Action           = 'action'
+    CollectionMode   = 'collection_mode'
+    CurrencyCode     = 'currency_code'
+    Origin           = 'origin'
+    PriceStatus      = 'price_status'
+    PriceType        = 'price_type'
+    PriceUpdatedAt   = 'price_updated_at'
+    ProductStatus    = 'product_status'
+    ProductType      = 'product_type'
+    ProductUpdatedAt = 'product_updated_at'
+    Status           = 'status'
+    Type             = 'type'
+    UpdatedAt        = 'updated_at'

paddle_billing/Notifications/Entities/Reports/ReportFilterOperator.py

@@ -0,0 +1,6 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class ReportFilterOperator(PaddleStrEnum):
+    Lt  = 'lt'
+    Gte = 'gte'

paddle_billing/Notifications/Entities/Reports/ReportStatus.py

@@ -0,0 +1,8 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class ReportStatus(PaddleStrEnum):
+    Pending = 'pending'
+    Ready   = 'ready'
+    Failed  = 'failed'
+    Expired = 'expired'

paddle_billing/Notifications/Entities/Reports/ReportType.py

@@ -0,0 +1,10 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class ReportType(PaddleStrEnum):
+    Adjustments          = 'adjustments'
+    AdjustmentLineItems  = 'adjustment_line_items'
+    Discounts            = 'discounts'
+    ProductsPrices       = 'products_prices'
+    Transactions         = 'transactions'
+    TransactionLineItems = 'transaction_line_items'

paddle_billing/Notifications/Entities/Reports/__init__.py

@@ -0,0 +1,5 @@
+from paddle_billing.Notifications.Entities.Reports.ReportFilter         import ReportFilter
+from paddle_billing.Notifications.Entities.Reports.ReportFilterName     import ReportFilterName
+from paddle_billing.Notifications.Entities.Reports.ReportFilterOperator import ReportFilterOperator
+from paddle_billing.Notifications.Entities.Reports.ReportStatus         import ReportStatus
+from paddle_billing.Notifications.Entities.Reports.ReportType           import ReportType

paddle_billing/Notifications/Entities/Shared/Action.py

@@ -0,0 +1,10 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class Action(PaddleStrEnum):
+    Credit            = 'credit'
+    CreditReverse     = 'credit_reverse'
+    Refund            = 'refund'
+    Chargeback        = 'chargeback'
+    ChargebackReverse = 'chargeback_reverse'
+    ChargebackWarning = 'chargeback_warning'

paddle_billing/Notifications/Entities/Shared/AddressPreview.py

@@ -0,0 +1,18 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Notifications.Entities.Shared.CountryCode import CountryCode
+
+
+@dataclass
+class AddressPreview:
+    postal_code:  str | None
+    country_code: CountryCode
+
+
+    @staticmethod
+    def from_dict(data: dict) -> AddressPreview:
+        return AddressPreview(
+            postal_code  = data.get('postal_code'),
+            country_code = CountryCode(data['country_code']),
+        )

paddle_billing/Notifications/Entities/Shared/AdjustmentItemTotals.py

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

paddle_billing/Notifications/Entities/Shared/AdjustmentProration.py

@@ -0,0 +1,18 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Notifications.Entities.Shared.AdjustmentTimePeriod import AdjustmentTimePeriod
+
+
+@dataclass
+class AdjustmentProration:
+    rate:           str
+    billing_period: AdjustmentTimePeriod
+
+
+    @staticmethod
+    def from_dict(data: dict) -> AdjustmentProration:
+        return AdjustmentProration(
+            rate           = data['rate'],
+            billing_period = AdjustmentTimePeriod.from_dict(data['billing_period']),
+        )

paddle_billing/Notifications/Entities/Shared/AdjustmentStatus.py

@@ -0,0 +1,8 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class AdjustmentStatus(PaddleStrEnum):
+    PendingApproval = 'pending_approval'
+    Approved        = 'approved'
+    Rejected        = 'rejected'
+    Reversed        = 'reversed'

paddle_billing/Notifications/Entities/Shared/AdjustmentTimePeriod.py

@@ -0,0 +1,17 @@
+from __future__  import annotations
+from dataclasses import dataclass
+from datetime    import datetime
+
+
+@dataclass
+class AdjustmentTimePeriod:
+    starts_at: datetime
+    ends_at:   datetime
+
+
+    @staticmethod
+    def from_dict(data: dict) -> AdjustmentTimePeriod:
+        return AdjustmentTimePeriod(
+            starts_at = datetime.fromisoformat(data['starts_at']),
+            ends_at   = datetime.fromisoformat(data['ends_at']),
+        )

paddle_billing/Notifications/Entities/Shared/AdjustmentTotals.py

@@ -0,0 +1,26 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Notifications.Entities.Shared.CurrencyCode import CurrencyCode
+
+
+@dataclass
+class AdjustmentTotals:
+    subtotal:      str
+    tax:           str
+    total:         str
+    fee:           str
+    earnings:      str
+    currency_code: CurrencyCode
+
+
+    @staticmethod
+    def from_dict(data: dict) -> AdjustmentTotals:
+        return AdjustmentTotals(
+            subtotal      = data['subtotal'],
+            tax           = data['tax'],
+            total         = data['total'],
+            fee           = data['fee'],
+            earnings      = data['earnings'],
+            currency_code = CurrencyCode(data['currency_code']),
+        )

paddle_billing/Notifications/Entities/Shared/AdjustmentType.py

@@ -0,0 +1,8 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class AdjustmentType(PaddleStrEnum):
+    Full      = 'full'
+    Partial   = 'partial'
+    Tax       = 'tax'
+    Proration = 'proration'

paddle_billing/Notifications/Entities/Shared/AvailablePaymentMethods.py

@@ -0,0 +1,11 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class AvailablePaymentMethods(PaddleStrEnum):
+    Alipay     = 'alipay'
+    ApplePay   = 'apple_pay'
+    Bancontact = 'bancontact'
+    Card       = 'card'
+    GooglePay  = 'google_pay'
+    Ideal      = 'ideal'
+    Paypal     = 'paypal'

paddle_billing/Notifications/Entities/Shared/BillingDetails.py

@@ -0,0 +1,22 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Notifications.Entities.Shared.TimePeriod import TimePeriod
+
+
+@dataclass
+class BillingDetails:
+    enable_checkout:        bool
+    payment_terms:          TimePeriod
+    purchase_order_number:  str | None = None
+    additional_information: str | None = None
+
+
+    @staticmethod
+    def from_dict(data: dict) -> BillingDetails:
+        return BillingDetails(
+            enable_checkout        = data['enable_checkout'],
+            payment_terms          = TimePeriod.from_dict(data['payment_terms']),
+            purchase_order_number  = data.get('purchase_order_number'),
+            additional_information = data.get('additional_information'),
+        )

paddle_billing/Notifications/Entities/Shared/Card.py

@@ -0,0 +1,24 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Transactions.TransactionCardType import TransactionCardType
+
+
+@dataclass
+class Card:
+    type:            TransactionCardType
+    last4:           str
+    expiry_month:    int
+    expiry_year:     int
+    cardholder_name: str | None
+
+
+    @staticmethod
+    def from_dict(data: dict) -> Card:
+        return Card(
+            type            = TransactionCardType(data['type']),
+            last4           = data['last4'],
+            expiry_month    = data['expiry_month'],
+            expiry_year     = data['expiry_year'],
+            cardholder_name = data.get('cardholder_name'),
+        )

paddle_billing/Notifications/Entities/Shared/CatalogType.py

@@ -0,0 +1,6 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class CatalogType(PaddleStrEnum):
+    Standard = 'standard'
+    Custom   = 'custom'

paddle_billing/Notifications/Entities/Shared/ChargebackFee.py

@@ -0,0 +1,18 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Notifications.Entities.Shared.Original import Original
+
+
+@dataclass
+class ChargebackFee:
+    amount:   str
+    original: Original | None
+
+
+    @staticmethod
+    def from_dict(data: dict) -> ChargebackFee:
+        return ChargebackFee(
+            amount   = data['amount'],
+            original = Original.from_dict(data['original']) if data.get('original') else None,
+        )