paddle-python-sdk 1.4.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

paddle_billing/Client.py

@@ -1,15 +1,13 @@
-from json import dumps as json_dumps, JSONEncoder
+from json import dumps as json_dumps
 from logging import Logger, getLogger
 from requests import Response, RequestException, Session
 from requests.adapters import HTTPAdapter
 from urllib3.util.retry import Retry
 from urllib.parse import urljoin, urlencode
 from uuid import uuid4
-from dataclasses import fields, is_dataclass
+from paddle_billing.Json import PayloadEncoder
 
 from paddle_billing.Operation import Operation
-from paddle_billing.FiltersUndefined import FiltersUndefined
-from paddle_billing.Undefined import Undefined
 from paddle_billing.HasParameters import HasParameters
 from paddle_billing.Options import Options
 from paddle_billing.ResponseParser import ResponseParser
@@ -33,28 +31,14 @@ 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.Simulations.SimulationsClient import SimulationsClient
+from paddle_billing.Resources.SimulationRuns.SimulationRunsClient import SimulationRunsClient
+from paddle_billing.Resources.SimulationRunEvents.SimulationRunEventsClient import SimulationRunEventsClient
+from paddle_billing.Resources.SimulationTypes.SimulationTypesClient import SimulationTypesClient
 from paddle_billing.Resources.Subscriptions.SubscriptionsClient import SubscriptionsClient
 from paddle_billing.Resources.Transactions.TransactionsClient import TransactionsClient
 
 
