paddle-python-sdk 1.16.1__tar.gz → 1.17.0__tar.gz

{paddle_python_sdk-1.16.1/paddle_python_sdk.egg-info → paddle_python_sdk-1.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: paddle-python-sdk
-Version: 1.16.1
+Version: 1.17.0
 Summary: Paddle's Python SDK for Paddle Billing
 Home-page: https://developer.paddle.com/api-reference/overview
 Author: Paddle and contributors

{paddle_python_sdk-1.16.1 → paddle_python_sdk-1.17.0}/paddle_billing/Client.py

@@ -15,8 +15,10 @@ from paddle_billing.ResponseParser import ResponseParser
 
 from paddle_billing.Logger.NullHandler import NullHandler
 
+from paddle_billing.Resources.Account.AccountClient import AccountClient
 from paddle_billing.Resources.Addresses.AddressesClient import AddressesClient
 from paddle_billing.Resources.Adjustments.AdjustmentsClient import AdjustmentsClient
+from paddle_billing.Resources.APIRoot.APIRootClient import APIRootClient
 from paddle_billing.Resources.Businesses.BusinessesClient import BusinessesClient
 from paddle_billing.Resources.CheckoutDomains.CheckoutDomainsClient import CheckoutDomainsClient
 from paddle_billing.Resources.ClientTokens.ClientTokensClient import ClientTokensClient
@@ -37,6 +39,7 @@ from paddle_billing.Resources.Prices.PricesClient import PricesClient
 from paddle_billing.Resources.PricingPreviews.PricingPreviewsClient import PricingPreviewsClient
 from paddle_billing.Resources.Products.ProductsClient import ProductsClient
 from paddle_billing.Resources.Reports.ReportsClient import ReportsClient
+from paddle_billing.Resources.Settings.SettingsClient import SettingsClient
 from paddle_billing.Resources.Simulations.SimulationsClient import SimulationsClient
 from paddle_billing.Resources.SimulationRuns.SimulationRunsClient import SimulationRunsClient
 from paddle_billing.Resources.SimulationRunEvents.SimulationRunEventsClient import SimulationRunEventsClient
@@ -74,8 +77,10 @@ class Client:
         self.status_code = None  # Used by pytest
 
         # Initialize the various clients
+        self.account = AccountClient(self)
         self.addresses = AddressesClient(self)
         self.adjustments = AdjustmentsClient(self)
+        self.api_root = APIRootClient(self)
         self.businesses = BusinessesClient(self)
         self.checkout_domains = CheckoutDomainsClient(self)
         self.client_tokens = ClientTokensClient(self)
@@ -95,6 +100,7 @@ class Client:
         self.pricing_previews = PricingPreviewsClient(self)
         self.products = ProductsClient(self)
         self.reports = ReportsClient(self)
+        self.settings = SettingsClient(self)
         self.simulations = SimulationsClient(self)
         self.simulation_runs = SimulationRunsClient(self)
         self.simulation_run_events = SimulationRunEventsClient(self)
@@ -211,7 +217,7 @@ class Client:
                 "Authorization": f"Bearer {self.__api_key}",
                 "Content-Type": "application/json",
                 "Paddle-Version": str(self.use_api_version),
-                "User-Agent": "PaddleSDK/python 1.16.1",
+                "User-Agent": "PaddleSDK/python 1.17.0",
             }
         )
 

paddle_python_sdk-1.17.0/paddle_billing/Entities/AccountDetails.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+
+from paddle_billing.Entities.Entity import Entity
+
+
+@dataclass
+class AccountDetails(Entity):
+    id: str
+    legacy_id: str | None
+    legal_name: str | None
+    display_name: str | None
+    website: str | None
+    email: str | None
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> AccountDetails:
+        return AccountDetails(
+            id=data["id"],
+            legacy_id=data["legacy_id"],
+            legal_name=data["legal_name"],
+            display_name=data["display_name"],
+            website=data["website"],
+            email=data["email"],
+        )

paddle_python_sdk-1.17.0/paddle_billing/Entities/ApiRoot/RootApi.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+
+from paddle_billing.Entities.ApiRoot.RootEnvironment import RootEnvironment
+
+
+@dataclass
+class RootApi:
+    name: str
+    version: str
+    environment: RootEnvironment
+    documentation_url: str
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> RootApi:
+        return RootApi(
+            name=data["name"],
+            version=data["version"],
+            environment=RootEnvironment(data["environment"]),
+            documentation_url=data["documentation_url"],
+        )

