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

paddle_billing/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/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/Entities/Discounts/__init__.py

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

paddle_billing/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/Entities/Event.py

@@ -0,0 +1,51 @@
+from __future__  import annotations
+from abc         import ABC
+from dataclasses import dataclass
+from datetime    import datetime
+from importlib   import import_module
+
+from paddle_billing.ConditionallyRemoveImportMeta import conditionally_remove_import_meta
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.Events import EventTypeName
+
+from paddle_billing.Notifications.Entities.Entity import Entity as NotificationEntity
+
+
+@dataclass
+class Event(Entity, ABC):
+    event_id:    str
+    event_type:  EventTypeName
+    occurred_at: datetime
+    data:        NotificationEntity
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> Event:
+        _type = data['event_type'].split('.')[0] or ''
+
+        entity_class_name  = data['event_type'].split('.')[0].lower().title()
+        entity_class       = None
+        instantiated_class = None
+        entity_module_path = 'paddle_billing.Notifications.Entities'
+
+        try:
+            imported_module = import_module(f"{entity_module_path}.{entity_class_name}")
+            entity_class    = getattr(imported_module, entity_class_name)
+
+            conditionally_remove_import_meta(entity_class, data)
+            instantiated_class = entity_class  # (**data['data'])
+        except Exception as error:
+            print(f"Error dynamically instantiating a '{entity_module_path}.{entity_class_name}' object: {error}")
+
+        if not entity_class:
+            raise ValueError(f"Event type '{entity_class_name}' cannot be mapped to an object")
+        if not issubclass(entity_class, NotificationEntity):
+            raise ValueError(f"Event type '{_type}' is not of NotificationEntity")
+
+        return Event(
+            data['event_id'],
+            EventTypeName(data['event_type']),
+            datetime.fromisoformat(data['occurred_at']),
+            instantiated_class.from_dict(data['data']),
+        )

paddle_billing/Entities/EventType.py

@@ -0,0 +1,23 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.Events import EventTypeName
+
+
+@dataclass
+class EventType(Entity):
+    name:               EventTypeName
+    description:        str
+    group:              str
+    available_versions: list
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> EventType:
+        return EventType(
+            name               = EventTypeName(data['name']),
+            description        = data['description'],
+            group              = data['group'],
+            available_versions = data['available_versions'],
+        )

paddle_billing/Entities/Events/EventTypeName.py

@@ -0,0 +1,52 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class EventTypeName(PaddleStrEnum):
+    AddressCreated           = 'address.created'
+    AddressImported          = 'address.imported'
+    AddressUpdated           = 'address.updated'
+    AdjustmentCreated        = 'adjustment.created'
+    AdjustmentUpdated        = 'adjustment.updated'
+    BusinessCreated          = 'business.created'
+    BusinessImported         = 'business.imported'
+    BusinessUpdated          = 'business.updated'
+    CustomerCreated          = 'customer.created'
+    CustomerImported         = 'customer.imported'
+    CustomerUpdated          = 'customer.updated'
+    DiscountCreated          = 'discount.created'
+    DiscountImported         = 'discount.imported'
+    DiscountUpdated          = 'discount.updated'
+    InvoiceCanceled          = 'invoice.canceled'
+    InvoiceCreated           = 'invoice.created'
+    InvoiceIssued            = 'invoice.issued'
+    InvoiceOverdue           = 'invoice.overdue'
+    InvoicePaid              = 'invoice.paid'
+    InvoiceScheduled         = 'invoice.scheduled'
+    PayoutCreated            = 'payout.created'
+    PayoutPaid               = 'payout.paid'
+    PriceCreated             = 'price.created'
+    PriceUpdated             = 'price.updated'
+    PriceImported            = 'price.imported'
+    ProductCreated           = 'product.created'
+    ProductUpdated           = 'product.updated'
+    ProductImported          = 'product.imported'
+    SubscriptionActivated    = 'subscription.activated'
+    SubscriptionCanceled     = 'subscription.canceled'
+    SubscriptionCreated      = 'subscription.created'
+    SubscriptionImported     = 'subscription.imported'
+    SubscriptionPastDue      = 'subscription.past_due'
+    SubscriptionPaused       = 'subscription.paused'
+    SubscriptionResumed      = 'subscription.resumed'
+    SubscriptionTrialing     = 'subscription.trialing'
+    SubscriptionUpdated      = 'subscription.updated'
+    TransactionBilled        = 'transaction.billed'
+    TransactionCanceled      = 'transaction.canceled'
+    TransactionCompleted     = 'transaction.completed'
+    TransactionCreated       = 'transaction.created'
+    TransactionPaid          = 'transaction.paid'
+    TransactionPastDue       = 'transaction.past_due'
+    TransactionPaymentFailed = 'transaction.payment_failed'
+    TransactionReady         = 'transaction.ready'
+    TransactionUpdated       = 'transaction.updated'
+    ReportCreated            = 'report.created'
+    ReportUpdated            = 'report.updated'

