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

paddle_billing/Resources/Subscriptions/SubscriptionsClient.py

@@ -0,0 +1,121 @@
+from paddle_billing.ResponseParser import ResponseParser
+
+from paddle_billing.Entities.Subscription        import Subscription
+from paddle_billing.Entities.SubscriptionPreview import SubscriptionPreview
+from paddle_billing.Entities.Transaction         import Transaction
+from paddle_billing.Entities.Collections         import Paginator, SubscriptionCollection
+
+from paddle_billing.Exceptions.SdkExceptions.InvalidArgumentException import InvalidArgumentException
+
+from paddle_billing.Resources.Subscriptions.Operations import (
+    CancelSubscription,
+    CreateOneTimeCharge,
+    SubscriptionIncludes,
+    ListSubscriptions,
+    PauseSubscription,
+    PreviewOneTimeCharge,
+    PreviewUpdateSubscription,
+    ResumeSubscription,
+    UpdateSubscription,
+)
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from paddle_billing.Client import Client
+
+
+class SubscriptionsClient:
+    def __init__(self, client: 'Client'):
+        self.client   = client
+        self.response = None
+
+
+    def list(self, operation: ListSubscriptions = None) -> SubscriptionCollection:
+        if operation is None:
+            operation = ListSubscriptions()
+
+        self.response = self.client.get_raw('/subscriptions', operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return SubscriptionCollection.from_list(
+            parser.get_data(),
+            Paginator(self.client, parser.get_pagination(), SubscriptionCollection)
+        )
+
+
+    def get(self, subscription_id: str, includes = None) -> Subscription:
+        if includes is None:
+            includes = []
+
+        invalid_items = [item for item in includes if not isinstance(item, SubscriptionIncludes)]
+        if invalid_items:
+            raise InvalidArgumentException('includes', SubscriptionIncludes.__name__, invalid_items)
+
+        params        = {'include': ','.join(include.value for include in includes)} if includes else {}
+        self.response = self.client.get_raw(f"/subscriptions/{subscription_id}", params)
+        parser        = ResponseParser(self.response)
+
+        return Subscription.from_dict(parser.get_data())
+
+
+    def update(self, subscription_id: str, operation: UpdateSubscription) -> Subscription:
+        self.response = self.client.patch_raw(f"/subscriptions/{subscription_id}", operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return Subscription.from_dict(parser.get_data())
+
+
+    def pause(self, subscription_id: str, operation: PauseSubscription) -> Subscription:
+        self.response = self.client.post_raw(f"/subscriptions/{subscription_id}/pause", operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return Subscription.from_dict(parser.get_data())
+
+
+    def resume(self, subscription_id: str, operation: ResumeSubscription) -> Subscription:
+        self.response = self.client.post_raw(f"/subscriptions/{subscription_id}/resume", operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return Subscription.from_dict(parser.get_data())
+
+
+    def cancel(self, subscription_id: str, operation: CancelSubscription) -> Subscription:
+        self.response = self.client.post_raw(f"/subscriptions/{subscription_id}/cancel", operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return Subscription.from_dict(parser.get_data())
+
+
+    def get_payment_method_change_transaction(self, subscription_id: str) -> Transaction:
+        self.response = self.client.get_raw(f"/subscriptions/{subscription_id}/update-payment-method-transaction")
+        parser        = ResponseParser(self.response)
+
+        return Transaction.from_dict(parser.get_data())
+
+
+    def activate(self, subscription_id: str) -> Subscription:
+        self.response = self.client.post_raw(f"/subscriptions/{subscription_id}/activate")
+        parser        = ResponseParser(self.response)
+
+        return Subscription.from_dict(parser.get_data())
+
+
+    def create_one_time_charge(self, subscription_id: str, operation: CreateOneTimeCharge) -> Subscription:
+        self.response = self.client.post_raw(f"/subscriptions/{subscription_id}/charge", operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return Subscription.from_dict(parser.get_data())
+
+
+    def preview_update(self, subscription_id: str, operation: PreviewUpdateSubscription) -> SubscriptionPreview:
+        self.response = self.client.patch_raw(f"/subscriptions/{subscription_id}/preview", operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return SubscriptionPreview.from_dict(parser.get_data())
+
+
+    def preview_one_time_charge(self, subscription_id: str, operation: PreviewOneTimeCharge) -> SubscriptionPreview:
+        self.response = self.client.post_raw(f"/subscriptions/{subscription_id}/charge/preview", operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return SubscriptionPreview.from_dict(parser.get_data())

paddle_billing/Resources/Transactions/Operations/CreateTransaction.py

@@ -0,0 +1,25 @@
+from dataclasses import asdict, dataclass
+
+from paddle_billing.Undefined             import Undefined
+from paddle_billing.Entities.Shared       import BillingDetails, Checkout, CollectionMode, CurrencyCode, CustomData, TransactionStatus
+from paddle_billing.Entities.Transactions import TransactionCreateItem, TransactionCreateItemWithPrice, TransactionTimePeriod
+
+
+@dataclass
+class CreateTransaction:
+    items:           list[TransactionCreateItem   | TransactionCreateItemWithPrice] = Undefined()
+    status:          TransactionStatus            | Undefined                       = Undefined()
+    customer_id:     str                   | None | Undefined                       = Undefined()
+    address_id:      str                   | None | Undefined                       = Undefined()
+    business_id:     str                   | None | Undefined                       = Undefined()
+    custom_data:     CustomData            | None | Undefined                       = Undefined()
+    currency_code:   CurrencyCode                 | Undefined                       = Undefined()
+    collection_mode: CollectionMode               | Undefined                       = Undefined()
+    discount_id:     str                   | None | Undefined                       = Undefined()
+    billing_details: BillingDetails        | None | Undefined                       = Undefined()
+    billing_period:  TransactionTimePeriod | None | Undefined                       = Undefined()
+    checkout:        Checkout              | None | Undefined                       = Undefined()
+
+
+    def get_parameters(self) -> dict:
+        return asdict(self)

paddle_billing/Resources/Transactions/Operations/List/Includes.py

@@ -0,0 +1,11 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class Includes(PaddleStrEnum):
+    Address                 = 'address'
+    Adjustment              = 'adjustment'
+    AdjustmentsTotals       = 'adjustments_totals'
+    AvailablePaymentMethods = 'available_payment_methods'
+    Business                = 'business'
+    Customer                = 'customer'
+    Discount                = 'discount'

paddle_billing/Resources/Transactions/Operations/List/Origin.py

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

paddle_billing/Resources/Transactions/Operations/ListTransactions.py

@@ -0,0 +1,86 @@
+from paddle_billing.EnumStringify import enum_stringify
+from paddle_billing.HasParameters import HasParameters
+
+from paddle_billing.Entities.Shared import CollectionMode, TransactionStatus
+
+from paddle_billing.Exceptions.SdkExceptions.InvalidArgumentException import InvalidArgumentException
+
+from paddle_billing.Resources.Shared.Operations                     import DateComparison, Pager
+from paddle_billing.Resources.Transactions.Operations.List.Includes import Includes
+from paddle_billing.Resources.Transactions.Operations.List.Origin   import Origin
+
+
+class ListTransactions(HasParameters):
+    def __init__(
+        self,
+        pager:              Pager          | None   = None,
+        billed_at:          DateComparison | None   = None,
+        collection_mode:    CollectionMode | None   = None,
+        created_at:         DateComparison | None   = None,
+        updated_at:         DateComparison | None   = None,
+        customer_ids:       list[str]               = None,
+        ids:                list[str]               = None,
+        includes:           list[Includes]          = None,
+        invoice_numbers:    list[str]               = None,
+        statuses:           list[TransactionStatus] = None,
+        subscription_ids:   list[str]               = None,
+        origins:            list[Origin]            = None,
+    ):
+        self.pager            = pager
+        self.billed_at        = billed_at
+        self.collection_mode  = collection_mode
+        self.created_at       = created_at
+        self.updated_at       = updated_at
+        self.includes         = includes         if includes         is not None else []
+        self.ids              = ids              if ids              is not None else []
+        self.customer_ids     = customer_ids     if customer_ids     is not None else []
+        self.subscription_ids = subscription_ids if subscription_ids is not None else []
+        self.invoice_numbers  = invoice_numbers  if invoice_numbers  is not None else []
+        self.statuses         = statuses         if statuses         is not None else []
+        self.origins          = origins          if origins          is not None else []
+
+        # Validation
+        for field_name, field_value, field_type in [
+            ('ids',              self.ids,              str),
+            ('customer_ids',     self.customer_ids,     str),
+            ('subscription_ids', self.subscription_ids, str),
+            ('invoice_numbers',  self.invoice_numbers,  str),
+            ('includes',         self.includes,         Includes),
+            ('statuses',         self.statuses,         TransactionStatus),
+            ('origins',          self.origins,          Origin),
+        ]:
+            invalid_items = [item for item in field_value if not isinstance(item, field_type)]
+            if invalid_items:
+                raise InvalidArgumentException(field_name, field_type.__name__, invalid_items)
+
+
+    def get_parameters(self) -> dict:
+        parameters = {}
+        if self.pager:
+            parameters.update(self.pager.get_parameters())
+
+        if self.billed_at is not None:
+            parameters[f"billed_at{self.billed_at.comparator}"] = self.billed_at.formatted()
+        if self.created_at is not None:
+            parameters[f"created_at{self.created_at.comparator}"] = self.created_at.formatted()
+        if self.updated_at is not None:
+            parameters[f"updated_at{self.updated_at.comparator}"] = self.updated_at.formatted()
+
+        if self.collection_mode:
+            parameters['collection_mode'] = self.collection_mode.value
+        if self.customer_ids:
+            parameters['customer_id'] = ','.join(self.customer_ids)
+        if self.ids:
+            parameters['id'] = ','.join(self.ids)
+        if self.includes:
+            parameters['include'] = ','.join(map(enum_stringify, self.includes))
+        if self.invoice_numbers:
+            parameters['invoice_number'] = ','.join(self.invoice_numbers)
+        if self.statuses:
+            parameters['status'] = ','.join(map(enum_stringify, self.statuses))
+        if self.subscription_ids:
+            parameters['subscription_id'] = ','.join(self.subscription_ids)
+        if self.origins:
+            parameters['origin'] = ','.join(map(enum_stringify, self.origins))
+
+        return parameters

paddle_billing/Resources/Transactions/Operations/PreviewTransaction.py

@@ -0,0 +1,24 @@
+from dataclasses import asdict, dataclass
+
+from paddle_billing.Undefined             import Undefined
+from paddle_billing.Entities.Shared       import AddressPreview, CollectionMode, CurrencyCode
+from paddle_billing.Entities.Transactions import TransactionItemPreviewWithPriceId, TransactionItemPreviewWithNonCatalogPrice
+
+
+
+@dataclass
+class PreviewTransaction:
+    items:               list[TransactionItemPreviewWithPriceId | TransactionItemPreviewWithNonCatalogPrice]
+    customer_id:         str            | None | Undefined = Undefined()
+    address_id:          str            | None | Undefined = Undefined()
+    business_id:         str            | None | Undefined = Undefined()
+    currency_code:       CurrencyCode          | Undefined = Undefined()
+    collection_mode:     CollectionMode        | Undefined = Undefined()
+    discount_id:         str            | None | Undefined = Undefined()
+    customer_ip_address: str            | None | Undefined = Undefined()
+    address:             AddressPreview | None | Undefined = Undefined()
+    ignore_trials:       bool                  | Undefined = Undefined()
+
+
+    def get_parameters(self) -> dict:
+        return asdict(self)

paddle_billing/Resources/Transactions/Operations/UpdateTransaction.py

@@ -0,0 +1,25 @@
+from dataclasses import asdict, dataclass
+
+from paddle_billing.Undefined             import Undefined
+from paddle_billing.Entities.Shared       import BillingDetails, Checkout, CollectionMode, CurrencyCode, CustomData, TransactionStatus
+from paddle_billing.Entities.Transactions import TransactionCreateItem, TransactionCreateItemWithPrice, TransactionTimePeriod
+
+
+@dataclass
+class UpdateTransaction:
+    items:           list[TransactionCreateItem   | TransactionCreateItemWithPrice] = Undefined()
+    status:          TransactionStatus            | Undefined                       = Undefined()
+    customer_id:     str                   | None | Undefined                       = Undefined()
+    address_id:      str                   | None | Undefined                       = Undefined()
+    business_id:     str                   | None | Undefined                       = Undefined()
+    custom_data:     CustomData            | None | Undefined                       = Undefined()
+    currency_code:   CurrencyCode                 | Undefined                       = Undefined()
+    collection_mode: CollectionMode               | Undefined                       = Undefined()
+    discount_id:     str                   | None | Undefined                       = Undefined()
+    billing_details: BillingDetails        | None | Undefined                       = Undefined()
+    billing_period:  TransactionTimePeriod | None | Undefined                       = Undefined()
+    checkout:        Checkout              | None | Undefined                       = Undefined()
+
+
+    def get_parameters(self) -> dict:
+        return asdict(self)

paddle_billing/Resources/Transactions/Operations/__init__.py

@@ -0,0 +1,6 @@
+from paddle_billing.Resources.Transactions.Operations.CreateTransaction  import CreateTransaction
+from paddle_billing.Resources.Transactions.Operations.ListTransactions   import ListTransactions
+from paddle_billing.Resources.Transactions.Operations.List.Includes      import Includes as TransactionIncludes
+from paddle_billing.Resources.Transactions.Operations.List.Origin        import Origin   as TransactionOrigin
+from paddle_billing.Resources.Transactions.Operations.PreviewTransaction import PreviewTransaction
+from paddle_billing.Resources.Transactions.Operations.UpdateTransaction  import UpdateTransaction

paddle_billing/Resources/Transactions/TransactionsClient.py

@@ -0,0 +1,90 @@
+from paddle_billing.ResponseParser import ResponseParser
+
+from paddle_billing.Entities.Transaction        import Transaction
+from paddle_billing.Entities.TransactionData    import TransactionData
+from paddle_billing.Entities.TransactionPreview import TransactionPreview
+from paddle_billing.Entities.Collections        import Paginator, TransactionCollection
+
+from paddle_billing.Exceptions.SdkExceptions.InvalidArgumentException import InvalidArgumentException
+
+from paddle_billing.Resources.Transactions.Operations import (
+    CreateTransaction,
+    ListTransactions,
+    UpdateTransaction,
+    PreviewTransaction,
+    TransactionIncludes,
+)
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from paddle_billing.Client import Client
+
+
+class TransactionsClient:
+    def __init__(self, client: 'Client'):
+        self.client   = client
+        self.response = None
+
+
+    def list(self, operation: ListTransactions = None) -> TransactionCollection:
+        if operation is None:
+            operation = ListTransactions()
+
+        self.response = self.client.get_raw('/transactions', operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return TransactionCollection.from_list(
+            parser.get_data(),
+            Paginator(self.client, parser.get_pagination(), TransactionCollection)
+        )
+
+
+    def get(self, transaction_id: str, includes = None) -> Transaction:
+        if includes is None:
+            includes = []
+
+        invalid_items = [item for item in includes if not isinstance(item, TransactionIncludes)]
+        if invalid_items:
+            raise InvalidArgumentException('includes', TransactionIncludes.__name__, invalid_items)
+
+        params        = {'include': ','.join(include.value for include in includes)} if includes else {}
+        self.response = self.client.get_raw(f"/transactions/{transaction_id}", params)
+        parser        = ResponseParser(self.response)
+
+        return Transaction.from_dict(parser.get_data())
+
+
+    def create(self, operation: CreateTransaction, includes = None) -> Transaction:
+        if includes is None:
+            includes = []
+
+        invalid_items = [item for item in includes if not isinstance(item, TransactionIncludes)]
+        if invalid_items:
+            raise InvalidArgumentException('includes', TransactionIncludes.__name__, invalid_items)
+
+        params        = {'include': ','.join(include.value for include in includes)} if includes else {}
+        self.response = self.client.post_raw('/transactions', operation.get_parameters(), params)
+        parser        = ResponseParser(self.response)
+
+        return Transaction.from_dict(parser.get_data())
+
+
+    def update(self, transaction_id: str, operation: UpdateTransaction) -> Transaction:
+        self.response = self.client.patch_raw(f"/transactions/{transaction_id}", operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return Transaction.from_dict(parser.get_data())
+
+
+    def preview(self, operation: PreviewTransaction) -> TransactionPreview:
+        self.response = self.client.post_raw('/transactions/preview', operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return TransactionPreview.from_dict(parser.get_data())
+
+
+    def get_invoice_pdf(self, transaction_id: str) -> TransactionData:
+        self.response = self.client.get_raw(f"/transactions/{transaction_id}/invoice")
+        parser        = ResponseParser(self.response)
+
+        return TransactionData.from_dict(parser.get_data())

paddle_billing/ResponseParser.py

@@ -0,0 +1,65 @@
+import json
+from requests     import Response
+
+from paddle_billing.Entities.Shared import Pagination
+
+from paddle_billing.Exceptions.ApiError import ApiError
+
+
+class ResponseParser:
+    def __init__(self, response: Response):
+        self.body = None
+
+        if not hasattr(response, 'text'):
+            return
+
+        try:
+            self.body = json.loads(response.text)
+        except json.JSONDecodeError:
+            self.body = None
+
+        if self.body and 'error' in self.body:
+            self.parse_errors()
+
+
+    def get_data(self) -> list | dict:
+        return self.body.get('data', []) if self.body else []
+
+
+    def get_pagination(self) -> Pagination:
+        meta       = self.body.get('meta',  {}) if self.body  else {}
+        pagination = meta.get('pagination', {}) if meta       else {}
+
+        return Pagination(
+            per_page        = pagination.get('per_page'),
+            next            = pagination.get('next'),
+            has_more        = pagination.get('has_more'),
+            estimated_total = pagination.get('estimated_total'),
+        )
+
+
+    def parse_errors(self):
+        if not self.body or 'error' not in self.body:
+            return
+
+        error           = self.body['error']
+        code            = error.get('code', 'shared_error')
+        exception_class = self.find_exception_class_from_code(code)
+
+        raise exception_class(error)
+
+
+    @staticmethod
+    def find_exception_class_from_code(code):
+        parts    = code.split('_')
+        resource = parts[0].capitalize() if parts else ''
+
+        if not resource:
+            return ApiError
+
+        class_name = f"api_error.{resource}ApiError"
+        try:
+            module = __import__(class_name, fromlist=[''])
+            return getattr(module, f'{resource}ApiError')
+        except (ImportError, AttributeError):
+            return ApiError

paddle_billing/Undefined.py

@@ -0,0 +1,2 @@
+class Undefined:
+    pass

paddle_billing/__init__.py

@@ -0,0 +1,4 @@
+# The order of these three imports matters
+from paddle_billing.Environment import Environment
+from paddle_billing.Options     import Options
+from paddle_billing.Client      import Client