paddle-python-sdk 0.3.2__py3-none-any.whl → 1.2.1__py3-none-any.whl

paddle_billing/Client.py

@@ -20,6 +20,7 @@ from paddle_billing.Resources.Addresses.AddressesClient import AddressesClient
 from paddle_billing.Resources.Adjustments.AdjustmentsClient import AdjustmentsClient
 from paddle_billing.Resources.Businesses.BusinessesClient import BusinessesClient
 from paddle_billing.Resources.Customers.CustomersClient import CustomersClient
+from paddle_billing.Resources.CustomerPortalSessions.CustomerPortalSessionsClient import CustomerPortalSessionsClient
 from paddle_billing.Resources.Discounts.DiscountsClient import DiscountsClient
 from paddle_billing.Resources.Events.EventsClient import EventsClient
 from paddle_billing.Resources.EventTypes.EventTypesClient import EventTypesClient
@@ -27,6 +28,7 @@ from paddle_billing.Resources.IPAddresses.IPAddressesClient import IPAddressesCl
 from paddle_billing.Resources.Notifications.NotificationsClient import NotificationsClient
 from paddle_billing.Resources.NotificationLogs.NotificationLogsClient import NotificationLogsClient
 from paddle_billing.Resources.NotificationSettings.NotificationSettingsClient import NotificationSettingsClient
+from paddle_billing.Resources.PaymentMethods.PaymentMethodsClient import PaymentMethodsClient
 from paddle_billing.Resources.Prices.PricesClient import PricesClient
 from paddle_billing.Resources.PricingPreviews.PricingPreviewsClient import PricingPreviewsClient
 from paddle_billing.Resources.Products.ProductsClient import ProductsClient
@@ -37,6 +39,12 @@ from paddle_billing.Resources.Transactions.TransactionsClient import Transaction
 
 class PayloadEncoder(JSONEncoder):
     def default(self, z):
+        if isinstance(z, Undefined):
+            return None
+
+        if hasattr(z, "to_json") and callable(z.to_json):
+            return z.to_json()
+
         if is_dataclass(z):
             data = {}
             for field in fields(z):
@@ -44,12 +52,6 @@ class PayloadEncoder(JSONEncoder):
 
             return FiltersUndefined.filter_undefined_values(data)
 
-        if isinstance(z, Undefined):
-            return None
-
-        if hasattr(z, "to_json") and callable(z.to_json):
-            return z.to_json()
-
         return super().default(z)
 
 
@@ -84,12 +86,14 @@ class Client:
         self.adjustments = AdjustmentsClient(self)
         self.businesses = BusinessesClient(self)
         self.customers = CustomersClient(self)
+        self.customer_portal_sessions = CustomerPortalSessionsClient(self)
         self.discounts = DiscountsClient(self)
         self.events = EventsClient(self)
         self.event_types = EventTypesClient(self)
         self.notifications = NotificationsClient(self)
         self.notification_logs = NotificationLogsClient(self)
         self.notification_settings = NotificationSettingsClient(self)
+        self.payment_methods = PaymentMethodsClient(self)
         self.prices = PricesClient(self)
         self.pricing_previews = PricingPreviewsClient(self)
         self.products = ProductsClient(self)
@@ -183,17 +187,11 @@ class Client:
     def post_raw(
         self, url: str, payload: dict | Operation | None = None, parameters: HasParameters | dict | None = None
     ) -> Response:
-        if isinstance(payload, dict):
-            payload = FiltersUndefined.filter_undefined_values(payload)  # Strip Undefined items from the dict
-
         url = Client.format_uri_parameters(url, parameters) if parameters else url
 
         return self._make_request("POST", url, payload)
 
     def patch_raw(self, url: str, payload: dict | Operation | None) -> Response:
-        if isinstance(payload, dict):
-            payload = FiltersUndefined.filter_undefined_values(payload)  # Strip Undefined items from the dict
-
         return self._make_request("PATCH", url, payload)
 
     def delete_raw(self, url: str) -> Response:
@@ -206,7 +204,7 @@ class Client:
                 "Authorization": f"Bearer {self.__api_key}",
                 "Content-Type": "application/json",
                 "Paddle-Version": str(self.use_api_version),
-                "User-Agent": "PaddleSDK/python 0.3.2",
+                "User-Agent": "PaddleSDK/python 1.2.1",
             }
         )
 