paddle_billing/Entities/Events/__init__.py

@@ -0,0 +1 @@
+from paddle_billing.Entities.Events.EventTypeName import EventTypeName

paddle_billing/Entities/Notification.py

@@ -0,0 +1,42 @@
+from __future__  import annotations
+from dataclasses import dataclass
+from datetime    import datetime
+
+from paddle_billing.Entities.Entity        import Entity
+from paddle_billing.Entities.Event         import Event
+from paddle_billing.Entities.Events        import EventTypeName
+from paddle_billing.Entities.Notifications import NotificationOrigin, NotificationStatus
+
+
+@dataclass
+class Notification(Entity):
+    id:                      str
+    type:                    EventTypeName
+    status:                  NotificationStatus
+    payload:                 Event
+    occurred_at:             datetime
+    delivered_at:            datetime | None
+    replayed_at:             datetime | None
+    origin:                  NotificationOrigin
+    last_attempt_at:         datetime | None
+    retry_at:                datetime | None
+    times_attempted:         int
+    notification_setting_id: str
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> Notification:
+        return Notification(
+            id                      = data['id'],
+            type                    = EventTypeName(data['type']),
+            status                  = NotificationStatus(data['status']),
+            payload                 = Event.from_dict(data['payload']),
+            occurred_at             = datetime.fromisoformat(data['occurred_at']),
+            origin                  = NotificationOrigin(data['origin']),
+            times_attempted         = data['times_attempted'],
+            notification_setting_id = data['notification_setting_id'],
+            delivered_at            = datetime.fromisoformat(data['delivered_at'])    if data.get('delivered_at')    else None,
+            replayed_at             = datetime.fromisoformat(data['replayed_at'])     if data.get('replayed_at')     else None,
+            last_attempt_at         = datetime.fromisoformat(data['last_attempt_at']) if data.get('last_attempt_at') else None,
+            retry_at                = datetime.fromisoformat(data['retry_at'])        if data.get('retry_at')        else None,
+        )

paddle_billing/Entities/NotificationLog.py

@@ -0,0 +1,25 @@
+from __future__  import annotations
+from dataclasses import dataclass
+from datetime    import datetime
+
+from paddle_billing.Entities.Entity import Entity
+
+
+@dataclass
+class NotificationLog(Entity):
+    id:                    str
+    response_code:         int
+    response_content_type: str | None
+    response_body:         str
+    attempted_at:          datetime
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> NotificationLog:
+        return NotificationLog(
+            id                    = data['id'],
+            response_code         = data['response_code'],
+            response_content_type = data.get('response_content_type'),
+            response_body         = data['response_body'],
+            attempted_at          = datetime.fromisoformat(data['attempted_at']),
+        )

paddle_billing/Entities/NotificationSetting.py

@@ -0,0 +1,34 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Entity               import Entity
+from paddle_billing.Entities.EventType            import EventType
+from paddle_billing.Entities.NotificationSettings import NotificationSettingType
+
+
+@dataclass
+class NotificationSetting(Entity):
+    id:                       str
+    description:              str
+    type:                     NotificationSettingType
+    destination:              str
+    active:                   bool
+    api_version:              int
+    include_sensitive_fields: bool
+    subscribed_events:        list[EventType]
+    endpoint_secret_key:      str
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> NotificationSetting:
+        return NotificationSetting(
+            id                       = data['id'],
+            description              = data['description'],
+            type                     = NotificationSettingType(data['type']),
+            destination              = data['destination'],
+            active                   = data['active'],
+            api_version              = data['api_version'],
+            include_sensitive_fields = data['include_sensitive_fields'],
+            subscribed_events        = [EventType.from_dict(event) for event in data.get('subscribed_events', [])],
+            endpoint_secret_key      = data['endpoint_secret_key'],
+        )

paddle_billing/Entities/NotificationSettings/NotificationSettingType.py

