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

paddle_billing/Entities/Shared/CurrencyCodePayouts.py

@@ -0,0 +1,17 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class CurrencyCodePayouts(PaddleStrEnum):
+    AUD = 'AUD'
+    CAD = 'CAD'
+    CHF = 'CHF'
+    CNY = 'CNY'
+    CZK = 'CZK'
+    DKK = 'DKK'
+    EUR = 'EUR'
+    GBP = 'GBP'
+    HUF = 'HUF'
+    PLN = 'PLN'
+    SEK = 'SEK'
+    USD = 'USD'
+    ZAR = 'ZAR'

paddle_billing/Entities/Shared/CustomData.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class CustomData:
+    data: dict | list  # JSON serializable Python types
+
+
+    def get_parameters(self):
+        return self.data

paddle_billing/Entities/Shared/Data.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+from typing      import Any
+
+
+@dataclass
+class Data:
+    data: dict | list | Any  # TODO Any? Should be JSON serializable Python types though
+
+    # from_dict method isn't needed, unless specific processing of 'data' is required.

paddle_billing/Entities/Shared/ErrorCode.py

@@ -0,0 +1,21 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class ErrorCode(PaddleStrEnum):
+    AlreadyCanceled         = 'already_canceled'
+    AlreadyRefunded         = 'already_refunded'
+    AuthenticationFailed    = 'authentication_failed'
+    BlockedCard             = 'blocked_card'
+    Canceled                = 'canceled'
+    Declined                = 'declined'
+    ExpiredCard             = 'expired_card'
+    Fraud                   = 'fraud'
+    InvalidAmount           = 'invalid_amount'
+    InvalidPaymentDetails   = 'invalid_payment_details'
+    IssuerUnavailable       = 'issuer_unavailable'
+    NotEnoughBalance        = 'not_enough_balance'
+    PspError                = 'psp_error'
+    RedactedPaymentMethod   = 'redacted_payment_method'
+    SystemError             = 'system_error'
+    TransactionNotPermitted = 'transaction_not_permitted'
+    Unknown                 = 'unknown'

paddle_billing/Entities/Shared/ImportMeta.py

@@ -0,0 +1,16 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class ImportMeta:
+    external_id:   str | None
+    imported_from: str
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> ImportMeta:
+        return ImportMeta(
+            external_id   = data.get('external_id'),
+            imported_from = data['imported_from'],
+        )

paddle_billing/Entities/Shared/Interval.py

@@ -0,0 +1,8 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class Interval(PaddleStrEnum):
+    Day   = 'day'
+    Week  = 'week'
+    Month = 'month'
+    Year  = 'year'

paddle_billing/Entities/Shared/Meta.py

@@ -0,0 +1,7 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+
+@dataclass
+class Meta:
+    request_id: str

paddle_billing/Entities/Shared/MetaPaginated.py

@@ -0,0 +1,18 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared.Pagination import Pagination
+
+
+@dataclass
+class MetaPaginated:
+    request_id: str
+    pagination: Pagination
+
+
+    @staticmethod
+    def from_dict(data: dict) -> MetaPaginated:
+        return MetaPaginated(
+            request_id = data['request_id'],
+            pagination = Pagination.from_dict(data['pagination']),
+        )

paddle_billing/Entities/Shared/MethodDetails.py

@@ -0,0 +1,19 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared.Card              import Card
+from paddle_billing.Entities.Shared.PaymentMethodType import PaymentMethodType
+
+
+@dataclass
+class MethodDetails:
+    type: PaymentMethodType
+    card: Card | None
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> MethodDetails:
+        return MethodDetails(
+            PaymentMethodType(data['type']),
+            Card.from_dict(data['card']) if data.get('card') else None,
+        )

paddle_billing/Entities/Shared/Money.py

@@ -0,0 +1,28 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared.CurrencyCode import CurrencyCode
+
+
+@dataclass
+class Money:
+    """
+    https://developer.paddle.com/api-reference/about/data-types#money
+    When specifying the amount, specify it with the lowest denomination of the currency included. For example,
+    $420.69USD would be called with Money('42069', CurrencyCode('USD'))
+    """
+    amount:        str
+    currency_code: CurrencyCode | None
+
+
+    def __post_init__(self):
+        if any(substring in self.amount for substring in [',', '.']):
+            raise ValueError('Money amount should not contain decimals or commas')
+
+
+    @staticmethod
+    def from_dict(data: dict) -> Money:
+        return Money(
+            amount        = data['amount'],
+            currency_code = CurrencyCode(data['currency_code']) if data.get('currency_code') else None,
+        )