paddle_billing/Entities/Collections/PaymentMethodCollection.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from paddle_billing.Entities.Collections.Collection import Collection
+from paddle_billing.Entities.Collections.Paginator import Paginator
+from paddle_billing.Entities.PaymentMethod import PaymentMethod
+
+
+class PaymentMethodCollection(Collection[PaymentMethod]):
+    @classmethod
+    def from_list(cls, items_data: list, paginator: Paginator | None = None) -> PaymentMethodCollection:
+        items: list[PaymentMethod] = [PaymentMethod.from_dict(item) for item in items_data]
+
+        return PaymentMethodCollection(items, paginator)

paddle_billing/Entities/Collections/__init__.py

@@ -11,6 +11,7 @@ from paddle_billing.Entities.Collections.NotificationCollection import Notificat
 from paddle_billing.Entities.Collections.NotificationLogCollection import NotificationLogCollection
 from paddle_billing.Entities.Collections.NotificationSettingCollection import NotificationSettingCollection
 from paddle_billing.Entities.Collections.Paginator import Paginator
+from paddle_billing.Entities.Collections.PaymentMethodCollection import PaymentMethodCollection
 from paddle_billing.Entities.Collections.PriceCollection import PriceCollection
 from paddle_billing.Entities.Collections.ProductCollection import ProductCollection
 from paddle_billing.Entities.Collections.ReportCollection import ReportCollection

paddle_billing/Entities/CustomerAuthToken.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from datetime import datetime
+
+from paddle_billing.Entities.Entity import Entity
+
+
+@dataclass
+class CustomerAuthToken(Entity):
+    customer_auth_token: str
+    expires_at: datetime
+
+    @staticmethod
+    def from_dict(data: dict) -> CustomerAuthToken:
+        return CustomerAuthToken(
+            customer_auth_token=data["customer_auth_token"],
+            expires_at=datetime.fromisoformat(data["expires_at"]),
+        )

paddle_billing/Entities/CustomerPortalSession.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from datetime import datetime
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.CustomerPortalSessions import CustomerPortalSessionUrls
+
+
+@dataclass
+class CustomerPortalSession(Entity):
+    id: str
+    customer_id: str
+    urls: CustomerPortalSessionUrls
+    created_at: datetime
+
+    @staticmethod
+    def from_dict(data: dict) -> CustomerPortalSession:
+        return CustomerPortalSession(
+            id=data["id"],
+            customer_id=data["customer_id"],
+            urls=CustomerPortalSessionUrls.from_dict(data["urls"]),
+            created_at=datetime.fromisoformat(data["created_at"]),
+        )

paddle_billing/Entities/CustomerPortalSessions/CustomerPortalSessionGeneralUrl.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+from dataclasses import dataclass
+
+
+@dataclass
+class CustomerPortalSessionGeneralUrl:
+    overview: str
+
+    @staticmethod
+    def from_dict(data: dict) -> CustomerPortalSessionGeneralUrl:
+        return CustomerPortalSessionGeneralUrl(
+            overview=data["overview"],
+        )

paddle_billing/Entities/CustomerPortalSessions/CustomerPortalSessionSubscriptionUrl.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+from dataclasses import dataclass
+
+
+@dataclass
+class CustomerPortalSessionSubscriptionUrl:
+    id: str
+    cancel_subscription: str
+    update_subscription_payment_method: str
+
+    @staticmethod
+    def from_dict(data: dict) -> CustomerPortalSessionSubscriptionUrl:
+        return CustomerPortalSessionSubscriptionUrl(
+            id=data["id"],
+            cancel_subscription=data["cancel_subscription"],
+            update_subscription_payment_method=data["update_subscription_payment_method"],
+        )

paddle_billing/Entities/CustomerPortalSessions/CustomerPortalSessionUrls.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.CustomerPortalSessions.CustomerPortalSessionGeneralUrl import (
+    CustomerPortalSessionGeneralUrl,
+)
+from paddle_billing.Entities.CustomerPortalSessions.CustomerPortalSessionSubscriptionUrl import (
+    CustomerPortalSessionSubscriptionUrl,
+)
+
+
+@dataclass
+class CustomerPortalSessionUrls:
+    general: CustomerPortalSessionGeneralUrl
+    subscriptions: list[CustomerPortalSessionSubscriptionUrl]
+
+    @staticmethod
+    def from_dict(data: dict) -> CustomerPortalSessionUrls:
+        return CustomerPortalSessionUrls(
+            general=CustomerPortalSessionGeneralUrl.from_dict(data["general"]),
+            subscriptions=[
+                CustomerPortalSessionSubscriptionUrl.from_dict(item) for item in data.get("subscriptions", [])
+            ],
+        )