paddle_python_sdk-1.17.0/paddle_billing/Entities/ApiRoot/RootAuthType.py

@@ -0,0 +1,8 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum, PaddleStrEnumMeta
+
+
+class RootAuthType(PaddleStrEnum, metaclass=PaddleStrEnumMeta):
+    ApiKey: "RootAuthType" = "api_key"
+    Oauth: "RootAuthType" = "oauth"
+    ClientToken: "RootAuthType" = "client_token"
+    Session: "RootAuthType" = "session"

paddle_python_sdk-1.17.0/paddle_billing/Entities/ApiRoot/RootCaller.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+
+from paddle_billing.Entities.ApiRoot.RootAuthType import RootAuthType
+from paddle_billing.Entities.ApiRoot.RootCallerAccount import RootCallerAccount
+
+
+@dataclass
+class RootCaller:
+    auth_type: RootAuthType | None
+    account: RootCallerAccount | None
+    permissions: list[str]
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> RootCaller:
+        return RootCaller(
+            auth_type=RootAuthType(data["auth_type"]) if data["auth_type"] is not None else None,
+            account=RootCallerAccount.from_dict(data["account"]) if data["account"] is not None else None,
+            permissions=list(data["permissions"]),
+        )

paddle_python_sdk-1.17.0/paddle_billing/Entities/ApiRoot/RootCallerAccount.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class RootCallerAccount:
+    id: str
+    name: str
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> RootCallerAccount:
+        return RootCallerAccount(
+            id=data["id"],
+            name=data["name"],
+        )

paddle_python_sdk-1.17.0/paddle_billing/Entities/ApiRoot/RootEnvironment.py

@@ -0,0 +1,6 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum, PaddleStrEnumMeta
+
+
+class RootEnvironment(PaddleStrEnum, metaclass=PaddleStrEnumMeta):
+    Production: "RootEnvironment" = "production"
+    Sandbox: "RootEnvironment" = "sandbox"

paddle_python_sdk-1.17.0/paddle_billing/Entities/ApiRoot/__init__.py

@@ -0,0 +1,5 @@
+from paddle_billing.Entities.ApiRoot.RootEnvironment import RootEnvironment
+from paddle_billing.Entities.ApiRoot.RootAuthType import RootAuthType
+from paddle_billing.Entities.ApiRoot.RootCallerAccount import RootCallerAccount
+from paddle_billing.Entities.ApiRoot.RootCaller import RootCaller
+from paddle_billing.Entities.ApiRoot.RootApi import RootApi

paddle_python_sdk-1.17.0/paddle_billing/Entities/RootContext.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.ApiRoot import RootApi, RootCaller
+
+
+@dataclass
+class RootContext(Entity):
+    api: RootApi
+    caller: RootCaller
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> RootContext:
+        return RootContext(
+            api=RootApi.from_dict(data["api"]),
+            caller=RootCaller.from_dict(data["caller"]),
+        )

paddle_python_sdk-1.17.0/paddle_billing/Entities/Settings/AudienceOptIn.py

@@ -0,0 +1,6 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum, PaddleStrEnumMeta
+
+
+class AudienceOptIn(PaddleStrEnum, metaclass=PaddleStrEnumMeta):
+    Never: "AudienceOptIn" = "never"
+    Choice: "AudienceOptIn" = "choice"

paddle_python_sdk-1.17.0/paddle_billing/Entities/Settings/BalanceCurrency.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.Settings.BalanceCurrencyCode import BalanceCurrencyCode
+
+
+@dataclass
+class BalanceCurrency(Entity):
+    primary: BalanceCurrencyCode
+    preferred: BalanceCurrencyCode
+    enabled: list[BalanceCurrencyCode]
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> BalanceCurrency:
+        return BalanceCurrency(
+            primary=BalanceCurrencyCode(data["primary"]),
+            preferred=BalanceCurrencyCode(data["preferred"]),
+            enabled=[BalanceCurrencyCode(currency) for currency in data["enabled"]],
+        )

paddle_python_sdk-1.17.0/paddle_billing/Entities/Settings/BalanceCurrencyCode.py