paddle_billing/Entities/Shared/Original.py

@@ -0,0 +1,18 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared.CurrencyCodeAdjustments import CurrencyCodeAdjustments
+
+
+@dataclass
+class Original:
+    amount:        str
+    currency_code: CurrencyCodeAdjustments
+
+
+    @staticmethod
+    def from_dict(data: dict) -> Original:
+        return Original(
+            amount        = data['amount'],
+            currency_code = CurrencyCodeAdjustments(data['currency_code']),
+        )

paddle_billing/Entities/Shared/Pagination.py

@@ -0,0 +1,20 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+
+@dataclass
+class Pagination:
+    per_page:        int
+    next:            str
+    has_more:        bool
+    estimated_total: int
+
+
+    @staticmethod
+    def from_dict(data: dict) -> Pagination:
+        return Pagination(
+            per_page        = data['per_page'],
+            next            = data['next'],
+            has_more        = data['has_more'],
+            estimated_total = data['estimated_total'],
+        )

paddle_billing/Entities/Shared/PaymentAttemptStatus.py

@@ -0,0 +1,13 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class PaymentAttemptStatus(PaddleStrEnum):
+    Authorized              = 'authorized'
+    AuthorizedFlagged       = 'authorized_flagged'
+    Canceled                = 'canceled'
+    Captured                = 'captured'
+    Error                   = 'error'
+    ActionRequired          = 'action_required'
+    PendingNoActionRequired = 'pending_no_action_required'
+    Created                 = 'created'
+    Unknown                 = 'unknown'

paddle_billing/Entities/Shared/PaymentMethodType.py

@@ -0,0 +1,14 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class PaymentMethodType(PaddleStrEnum):
+    Alipay       = 'alipay'
+    ApplePay     = 'apple_pay'
+    Bancontact   = 'bancontact'
+    Card         = 'card'
+    GooglePay    = 'google_pay'
+    Ideal        = 'ideal'
+    Offline      = 'offline'
+    Paypal       = 'paypal'
+    Unknown      = 'unknown'
+    WireTransfer = 'wire_transfer'

paddle_billing/Entities/Shared/PayoutTotalsAdjustment.py

@@ -0,0 +1,29 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared.ChargebackFee       import ChargebackFee
+from paddle_billing.Entities.Shared.CurrencyCodePayouts import CurrencyCodePayouts
+
+
+@dataclass
+class PayoutTotalsAdjustment:
+    subtotal:       str
+    tax:            str
+    total:          str
+    fee:            str
+    chargeback_fee: ChargebackFee | None
+    earnings:       str
+    currency_code:  CurrencyCodePayouts
+
+
+    @staticmethod
+    def from_dict(data: dict) -> PayoutTotalsAdjustment:
+        return PayoutTotalsAdjustment(
+            subtotal       = data['subtotal'],
+            tax            = data['tax'],
+            total          = data['total'],
+            fee            = data['fee'],
+            chargeback_fee = ChargebackFee.from_dict(data['chargeback_fee']) if data.get('chargeback_fee') else None,
+            earnings       = data['earnings'],
+            currency_code  = CurrencyCodePayouts(data['currency_code']),
+        )

paddle_billing/Entities/Shared/PriceQuantity.py

@@ -0,0 +1,16 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+
+@dataclass
+class PriceQuantity:
+    minimum: int
+    maximum: int
+
+
+    @staticmethod
+    def from_dict(data: dict) -> PriceQuantity:
+        return PriceQuantity(
+            minimum = data['minimum'],
+            maximum = data['maximum'],
+        )

paddle_billing/Entities/Shared/Status.py

@@ -0,0 +1,6 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class Status(PaddleStrEnum):
+    Active   = 'active'
+    Archived = 'archived'

paddle_billing/Entities/Shared/TaxCategory.py

@@ -0,0 +1,13 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class TaxCategory(PaddleStrEnum):
+    DigitalGoods                = 'digital-goods'
+    Ebooks                      = 'ebooks'
+    ImplementationServices      = 'implementation-services'
+    ProfessionalServices        = 'professional-services'
+    Saas                        = 'saas'
+    SoftwareProgrammingServices = 'software-programming-services'
+    Standard                    = 'standard'
+    TrainingServices            = 'training-services'
+    WebsiteHosting              = 'website-hosting'