paddle_billing/Entities/CustomerPortalSessions/__init__.py

@@ -0,0 +1,7 @@
+from paddle_billing.Entities.CustomerPortalSessions.CustomerPortalSessionUrls import CustomerPortalSessionUrls
+from paddle_billing.Entities.CustomerPortalSessions.CustomerPortalSessionGeneralUrl import (
+    CustomerPortalSessionGeneralUrl,
+)
+from paddle_billing.Entities.CustomerPortalSessions.CustomerPortalSessionSubscriptionUrl import (
+    CustomerPortalSessionSubscriptionUrl,
+)

paddle_billing/Entities/NotificationSetting.py

@@ -3,7 +3,7 @@ from dataclasses import dataclass
 
 from paddle_billing.Entities.Entity import Entity
 from paddle_billing.Entities.EventType import EventType
-from paddle_billing.Entities.NotificationSettings import NotificationSettingType
+from paddle_billing.Entities.NotificationSettings import NotificationSettingType, NotificationSettingTrafficSource
 
 
 @dataclass
@@ -17,6 +17,7 @@ class NotificationSetting(Entity):
     include_sensitive_fields: bool
     subscribed_events: list[EventType]
     endpoint_secret_key: str
+    traffic_source: NotificationSettingTrafficSource
 
     @staticmethod
     def from_dict(data: dict) -> NotificationSetting:
@@ -30,4 +31,5 @@ class NotificationSetting(Entity):
             include_sensitive_fields=data["include_sensitive_fields"],
             subscribed_events=[EventType.from_dict(event) for event in data.get("subscribed_events", [])],
             endpoint_secret_key=data["endpoint_secret_key"],
+            traffic_source=NotificationSettingTrafficSource(data["traffic_source"]),
         )

paddle_billing/Entities/NotificationSettings/NotificationSettingTrafficSource.py

@@ -0,0 +1,7 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum, PaddleStrEnumMeta
+
+
+class NotificationSettingTrafficSource(PaddleStrEnum, metaclass=PaddleStrEnumMeta):
+    All: "NotificationSettingTrafficSource" = "all"
+    Platform: "NotificationSettingTrafficSource" = "platform"
+    Simulation: "NotificationSettingTrafficSource" = "simulation"

paddle_billing/Entities/NotificationSettings/__init__.py

@@ -1 +1,4 @@
+from paddle_billing.Entities.NotificationSettings.NotificationSettingTrafficSource import (
+    NotificationSettingTrafficSource,
+)
 from paddle_billing.Entities.NotificationSettings.NotificationSettingType import NotificationSettingType

paddle_billing/Entities/PaymentMethod.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from datetime import datetime
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.Shared import (
+    Card,
+    Paypal,
+    SavedPaymentMethodOrigin,
+    SavedPaymentMethodType,
+)
+
+
+@dataclass
+class PaymentMethod(Entity):
+    id: str
+    customer_id: str
+    address_id: str
+    type: SavedPaymentMethodType
+    card: Card | None
+    paypal: Paypal | None
+    origin: SavedPaymentMethodOrigin
+    saved_at: datetime
+    updated_at: datetime
+
+    @staticmethod
+    def from_dict(data: dict) -> PaymentMethod:
+        return PaymentMethod(
+            id=data["id"],
+            customer_id=data["customer_id"],
+            address_id=data["address_id"],
+            type=SavedPaymentMethodType(data["type"]),
+            card=Card.from_dict(data["card"]) if data.get("card") else None,
+            paypal=Paypal.from_dict(data["paypal"]) if data.get("paypal") else None,
+            origin=SavedPaymentMethodOrigin(data["origin"]),
+            saved_at=datetime.fromisoformat(data["saved_at"]),
+            updated_at=datetime.fromisoformat(data["updated_at"]),
+        )

paddle_billing/Entities/Price.py

@@ -15,10 +15,6 @@ from paddle_billing.Entities.Shared import (
     UnitPriceOverride,
 )
 
-from paddle_billing.Logger import get_logger
-
-log = get_logger()
-
 
 @dataclass
 class Price(Entity):

paddle_billing/Entities/Reports/ReportFilter.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from dataclasses import asdict, dataclass
+from dataclasses import dataclass
 
 from paddle_billing.Entities.Reports import ReportFilterName, ReportFilterOperator
 