@@ -0,0 +1,9 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum, PaddleStrEnumMeta
+
+
+class BalanceCurrencyCode(PaddleStrEnum, metaclass=PaddleStrEnumMeta):
+    AUD: "BalanceCurrencyCode" = "AUD"
+    CAD: "BalanceCurrencyCode" = "CAD"
+    EUR: "BalanceCurrencyCode" = "EUR"
+    GBP: "BalanceCurrencyCode" = "GBP"
+    USD: "BalanceCurrencyCode" = "USD"

paddle_python_sdk-1.17.0/paddle_billing/Entities/Settings/CheckoutFeatures.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.Settings.AudienceOptIn import AudienceOptIn
+
+
+@dataclass
+class CheckoutFeatures(Entity):
+    discounts_enabled: bool
+    audience_opt_in: AudienceOptIn
+    saved_payment_methods_enabled: bool
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> CheckoutFeatures:
+        return CheckoutFeatures(
+            discounts_enabled=data["discounts_enabled"],
+            audience_opt_in=AudienceOptIn(data["audience_opt_in"]),
+            saved_payment_methods_enabled=data["saved_payment_methods_enabled"],
+        )

paddle_python_sdk-1.17.0/paddle_billing/Entities/Settings/CheckoutPaymentMethodSetting.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class CheckoutPaymentMethodSetting:
+    enabled: bool
+    available: bool
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> CheckoutPaymentMethodSetting:
+        return CheckoutPaymentMethodSetting(
+            enabled=data["enabled"],
+            available=data["available"],
+        )

paddle_python_sdk-1.17.0/paddle_billing/Entities/Settings/CheckoutPaymentMethodSettingUpdate.py

@@ -0,0 +1,6 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class CheckoutPaymentMethodSettingUpdate:
+    enabled: bool

paddle_python_sdk-1.17.0/paddle_billing/Entities/Settings/CheckoutPaymentMethodSettings.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.Settings.CheckoutPaymentMethods import CheckoutPaymentMethods
+
+
+@dataclass
+class CheckoutPaymentMethodSettings(Entity):
+    payment_methods: CheckoutPaymentMethods
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> CheckoutPaymentMethodSettings:
+        return CheckoutPaymentMethodSettings(
+            payment_methods=CheckoutPaymentMethods.from_dict(data["payment_methods"]),
+        )

paddle_python_sdk-1.17.0/paddle_billing/Entities/Settings/CheckoutPaymentMethods.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+
+from paddle_billing.Entities.Settings.CheckoutPaymentMethodSetting import CheckoutPaymentMethodSetting
+
+
+@dataclass
+class CheckoutPaymentMethods:
+    alipay: CheckoutPaymentMethodSetting
+    apple_pay: CheckoutPaymentMethodSetting
+    bancontact: CheckoutPaymentMethodSetting
+    blik: CheckoutPaymentMethodSetting
+    card: CheckoutPaymentMethodSetting
+    google_pay: CheckoutPaymentMethodSetting
+    ideal: CheckoutPaymentMethodSetting
+    kakao_pay: CheckoutPaymentMethodSetting
+    mb_way: CheckoutPaymentMethodSetting
+    naver_pay: CheckoutPaymentMethodSetting
+    payco: CheckoutPaymentMethodSetting
+    paypal: CheckoutPaymentMethodSetting
+    pix: CheckoutPaymentMethodSetting
+    samsung_pay: CheckoutPaymentMethodSetting
+    south_korea_local_card: CheckoutPaymentMethodSetting
+    upi: CheckoutPaymentMethodSetting
+    wechat_pay: CheckoutPaymentMethodSetting
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> CheckoutPaymentMethods:
+        return CheckoutPaymentMethods(
+            alipay=CheckoutPaymentMethodSetting.from_dict(data["alipay"]),
+            apple_pay=CheckoutPaymentMethodSetting.from_dict(data["apple_pay"]),
+            bancontact=CheckoutPaymentMethodSetting.from_dict(data["bancontact"]),
+            blik=CheckoutPaymentMethodSetting.from_dict(data["blik"]),
+            card=CheckoutPaymentMethodSetting.from_dict(data["card"]),
+            google_pay=CheckoutPaymentMethodSetting.from_dict(data["google_pay"]),
+            ideal=CheckoutPaymentMethodSetting.from_dict(data["ideal"]),
+            kakao_pay=CheckoutPaymentMethodSetting.from_dict(data["kakao_pay"]),
+            mb_way=CheckoutPaymentMethodSetting.from_dict(data["mb_way"]),
+            naver_pay=CheckoutPaymentMethodSetting.from_dict(data["naver_pay"]),
+            payco=CheckoutPaymentMethodSetting.from_dict(data["payco"]),
+            paypal=CheckoutPaymentMethodSetting.from_dict(data["paypal"]),
+            pix=CheckoutPaymentMethodSetting.from_dict(data["pix"]),
+            samsung_pay=CheckoutPaymentMethodSetting.from_dict(data["samsung_pay"]),
+            south_korea_local_card=CheckoutPaymentMethodSetting.from_dict(data["south_korea_local_card"]),
+            upi=CheckoutPaymentMethodSetting.from_dict(data["upi"]),
+            wechat_pay=CheckoutPaymentMethodSetting.from_dict(data["wechat_pay"]),
+        )