paddle_billing/Entities/Shared/TaxMode.py

@@ -0,0 +1,7 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class TaxMode(PaddleStrEnum):
+    AccountSetting = 'account_setting'
+    External       = 'external'
+    Internal       = 'internal'

paddle_billing/Entities/Shared/TaxRatesUsed.py

@@ -0,0 +1,18 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared.Totals import Totals
+
+
+@dataclass
+class TaxRatesUsed:
+    tax_rate: str
+    totals:   Totals
+
+
+    @staticmethod
+    def from_dict(data: dict) -> TaxRatesUsed:
+        return TaxRatesUsed(
+            tax_rate = data['tax_rate'],
+            totals   = Totals.from_dict(data['totals']),
+        )

paddle_billing/Entities/Shared/TimePeriod.py

@@ -0,0 +1,18 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared.Interval import Interval
+
+
+@dataclass
+class TimePeriod:
+    interval:  Interval
+    frequency: int
+
+
+    @staticmethod
+    def from_dict(data: dict) -> TimePeriod:
+        return TimePeriod(
+            interval  = Interval(data['interval']),
+            frequency = data['frequency'],
+        )

paddle_billing/Entities/Shared/Totals.py

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

paddle_billing/Entities/Shared/TransactionDetailsPreview.py

@@ -0,0 +1,22 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared.TaxRatesUsed               import TaxRatesUsed
+from paddle_billing.Entities.Shared.TransactionLineItemPreview import TransactionLineItemPreview
+from paddle_billing.Entities.Shared.TransactionTotals          import TransactionTotals
+
+
+@dataclass
+class TransactionDetailsPreview:
+    tax_rates_used: list[TaxRatesUsed]
+    totals:         TransactionTotals
+    line_items:     list[TransactionLineItemPreview]
+
+
+    @staticmethod
+    def from_dict(data: dict) -> TransactionDetailsPreview:
+        return TransactionDetailsPreview(
+            totals         = TransactionTotals.from_dict(data['totals']),
+            tax_rates_used = [TaxRatesUsed.from_dict(rate)               for rate in data['tax_rates_used']],
+            line_items     = [TransactionLineItemPreview.from_dict(item) for item in data['line_items']],
+        )

paddle_billing/Entities/Shared/TransactionLineItemPreview.py

@@ -0,0 +1,28 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Product           import Product
+from paddle_billing.Entities.Shared.Totals     import Totals
+from paddle_billing.Entities.Shared.UnitTotals import UnitTotals
+
+
+@dataclass
+class TransactionLineItemPreview:
+    price_id:    str
+    quantity:    int
+    tax_rate:    str
+    unit_totals: UnitTotals
+    totals:      Totals
+    product:     Product
+
+
+    @staticmethod
+    def from_dict(data: dict) -> TransactionLineItemPreview:
+        return TransactionLineItemPreview(
+            price_id    = data['price_id'],
+            quantity    = data['quantity'],
+            tax_rate    = data['tax_rate'],
+            unit_totals = UnitTotals.from_dict(data['unit_totals']),
+            totals      = Totals.from_dict(data['totals']),
+            product     = Product.from_dict(data['product']),
+        )

paddle_billing/Entities/Shared/TransactionOrigin.py

@@ -0,0 +1,10 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class TransactionOrigin(PaddleStrEnum):
+    Api                             = 'api'
+    SubscriptionCharge              = 'subscription_charge'
+    SubscriptionPaymentMethodChange = 'subscription_payment_method_change'
+    SubscriptionRecurring           = 'subscription_recurring'
+    SubscriptionUpdate              = 'subscription_update'
+    Web                             = 'web'

paddle_billing/Entities/Shared/TransactionPaymentAttempt.py

