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

paddle_billing/Resources/EventTypes/EventTypesClient.py

@@ -0,0 +1,22 @@
+from paddle_billing.ResponseParser       import ResponseParser
+from paddle_billing.Entities.Collections import Paginator, EventTypeCollection
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from paddle_billing.Client import Client
+
+
+class EventTypesClient:
+    def __init__(self, client: 'Client'):
+        self.client   = client
+        self.response = None
+
+
+    def list(self) -> EventTypeCollection:
+        self.response = self.client.get_raw('/event-types')
+        parser        = ResponseParser(self.response)
+
+        return EventTypeCollection.from_list(
+            parser.get_data(),
+            Paginator(self.client, parser.get_pagination(), EventTypeCollection)
+        )

paddle_billing/Resources/Events/EventsClient.py

@@ -0,0 +1,26 @@
+from paddle_billing.ResponseParser              import ResponseParser
+from paddle_billing.Entities.Collections        import EventCollection, Paginator
+from paddle_billing.Resources.Events.Operations import ListEvents
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from paddle_billing.Client import Client
+
+
+class EventsClient:
+    def __init__(self, client: 'Client'):
+        self.client   = client
+        self.response = None
+
+
+    def list(self, operation: ListEvents = None) -> EventCollection:
+        if operation is None:
+            operation = ListEvents()
+
+        self.response = self.client.get_raw('/events', operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return EventCollection.from_list(
+            parser.get_data(),
+            Paginator(self.client, parser.get_pagination(), EventCollection)
+        )

paddle_billing/Resources/Events/Operations/ListEvents.py

@@ -0,0 +1,12 @@
+from paddle_billing.HasParameters import HasParameters
+
+from paddle_billing.Resources.Shared.Operations import Pager
+
+
+class ListEvents(HasParameters):
+    def __init__(self, pager: Pager | None = None):
+        self.pager = pager
+
+
+    def get_parameters(self) -> dict:
+        return self.pager.get_parameters() if self.pager else {}

paddle_billing/Resources/Events/Operations/__init__.py

@@ -0,0 +1 @@
+from paddle_billing.Resources.Events.Operations.ListEvents import ListEvents

paddle_billing/Resources/NotificationLogs/NotificationLogsClient.py

@@ -0,0 +1,26 @@
+from paddle_billing.ResponseParser                        import ResponseParser
+from paddle_billing.Entities.Collections                  import Paginator, NotificationLogCollection
+from paddle_billing.Resources.NotificationLogs.Operations import ListNotificationLogs
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from paddle_billing.Client import Client
+
+
+class NotificationLogsClient:
+    def __init__(self, client: 'Client'):
+        self.client   = client
+        self.response = None
+
+
+    def list(self, notification_id: str, operation: ListNotificationLogs = None) -> NotificationLogCollection:
+        if operation is None:
+            operation = ListNotificationLogs()
+
+        self.response = self.client.get_raw(f"/notifications/{notification_id}/logs", operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return NotificationLogCollection.from_list(
+            parser.get_data(),
+            Paginator(self.client, parser.get_pagination(), NotificationLogCollection)
+        )

paddle_billing/Resources/NotificationLogs/Operations/ListNotificationLogs.py

@@ -0,0 +1,11 @@
+from paddle_billing.HasParameters               import HasParameters
+from paddle_billing.Resources.Shared.Operations import Pager
+
+
+class ListNotificationLogs(HasParameters):
+    def __init__(self, pager: Pager = None):
+        self.pager = pager
+
+
+    def get_parameters(self) -> dict:
+        return self.pager.get_parameters() if self.pager else {}

paddle_billing/Resources/NotificationLogs/Operations/__init__.py

@@ -0,0 +1 @@
+from paddle_billing.Resources.NotificationLogs.Operations.ListNotificationLogs import ListNotificationLogs

paddle_billing/Resources/NotificationSettings/NotificationSettingsClient.py

@@ -0,0 +1,54 @@
+from paddle_billing.ResponseParser import ResponseParser
+
+from paddle_billing.Entities.Collections         import NotificationSettingCollection
+from paddle_billing.Entities.NotificationSetting import NotificationSetting
+
+from paddle_billing.Resources.NotificationSettings.Operations import CreateNotificationSetting, UpdateNotificationSetting
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from paddle_billing.Client import Client
+
+
+class NotificationSettingsClient:
+    def __init__(self, client: 'Client'):
+        self.client   = client
+        self.response = None
+
+
+    def list(self) -> NotificationSettingCollection:
+        self.response = self.client.get_raw('/notification-settings')
+        parser        = ResponseParser(self.response)
+
+        return NotificationSettingCollection.from_list(parser.get_data())
+
+
+    def get(self, notification_setting_id: str) -> NotificationSetting:
+        self.response = self.client.get_raw(f"/notification-settings/{notification_setting_id}")
+        parser        = ResponseParser(self.response)
+
+        return NotificationSetting.from_dict(parser.get_data())
+
+
+    def create(self, operation: CreateNotificationSetting) -> NotificationSetting:
+        self.response = self.client.post_raw('/notification-settings', operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return NotificationSetting.from_dict(parser.get_data())
+
+
+    def update(self, notification_setting_id: str, operation: UpdateNotificationSetting) -> NotificationSetting:
+        self.response = self.client.patch_raw(
+            f"/notification-settings/{notification_setting_id}",
+            operation.get_parameters()
+        )
+        parser = ResponseParser(self.response)
+
+        return NotificationSetting.from_dict(parser.get_data())
+
+
+    def delete(self, notification_setting_id: str) -> NotificationSetting:
+        self.response = self.client.delete_raw(f"/notification-settings/{notification_setting_id}")
+        parser        = ResponseParser(self.response)
+
+        return NotificationSetting.from_dict(parser.get_data())

paddle_billing/Resources/NotificationSettings/Operations/CreateNotificationSetting.py

@@ -0,0 +1,21 @@
+from dataclasses import asdict, dataclass
+
+from paddle_billing.Undefined                     import Undefined
+from paddle_billing.Entities.Events               import EventTypeName
+from paddle_billing.Entities.NotificationSettings import NotificationSettingType
+
+
+@dataclass
+class CreateNotificationSetting:
+    description:              str
+    destination:              str
+    subscribed_events:        list[EventTypeName]
+    type:                     NotificationSettingType
+    include_sensitive_fields: bool
+    api_version:              int | Undefined = Undefined()
+
+
+    def get_parameters(self) -> dict:
+        return asdict(self)
+
+

paddle_billing/Resources/NotificationSettings/Operations/UpdateNotificationSetting.py

@@ -0,0 +1,20 @@
+from dataclasses import asdict, dataclass
+
+from paddle_billing.Undefined       import Undefined
+from paddle_billing.Entities.Events import EventTypeName
+
+
+@dataclass
+class UpdateNotificationSetting:
+    description:              str                 | Undefined = Undefined()
+    destination:              str                 | Undefined = Undefined()
+    active:                   bool                | Undefined = Undefined()
+    api_version:              int                 | Undefined = Undefined()
+    include_sensitive_fields: bool                | Undefined = Undefined()
+    subscribed_events:        list[EventTypeName] | Undefined = Undefined()
+
+
+    def get_parameters(self) -> dict:
+        return asdict(self)
+
+

paddle_billing/Resources/NotificationSettings/Operations/__init__.py

@@ -0,0 +1,2 @@
+from paddle_billing.Resources.NotificationSettings.Operations.CreateNotificationSetting import CreateNotificationSetting
+from paddle_billing.Resources.NotificationSettings.Operations.UpdateNotificationSetting import UpdateNotificationSetting

paddle_billing/Resources/Notifications/NotificationsClient.py

@@ -0,0 +1,44 @@
+from paddle_billing.ResponseParser import ResponseParser
+
+from paddle_billing.Entities.Collections  import NotificationCollection, Paginator
+from paddle_billing.Entities.Notification import Notification
+
+from paddle_billing.Resources.Notifications.Operations import ListNotifications
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from paddle_billing.Client import Client
+
+
+class NotificationsClient:
+    def __init__(self, client: 'Client'):
+        self.client   = client
+        self.response = None
+
+
+    def list(self, operation: ListNotifications = None) -> NotificationCollection:
+        if operation is None:
+            operation = ListNotifications()
+
+        self.response = self.client.get_raw('/notifications', operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return NotificationCollection.from_list(
+            parser.get_data(),
+            Paginator(self.client, parser.get_pagination(), NotificationCollection)
+        )
+
+
+    def get(self, notification_id: str) -> Notification:
+        self.response = self.client.get_raw(f"/notifications/{notification_id}")
+        parser        = ResponseParser(self.response)
+
+        return Notification.from_dict(parser.get_data())
+
+
+    def replay(self, notification_id: str) -> str:
+        self.response = self.client.post_raw(f"/notifications/{notification_id}")
+        parser        = ResponseParser(self.response)
+        data          = parser.get_data()
+
+        return data.get('notification_id', '')

paddle_billing/Resources/Notifications/Operations/ListNotifications.py

@@ -0,0 +1,58 @@
+from paddle_billing.EnumStringify import enum_stringify
+from paddle_billing.HasParameters import HasParameters
+
+from paddle_billing.Entities.DateTime      import DateTime
+from paddle_billing.Entities.Notifications import NotificationStatus
+
+from paddle_billing.Exceptions.SdkExceptions.InvalidArgumentException import InvalidArgumentException
+
+from paddle_billing.Resources.Shared.Operations import Pager
+
+
+class ListNotifications(HasParameters):
+    def __init__(
+        self,
+        pager:                    Pager                    | None = None,
+        notification_setting_ids: list[str]                       = None,
+        search:                   str                      | None = None,
+        statuses:                 list[NotificationStatus]        = None,
+        filter:                   str                      | None = None,
+        end:                      DateTime                 | None = None,
+        start:                    DateTime                 | None = None,
+    ):
+        self.pager                    = pager
+        self.search                   = search
+        self.filter                   = filter
+        self.end                      = end    # DateTime.from_datetime(end)
+        self.start                    = start  # DateTime.from_datetime(start)
+        self.notification_setting_ids = notification_setting_ids if notification_setting_ids is not None else []
+        self.statuses                 = statuses                 if statuses                 is not None else []
+
+        # Validation
+        for field_name, field_value, field_type in [
+            ('notification_setting_ids', self.notification_setting_ids, str),
+            ('statuses',                 self.statuses,                 NotificationStatus),
+        ]:
+            invalid_items = [item for item in field_value if not isinstance(item, field_type)]
+            if invalid_items:
+                raise InvalidArgumentException(field_name, field_type.__name__, invalid_items)
+
+
+    def get_parameters(self) -> dict:
+        parameters = {}
+        if self.pager:
+            parameters.update(self.pager.get_parameters())
+        if self.notification_setting_ids:
+            parameters['notification_setting_id'] = ','.join(self.notification_setting_ids)
+        if self.search:
+            parameters['search'] = self.search
+        if self.statuses:
+            parameters['status'] = ','.join(map(enum_stringify, self.statuses))
+        if self.filter:
+            parameters['filter'] = self.filter
+        if self.end:
+            parameters['to'] = self.end.format()
+        if self.start:
+            parameters['from'] = self.start.format()
+
+        return parameters

paddle_billing/Resources/Notifications/Operations/__init__.py

@@ -0,0 +1 @@
+from paddle_billing.Resources.Notifications.Operations.ListNotifications import ListNotifications

paddle_billing/Resources/Prices/Operations/CreatePrice.py

@@ -0,0 +1,23 @@
+from dataclasses import asdict, dataclass
+
+from paddle_billing.Undefined       import Undefined
+from paddle_billing.Entities.Shared import CatalogType, CustomData, Money, PriceQuantity, TaxMode, TimePeriod, UnitPriceOverride
+
+
+@dataclass
+class CreatePrice:
+    description:          str
+    product_id:           str
+    unit_price:           Money
+    name:                 str                     | None | Undefined = Undefined()
+    type:                 CatalogType             | None | Undefined = Undefined()
+    unit_price_overrides: list[UnitPriceOverride]        | Undefined = Undefined()
+    tax_mode:             TaxMode                        | Undefined = Undefined()
+    trial_period:         TimePeriod              | None | Undefined = Undefined()
+    billing_cycle:        TimePeriod              | None | Undefined = Undefined()
+    quantity:             PriceQuantity                  | Undefined = Undefined()
+    custom_data:          CustomData                     | Undefined = Undefined()
+
+
+    def get_parameters(self) -> dict:
+        return asdict(self)

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

@@ -0,0 +1,5 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class Includes(PaddleStrEnum):
+    Product = 'product'

paddle_billing/Resources/Prices/Operations/ListPrices.py

@@ -0,0 +1,62 @@
+from paddle_billing.EnumStringify import enum_stringify
+from paddle_billing.HasParameters import HasParameters
+
+from paddle_billing.Entities.Shared import CatalogType, Status
+
+from paddle_billing.Exceptions.SdkExceptions.InvalidArgumentException import InvalidArgumentException
+
+from paddle_billing.Resources.Shared.Operations               import Pager
+from paddle_billing.Resources.Prices.Operations.List.Includes import Includes as PriceIncludes
+
+
+
+class ListPrices(HasParameters):
+    def __init__(
+        self, 
+        pager:       Pager | None        = None,
+        includes:    list[PriceIncludes] = None,
+        ids:         list[str]           = None,
+        types:       list[CatalogType]   = None,
+        product_ids: list[str]           = None,
+        statuses:    list[Status]        = None,
+        recurring:   bool | None         = None,
+    ):
+        self.pager       = pager
+        self.recurring   = recurring
+        self.includes    = includes    if includes    is not None else []
+        self.ids         = ids         if ids         is not None else []
+        self.types       = types       if types       is not None else []
+        self.product_ids = product_ids if product_ids is not None else []
+        self.statuses    = statuses    if statuses    is not None else []
+
+        # Validation
+        for field_name, field_value, field_type in [
+            ('ids',         self.ids,         str),
+            ('includes',    self.includes,    PriceIncludes),
+            ('product_ids', self.product_ids, str),
+            ('statuses',    self.statuses,    Status),
+            ('types',       self.types,       CatalogType),
+        ]:
+            invalid_items = [item for item in field_value if not isinstance(item, field_type)]
+            if invalid_items:
+                raise InvalidArgumentException(field_name, field_type.__name__, invalid_items)
+
+
+    def get_parameters(self) -> dict:
+        parameters = {}
+        if self.pager:
+            parameters.update(self.pager.get_parameters())
+        if self.ids:
+            parameters['id'] = ','.join(self.ids)
+        if self.includes:
+            parameters['include'] = ','.join(map(enum_stringify, self.includes))
+        if self.product_ids:
+            parameters['product_id'] = ','.join(self.product_ids)
+        if self.recurring is not None:
+            parameters['recurring'] = 'true' if self.recurring else 'false'
+        if self.statuses:
+            parameters['status'] = ','.join(map(enum_stringify, self.statuses))
+        if self.types:
+            parameters['type'] = ','.join(map(enum_stringify, self.types))
+
+        return parameters

paddle_billing/Resources/Prices/Operations/UpdatePrice.py

@@ -0,0 +1,23 @@
+from dataclasses import asdict, dataclass
+
+from paddle_billing.Undefined       import Undefined
+from paddle_billing.Entities.Shared import CatalogType, CustomData, Money, PriceQuantity, Status, TaxMode, TimePeriod, UnitPriceOverride
+
+
+@dataclass
+class UpdatePrice:
+    description:          str                            | Undefined = Undefined()
+    name:                 str                     | None | Undefined = Undefined()
+    type:                 CatalogType                    | Undefined = Undefined()
+    billing_cycle:        TimePeriod              | None | Undefined = Undefined()
+    trial_period:         TimePeriod              | None | Undefined = Undefined()
+    tax_mode:             TaxMode                        | Undefined = Undefined()
+    unit_price:           Money                          | Undefined = Undefined()
+    unit_price_overrides: list[UnitPriceOverride]        | Undefined = Undefined()
+    quantity:             PriceQuantity                  | Undefined = Undefined()
+    status:               Status                         | Undefined = Undefined()
+    custom_data:          CustomData              | None | Undefined = Undefined()
+
+
+    def get_parameters(self) -> dict:
+        return asdict(self)

paddle_billing/Resources/Prices/Operations/__init__.py

@@ -0,0 +1,4 @@
+from paddle_billing.Resources.Prices.Operations.CreatePrice   import CreatePrice
+from paddle_billing.Resources.Prices.Operations.ListPrices    import ListPrices
+from paddle_billing.Resources.Prices.Operations.List.Includes import Includes as PriceIncludes
+from paddle_billing.Resources.Prices.Operations.UpdatePrice   import UpdatePrice

paddle_billing/Resources/Prices/PricesClient.py

@@ -0,0 +1,65 @@
+from paddle_billing.ResponseParser import ResponseParser
+
+from paddle_billing.Entities.Price       import Price
+from paddle_billing.Entities.Collections import Paginator, PriceCollection
+from paddle_billing.Entities.Shared      import Status
+
+from paddle_billing.Exceptions.SdkExceptions.InvalidArgumentException import InvalidArgumentException
+
+from paddle_billing.Resources.Prices.Operations import CreatePrice, ListPrices, UpdatePrice, PriceIncludes
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from paddle_billing.Client import Client
+
+
+class PricesClient:
+    def __init__(self, client: 'Client'):
+        self.client   = client
+        self.response = None
+
+
+    def list(self, operation: ListPrices = None) -> PriceCollection:
+        if operation is None:
+            operation = ListPrices()
+
+        self.response = self.client.get_raw('/prices', operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return PriceCollection.from_list(
+            parser.get_data(),
+            Paginator(self.client, parser.get_pagination(), PriceCollection)
+        )
+
+
+    def get(self, price_id: str, includes = None) -> Price:
+        if includes is None:
+            includes = []
+
+        invalid_items = [item for item in includes if not isinstance(item, PriceIncludes)]
+        if invalid_items:
+            raise InvalidArgumentException('includes', PriceIncludes.__name__, invalid_items)
+
+        params        = {'include': ','.join(include.value for include in includes)} if includes else {}
+        self.response = self.client.get_raw(f"/prices/{price_id}", params)
+        parser        = ResponseParser(self.response)
+
+        return Price.from_dict(parser.get_data())
+
+
+    def create(self, operation: CreatePrice) -> Price:
+        self.response = self.client.post_raw('/prices', operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return Price.from_dict(parser.get_data())
+
+
+    def update(self, price_id: str, operation: UpdatePrice) -> Price:
+        self.response = self.client.patch_raw(f"/prices/{price_id}", operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return Price.from_dict(parser.get_data())
+
+
+    def archive(self, price_id: str) -> Price:
+        return self.update(price_id, UpdatePrice(status=Status.Archived))

paddle_billing/Resources/PricingPreviews/Operations/PreviewPrice.py

@@ -0,0 +1,20 @@
+from dataclasses import asdict, dataclass
+
+from paddle_billing.Undefined                import Undefined
+from paddle_billing.Entities.PricingPreviews import PricePreviewItem
+from paddle_billing.Entities.Shared          import CurrencyCode, AddressPreview
+
+
+@dataclass
+class PreviewPrice:
+    items:               list[PricePreviewItem]
+    customer_id:         str                    | None | Undefined = Undefined()
+    address_id:          str                    | None | Undefined = Undefined()
+    business_id:         str                    | None | Undefined = Undefined()
+    currency_code:       CurrencyCode                  | Undefined = Undefined()
+    discount_id:         str                    | None | Undefined = Undefined()
+    address:             AddressPreview         | None | Undefined = Undefined()
+    customer_ip_address: str                    | None | Undefined = Undefined()
+
+    def get_parameters(self) -> dict:
+        return asdict(self)

paddle_billing/Resources/PricingPreviews/Operations/__init__.py

@@ -0,0 +1 @@
+from paddle_billing.Resources.PricingPreviews.Operations.PreviewPrice import PreviewPrice

paddle_billing/Resources/PricingPreviews/PricingPreviewsClient.py

@@ -0,0 +1,20 @@
+from paddle_billing.ResponseParser                       import ResponseParser
+from paddle_billing.Entities.PricePreview                import PricePreview
+from paddle_billing.Resources.PricingPreviews.Operations import PreviewPrice
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from paddle_billing.Client import Client
+
+
+class PricingPreviewsClient:
+    def __init__(self, client: 'Client'):
+        self.client   = client
+        self.response = None
+
+
+    def preview_prices(self, operation: PreviewPrice) -> PricePreview:
+        self.response = self.client.post_raw('/pricing-preview', operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return PricePreview.from_dict(parser.get_data())

paddle_billing/Resources/Products/Operations/CreateProduct.py

@@ -0,0 +1,18 @@
+from dataclasses import asdict, dataclass
+
+from paddle_billing.Undefined       import Undefined
+from paddle_billing.Entities.Shared import CatalogType, CustomData, TaxCategory
+
+
+@dataclass
+class CreateProduct:
+    name:         str
+    tax_category: TaxCategory
+    type:         CatalogType | None | Undefined = Undefined()
+    description:  str         | None | Undefined = Undefined()
+    image_url:    str         | None | Undefined = Undefined()
+    custom_data:  CustomData  | None | Undefined = Undefined()
+
+
+    def get_parameters(self) -> dict:
+        return asdict(self)

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

@@ -0,0 +1,5 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class Includes(PaddleStrEnum):
+    Prices = 'prices'