@@ -13,6 +13,3 @@ class ReportFilter:
     @staticmethod
     def from_dict(data: dict) -> ReportFilter:
         return ReportFilter(**data)
-
-    def get_parameters(self) -> dict:
-        return asdict(self)

paddle_billing/Entities/Shared/CustomData.py

@@ -4,8 +4,5 @@ class CustomData:
     def __init__(self, data: dict | list):
         self.data = data
 
-    def get_parameters(self):
-        return self.data
-
     def to_json(self):
         return self.data

paddle_billing/Entities/Shared/Paypal.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+from dataclasses import dataclass
+
+
+@dataclass
+class Paypal:
+    email: str
+    reference: str
+
+    @staticmethod
+    def from_dict(data: dict) -> Paypal:
+        return Paypal(
+            email=data["email"],
+            reference=data["reference"],
+        )

paddle_billing/Entities/Shared/SavedPaymentMethodOrigin.py

@@ -0,0 +1,6 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum, PaddleStrEnumMeta
+
+
+class SavedPaymentMethodOrigin(PaddleStrEnum, metaclass=PaddleStrEnumMeta):
+    SavedDuringPurchase: "SavedPaymentMethodOrigin" = "saved_during_purchase"
+    Subscription: "SavedPaymentMethodOrigin" = "subscription"

paddle_billing/Entities/Shared/SavedPaymentMethodType.py

@@ -0,0 +1,9 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum, PaddleStrEnumMeta
+
+
+class SavedPaymentMethodType(PaddleStrEnum, metaclass=PaddleStrEnumMeta):
+    Alipay: "SavedPaymentMethodType" = "alipay"
+    ApplePay: "SavedPaymentMethodType" = "apple_pay"
+    Card: "SavedPaymentMethodType" = "card"
+    GooglePay: "SavedPaymentMethodType" = "google_pay"
+    Paypal: "SavedPaymentMethodType" = "paypal"

paddle_billing/Entities/Shared/TransactionLineItemPreview.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 from dataclasses import dataclass
 
-from paddle_billing.Entities.Product import Product
+from paddle_billing.Entities.Shared.TransactionPreviewProduct import TransactionPreviewProduct
 from paddle_billing.Entities.Shared.Totals import Totals
 from paddle_billing.Entities.Shared.UnitTotals import UnitTotals
 from paddle_billing.Entities.Shared.Proration import Proration
@@ -9,22 +9,22 @@ from paddle_billing.Entities.Shared.Proration import Proration
 
 @dataclass
 class TransactionLineItemPreview:
-    price_id: str
+    price_id: str | None
     quantity: int
     tax_rate: str
     unit_totals: UnitTotals
     totals: Totals
-    product: Product
+    product: TransactionPreviewProduct
     proration: Proration | None
 
     @staticmethod
     def from_dict(data: dict) -> TransactionLineItemPreview:
         return TransactionLineItemPreview(
-            price_id=data["price_id"],
+            price_id=data.get("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"]),
+            product=TransactionPreviewProduct.from_dict(data["product"]),
             proration=Proration.from_dict(data["proration"]) if data.get("proration") else None,
         )

paddle_billing/Entities/Shared/TransactionPreviewProduct.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from datetime import datetime
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.Shared import CatalogType, CustomData, ImportMeta, Status, TaxCategory
+
+
+@dataclass
+class TransactionPreviewProduct(Entity):
+    id: str | None
+    name: str
+    description: str | None
+    tax_category: TaxCategory
+    image_url: str | None
+    status: Status
+    created_at: datetime
+    updated_at: datetime
+    type: CatalogType | None = None
+    custom_data: CustomData | None = None
+    import_meta: ImportMeta | None = None
+
+    @staticmethod
+    def from_dict(data: dict) -> TransactionPreviewProduct:
+        return TransactionPreviewProduct(
+            id=data.get("id"),
+            name=data["name"],
+            description=data.get("description"),
+            tax_category=TaxCategory(data["tax_category"]),
+            image_url=data.get("image_url"),
+            status=Status(data["status"]),
+            created_at=datetime.fromisoformat(data["created_at"]),
+            updated_at=datetime.fromisoformat(data["updated_at"]),
+            type=CatalogType(data["type"]) if data.get("type") else None,
+            custom_data=CustomData(data["custom_data"]) if data.get("custom_data") else None,
+            import_meta=ImportMeta.from_dict(data["import_meta"]) if data.get("import_meta") else None,
+        )