@@ -0,0 +1,35 @@
+from __future__  import annotations
+from dataclasses import dataclass
+from datetime    import datetime
+
+from paddle_billing.Entities.Shared.ErrorCode            import ErrorCode
+from paddle_billing.Entities.Shared.MethodDetails        import MethodDetails
+from paddle_billing.Entities.Shared.PaymentAttemptStatus import PaymentAttemptStatus
+
+
+@dataclass
+class TransactionPaymentAttempt:
+    payment_attempt_id:       str
+    payment_method_id:        str
+    stored_payment_method_id: str
+    amount:                   str
+    status:                   PaymentAttemptStatus
+    error_code:               ErrorCode | None
+    method_details:           MethodDetails
+    created_at:               datetime
+    captured_at:              datetime | None
+
+
+    @staticmethod
+    def from_dict(data: dict) -> TransactionPaymentAttempt:
+        return TransactionPaymentAttempt(
+            payment_attempt_id       = data['payment_attempt_id'],
+            payment_method_id        = data['payment_method_id'],
+            stored_payment_method_id = data['stored_payment_method_id'],
+            amount                   = data['amount'],
+            status                   = PaymentAttemptStatus(data['status']),
+            method_details           = MethodDetails.from_dict(data['method_details']),
+            created_at               = datetime.fromisoformat(data['created_at']),
+            error_code               = ErrorCode(data['error_code'])               if data.get('error_code')  else None,
+            captured_at              = datetime.fromisoformat(data['captured_at']) if data.get('captured_at') else None,
+        )

paddle_billing/Entities/Shared/TransactionPayoutTotals.py

@@ -0,0 +1,36 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared.CurrencyCodePayouts import CurrencyCodePayouts
+
+
+@dataclass
+class TransactionPayoutTotals:
+    subtotal:          str
+    discount:          str
+    tax:               str
+    total:             str
+    credit:            str
+    balance:           str
+    grand_total:       str
+    fee:               str | None
+    earnings:          str | None
+    currency_code:     CurrencyCodePayouts
+    credit_to_balance: str
+
+
+    @staticmethod
+    def from_dict(data: dict) -> TransactionPayoutTotals:
+        return TransactionPayoutTotals(
+            subtotal          = data['subtotal'],
+            discount          = data['discount'],
+            tax               = data['tax'],
+            total             = data['total'],
+            credit            = data['credit'],
+            balance           = data['balance'],
+            grand_total       = data['grand_total'],
+            fee               = data.get('fee'),
+            earnings          = data.get('earnings'),
+            currency_code     = CurrencyCodePayouts(data['currency_code']),
+            credit_to_balance = data['credit_to_balance'],
+        )

paddle_billing/Entities/Shared/TransactionPayoutTotalsAdjusted.py

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

paddle_billing/Entities/Shared/TransactionStatus.py

@@ -0,0 +1,11 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class TransactionStatus(PaddleStrEnum):
+    Draft     = 'draft'
+    Ready     = 'ready'
+    Billed    = 'billed'
+    Paid      = 'paid'
+    Completed = 'completed'
+    Canceled  = 'canceled'
+    PastDue   = 'past_due'

paddle_billing/Entities/Shared/TransactionTotals.py

@@ -0,0 +1,36 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared.CurrencyCode import CurrencyCode
+
+
+@dataclass
+class TransactionTotals:
+    subtotal:          str
+    discount:          str
+    tax:               str
+    total:             str
+    credit:            str
+    balance:           str
+    grand_total:       str | None
+    fee:               str | None
+    earnings:          str | None
+    currency_code:     CurrencyCode
+    credit_to_balance: str
+
+
+    @staticmethod
+    def from_dict(data: dict) -> TransactionTotals:
+        return TransactionTotals(
+            subtotal          = data['subtotal'],
+            discount          = data['discount'],
+            tax               = data['tax'],
+            total             = data['total'],
+            credit            = data['credit'],
+            balance           = data['balance'],
+            grand_total       = data.get('grand_total'),
+            fee               = data.get('fee'),
+            earnings          = data.get('earnings'),
+            currency_code     = CurrencyCode(data['currency_code']),
+            credit_to_balance = data['credit_to_balance'],
+        )

paddle_billing/Entities/Shared/TransactionTotalsAdjusted.py

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

paddle_billing/Entities/Shared/UnitPriceOverride.py

@@ -0,0 +1,19 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared.CountryCode import CountryCode
+from paddle_billing.Entities.Shared.Money       import Money
+
+
+@dataclass
+class UnitPriceOverride:
+    country_codes: list[CountryCode]
+    unit_price:    Money
+
+
+    @staticmethod
+    def from_dict(data: dict) -> UnitPriceOverride:
+        return UnitPriceOverride(
+            country_codes = [CountryCode(code) for code in data['country_codes']],
+            unit_price    = Money.from_dict(data['unit_price'])
+        )

paddle_billing/Entities/Shared/UnitTotals.py

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