@@ -0,0 +1,6 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class NotificationSettingType(PaddleStrEnum):
+    Email = 'email'
+    Url   = 'url'

paddle_billing/Entities/NotificationSettings/__init__.py

@@ -0,0 +1 @@
+from paddle_billing.Entities.NotificationSettings.NotificationSettingType import NotificationSettingType

paddle_billing/Entities/Notifications/NotificationOrigin.py

@@ -0,0 +1,6 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class NotificationOrigin(PaddleStrEnum):
+    Event  = 'event'
+    Replay = 'replay'

paddle_billing/Entities/Notifications/NotificationPayout.py

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

paddle_billing/Entities/Notifications/NotificationPayoutStatus.py

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

paddle_billing/Entities/Notifications/NotificationStatus.py

@@ -0,0 +1,8 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class NotificationStatus(PaddleStrEnum):
+    NotAttempted = 'not_attempted'
+    NeedsRetry   = 'needs_retry'
+    Delivered    = 'delivered'
+    Failed       = 'failed'

paddle_billing/Entities/Notifications/__init__.py

@@ -0,0 +1,4 @@
+from paddle_billing.Entities.Notifications.NotificationOrigin       import NotificationOrigin
+from paddle_billing.Entities.Notifications.NotificationPayout       import NotificationPayout
+from paddle_billing.Entities.Notifications.NotificationPayoutStatus import NotificationPayoutStatus
+from paddle_billing.Entities.Notifications.NotificationStatus       import NotificationStatus

paddle_billing/Entities/Price.py

@@ -0,0 +1,68 @@
+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 (
+    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
+    product:              Product    | None
+    created_at:           datetime
+    updated_at:           datetime
+
+
+    @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')),
+            created_at           = datetime.fromisoformat(data['created_at']),
+            updated_at           = datetime.fromisoformat(data['updated_at']),
+            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,
+            product              = Product.from_dict(data['product'])          if data.get('product')       else None,
+        )
+
+
+
+# Prevents circular import
+from paddle_billing.Entities.Product import Product  # noqa E402

paddle_billing/Entities/PricePreview.py

@@ -0,0 +1,34 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Entity          import Entity
+from paddle_billing.Entities.Shared          import AddressPreview, AvailablePaymentMethods, CurrencyCode
+from paddle_billing.Entities.PricingPreviews import PricePreviewDetails
+
+
+@dataclass
+class PricePreview(Entity):
+    customer_id:               str | None
+    address_id:                str | None
+    business_id:               str | None
+    currency_code:             CurrencyCode
+    discount_id:               str | None
+    address:                   AddressPreview | None
+    customer_ip_address:       str | None
+    details:                   PricePreviewDetails
+    available_payment_methods: list[AvailablePaymentMethods]
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> PricePreview:
+        return PricePreview(
+            customer_id               = data.get('customer_id'),
+            address_id                = data.get('address_id'),
+            business_id               = data.get('business_id'),
+            currency_code             = CurrencyCode(data['currency_code']),
+            discount_id               = data.get('discount_id'),
+            address                   = AddressPreview.from_dict(data['address']) if data.get('address') else None,
+            customer_ip_address       = data.get('customer_ip_address'),
+            details                   = PricePreviewDetails.from_dict(data['details']),
+            available_payment_methods = [AvailablePaymentMethods(item) for item in data['available_payment_methods']],
+        )

paddle_billing/Entities/PricingPreviews/PricePreviewDetails.py

@@ -0,0 +1,15 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.PricingPreviews.PricePreviewLineItem import PricePreviewLineItem
+
+
+@dataclass
+class PricePreviewDetails(Entity):
+    line_items: list[PricePreviewLineItem]
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> PricePreviewDetails:
+        return PricePreviewDetails(line_items=[PricePreviewLineItem.from_dict(item) for item in data['line_items']])

paddle_billing/Entities/PricingPreviews/PricePreviewDiscounts.py

@@ -0,0 +1,20 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Discount import Discount
+
+
+@dataclass
+class PricePreviewDiscounts:
+    discount:        Discount
+    total:           str
+    formatted_total: str
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> PricePreviewDiscounts:
+        return PricePreviewDiscounts(
+            discount        = Discount.from_dict(data['discount']),
+            total           = data['total'],
+            formatted_total = data['formatted_total'],
+        )

paddle_billing/Entities/PricingPreviews/PricePreviewItem.py