paddle_python_sdk-1.17.0/paddle_billing/Entities/Settings/CheckoutPaymentMethodsUpdate.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+
+from paddle_billing.Undefined import Undefined
+from paddle_billing.Entities.Settings.CheckoutPaymentMethodSettingUpdate import CheckoutPaymentMethodSettingUpdate
+
+
+@dataclass
+class CheckoutPaymentMethodsUpdate:
+    alipay: CheckoutPaymentMethodSettingUpdate | Undefined = Undefined()
+    apple_pay: CheckoutPaymentMethodSettingUpdate | Undefined = Undefined()
+    bancontact: CheckoutPaymentMethodSettingUpdate | Undefined = Undefined()
+    blik: CheckoutPaymentMethodSettingUpdate | Undefined = Undefined()
+    card: CheckoutPaymentMethodSettingUpdate | Undefined = Undefined()
+    google_pay: CheckoutPaymentMethodSettingUpdate | Undefined = Undefined()
+    ideal: CheckoutPaymentMethodSettingUpdate | Undefined = Undefined()
+    kakao_pay: CheckoutPaymentMethodSettingUpdate | Undefined = Undefined()
+    mb_way: CheckoutPaymentMethodSettingUpdate | Undefined = Undefined()
+    naver_pay: CheckoutPaymentMethodSettingUpdate | Undefined = Undefined()
+    payco: CheckoutPaymentMethodSettingUpdate | Undefined = Undefined()
+    paypal: CheckoutPaymentMethodSettingUpdate | Undefined = Undefined()
+    pix: CheckoutPaymentMethodSettingUpdate | Undefined = Undefined()
+    samsung_pay: CheckoutPaymentMethodSettingUpdate | Undefined = Undefined()
+    south_korea_local_card: CheckoutPaymentMethodSettingUpdate | Undefined = Undefined()
+    upi: CheckoutPaymentMethodSettingUpdate | Undefined = Undefined()
+    wechat_pay: CheckoutPaymentMethodSettingUpdate | Undefined = Undefined()

paddle_python_sdk-1.17.0/paddle_billing/Entities/Settings/CheckoutRecovery.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.Settings.CheckoutRecoveryDiscount import CheckoutRecoveryDiscount
+
+
+@dataclass
+class CheckoutRecovery(Entity):
+    enabled: bool
+    discount: CheckoutRecoveryDiscount | None
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> CheckoutRecovery:
+        return CheckoutRecovery(
+            enabled=data["enabled"],
+            discount=CheckoutRecoveryDiscount.from_dict(data["discount"]) if data["discount"] is not None else None,
+        )

paddle_python_sdk-1.17.0/paddle_billing/Entities/Settings/CheckoutRecoveryDiscount.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+
+from paddle_billing.Entities.Settings.CheckoutRecoveryDiscountType import CheckoutRecoveryDiscountType
+
+
+@dataclass
+class CheckoutRecoveryDiscount:
+    type: CheckoutRecoveryDiscountType
+    amount: str
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> CheckoutRecoveryDiscount:
+        return CheckoutRecoveryDiscount(
+            type=CheckoutRecoveryDiscountType(data["type"]),
+            amount=data["amount"],
+        )

paddle_python_sdk-1.17.0/paddle_billing/Entities/Settings/CheckoutRecoveryDiscountType.py

@@ -0,0 +1,5 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum, PaddleStrEnumMeta
+
+
+class CheckoutRecoveryDiscountType(PaddleStrEnum, metaclass=PaddleStrEnumMeta):
+    Percentage: "CheckoutRecoveryDiscountType" = "percentage"

