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

paddle_billing/Entities/Transactions/TransactionLineItem.py

@@ -0,0 +1,35 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Product import Product
+
+from paddle_billing.Entities.Transactions.TransactionProration import TransactionProration
+
+from paddle_billing.Entities.Shared.Totals     import Totals
+from paddle_billing.Entities.Shared.UnitTotals import UnitTotals
+
+
+@dataclass
+class TransactionLineItem:
+    id:          str
+    price_id:    str
+    quantity:    int
+    proration:   TransactionProration | None
+    tax_rate:    str
+    unit_totals: UnitTotals
+    totals:      Totals
+    product:     Product
+
+
+    @staticmethod
+    def from_dict(data: dict) -> TransactionLineItem:
+        return TransactionLineItem(
+            id          = data['id'],
+            price_id    = data['price_id'],
+            quantity    = data['quantity'],
+            proration   = TransactionProration.from_dict(data['proration']) if data.get('proration') else None,
+            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/Transactions/TransactionNonCatalogPrice.py

@@ -0,0 +1,39 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared.TimePeriod        import TimePeriod
+from paddle_billing.Entities.Shared.TaxMode           import TaxMode
+from paddle_billing.Entities.Shared.Money             import Money
+from paddle_billing.Entities.Shared.PriceQuantity     import PriceQuantity
+from paddle_billing.Entities.Shared.CustomData        import CustomData
+from paddle_billing.Entities.Shared.UnitPriceOverride import UnitPriceOverride
+
+
+@dataclass
+class TransactionNonCatalogPrice:
+    description:          str
+    name:                 str        | None
+    billing_cycle:        TimePeriod | None
+    trial_period:         TimePeriod | None
+    custom_data:          CustomData | None
+    tax_mode:             TaxMode
+    unit_price:           Money
+    unit_price_overrides: list[UnitPriceOverride]
+    quantity:             PriceQuantity
+    product_id:           str
+
+
+    @staticmethod
+    def from_dict(data: dict) -> TransactionNonCatalogPrice:
+        return TransactionNonCatalogPrice(
+            description          = data['description'],
+            name                 = data.get('name'),
+            tax_mode             = data['tax_mode'],
+            unit_price           = Money.from_dict(data['unit_price']),
+            quantity             = PriceQuantity.from_dict(data['quantity']),
+            product_id           = data['product_id'],
+            unit_price_overrides = [UnitPriceOverride.from_dict(item) for item in data['unit_price_overrides']],
+            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,
+        )

paddle_billing/Entities/Transactions/TransactionNonCatalogPriceWithProduct.py

@@ -0,0 +1,41 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared.CustomData        import CustomData
+from paddle_billing.Entities.Shared.Money             import Money
+from paddle_billing.Entities.Shared.PriceQuantity     import PriceQuantity
+from paddle_billing.Entities.Shared.TaxMode           import TaxMode
+from paddle_billing.Entities.Shared.TimePeriod        import TimePeriod
+from paddle_billing.Entities.Shared.UnitPriceOverride import UnitPriceOverride
+
+from paddle_billing.Entities.Transactions.TransactionNonCatalogProduct import TransactionNonCatalogProduct
+
+
+@dataclass
+class TransactionNonCatalogPriceWithProduct:
+    description:          str
+    name:                 str        | None
+    billing_cycle:        TimePeriod | None
+    trial_period:         TimePeriod | None
+    custom_data:          CustomData | None
+    tax_mode:             TaxMode
+    unit_price:           Money
+    unit_price_overrides: list[UnitPriceOverride]
+    quantity:             PriceQuantity
+    product:              TransactionNonCatalogProduct
+
+
+    @staticmethod
+    def from_dict(data: dict) -> TransactionNonCatalogPriceWithProduct:
+        return TransactionNonCatalogPriceWithProduct(
+            description          = data['description'],
+            name                 = data.get('name'),
+            tax_mode             = data['tax_mode'],
+            unit_price           = Money.from_dict(data['unit_price']),
+            quantity             = PriceQuantity.from_dict(data['quantity']),
+            product              = TransactionNonCatalogProduct.from_dict(data['product_id']),
+            unit_price_overrides = [UnitPriceOverride.from_dict(item) for item in data['unit_price_overrides']],
+            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,
+        )

paddle_billing/Entities/Transactions/TransactionNonCatalogProduct.py

@@ -0,0 +1,25 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared.CustomData  import CustomData
+from paddle_billing.Entities.Shared.TaxCategory import TaxCategory
+
+
+@dataclass
+class TransactionNonCatalogProduct:
+    name:         str
+    tax_category: TaxCategory
+    description:  str        | None
+    image_url:    str        | None
+    custom_data:  CustomData | None
+
+
+    @staticmethod
+    def from_dict(data: dict) -> TransactionNonCatalogProduct:
+        return TransactionNonCatalogProduct(
+            name         = data['name'],
+            description  = data.get('description'),
+            image_url    = data.get('image_url'),
+            tax_category = TaxCategory(data['tax_category']) if data.get('tax_category') else None,
+            custom_data  = CustomData(data['custom_data'])   if data.get('custom_data')  else None,
+        )

paddle_billing/Entities/Transactions/TransactionProration.py

@@ -0,0 +1,18 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Transactions.TransactionTimePeriod import TransactionTimePeriod
+
+
+@dataclass
+class TransactionProration:
+    rate:           str
+    billing_period: TransactionTimePeriod | None
+
+
+    @staticmethod
+    def from_dict(data: dict) -> TransactionProration:
+        return TransactionProration(
+            rate           = data['rate'],
+            billing_period = TransactionTimePeriod.from_dict(data['billing_period']) if data.get('billing_period') else None,
+        )

paddle_billing/Entities/Transactions/TransactionTimePeriod.py

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

paddle_billing/Entities/Transactions/TransactionUpdateTransactionItem.py

@@ -0,0 +1,8 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+
+@dataclass
+class TransactionUpdateTransactionItem:
+    price_id: str
+    quantity: int

paddle_billing/Entities/Transactions/__init__.py

@@ -0,0 +1,20 @@
+from paddle_billing.Entities.Transactions.TransactionAdjustmentsTotals              import TransactionAdjustmentsTotals
+from paddle_billing.Entities.Transactions.TransactionBreakdown                      import TransactionBreakdown
+from paddle_billing.Entities.Transactions.TransactionCardType                       import TransactionCardType
+from paddle_billing.Entities.Transactions.TransactionCreateItem                     import TransactionCreateItem
+from paddle_billing.Entities.Transactions.TransactionCreateItemWithPrice            import TransactionCreateItemWithPrice
+from paddle_billing.Entities.Transactions.TransactionItemPreviewWithNonCatalogPrice import TransactionItemPreviewWithNonCatalogPrice
+from paddle_billing.Entities.Transactions.TransactionItemPreviewWithPriceId         import TransactionItemPreviewWithPriceId
+from paddle_billing.Entities.Transactions.TransactionNonCatalogPrice                import TransactionNonCatalogPrice
+from paddle_billing.Entities.Transactions.TransactionNonCatalogPriceWithProduct     import TransactionNonCatalogPriceWithProduct
+from paddle_billing.Entities.Transactions.TransactionNonCatalogProduct              import TransactionNonCatalogProduct
+from paddle_billing.Entities.Transactions.TransactionProration                      import TransactionProration
+from paddle_billing.Entities.Transactions.TransactionTimePeriod                     import TransactionTimePeriod
+from paddle_billing.Entities.Transactions.TransactionUpdateTransactionItem          import TransactionUpdateTransactionItem
+
+
+# These cause circular imports
+# from paddle_billing.Entities.Transactions.TransactionDetails                        import TransactionDetails
+# from paddle_billing.Entities.Transactions.TransactionItem                           import TransactionItem
+# from paddle_billing.Entities.Transactions.TransactionItemPreviewWithPrice           import TransactionItemPreviewWithPrice
+# from paddle_billing.Entities.Transactions.TransactionLineItem                       import TransactionLineItem

paddle_billing/EnumStringify.py

@@ -0,0 +1,2 @@
+def enum_stringify(enum):
+    return enum.value

paddle_billing/Environment.py

@@ -0,0 +1,14 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class Environment(PaddleStrEnum):
+    PRODUCTION = 'production'
+    SANDBOX    = 'sandbox'
+
+
+    @property
+    def base_url(self) -> str:
+        return {
+            'production': 'https://api.paddle.com',
+            'sandbox':    'https://sandbox-api.paddle.com',
+        }[self.value]

paddle_billing/Exceptions/ApiError.py

@@ -0,0 +1,28 @@
+from paddle_billing.Exceptions.FieldError import FieldError
+
+
+class ApiError(Exception):
+    def __init__(self, error_type, error_code, detail, docs_url, *field_errors):
+        self.error_type   = error_type
+        self.error_code   = error_code
+        self.detail       = detail
+        self.docs_url     = docs_url
+        self.field_errors = field_errors
+        super().__init__(self.detail)
+
+
+    def __repr__(self):
+        return (f"ApiError(type='{self.error_type}', error_code='{self.error_code}', detail='{self.detail}', "
+                f"docs_url='{self.docs_url}', field_errors={self.field_errors})")
+
+
+    @classmethod
+    def from_error_data(cls, error):
+        field_errors = [FieldError(fe['field'], fe['message']) for fe in error.get('errors', [])]
+        return cls(
+            error['type'],
+            error['code'],
+            error['detail'],
+            error['documentation_url'],
+            *field_errors
+        )

paddle_billing/Exceptions/ApiErrors/AddressApiError.py

@@ -0,0 +1,5 @@
+from paddle_billing.Exceptions.ApiError import ApiError
+
+
+class AddressApiError(ApiError):
+    pass

paddle_billing/Exceptions/ApiErrors/AdjustmentApiError.py

@@ -0,0 +1,5 @@
+from paddle_billing.Exceptions.ApiError import ApiError
+
+
+class AdjustmentApiError(ApiError):
+    pass

paddle_billing/Exceptions/ApiErrors/BusinessApiError.py

@@ -0,0 +1,5 @@
+from paddle_billing.Exceptions.ApiError import ApiError
+
+
+class BusinessApiError(ApiError):
+    pass

paddle_billing/Exceptions/ApiErrors/CustomerApiError.py

@@ -0,0 +1,5 @@
+from paddle_billing.Exceptions.ApiError import ApiError
+
+
+class CustomerApiError(ApiError):
+    pass

paddle_billing/Exceptions/ApiErrors/DiscountApiError.py

@@ -0,0 +1,5 @@
+from paddle_billing.Exceptions.ApiError import ApiError
+
+
+class DiscountApiError(ApiError):
+    pass

paddle_billing/Exceptions/ApiErrors/PriceApiError.py

@@ -0,0 +1,5 @@
+from paddle_billing.Exceptions.ApiError import ApiError
+
+
+class PriceApiError(ApiError):
+    pass

paddle_billing/Exceptions/ApiErrors/ProductApiError.py

@@ -0,0 +1,5 @@
+from paddle_billing.Exceptions.ApiError import ApiError
+
+
+class ProductApiError(ApiError):
+    pass

paddle_billing/Exceptions/ApiErrors/SubscriptionApiError.py

@@ -0,0 +1,5 @@
+from paddle_billing.Exceptions.ApiError import ApiError
+
+
+class SubscriptionApiError(ApiError):
+    pass

paddle_billing/Exceptions/ApiErrors/TransactionApiError.py

@@ -0,0 +1,5 @@
+from paddle_billing.Exceptions.ApiError import ApiError
+
+
+class TransactionApiError(ApiError):
+    pass

paddle_billing/Exceptions/FieldError.py

@@ -0,0 +1,8 @@
+class FieldError:
+    def __init__(self, field, error):
+        self.field = field
+        self.error = error
+
+
+    def __repr__(self):
+        return f"FieldError(field='{self.field}', error='{self.error}')"

paddle_billing/Exceptions/SdkException.py

@@ -0,0 +1,2 @@
+class SdkException(Exception):
+    pass

paddle_billing/Exceptions/SdkExceptions/InvalidArgumentException.py

@@ -0,0 +1,8 @@
+from paddle_billing.Exceptions.SdkException import SdkException
+
+
+class InvalidArgumentException(SdkException):
+    @staticmethod
+    def array_contains_invalid_types(field, expected_type, given):
+        message = f"Expected '{field}' to only contain only type/s '{expected_type}', '{given}' given"
+        return InvalidArgumentException(message)

paddle_billing/Exceptions/SdkExceptions/MalformedResponse.py

@@ -0,0 +1,7 @@
+from paddle_billing.Exceptions.SdkException import SdkException
+
+
+class MalformedResponse(SdkException):
+    def __init__(self, e):
+        super().__init__(str(e))
+        self.original_exception = e

paddle_billing/FiltersNone.py

@@ -0,0 +1,8 @@
+class FiltersNone:
+    @staticmethod
+    def filter_none_values(input_dict) -> dict:
+        """
+        This method filters out values that are None from the given list
+        """
+        return {key: value for key, value in input_dict.items() if value is not None}
+

paddle_billing/FiltersUndefined.py

@@ -0,0 +1,11 @@
+from paddle_billing.Undefined import Undefined
+
+
+class FiltersUndefined:
+    @staticmethod
+    def filter_undefined_values(input_dict) -> dict:
+        """
+        This method filters out values that are None from the given list
+        """
+        return {key: value for key, value in input_dict.items() if not isinstance(value, Undefined)}
+

paddle_billing/HasParameters.py

@@ -0,0 +1,11 @@
+from abc import ABC, abstractmethod
+
+
+class HasParameters(ABC):
+    @abstractmethod
+    def get_parameters(self) -> dict:
+        """
+        Implementations of this method should return a dictionary of parameters
+        suitable to be used in API calls, e.g., {'foo': 'bar'} which would result in foo=bar in an API call.
+        """
+        pass

paddle_billing/Logger/Formatter.py

@@ -0,0 +1,18 @@
+import logging
+import re
+
+
+class CustomLogger(logging.Filter):
+    def filter(self, record):
+        # Define multiple regex patterns for different sensitive data types
+        search_patterns = {
+            r"'X-Transaction-ID': '\s*([^']+)'": "'X-Transaction-ID': '<redacted>'",
+            r"Bearer \s*([^']+)":                "Bearer <API_SECRET_KEY>",
+        }
+
+        # If the log record's message is a string, apply each regex substitution
+        if isinstance(record.msg, str):
+            for pattern, replacement in search_patterns.items():
+                record.msg = re.sub(pattern, replacement, record.msg)
+
+        return True  # Return True to indicate the record should be processed

paddle_billing/Logger/NullHandler.py

@@ -0,0 +1,6 @@
+import logging
+
+
+class NullHandler(logging.Handler):
+    def emit(self, record):
+        pass

paddle_billing/Logger/__init__.py

@@ -0,0 +1,30 @@
+import logging
+from paddle_billing.Logger.Formatter import CustomLogger
+
+
+def get_logger(
+    log_level:     int        = logging.INFO,
+    log_file_path: str | None = None,
+) -> logging.Logger:
+    """
+    Configures a logger instance that our Client() uses
+
+    :param log_level:     Defaults to logging.INFO
+    :param log_file_path: Defaults to None, which streams logs to the console. If a file path is provided logs are written to the file.
+    :return:              Returns a logger instance
+    """
+    logger = logging.getLogger('paddle_billing')
+
+    if not logger.handlers:
+        logger.setLevel(log_level)
+
+        formatter = logging.Formatter("{asctime} {levelname:<8} {message}", style='{')
+        handler   = logging.NullHandler() if not log_file_path else logging.FileHandler(log_file_path)
+
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+
+        # Filter out secrets from outputting to logs
+        logger.addFilter(CustomLogger())
+
+    return logger

paddle_billing/Notifications/Entities/Address.py

@@ -0,0 +1,44 @@
+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 CountryCode, CustomData, ImportMeta, Status
+
+
+@dataclass
+class Address(Entity):
+    id:           str
+    description:  str | None
+    first_line:   str | None
+    second_line:  str | None
+    city:         str | None
+    postal_code:  str | None
+    region:       str | None
+    country_code: CountryCode
+    status:       Status
+    created_at:   datetime
+    updated_at:   datetime
+    custom_data:  CustomData | None = None
+    import_meta:  ImportMeta | None = None
+    customer_id:  str        | None = None
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> Address:
+        return Address(
+            id           = data['id'],
+            customer_id  = data.get('customer_id'),
+            description  = data.get('description'),
+            first_line   = data.get('first_line'),
+            second_line  = data.get('second_line'),
+            city         = data.get('city'),
+            postal_code  = data.get('postal_code'),
+            region       = data.get('region'),
+            country_code = CountryCode(data['country_code']),
+            status       = Status(data['status']),
+            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/Adjustment.py

@@ -0,0 +1,45 @@
+from __future__  import annotations
+from dataclasses import dataclass
+from datetime    import datetime
+
+from paddle_billing.Notifications.Entities.Adjustments import AdjustmentItem
+from paddle_billing.Notifications.Entities.Entity      import Entity
+from paddle_billing.Notifications.Entities.Shared      import Action, AdjustmentStatus, CurrencyCode, PayoutTotalsAdjustment, AdjustmentTotals
+
+
+@dataclass
+class Adjustment(Entity):
+    id:                        str
+    action:                    Action
+    transaction_id:            str
+    subscription_id:           str | None
+    customer_id:               str
+    reason:                    str
+    credit_applied_to_balance: bool | None
+    currency_code:             CurrencyCode
+    status:                    AdjustmentStatus
+    items:                     list[AdjustmentItem]
+    totals:                    AdjustmentTotals
+    payout_totals:             PayoutTotalsAdjustment | None
+    created_at:                datetime
+    updated_at:                datetime | None
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> Adjustment:
+        return Adjustment(
+            id                        = data['id'],
+            action                    = Action(data['action']),
+            transaction_id            = data['transaction_id'],
+            subscription_id           = data.get('subscription_id'),
+            customer_id               = data['customer_id'],
+            reason                    = data['reason'],
+            credit_applied_to_balance = data.get('credit_applied_to_balance'),
+            currency_code             = CurrencyCode(data['currency_code']),
+            status                    = AdjustmentStatus(data['status']),
+            totals                    = AdjustmentTotals.from_dict(data['totals']),
+            created_at                = datetime.fromisoformat(data['created_at']),
+            items                     = [AdjustmentItem.from_dict(item) for item in data['items']],
+            payout_totals             = PayoutTotalsAdjustment.from_dict(data['payout_totals']) if data.get('payout_totals') else None,
+            updated_at                = datetime.fromisoformat(data['updated_at'])              if data.get('updated_at')    else None,
+        )

paddle_billing/Notifications/Entities/Adjustments/AdjustmentItem.py

@@ -0,0 +1,26 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Notifications.Entities.Shared import AdjustmentItemTotals, AdjustmentProration, AdjustmentType
+
+
+@dataclass
+class AdjustmentItem:
+    id:        str
+    item_id:   str
+    type:      AdjustmentType
+    amount:    str                 | None
+    proration: AdjustmentProration | None
+    totals:    AdjustmentItemTotals
+
+
+    @staticmethod
+    def from_dict(data: dict) -> AdjustmentItem:
+        return AdjustmentItem(
+            id        = data['id'],
+            item_id   = data['item_id'],
+            type      = AdjustmentType(data['type']),
+            amount    = data.get('amount'),
+            proration = AdjustmentProration.from_dict(data['proration']) if data.get('proration') else None,
+            totals    = AdjustmentItemTotals.from_dict(data['totals']),
+        )

paddle_billing/Notifications/Entities/Adjustments/__init__.py

@@ -0,0 +1 @@
+from paddle_billing.Notifications.Entities.Adjustments.AdjustmentItem import AdjustmentItem

paddle_billing/Notifications/Entities/Business.py

@@ -0,0 +1,39 @@
+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.Businesses import BusinessesContacts
+from paddle_billing.Notifications.Entities.Shared     import CustomData, ImportMeta, Status
+
+
+@dataclass
+class Business(Entity):
+    id:             str
+    name:           str
+    company_number: str | None
+    tax_identifier: str | None
+    status:         Status
+    contacts:       list[BusinessesContacts]
+    created_at:     datetime
+    updated_at:     datetime
+    custom_data:    CustomData | None = None
+    import_meta:    ImportMeta | None = None
+    customer_id:    str        | None = None
+
+
+    @classmethod
+    def from_dict(cls, data: dict) -> Business:
+        return Business(
+            id             = data['id'],
+            customer_id    = data.get('customer_id'),
+            name           = data['name'],
+            company_number = data.get('company_number'),
+            tax_identifier = data.get('tax_identifier'),
+            status         = Status(data['status']),
+            created_at     = datetime.fromisoformat(data['created_at']),
+            updated_at     = datetime.fromisoformat(data['updated_at']),
+            contacts       = [BusinessesContacts.from_dict(contact) for contact in data['contacts']],
+            custom_data    = CustomData(data['custom_data'])           if data.get('custom_data') else None,
+            import_meta    = ImportMeta.from_dict(data['import_meta']) if data.get('import_meta') else None,
+        )

paddle_billing/Notifications/Entities/Businesses/BusinessesContacts.py

@@ -0,0 +1,16 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+
+@dataclass
+class BusinessesContacts:
+    name:  str
+    email: str
+
+
+    @staticmethod
+    def from_dict(data: dict) -> BusinessesContacts:
+        return BusinessesContacts(
+            name  = data['name'],
+            email = data['email'],
+        )

paddle_billing/Notifications/Entities/Businesses/__init__.py

@@ -0,0 +1 @@
+from paddle_billing.Notifications.Entities.Businesses.BusinessesContacts import BusinessesContacts