@@ -0,0 +1,16 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+
+@dataclass
+class PricePreviewItem:
+    price_id: str
+    quantity: int
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> PricePreviewItem:
+        return PricePreviewItem(
+            price_id = data['price_id'],
+            quantity = data['quantity'],
+        )

paddle_billing/Entities/PricingPreviews/PricePreviewLineItem.py

@@ -0,0 +1,38 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Price   import Price
+from paddle_billing.Entities.Product import Product
+from paddle_billing.Entities.Shared  import Totals, UnitTotals
+
+from paddle_billing.Entities.PricingPreviews.PricePreviewDiscounts           import PricePreviewDiscounts
+from paddle_billing.Entities.PricingPreviews.PricePreviewTotalsFormatted     import PricePreviewTotalsFormatted
+from paddle_billing.Entities.PricingPreviews.PricePreviewUnitTotalsFormatted import PricePreviewUnitTotalsFormatted
+
+
+@dataclass
+class PricePreviewLineItem:
+    price:                 Price
+    quantity:              int
+    tax_rate:              str
+    unit_totals:           UnitTotals
+    formatted_unit_totals: PricePreviewUnitTotalsFormatted
+    totals:                Totals
+    formatted_totals:      PricePreviewTotalsFormatted
+    product:               Product
+    discounts:             list[PricePreviewDiscounts]
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> PricePreviewLineItem:
+        return PricePreviewLineItem(
+            price                 = Price.from_dict(data['price']),
+            quantity              = data['quantity'],
+            tax_rate              = data['tax_rate'],
+            unit_totals           = UnitTotals.from_dict(data['unit_totals']),
+            formatted_unit_totals = PricePreviewUnitTotalsFormatted.from_dict(data['formatted_unit_totals']),
+            totals                = Totals.from_dict(data['totals']),
+            formatted_totals      = PricePreviewTotalsFormatted.from_dict(data['formatted_totals']),
+            product               = Product.from_dict(data['product']),
+            discounts             = [PricePreviewDiscounts.from_dict(item) for item in data['discounts']],
+        )

paddle_billing/Entities/PricingPreviews/PricePreviewTotalsFormatted.py

@@ -0,0 +1,20 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+
+@dataclass
+class PricePreviewTotalsFormatted:
+    subtotal: str
+    discount: str
+    tax:      str
+    total:    str
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> PricePreviewTotalsFormatted:
+        return PricePreviewTotalsFormatted(
+            subtotal = data['subtotal'],
+            discount = data['discount'],
+            tax      = data['tax'],
+            total    = data['total'],
+        )

paddle_billing/Entities/PricingPreviews/PricePreviewUnitTotalsFormatted.py

@@ -0,0 +1,20 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+
+@dataclass
+class PricePreviewUnitTotalsFormatted:
+    subtotal: str
+    discount: str
+    tax:      str
+    total:    str
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> PricePreviewUnitTotalsFormatted:
+        return PricePreviewUnitTotalsFormatted(
+            subtotal = data['subtotal'],
+            discount = data['discount'],
+            tax      = data['tax'],
+            total    = data['total'],
+        )

paddle_billing/Entities/PricingPreviews/__init__.py

@@ -0,0 +1,6 @@
+from paddle_billing.Entities.PricingPreviews.PricePreviewDetails             import PricePreviewDetails
+from paddle_billing.Entities.PricingPreviews.PricePreviewDiscounts           import PricePreviewDiscounts
+from paddle_billing.Entities.PricingPreviews.PricePreviewItem                import PricePreviewItem
+from paddle_billing.Entities.PricingPreviews.PricePreviewLineItem            import PricePreviewLineItem
+from paddle_billing.Entities.PricingPreviews.PricePreviewTotalsFormatted     import PricePreviewTotalsFormatted
+from paddle_billing.Entities.PricingPreviews.PricePreviewUnitTotalsFormatted import PricePreviewUnitTotalsFormatted

paddle_billing/Entities/Product.py

@@ -0,0 +1,45 @@
+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 CatalogType, CustomData, ImportMeta, Status, TaxCategory
+
+
+@dataclass
+class Product(Entity):
+    id:           str
+    name:         str
+    status:       Status
+    tax_category: TaxCategory
+    created_at:   datetime
+    updated_at:   datetime
+    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
+
+
+    @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']),
+            created_at   = datetime.fromisoformat(data['created_at']),
+            updated_at   = datetime.fromisoformat(data['updated_at']),
+            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,
+        )
+
+
+
+# Prevents circular import
+from paddle_billing.Entities.Price  import Price  # noqa E402