paddle_python_sdk-1.17.0/paddle_billing/Entities/Settings/CheckoutRecoveryDiscountUpdate.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Settings.CheckoutRecoveryDiscountType import CheckoutRecoveryDiscountType
+
+
+@dataclass
+class CheckoutRecoveryDiscountUpdate:
+    type: CheckoutRecoveryDiscountType
+    amount: str

paddle_python_sdk-1.17.0/paddle_billing/Entities/Settings/CheckoutStylesOverlay.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+
+from paddle_billing.Entities.Entity import Entity
+
+
+@dataclass
+class CheckoutStylesOverlay(Entity):
+    primary_checkout_color: str | None
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> CheckoutStylesOverlay:
+        return CheckoutStylesOverlay(
+            primary_checkout_color=data["primary_checkout_color"],
+        )

paddle_python_sdk-1.17.0/paddle_billing/Entities/Settings/CheckoutUrl.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+
+from paddle_billing.Entities.Entity import Entity
+
+
+@dataclass
+class CheckoutUrl(Entity):
+    default_url: str | None
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> CheckoutUrl:
+        return CheckoutUrl(
+            default_url=data["default_url"],
+        )

paddle_python_sdk-1.17.0/paddle_billing/Entities/Settings/CurrencyConversion.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class CurrencyConversion:
+    enabled: bool
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> CurrencyConversion:
+        return CurrencyConversion(
+            enabled=data["enabled"],
+        )

paddle_python_sdk-1.17.0/paddle_billing/Entities/Settings/CurrencyConversionUpdate.py

@@ -0,0 +1,6 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class CurrencyConversionUpdate:
+    enabled: bool

paddle_python_sdk-1.17.0/paddle_billing/Entities/Settings/CurrencyConversions.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.Settings.CurrencyConversion import CurrencyConversion
+
+
+@dataclass
+class CurrencyConversions(Entity):
+    """
+    Currency conversion settings, keyed by three-letter ISO 4217 currency code, for example `USD`.
+    """
+
+    conversions: dict[str, CurrencyConversion]
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> CurrencyConversions:
+        return CurrencyConversions(
+            conversions={code: CurrencyConversion.from_dict(setting) for code, setting in data.items()},
+        )

paddle_python_sdk-1.17.0/paddle_billing/Entities/Settings/DefaultTaxMode.py

@@ -0,0 +1,7 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum, PaddleStrEnumMeta
+
+
+class DefaultTaxMode(PaddleStrEnum, metaclass=PaddleStrEnumMeta):
+    Exclusive: "DefaultTaxMode" = "exclusive"
+    Inclusive: "DefaultTaxMode" = "inclusive"
+    Location: "DefaultTaxMode" = "location"

paddle_python_sdk-1.17.0/paddle_billing/Entities/Settings/StatementDescriptorPreview.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class StatementDescriptorPreview:
+    default: str
+    paypal: str
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> StatementDescriptorPreview:
+        return StatementDescriptorPreview(
+            default=data["default"],
+            paypal=data["paypal"],
+        )

paddle_python_sdk-1.17.0/paddle_billing/Entities/Settings/StatementDescriptorSettings.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.Settings.StatementDescriptorPreview import StatementDescriptorPreview
+
+
+@dataclass
+class StatementDescriptorSettings(Entity):
+    name: str
+    preview: StatementDescriptorPreview
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> StatementDescriptorSettings:
+        return StatementDescriptorSettings(
+            name=data["name"],
+            preview=StatementDescriptorPreview.from_dict(data["preview"]),
+        )

paddle_python_sdk-1.17.0/paddle_billing/Entities/Settings/TaxSettings.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.Settings.DefaultTaxMode import DefaultTaxMode
+
+
+@dataclass
+class TaxSettings(Entity):
+    default_tax_mode: DefaultTaxMode
+
+    @staticmethod
+    def from_dict(data: dict[str, Any]) -> TaxSettings:
+        return TaxSettings(
+            default_tax_mode=DefaultTaxMode(data["default_tax_mode"]),
+        )

paddle_python_sdk-1.17.0/paddle_billing/Entities/Settings/__init__.py