-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):
-                data[field.name] = getattr(z, field.name)
-
-            return FiltersUndefined.filter_undefined_values(data)
-
-        return super().default(z)
-
-
 class Client:
     """
     Client for making API requests using Python's requests library.
@@ -98,6 +82,10 @@ class Client:
         self.pricing_previews = PricingPreviewsClient(self)
         self.products = ProductsClient(self)
         self.reports = ReportsClient(self)
+        self.simulations = SimulationsClient(self)
+        self.simulation_runs = SimulationRunsClient(self)
+        self.simulation_run_events = SimulationRunEventsClient(self)
+        self.simulation_types = SimulationTypesClient(self)
         self.subscriptions = SubscriptionsClient(self)
         self.transactions = TransactionsClient(self)
         self.ip_addresses = IPAddressesClient(self)
@@ -204,7 +192,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.4.0",
+                "User-Agent": "PaddleSDK/python 1.5.0",
             }
         )
 

paddle_billing/Entities/Collections/SimulationCollection.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.Simulation import Simulation
+
+
+class SimulationCollection(Collection[Simulation]):
+    @classmethod
+    def from_list(cls, items_data: list, paginator: Paginator | None = None) -> SimulationCollection:
+        items: list[Simulation] = [Simulation.from_dict(item) for item in items_data]
+
+        return SimulationCollection(items, paginator)

paddle_billing/Entities/Collections/SimulationRunCollection.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.SimulationRun import SimulationRun
+
+
+class SimulationRunCollection(Collection[SimulationRun]):
+    @classmethod
+    def from_list(cls, items_data: list, paginator: Paginator | None = None) -> SimulationRunCollection:
+        items: list[SimulationRun] = [SimulationRun.from_dict(item) for item in items_data]
+
+        return SimulationRunCollection(items, paginator)

paddle_billing/Entities/Collections/SimulationRunEventCollection.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.SimulationRunEvent import SimulationRunEvent
+
+
+class SimulationRunEventCollection(Collection[SimulationRunEvent]):
+    @classmethod
+    def from_list(cls, items_data: list, paginator: Paginator | None = None) -> SimulationRunEventCollection:
+        items: list[SimulationRunEvent] = [SimulationRunEvent.from_dict(item) for item in items_data]
+
+        return SimulationRunEventCollection(items, paginator)

paddle_billing/Entities/Collections/SimulationTypeCollection.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.SimulationType import SimulationType
+
+
+class SimulationTypeCollection(Collection[SimulationType]):
+    @classmethod
+    def from_list(cls, items_data: list, paginator: Paginator | None = None) -> SimulationTypeCollection:
+        items: list[SimulationType] = [SimulationType.from_dict(item) for item in items_data]
+
+        return SimulationTypeCollection(items, paginator)

paddle_billing/Entities/Collections/__init__.py

@@ -15,6 +15,10 @@ from paddle_billing.Entities.Collections.PaymentMethodCollection import PaymentM
 from paddle_billing.Entities.Collections.PriceCollection import PriceCollection
 from paddle_billing.Entities.Collections.ProductCollection import ProductCollection
 from paddle_billing.Entities.Collections.ReportCollection import ReportCollection
+from paddle_billing.Entities.Collections.SimulationCollection import SimulationCollection
+from paddle_billing.Entities.Collections.SimulationRunCollection import SimulationRunCollection
+from paddle_billing.Entities.Collections.SimulationRunEventCollection import SimulationRunEventCollection
+from paddle_billing.Entities.Collections.SimulationTypeCollection import SimulationTypeCollection
 from paddle_billing.Entities.Collections.SubscriptionCollection import SubscriptionCollection
 from paddle_billing.Entities.Collections.SubscriptionPreviewCollection import SubscriptionPreviewCollection
 from paddle_billing.Entities.Collections.TransactionCollection import TransactionCollection

paddle_billing/Entities/Events/EventTypeName.py

@@ -22,6 +22,8 @@ class EventTypeName(PaddleStrEnum, metaclass=PaddleStrEnumMeta):
     InvoiceOverdue: "EventTypeName" = "invoice.overdue"
     InvoicePaid: "EventTypeName" = "invoice.paid"
     InvoiceScheduled: "EventTypeName" = "invoice.scheduled"
+    PaymentMethodDeleted: "EventTypeName" = "payment_method.deleted"
+    PaymentMethodSaved: "EventTypeName" = "payment_method.saved"
     PayoutCreated: "EventTypeName" = "payout.created"
     PayoutPaid: "EventTypeName" = "payout.paid"
     PriceCreated: "EventTypeName" = "price.created"
@@ -47,6 +49,7 @@ class EventTypeName(PaddleStrEnum, metaclass=PaddleStrEnumMeta):
     TransactionPastDue: "EventTypeName" = "transaction.past_due"
     TransactionPaymentFailed: "EventTypeName" = "transaction.payment_failed"
     TransactionReady: "EventTypeName" = "transaction.ready"
+    TransactionRevised: "EventTypeName" = "transaction.revised"
     TransactionUpdated: "EventTypeName" = "transaction.updated"
     ReportCreated: "EventTypeName" = "report.created"
     ReportUpdated: "EventTypeName" = "report.updated"

paddle_billing/Entities/Simulation.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+from abc import ABC
+from dataclasses import dataclass
+from datetime import datetime
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.Events import EventTypeName
+from paddle_billing.Entities.Simulations import SimulationScenarioType, SimulationStatus
+
+from paddle_billing.Notifications.Entities.Simulations.SimulationEntity import SimulationEntity
+from paddle_billing.Notifications.Entities.UndefinedEntity import UndefinedEntity
+
+
+@dataclass
+class Simulation(Entity, ABC):
+    id: str
+    status: SimulationStatus
+    notification_setting_id: str
+    name: str
+    type: EventTypeName | SimulationScenarioType
+    payload: SimulationEntity | UndefinedEntity | None
+    last_run_at: datetime | None
+    created_at: datetime
+    updated_at: datetime
+
+    @staticmethod
+    def from_dict(data: dict) -> Simulation:
+        type = EventTypeName(data["type"])
+        if not type.is_known():
+            type = SimulationScenarioType(data["type"])
+
+        return Simulation(
+            id=data["id"],
+            status=SimulationStatus(data["status"]),
+            notification_setting_id=data["notification_setting_id"],
+            name=data["name"],
+            type=type,
+            payload=(
+                SimulationEntity.from_dict_for_event_type(data["payload"], type.value)
+                if isinstance(type, EventTypeName) and data.get("payload")
+                else None
+            ),
+            last_run_at=datetime.fromisoformat(data["last_run_at"]) if data.get("last_run_at") else None,
+            created_at=datetime.fromisoformat(data["created_at"]),
+            updated_at=datetime.fromisoformat(data["updated_at"]),
+        )

paddle_billing/Entities/SimulationRun.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+from abc import ABC
+from dataclasses import dataclass
+from datetime import datetime
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.Events import EventTypeName
+from paddle_billing.Entities.Simulations import SimulationScenarioType
+from paddle_billing.Entities.SimulationRuns import SimulationRunStatus
+from paddle_billing.Entities.SimulationRunEvent import SimulationRunEvent
+
+
+@dataclass
+class SimulationRun(Entity, ABC):
+    id: str
+    status: SimulationRunStatus
+    type: EventTypeName | SimulationScenarioType
+    created_at: datetime
+    updated_at: datetime
+    events: list[SimulationRunEvent]
+
+    @staticmethod
+    def from_dict(data: dict) -> SimulationRun:
+        type = EventTypeName(data["type"])
+        if not type.is_known():
+            type = SimulationScenarioType(data["type"])
+
+        return SimulationRun(
+            id=data["id"],
+            status=SimulationRunStatus(data["status"]),
+            type=type,
+            created_at=datetime.fromisoformat(data["created_at"]),
+            updated_at=datetime.fromisoformat(data["updated_at"]),
+            events=[SimulationRunEvent.from_dict(event) for event in data.get("events", [])],
+        )

paddle_billing/Entities/SimulationRunEvent.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+from abc import ABC
+from dataclasses import dataclass
+from datetime import datetime
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.Events import EventTypeName
+from paddle_billing.Entities.SimulationRunEvents import (
+    SimulationRunEventStatus,
+    SimulationRunEventRequest,
+    SimulationRunEventResponse,
+)
+
+from paddle_billing.Notifications.Entities.Entity import Entity as NotificationEntity
+from paddle_billing.Notifications.Entities.UndefinedEntity import UndefinedEntity
+
+
+@dataclass
+class SimulationRunEvent(Entity, ABC):
+    id: str
+    status: SimulationRunEventStatus
+    event_type: EventTypeName
+    payload: NotificationEntity | UndefinedEntity
+    request: SimulationRunEventRequest | None
+    response: SimulationRunEventResponse | None
+    created_at: datetime
+    updated_at: datetime
+
+    @staticmethod
+    def from_dict(data: dict) -> SimulationRunEvent:
+        return SimulationRunEvent(
+            id=data["id"],
+            status=SimulationRunEventStatus(data["status"]),
+            event_type=EventTypeName(data["event_type"]),
+            payload=NotificationEntity.from_dict_for_event_type(data["payload"], data["event_type"]),
+            request=SimulationRunEventRequest.from_dict(data["request"]) if data.get("request") else None,
+            response=SimulationRunEventResponse.from_dict(data["response"]) if data.get("response") else None,
+            created_at=datetime.fromisoformat(data["created_at"]),
+            updated_at=datetime.fromisoformat(data["updated_at"]),
+        )

paddle_billing/Entities/SimulationRunEvents/SimulationRunEventRequest.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Entity import Entity
+
+
+@dataclass
+class SimulationRunEventRequest(Entity):
+    body: str
+
+    @staticmethod
+    def from_dict(data: dict) -> SimulationRunEventRequest:
+        return SimulationRunEventRequest(
+            body=data["body"],
+        )

paddle_billing/Entities/SimulationRunEvents/SimulationRunEventResponse.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Entity import Entity
+
+
+@dataclass
+class SimulationRunEventResponse(Entity):
+    body: str
+    status_code: int
+
+    @staticmethod
+    def from_dict(data: dict) -> SimulationRunEventResponse:
+        return SimulationRunEventResponse(
+            body=data["body"],
+            status_code=data["status_code"],
+        )

paddle_billing/Entities/SimulationRunEvents/SimulationRunEventStatus.py

@@ -0,0 +1,8 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum, PaddleStrEnumMeta
+
+
+class SimulationRunEventStatus(PaddleStrEnum, metaclass=PaddleStrEnumMeta):
+    Aborted: "SimulationRunEventStatus" = "aborted"
+    Failed: "SimulationRunEventStatus" = "failed"
+    Success: "SimulationRunEventStatus" = "success"
+    Pending: "SimulationRunEventStatus" = "pending"

paddle_billing/Entities/SimulationRunEvents/__init__.py

@@ -0,0 +1,3 @@
+from paddle_billing.Entities.SimulationRunEvents.SimulationRunEventRequest import SimulationRunEventRequest
+from paddle_billing.Entities.SimulationRunEvents.SimulationRunEventResponse import SimulationRunEventResponse
+from paddle_billing.Entities.SimulationRunEvents.SimulationRunEventStatus import SimulationRunEventStatus

paddle_billing/Entities/SimulationRuns/SimulationRunStatus.py

@@ -0,0 +1,7 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum, PaddleStrEnumMeta
+
+
+class SimulationRunStatus(PaddleStrEnum, metaclass=PaddleStrEnumMeta):
+    Canceled: "SimulationRunStatus" = "canceled"
+    Completed: "SimulationRunStatus" = "completed"
+    Pending: "SimulationRunStatus" = "pending"

paddle_billing/Entities/SimulationRuns/__init__.py

@@ -0,0 +1 @@
+from paddle_billing.Entities.SimulationRuns.SimulationRunStatus import SimulationRunStatus

paddle_billing/Entities/SimulationType.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+from abc import ABC
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Entity import Entity
+from paddle_billing.Entities.Events import EventTypeName
+from paddle_billing.Entities.Simulations import SimulationKind
+
+
+@dataclass
+class SimulationType(Entity, ABC):
+    name: str
+    label: str
+    description: str
+    group: str
+    type: SimulationKind
+    events: list[EventTypeName]
+
+    @staticmethod
+    def from_dict(data: dict) -> SimulationType:
+        return SimulationType(
+            name=data["name"],
+            label=data["label"],
+            description=data["description"],
+            group=data["group"],
+            type=SimulationKind(data["type"]),
+            events=[EventTypeName(event) for event in data.get("events", [])],
+        )

paddle_billing/Entities/Simulations/SimulationKind.py

@@ -0,0 +1,6 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum, PaddleStrEnumMeta
+
+
+class SimulationKind(PaddleStrEnum, metaclass=PaddleStrEnumMeta):
+    Scenario: "SimulationKind" = "scenario"
+    SingleEvent: "SimulationKind" = "single_event"

paddle_billing/Entities/Simulations/SimulationScenarioType.py

@@ -0,0 +1,9 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum, PaddleStrEnumMeta
+
+
+class SimulationScenarioType(PaddleStrEnum, metaclass=PaddleStrEnumMeta):
+    SubscriptionCreation: "SimulationScenarioType" = "subscription_creation"
+    SubscriptionRenewal: "SimulationScenarioType" = "subscription_renewal"
+    SubscriptionPause: "SimulationScenarioType" = "subscription_pause"
+    SubscriptionResume: "SimulationScenarioType" = "subscription_resume"
+    SubscriptionCancellation: "SimulationScenarioType" = "subscription_cancellation"

paddle_billing/Entities/Simulations/SimulationStatus.py

@@ -0,0 +1,6 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum, PaddleStrEnumMeta
+
+
+class SimulationStatus(PaddleStrEnum, metaclass=PaddleStrEnumMeta):
+    Active: "SimulationStatus" = "active"
+    Archived: "SimulationStatus" = "archived"

paddle_billing/Entities/Simulations/__init__.py

@@ -0,0 +1,3 @@
+from paddle_billing.Entities.Simulations.SimulationKind import SimulationKind
+from paddle_billing.Entities.Simulations.SimulationScenarioType import SimulationScenarioType
+from paddle_billing.Entities.Simulations.SimulationStatus import SimulationStatus

paddle_billing/Entities/Transaction.py

@@ -58,6 +58,7 @@ class Transaction(Entity):
     customer: Customer | None = None
     discount: Discount | None = None
     available_payment_methods: list[PaymentMethodType] | None = None
+    revised_at: datetime | None = None
 
     @staticmethod
     def from_dict(data: dict) -> Transaction:
@@ -95,4 +96,5 @@ class Transaction(Entity):
                 if data.get("adjustment_totals")
                 else None
             ),
+            revised_at=datetime.fromisoformat(data["revised_at"]) if data.get("revised_at") else None,
         )

paddle_billing/Json/JsonExclude.py

@@ -0,0 +1,6 @@
+def json_exclude(properties: list[str]):
+    def wrapper(cls):
+        cls.json_exclude_properties = properties
+        return cls
+
+    return wrapper

paddle_billing/Json/JsonFormatProperties.py

@@ -0,0 +1,6 @@
+def json_format_properties(properties: list[str]):
+    def wrapper(cls):
+        cls.json_format_properties = properties
+        return cls
+
+    return wrapper

paddle_billing/Json/PayloadEncoder.py

@@ -0,0 +1,42 @@
+from json import JSONEncoder
+from dataclasses import fields, is_dataclass
+from datetime import datetime
+import re
+
+from paddle_billing.Entities.DateTime import DateTime
+from paddle_billing.FiltersUndefined import FiltersUndefined
+from paddle_billing.Undefined import Undefined
+
+
+class PayloadEncoder(JSONEncoder):
+    def default(self, z):
+        if isinstance(z, Undefined):
+            return None
+
+        if isinstance(z, datetime):
+            return DateTime.from_datetime(z)
+
+        if hasattr(z, "to_json") and callable(z.to_json):
+            return z.to_json()
+
+        if is_dataclass(z):
+            exclude_properties = getattr(z.__class__, "json_exclude_properties", [])
+            format_properties = getattr(z.__class__, "json_format_properties", None)
+
+            data = {}
+            for field in fields(z):
+                key = (
+                    self._camel_to_snake(field.name)
+                    if format_properties and field.name in format_properties
+                    else field.name
+                )
+
+                if field.name not in exclude_properties:
+                    data[key] = getattr(z, field.name)
+
+            return FiltersUndefined.filter_undefined_values(data)
+
+        return super().default(z)
+
+    def _camel_to_snake(self, name: str) -> str:
+        return re.sub(r"(?<!^)(?=[A-Z])", "_", name).lower()

paddle_billing/Json/__init__.py

@@ -0,0 +1,3 @@
+from paddle_billing.Json.JsonExclude import json_exclude
+from paddle_billing.Json.JsonFormatProperties import json_format_properties
+from paddle_billing.Json.PayloadEncoder import PayloadEncoder

paddle_billing/Notifications/Entities/Entity.py

@@ -36,7 +36,7 @@ class Entity(ABC, EntityDict):
             return UndefinedEntity(data)
 
         if not issubclass(entity_class, Entity):
-            raise ValueError(f"Event type '{entity_class_name}' is not of NotificationEntity")
+            raise ValueError(f"Event type '{entity_class_name}' is not of Entity")
 
         return instantiated_class
 

paddle_billing/Notifications/Entities/Price.py

@@ -57,7 +57,3 @@ class Price(Entity):
             created_at=datetime.fromisoformat(data["created_at"]) if data.get("created_at") else None,
             updated_at=datetime.fromisoformat(data["updated_at"]) if data.get("updated_at") else None,
         )
-
-
-# Prevents circular import
-from paddle_billing.Entities.Product import Product  # noqa E402

paddle_billing/Notifications/Entities/Product.py

@@ -4,9 +4,11 @@ from datetime import datetime
 
 from paddle_billing.Notifications.Entities.Entity import Entity
 from paddle_billing.Notifications.Entities.Shared import CatalogType, CustomData, ImportMeta, Status, TaxCategory
+from paddle_billing.Json import json_exclude
 
 
 @dataclass
+@json_exclude(["prices"])
 class Product(Entity):
     id: str
     name: str
@@ -16,7 +18,7 @@ class Product(Entity):
     image_url: str | None
     custom_data: CustomData | None = None
     import_meta: ImportMeta | None = None
-    prices: list[Price] | None = None
+    prices: list[Price] | None = None  # Deprecated: prices are not included in product notifications.
     type: CatalogType | None = None
     created_at: datetime | None = None
     updated_at: datetime | None = None

paddle_billing/Notifications/Entities/Simulations/Address.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from datetime import datetime
+
+from paddle_billing.Undefined import Undefined
+from paddle_billing.Notifications.Entities.Shared import CountryCode, CustomData, ImportMeta, Status
+from paddle_billing.Notifications.Entities.Simulations.SimulationEntity import SimulationEntity
+
+
+@dataclass
+class Address(SimulationEntity):
+    id: str | Undefined = Undefined()
+    description: str | None | Undefined = Undefined()
+    first_line: str | None | Undefined = Undefined()
+    second_line: str | None | Undefined = Undefined()
+    city: str | None | Undefined = Undefined()
+    postal_code: str | None | Undefined = Undefined()
+    region: str | None | Undefined = Undefined()
+    country_code: CountryCode | Undefined = Undefined()
+    status: Status | Undefined = Undefined()
+    created_at: datetime | Undefined = Undefined()
+    updated_at: datetime | Undefined = Undefined()
+    custom_data: CustomData | None | Undefined = Undefined()
+    import_meta: ImportMeta | None | Undefined = Undefined()
+    customer_id: str | None | Undefined = Undefined()
+
+    @staticmethod
+    def from_dict(data: dict) -> Address:
+        return Address(
+            id=data.get("id", Undefined()),
+            customer_id=data.get("customer_id", Undefined()),
+            description=data.get("description", Undefined()),
+            first_line=data.get("first_line", Undefined()),
+            second_line=data.get("second_line", Undefined()),
+            city=data.get("city", Undefined()),
+            postal_code=data.get("postal_code", Undefined()),
+            region=data.get("region", Undefined()),
+            country_code=CountryCode(data["country_code"]) if data.get("country_code") else Undefined(),
+            status=Status(data["status"]) if data.get("status") else Undefined(),
+            created_at=datetime.fromisoformat(data["created_at"]) if data.get("created_at") else Undefined(),
+            updated_at=datetime.fromisoformat(data["updated_at"]) if data.get("updated_at") else Undefined(),
+            custom_data=(
+                CustomData(data["custom_data"])
+                if isinstance(data.get("custom_data"), dict)
+                else data.get("custom_data", Undefined())
+            ),
+            import_meta=(
+                ImportMeta.from_dict(data["import_meta"])
+                if isinstance(data.get("import_meta"), dict)
+                else data.get("import_meta", Undefined())
+            ),
+        )

paddle_billing/Notifications/Entities/Simulations/Adjustment.py

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