paddle_billing/Entities/Shared/__init__.py

@@ -31,8 +31,11 @@ from paddle_billing.Entities.Shared.Pagination import Pagination
 from paddle_billing.Entities.Shared.PaymentAttemptStatus import PaymentAttemptStatus
 from paddle_billing.Entities.Shared.PaymentMethodType import PaymentMethodType
 from paddle_billing.Entities.Shared.PayoutTotalsAdjustment import PayoutTotalsAdjustment
+from paddle_billing.Entities.Shared.Paypal import Paypal
 from paddle_billing.Entities.Shared.PriceQuantity import PriceQuantity
 from paddle_billing.Entities.Shared.Proration import Proration
+from paddle_billing.Entities.Shared.SavedPaymentMethodOrigin import SavedPaymentMethodOrigin
+from paddle_billing.Entities.Shared.SavedPaymentMethodType import SavedPaymentMethodType
 from paddle_billing.Entities.Shared.Status import Status
 from paddle_billing.Entities.Shared.TransactionStatus import TransactionStatus
 from paddle_billing.Entities.Shared.TaxCategory import TaxCategory

paddle_billing/Entities/Subscriptions/SubscriptionAdjustmentItem.py

@@ -9,7 +9,7 @@ class SubscriptionAdjustmentItem:
     item_id: str
     type: AdjustmentType
     amount: str | None
-    proration: Proration
+    proration: Proration | None
     totals: AdjustmentItemTotals
 
     @staticmethod
@@ -18,6 +18,6 @@ class SubscriptionAdjustmentItem:
             item_id=data["item_id"],
             type=AdjustmentType(data["type"]),
             amount=data.get("amount"),
-            proration=Proration.from_dict(data["proration"]),
+            proration=Proration.from_dict(data["proration"]) if data.get("proration") else None,
             totals=AdjustmentItemTotals.from_dict(data["totals"]),
         )

paddle_billing/Entities/Subscriptions/__init__.py

@@ -6,15 +6,8 @@ from paddle_billing.Entities.Subscriptions.SubscriptionDiscount import Subscript
 from paddle_billing.Entities.Subscriptions.SubscriptionEffectiveFrom import SubscriptionEffectiveFrom
 from paddle_billing.Entities.Subscriptions.SubscriptionItem import SubscriptionItem
 from paddle_billing.Entities.Subscriptions.SubscriptionItemStatus import SubscriptionItemStatus
-from paddle_billing.Entities.Subscriptions.SubscriptionItems import SubscriptionItems
-from paddle_billing.Entities.Subscriptions.SubscriptionItemsWithPrice import SubscriptionItemsWithPrice
 from paddle_billing.Entities.Subscriptions.SubscriptionManagementUrls import SubscriptionManagementUrls
 from paddle_billing.Entities.Subscriptions.SubscriptionNextTransaction import SubscriptionNextTransaction
