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

paddle_billing/Resources/Products/Operations/ListProducts.py

@@ -0,0 +1,59 @@
+from paddle_billing.EnumStringify import enum_stringify
+from paddle_billing.HasParameters import HasParameters
+
+from paddle_billing.Entities.Shared import CatalogType, Status, TaxCategory
+
+from paddle_billing.Exceptions.SdkExceptions.InvalidArgumentException import InvalidArgumentException
+
+from paddle_billing.Resources.Products.Operations.List.Includes import Includes as ProductIncludes
+from paddle_billing.Resources.Shared.Operations                 import Pager
+
+
+class ListProducts(HasParameters):
+    def __init__(
+        self,
+        pager:          Pager | None          = None,
+        includes:       list[ProductIncludes] = None,
+        ids:            list[str]             = None,
+        types:          list[CatalogType]     = None,
+        product_ids:    list[str]             = None,
+        statuses:       list[Status]          = None,
+        tax_categories: list[TaxCategory]     = None,
+    ):
+        self.pager          = pager
+        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 []
+        self.tax_categories = tax_categories if tax_categories is not None else []
+
+        # Validation
+        for field_name, field_value, field_type in [
+            ('ids',            self.ids,            str),
+            ('includes',       self.includes,       ProductIncludes),
+            ('statuses',       self.statuses,       Status),
+            ('tax_categories', self.tax_categories, TaxCategory),
+            ('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.statuses:
+            parameters['status'] = ','.join(map(enum_stringify, self.statuses))
+        if self.tax_categories:
+            parameters['tax_category'] = ','.join(map(enum_stringify, self.tax_categories))
+        if self.types:
+            parameters['type'] = ','.join(map(enum_stringify, self.types))
+
+        return parameters

paddle_billing/Resources/Products/Operations/UpdateProduct.py

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

paddle_billing/Resources/Products/Operations/__init__.py

@@ -0,0 +1,4 @@
+from paddle_billing.Resources.Products.Operations.CreateProduct import CreateProduct
+from paddle_billing.Resources.Products.Operations.ListProducts  import ListProducts
+from paddle_billing.Resources.Products.Operations.List.Includes import Includes as ProductIncludes
+from paddle_billing.Resources.Products.Operations.UpdateProduct import UpdateProduct

paddle_billing/Resources/Products/ProductsClient.py

@@ -0,0 +1,70 @@
+from paddle_billing.ResponseParser import ResponseParser
+
+from paddle_billing.Entities.Collections import Paginator, ProductCollection
+from paddle_billing.Entities.Product     import Product
+from paddle_billing.Entities.Shared      import Status
+
+from paddle_billing.Exceptions.SdkExceptions.InvalidArgumentException import InvalidArgumentException
+
+from paddle_billing.Resources.Products.Operations import CreateProduct, ListProducts, UpdateProduct, ProductIncludes
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from paddle_billing.Client import Client
+
+
+class ProductsClient:
+    def __init__(self, client: 'Client'):
+        self.client   = client
+        self.response = None
+
+
+    def list(self, operation: ListProducts = None) -> ProductCollection:
+        if operation is None:
+            operation = ListProducts()
+
+        self.response = self.client.get_raw('/products', operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return ProductCollection.from_list(
+            parser.get_data(),
+            Paginator(self.client, parser.get_pagination(), ProductCollection)
+        )
+
+
+    def get(self, product_id: str, includes = None) -> Product | Product:
+        if product_id is None:
+            raise ValueError('product_id is required')
+        if not isinstance(product_id, str):
+            raise ValueError('product_id must be a string')
+
+        if includes is None:
+            includes = []
+
+        invalid_items = [item for item in includes if not isinstance(item, ProductIncludes)]
+        if invalid_items:
+            raise InvalidArgumentException('includes', ProductIncludes.__name__, invalid_items)
+
+        params         = {'include': ','.join(include.value for include in includes)} if includes else {}
+        self.response = self.client.get_raw(f"/products/{product_id}", params)
+        parser         = ResponseParser(self.response)
+
+        return Product.from_dict(parser.get_data())
+
+
+    def create(self, operation: CreateProduct) -> Product:
+        self.response = self.client.post_raw('/products', operation.get_parameters())
+        parser         = ResponseParser(self.response)
+
+        return Product.from_dict(parser.get_data())
+
+
+    def update(self, product_id: str, operation: UpdateProduct) -> Product:
+        self.response = self.client.patch_raw(f"/products/{product_id}", operation.get_parameters())
+        parser         = ResponseParser(self.response)
+
+        return Product.from_dict(parser.get_data())
+
+
+    def archive(self, product_id: str) -> Product:
+        return self.update(product_id, UpdateProduct(status=Status.Archived))

paddle_billing/Resources/Reports/Operations/CreateReport.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass, field
+
+from paddle_billing.Entities.Reports import ReportType, ReportFilter
+
+from paddle_billing.Exceptions.SdkExceptions.InvalidArgumentException import InvalidArgumentException
+
+
+@dataclass
+class CreateReport:
+    type:    ReportType
+    filters: list[ReportFilter] = field(default_factory=list)
+
+
+    def __post_init__(self):
+        # Validation
+        if any(not isinstance(filter_item, ReportFilter) for filter_item in self.filters):
+            invalid_items = [filter_item for filter_item in self.filters if not isinstance(filter_item, ReportFilter)]
+            raise InvalidArgumentException('filters', 'ReportFilter', ', '.join(map(str, invalid_items)))
+
+
+    def get_parameters(self) -> dict:
+        parameters = {'type': self.type}
+
+        if self.filters is not None and self.filters != []:
+            parameters.update({'filters': [filter_.get_parameters() for filter_ in self.filters]})
+
+        return parameters

paddle_billing/Resources/Reports/Operations/ListReports.py

@@ -0,0 +1,35 @@
+from paddle_billing.EnumStringify import enum_stringify
+from paddle_billing.HasParameters import HasParameters
+
+from paddle_billing.Entities.Reports import ReportStatus
+
+from paddle_billing.Exceptions.SdkExceptions.InvalidArgumentException import InvalidArgumentException
+
+from paddle_billing.Resources.Shared.Operations import Pager
+
+
+
+class ListReports(HasParameters):
+    def __init__(
+        self,
+        pager:    Pager | None       = None,
+        statuses: list[ReportStatus] = None,
+    ):
+        self.pager    = pager
+        self.statuses = statuses if statuses is not None else []
+
+        # Validation
+        for field_name, field_value, field_type in [('statuses', self.statuses, ReportStatus)]:
+            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.statuses:
+            parameters['status'] = ','.join(map(enum_stringify, self.statuses))
+
+        return parameters

paddle_billing/Resources/Reports/Operations/__init__.py

@@ -0,0 +1,2 @@
+from paddle_billing.Resources.Reports.Operations.CreateReport import CreateReport
+from paddle_billing.Resources.Reports.Operations.ListReports  import ListReports

paddle_billing/Resources/Reports/ReportsClient.py

@@ -0,0 +1,51 @@
+from paddle_billing.ResponseParser import ResponseParser
+
+from paddle_billing.Entities.Report      import Report
+from paddle_billing.Entities.ReportCSV   import ReportCSV
+from paddle_billing.Entities.Collections import Paginator, ReportCollection
+
+from paddle_billing.Resources.Reports.Operations import CreateReport, ListReports
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from paddle_billing.Client import Client
+
+
+class ReportsClient:
+    def __init__(self, client: 'Client'):
+        self.client   = client
+        self.response = None
+
+
+    def list(self, operation: ListReports = None) -> ReportCollection:
+        if operation is None:
+            operation = ListReports()
+
+        self.response = self.client.get_raw('/reports', operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return ReportCollection.from_list(
+            parser.get_data(),
+            Paginator(self.client, parser.get_pagination(), ReportCollection)
+        )
+
+
+    def get(self, report_id: str) -> Report:
+        self.response   = self.client.get_raw(f"/reports/{report_id}")
+        parser          = ResponseParser(self.response)
+
+        return Report.from_dict(parser.get_data())
+
+
+    def get_report_csv(self, report_id: str) -> ReportCSV:
+        self.response = self.client.get_raw(f"/reports/{report_id}/download-url")
+        parser        = ResponseParser(self.response)
+
+        return ReportCSV.from_dict(parser.get_data())
+
+
+    def create(self, operation: CreateReport) -> Report:
+        self.response = self.client.post_raw('/reports', operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return Report.from_dict(parser.get_data())

paddle_billing/Resources/Shared/Operations/List/Comparator.py

@@ -0,0 +1,8 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class Comparator(PaddleStrEnum):
+    LT  = 'LT'
+    LTE = 'LTE'
+    GT  = 'GT'
+    GTE = 'GTE'

paddle_billing/Resources/Shared/Operations/List/DateComparison.py

@@ -0,0 +1,31 @@
+from datetime import datetime
+
+from paddle_billing.Entities.DateTime import DateTime
+
+from paddle_billing.Resources.Shared.Operations.List.Comparator import Comparator
+
+
+class DateComparison:
+    def __init__(
+        self,
+        date:       datetime,
+        comparator: Comparator | None = None,
+    ):
+        self.date       = date
+        self._comparator = comparator
+
+
+    @property
+    def comparator(self) -> str:
+        return f"[{self._comparator.value}]" if self._comparator else ''
+
+
+    def formatted(self) -> str:
+        if isinstance(self.date, datetime):
+            date_obj = DateTime.from_datetime(self.date)
+        elif isinstance(self.date, DateTime):
+            date_obj = self.date
+        else:
+            raise TypeError(f"Invalid '{type(self.date)}' type for date")
+
+        return date_obj.format() if date_obj else ''

paddle_billing/Resources/Shared/Operations/List/OrderBy.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+
+class OrderBy:
+    def __init__(self, field: str, direction: str):
+        self.field     = field
+        self.direction = direction
+
+
+    @classmethod
+    def id_ascending(cls) -> OrderBy:
+        return OrderBy('id', 'asc')
+
+
+    @classmethod
+    def id_descending(cls) -> OrderBy:
+        return OrderBy('id', 'desc')
+
+
+    def __str__(self):
+        return f"{self.field}[{self.direction}]"

paddle_billing/Resources/Shared/Operations/List/Pager.py

@@ -0,0 +1,24 @@
+from paddle_billing.FiltersNone   import FiltersNone
+from paddle_billing.HasParameters import HasParameters
+
+from paddle_billing.Resources.Shared.Operations.List.OrderBy import OrderBy
+
+
+class Pager(HasParameters):
+    def __init__(
+        self,
+        after:       str     | None = None,
+        order_by:    OrderBy | None = None,
+        per_page:    int            = 50,
+    ):
+        self.after    = after
+        self.order_by = order_by if order_by is not None else OrderBy.id_ascending()
+        self.per_page = per_page
+
+
+    def get_parameters(self) -> dict:
+        return FiltersNone.filter_none_values({
+            'after':    self.after,
+            'order_by': str(self.order_by),
+            'per_page': self.per_page
+        })

paddle_billing/Resources/Shared/Operations/__init__.py

@@ -0,0 +1,4 @@
+from paddle_billing.Resources.Shared.Operations.List.Comparator     import Comparator
+from paddle_billing.Resources.Shared.Operations.List.DateComparison import DateComparison
+from paddle_billing.Resources.Shared.Operations.List.OrderBy        import OrderBy
+from paddle_billing.Resources.Shared.Operations.List.Pager          import Pager

paddle_billing/Resources/Subscriptions/Operations/CancelSubscription.py

@@ -0,0 +1,12 @@
+from dataclasses import asdict, dataclass
+
+from paddle_billing.Entities.Subscriptions import SubscriptionEffectiveFrom
+
+
+@dataclass
+class CancelSubscription:
+    effective_from: SubscriptionEffectiveFrom = None
+
+
+    def get_parameters(self) -> dict:
+        return asdict(self)

paddle_billing/Resources/Subscriptions/Operations/CreateOneTimeCharge.py

@@ -0,0 +1,22 @@
+from dataclasses import asdict, dataclass
+
+from paddle_billing.Undefined import Undefined
+
+from paddle_billing.Entities.Subscriptions import (
+    SubscriptionEffectiveFrom,
+    SubscriptionItems,
+    SubscriptionItemsWithPrice,
+    SubscriptionOnPaymentFailure,
+)
+
+
+@dataclass
+class CreateOneTimeCharge:
+    effective_from:     SubscriptionEffectiveFrom
+    items:              list[SubscriptionItems | SubscriptionItemsWithPrice]
+    on_payment_failure: SubscriptionOnPaymentFailure | Undefined = Undefined()
+    receipt_data:       str                          | Undefined = Undefined()
+
+
+    def get_parameters(self) -> dict:
+        return asdict(self)

paddle_billing/Resources/Subscriptions/Operations/Get/Includes.py

@@ -0,0 +1,6 @@
+from paddle_billing.PaddleStrEnum import PaddleStrEnum
+
+
+class Includes(PaddleStrEnum):
+    NextTransaction             = 'next_transaction'
+    RecurringTransactionDetails = 'recurring_transaction_details'

paddle_billing/Resources/Subscriptions/Operations/ListSubscriptions.py

@@ -0,0 +1,59 @@
+from paddle_billing.EnumStringify import enum_stringify
+from paddle_billing.HasParameters import HasParameters
+
+from paddle_billing.Entities.Shared        import CollectionMode
+from paddle_billing.Entities.Subscriptions import SubscriptionStatus, SubscriptionScheduledChangeAction
+
+from paddle_billing.Exceptions.SdkExceptions.InvalidArgumentException import InvalidArgumentException
+
+from paddle_billing.Resources.Shared.Operations import Pager
+
+
+class ListSubscriptions(HasParameters):
+    def __init__(
+        self,
+        pager:                    Pager | None                            = None,
+        address_ids:              list[str]                               = None,
+        collection_mode:          CollectionMode | None                   = None,
+        customer_ids:             list[str]                               = None,
+        ids:                      list[str]                               = None,
+        price_ids:                list[str]                               = None,
+        scheduled_change_actions: list[SubscriptionScheduledChangeAction] = None,
+        statuses:                 list[SubscriptionStatus]                = None,
+    ):
+        self.pager                    = pager
+        self.collection_mode          = collection_mode
+        self.address_ids              = address_ids              if address_ids              is not None else []
+        self.customer_ids             = customer_ids             if customer_ids             is not None else []
+        self.ids                      = ids                      if ids                      is not None else []
+        self.price_ids                = price_ids                if price_ids                is not None else []
+        self.scheduled_change_actions = scheduled_change_actions if scheduled_change_actions is not None else []
+        self.statuses                 = statuses                 if statuses                 is not None else []
+
+        # Validation
+        for field_name, field_value, field_type in [
+            ('address_ids',              self.address_ids,              str),
+            ('customer_ids',             self.customer_ids,             str),
+            ('ids',                      self.ids,                      str),
+            ('price_ids',                self.price_ids,                str),
+            ('scheduled_change_actions', self.scheduled_change_actions, SubscriptionScheduledChangeAction),
+            ('statuses',                 self.statuses,                 SubscriptionStatus),
+        ]:
+            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 = self.pager.get_parameters() if self.pager else {}
+        parameters.update({
+            'address_id':              ','.join(self.address_ids),
+            'collection_mode':         self.collection_mode.value if self.collection_mode else None,
+            'customer_id':             ','.join(self.customer_ids),
+            'id':                      ','.join(self.ids),
+            'price_id':                ','.join(self.price_ids),
+            'scheduled_change_action': ','.join(map(enum_stringify, self.scheduled_change_actions)),
+            'status':                  ','.join(map(enum_stringify, self.statuses)),
+        })
+
+        return {key: value for key, value in parameters.items() if value}

paddle_billing/Resources/Subscriptions/Operations/PauseSubscription.py

@@ -0,0 +1,19 @@
+from dataclasses import asdict, dataclass
+
+from paddle_billing.Entities.DateTime      import DateTime
+from paddle_billing.Entities.Subscriptions import SubscriptionEffectiveFrom
+
+
+@dataclass
+class PauseSubscription:
+    effective_from: SubscriptionEffectiveFrom | None = None
+    resume_at:      DateTime                  | None = None
+
+
+    def get_parameters(self) -> dict:
+        parameters = asdict(self)
+        parameters['resume_at'] = self.resume_at.format() \
+            if isinstance(self.resume_at, DateTime) \
+            else self.resume_at
+
+        return parameters

paddle_billing/Resources/Subscriptions/Operations/PreviewOneTimeCharge.py

@@ -0,0 +1,22 @@
+from dataclasses import asdict, dataclass
+
+from paddle_billing.Undefined import Undefined
+
+from paddle_billing.Entities.Subscriptions import (
+    SubscriptionEffectiveFrom,
+    SubscriptionItems,
+    SubscriptionItemsWithPrice,
+    SubscriptionOnPaymentFailure,
+)
+
+
+@dataclass
+class PreviewOneTimeCharge:
+    effective_from:     SubscriptionEffectiveFrom
+    items:              list[SubscriptionItems | SubscriptionItemsWithPrice]
+    on_payment_failure: SubscriptionOnPaymentFailure | Undefined = Undefined()
+    receipt_data:       str                          | Undefined = Undefined()
+
+
+    def get_parameters(self) -> dict:
+        return asdict(self)

paddle_billing/Resources/Subscriptions/Operations/PreviewUpdateSubscription.py

@@ -0,0 +1,37 @@
+from dataclasses import asdict, dataclass
+
+from paddle_billing.Undefined import Undefined
+
+from paddle_billing.Entities.DateTime      import DateTime
+from paddle_billing.Entities.Shared        import BillingDetails, CollectionMode, CurrencyCode, CustomData
+from paddle_billing.Entities.Subscriptions import SubscriptionItems, SubscriptionOnPaymentFailure, SubscriptionProrationBillingMode
+
+from paddle_billing.Resources.Subscriptions.Operations.Update.SubscriptionDiscount import SubscriptionDiscount
+
+
+@dataclass
+class PreviewUpdateSubscription:
+    customer_id:            str                                      | Undefined = Undefined()
+    address_id:             str                                      | Undefined = Undefined()
+    business_id:            str                               | None | Undefined = Undefined()
+    currency_code:          CurrencyCode                             | Undefined = Undefined()
+    next_billed_at:         DateTime                                 | Undefined = Undefined()
+    discount:               SubscriptionDiscount              | None | Undefined = Undefined()
+    collection_mode:        CollectionMode                           | Undefined = Undefined()
+    billing_details:        BillingDetails                    | None | Undefined = Undefined()
+    scheduled_change:                                           None | Undefined = Undefined()
+    items:                  list[SubscriptionItems]                  | Undefined = Undefined()
+    custom_data:            CustomData                        | None | Undefined = Undefined()
+    proration_billing_mode: SubscriptionProrationBillingMode         | Undefined = Undefined()
+    on_payment_failure:     SubscriptionOnPaymentFailure             | Undefined = Undefined()
+
+
+    def get_parameters(self) -> dict:
+        parameters = asdict(self)
+
+        if isinstance(self.next_billed_at, DateTime):
+            parameters['next_billed_at'] = self.next_billed_at.format()
+        if not isinstance(self.items, Undefined):
+            parameters['items'] = [item.get_parameters() for item in self.items]
+
+        return parameters

paddle_billing/Resources/Subscriptions/Operations/ResumeSubscription.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass
+
+from paddle_billing.Entities.DateTime      import DateTime
+from paddle_billing.Entities.Subscriptions import SubscriptionResumeEffectiveFrom
+
+
+@dataclass
+class ResumeSubscription:
+    effective_from: SubscriptionResumeEffectiveFrom | DateTime | None = None
+
+
+    def get_parameters(self) -> dict:
+        effective_from = self.effective_from.format() \
+            if isinstance(self.effective_from, DateTime) \
+            else self.effective_from
+
+        return {'effective_from': effective_from}

paddle_billing/Resources/Subscriptions/Operations/Update/SubscriptionDiscount.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Subscriptions.SubscriptionEffectiveFrom import SubscriptionEffectiveFrom
+
+
+@dataclass
+class SubscriptionDiscount:
+    id:             str
+    effective_from: SubscriptionEffectiveFrom

paddle_billing/Resources/Subscriptions/Operations/UpdateSubscription.py

@@ -0,0 +1,37 @@
+from dataclasses import asdict, dataclass
+
+from paddle_billing.Undefined import Undefined
+
+from paddle_billing.Entities.DateTime      import DateTime
+from paddle_billing.Entities.Shared        import BillingDetails, CollectionMode, CurrencyCode, CustomData
+from paddle_billing.Entities.Subscriptions import SubscriptionItems, SubscriptionOnPaymentFailure, SubscriptionProrationBillingMode
+
+from paddle_billing.Resources.Subscriptions.Operations.Update.SubscriptionDiscount import SubscriptionDiscount
+
+
+@dataclass
+class UpdateSubscription:
+    customer_id:            str                                      | Undefined = Undefined()
+    address_id:             str                                      | Undefined = Undefined()
+    business_id:            str                               | None | Undefined = Undefined()
+    currency_code:          CurrencyCode                             | Undefined = Undefined()
+    next_billed_at:         DateTime                                 | Undefined = Undefined()
+    discount:               SubscriptionDiscount              | None | Undefined = Undefined()
+    collection_mode:        CollectionMode                           | Undefined = Undefined()
+    billing_details:        BillingDetails                    | None | Undefined = Undefined()
+    scheduled_change:                                           None | Undefined = Undefined()
+    items:                  list[SubscriptionItems]                  | Undefined = Undefined()
+    custom_data:            CustomData                        | None | Undefined = Undefined()
+    proration_billing_mode: SubscriptionProrationBillingMode         | Undefined = Undefined()
+    on_payment_failure:     SubscriptionOnPaymentFailure             | Undefined = Undefined()
+
+
+    def get_parameters(self) -> dict:
+        parameters = asdict(self)
+
+        if isinstance(self.next_billed_at, DateTime):
+            parameters['next_billed_at'] = self.next_billed_at.format()
+        if not isinstance(self.items, Undefined):
+            parameters['items'] = [item.get_parameters() for item in self.items]
+
+        return parameters

paddle_billing/Resources/Subscriptions/Operations/__init__.py

@@ -0,0 +1,10 @@
+from paddle_billing.Resources.Subscriptions.Operations.CancelSubscription          import CancelSubscription
+from paddle_billing.Resources.Subscriptions.Operations.CreateOneTimeCharge         import CreateOneTimeCharge
+from paddle_billing.Resources.Subscriptions.Operations.Get.Includes                import Includes as SubscriptionIncludes
+from paddle_billing.Resources.Subscriptions.Operations.ListSubscriptions           import ListSubscriptions
+from paddle_billing.Resources.Subscriptions.Operations.PauseSubscription           import PauseSubscription
+from paddle_billing.Resources.Subscriptions.Operations.PreviewOneTimeCharge        import PreviewOneTimeCharge
+from paddle_billing.Resources.Subscriptions.Operations.PreviewUpdateSubscription   import PreviewUpdateSubscription
+from paddle_billing.Resources.Subscriptions.Operations.ResumeSubscription          import ResumeSubscription
+from paddle_billing.Resources.Subscriptions.Operations.UpdateSubscription          import UpdateSubscription
+from paddle_billing.Resources.Subscriptions.Operations.Update.SubscriptionDiscount import SubscriptionDiscount