@@ -0,0 +1,22 @@
+from paddle_billing.Entities.Settings.BalanceCurrencyCode import BalanceCurrencyCode
+from paddle_billing.Entities.Settings.AudienceOptIn import AudienceOptIn
+from paddle_billing.Entities.Settings.CheckoutRecoveryDiscountType import CheckoutRecoveryDiscountType
+from paddle_billing.Entities.Settings.DefaultTaxMode import DefaultTaxMode
+from paddle_billing.Entities.Settings.BalanceCurrency import BalanceCurrency
+from paddle_billing.Entities.Settings.CheckoutFeatures import CheckoutFeatures
+from paddle_billing.Entities.Settings.CheckoutPaymentMethodSetting import CheckoutPaymentMethodSetting
+from paddle_billing.Entities.Settings.CheckoutPaymentMethods import CheckoutPaymentMethods
+from paddle_billing.Entities.Settings.CheckoutPaymentMethodSettings import CheckoutPaymentMethodSettings
+from paddle_billing.Entities.Settings.CheckoutPaymentMethodSettingUpdate import CheckoutPaymentMethodSettingUpdate
+from paddle_billing.Entities.Settings.CheckoutPaymentMethodsUpdate import CheckoutPaymentMethodsUpdate
+from paddle_billing.Entities.Settings.CheckoutRecoveryDiscount import CheckoutRecoveryDiscount
+from paddle_billing.Entities.Settings.CheckoutRecoveryDiscountUpdate import CheckoutRecoveryDiscountUpdate
+from paddle_billing.Entities.Settings.CheckoutRecovery import CheckoutRecovery
+from paddle_billing.Entities.Settings.CheckoutStylesOverlay import CheckoutStylesOverlay
+from paddle_billing.Entities.Settings.CheckoutUrl import CheckoutUrl
+from paddle_billing.Entities.Settings.CurrencyConversion import CurrencyConversion
+from paddle_billing.Entities.Settings.CurrencyConversionUpdate import CurrencyConversionUpdate
+from paddle_billing.Entities.Settings.CurrencyConversions import CurrencyConversions
+from paddle_billing.Entities.Settings.StatementDescriptorPreview import StatementDescriptorPreview
+from paddle_billing.Entities.Settings.StatementDescriptorSettings import StatementDescriptorSettings
+from paddle_billing.Entities.Settings.TaxSettings import TaxSettings

{paddle_python_sdk-1.16.1 → paddle_python_sdk-1.17.0}/paddle_billing/Entities/Shared/PaymentAttemptStatus.py

@@ -11,3 +11,4 @@ class PaymentAttemptStatus(PaddleStrEnum, metaclass=PaddleStrEnumMeta):
     PendingNoActionRequired: "PaymentAttemptStatus" = "pending_no_action_required"
     Created: "PaymentAttemptStatus" = "created"
     Unknown: "PaymentAttemptStatus" = "unknown"
+    Dropped: "PaymentAttemptStatus" = "dropped"

{paddle_python_sdk-1.16.1 → paddle_python_sdk-1.17.0}/paddle_billing/Entities/Transaction.py

@@ -54,15 +54,22 @@ class Transaction(Entity):
     billed_at: datetime | None
     address: Address | None = None
     adjustments: list[Adjustment] | None = None
-    adjustment_totals: TransactionAdjustmentsTotals | None = None
+    adjustment_totals: TransactionAdjustmentsTotals | None = None  # Deprecated: use adjustments_totals.
     business: Business | None = None
     customer: Customer | None = None
     discount: Discount | None = None
     available_payment_methods: list[PaymentMethodType] | None = None
     revised_at: datetime | None = None
+    adjustments_totals: TransactionAdjustmentsTotals | None = None
 
     @staticmethod
     def from_dict(data: dict[str, Any]) -> Transaction:
+        adjustments_totals = (
+            TransactionAdjustmentsTotals.from_dict(data["adjustments_totals"])
+            if data.get("adjustments_totals")
+            else None
+        )
+
         return Transaction(
             address_id=data.get("address_id"),
             business_id=data.get("business_id"),
@@ -92,10 +99,7 @@ class Transaction(Entity):
             customer=Customer.from_dict(data["customer"]) if data.get("customer") else None,
             discount=Discount.from_dict(data["discount"]) if data.get("discount") else None,
             available_payment_methods=[PaymentMethodType(item) for item in data.get("available_payment_methods", [])],
-            adjustment_totals=(
-                TransactionAdjustmentsTotals.from_dict(data["adjustment_totals"])
-                if data.get("adjustment_totals")
-                else None
-            ),
+            adjustment_totals=adjustments_totals,
             revised_at=datetime.fromisoformat(data["revised_at"]) if data.get("revised_at") else None,
+            adjustments_totals=adjustments_totals,
         )