-from paddle_billing.Entities.Subscriptions.SubscriptionNonCatalogPrice import SubscriptionNonCatalogPrice
-from paddle_billing.Entities.Subscriptions.SubscriptionNonCatalogPriceWithProduct import (
-    SubscriptionNonCatalogPriceWithProduct,
-)
-from paddle_billing.Entities.Subscriptions.SubscriptionNonCatalogProduct import SubscriptionNonCatalogProduct
 from paddle_billing.Entities.Subscriptions.SubscriptionOnPaymentFailure import SubscriptionOnPaymentFailure
 from paddle_billing.Entities.Subscriptions.SubscriptionPreviewSubscriptionUpdateSummary import (
     SubscriptionPreviewSubscriptionUpdateSummary,
@@ -26,4 +19,3 @@ from paddle_billing.Entities.Subscriptions.SubscriptionResumeEffectiveFrom impor
 from paddle_billing.Entities.Subscriptions.SubscriptionScheduledChange import SubscriptionScheduledChange
 from paddle_billing.Entities.Subscriptions.SubscriptionScheduledChangeAction import SubscriptionScheduledChangeAction
 from paddle_billing.Entities.Subscriptions.SubscriptionStatus import SubscriptionStatus
-from paddle_billing.Entities.Subscriptions.SubscriptionUpdateItem import SubscriptionUpdateItem

paddle_billing/Entities/Transactions/TransactionItem.py

@@ -8,7 +8,6 @@ from paddle_billing.Entities.Shared.Proration import Proration
 
 @dataclass
 class TransactionItem:
-    price_id: str | None
     price: Price
     quantity: int
     proration: Proration | None
@@ -16,7 +15,6 @@ class TransactionItem:
     @staticmethod
     def from_dict(data: dict) -> TransactionItem:
         return TransactionItem(
-            price_id=data.get("price_id"),
             price=Price.from_dict(data["price"]),
             quantity=data["quantity"],
             proration=Proration.from_dict(data["proration"]) if data.get("proration") else None,

paddle_billing/Entities/Transactions/TransactionItemPreviewWithPrice.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 from dataclasses import dataclass
 
-from paddle_billing.Entities.Price import Price
+from paddle_billing.Entities.Transactions.TransactionPreviewPrice import TransactionPreviewPrice
 
 from paddle_billing.Entities.Shared.Proration import Proration
 
 
 @dataclass
 class TransactionItemPreviewWithPrice:
-    price: Price
+    price: TransactionPreviewPrice
     quantity: int
     include_in_totals: bool
     proration: Proration | None
@@ -16,7 +16,7 @@ class TransactionItemPreviewWithPrice:
     @staticmethod
     def from_dict(data: dict) -> TransactionItemPreviewWithPrice:
         return TransactionItemPreviewWithPrice(
-            price=Price.from_dict(data["price"]),
+            price=TransactionPreviewPrice.from_dict(data["price"]),
             quantity=data["quantity"],
             include_in_totals=data["include_in_totals"],
             proration=Proration.from_dict(data["proration"]) if data.get("proration") else None,

paddle_billing/Entities/Transactions/TransactionPreviewPrice.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from datetime import datetime
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.Shared import (
+    CatalogType,
+    CustomData,
+    Duration,
+    ImportMeta,
+    Money,
+    PriceQuantity,
+    Status,
+    TaxMode,
+    UnitPriceOverride,
+)
+
+
+@dataclass
+class TransactionPreviewPrice(Entity):
+    id: str | None
+    product_id: str | None
+    name: str | None
+    description: str
+    type: CatalogType
+    billing_cycle: Duration | None
+    trial_period: Duration | None
+    tax_mode: TaxMode
+    unit_price: Money
+    unit_price_overrides: list[UnitPriceOverride]
+    quantity: PriceQuantity
+    status: Status
+    custom_data: CustomData | None
+    import_meta: ImportMeta | None
+    created_at: datetime
+    updated_at: datetime
+
+    @staticmethod
+    def from_dict(data: dict) -> TransactionPreviewPrice:
+        return TransactionPreviewPrice(
+            id=data.get("id"),
+            product_id=data.get("product_id"),
+            name=data.get("name"),
+            description=data["description"],
+            unit_price=Money.from_dict(data["unit_price"]),
+            quantity=PriceQuantity.from_dict(data["quantity"]),
+            status=Status(data["status"]),
+            tax_mode=TaxMode(data.get("tax_mode")),
+            created_at=datetime.fromisoformat(data["created_at"]),
+            updated_at=datetime.fromisoformat(data["updated_at"]),
+            unit_price_overrides=[
+                UnitPriceOverride.from_dict(override) for override in data.get("unit_price_overrides", [])
+            ],
+            type=CatalogType(data.get("type")) if data.get("type") else None,
+            billing_cycle=Duration.from_dict(data["billing_cycle"]) if data.get("billing_cycle") else None,
+            trial_period=Duration.from_dict(data["trial_period"]) if data.get("trial_period") else None,
+            custom_data=CustomData(data["custom_data"]) if data.get("custom_data") else None,
+            import_meta=ImportMeta.from_dict(data["import_meta"]) if data.get("import_meta") else None,
+        )

paddle_billing/Entities/Transactions/__init__.py

@@ -1,19 +1,7 @@
 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.Shared.TimePeriod import TimePeriod
-from paddle_billing.Entities.Transactions.TransactionUpdateTransactionItem import TransactionUpdateTransactionItem
 
 
 # These cause circular imports

paddle_billing/Notifications/Entities/Entity.py

@@ -44,10 +44,12 @@ class Entity(ABC, EntityDict):
     def _resolve_event_class_name(event_type) -> str:
         if event_type == "subscription.created":
             return "SubscriptionCreated"
+        if event_type == "payment_method.deleted":
+            return "PaymentMethodDeleted"
 
         event_entity = event_type.split(".")[0] or ""
 
-        return event_entity.lower().title()
+        return event_entity.lower().title().replace("_", "")
 
     def to_dict(self) -> dict:
         return asdict(self)