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

paddle_billing/Resources/Adjustments/AdjustmentsClient.py

@@ -0,0 +1,36 @@
+from paddle_billing.ResponseParser import ResponseParser
+
+from paddle_billing.Entities.Adjustment  import Adjustment
+from paddle_billing.Entities.Collections import Paginator, AdjustmentCollection
+
+from paddle_billing.Resources.Adjustments.Operations import CreateAdjustment, ListAdjustments
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from paddle_billing.Client import Client
+
+
+class AdjustmentsClient:
+    def __init__(self, client: 'Client'):
+        self.client   = client
+        self.response = None
+
+
+    def list(self, operation: ListAdjustments = None) -> AdjustmentCollection:
+        if operation is None:
+            operation = ListAdjustments()
+
+        self.response = self.client.get_raw('/adjustments', operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return AdjustmentCollection.from_list(
+            parser.get_data(),
+            Paginator(self.client, parser.get_pagination(), AdjustmentCollection)
+        )
+
+
+    def create(self, operation: CreateAdjustment) -> Adjustment:
+        self.response = self.client.post_raw('/adjustments', operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return Adjustment.from_dict(parser.get_data())

paddle_billing/Resources/Adjustments/Operations/Create/AdjustmentItem.py

@@ -0,0 +1,11 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared import AdjustmentType
+
+
+@dataclass
+class AdjustmentItem:
+    item_id:   str
+    type:      AdjustmentType
+    amount:    str | None

paddle_billing/Resources/Adjustments/Operations/CreateAdjustment.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass
+
+from paddle_billing.Entities.Shared import Action
+
+from paddle_billing.Resources.Adjustments.Operations import CreateAdjustmentItem
+
+
+@dataclass
+class CreateAdjustment:
+    action:         Action
+    items:          list[CreateAdjustmentItem]
+    reason:         str
+    transaction_id: str
+
+
+    def get_parameters(self) -> dict:
+        items = [{
+            'item_id':  item.item_id,
+            'type':     item.type,
+            'amount':   item.amount,
+        } for item in self.items]
+
+        return {
+            'action':         self.action.value,
+            'items':          items,
+            'reason':         self.reason,
+            'transaction_id': self.transaction_id,
+        }

paddle_billing/Resources/Adjustments/Operations/ListAdjustments.py

@@ -0,0 +1,60 @@
+from paddle_billing.EnumStringify import enum_stringify
+from paddle_billing.HasParameters import HasParameters
+
+from paddle_billing.Entities.Shared import Action, AdjustmentStatus
+
+from paddle_billing.Exceptions.SdkExceptions.InvalidArgumentException import InvalidArgumentException
+
+from paddle_billing.Resources.Shared.Operations import Pager
+
+
+class ListAdjustments(HasParameters):
+    def __init__(
+        self,
+        pager:            Pager | None           = None,
+        ids:              list[str]              = None,
+        statuses:         list[AdjustmentStatus] = None,
+        customer_ids:     list[str]              = None,
+        transaction_ids:  list[str]              = None,
+        subscription_ids: list[str]              = None,
+        action:           Action | None          = None,
+    ):
+        self.pager            = pager
+        self.action           = action
+        self.ids              = ids              if ids              is not None else []
+        self.statuses         = statuses         if statuses         is not None else []
+        self.customer_ids     = customer_ids     if customer_ids     is not None else []
+        self.transaction_ids  = transaction_ids  if transaction_ids  is not None else []
+        self.subscription_ids = subscription_ids if subscription_ids is not None else []
+
+        # Validation
+        for field_name, field_value, field_type in [
+            ('ids',              self.ids,              str),
+            ('customer_ids',     self.customer_ids,     str),
+            ('statuses',         self.statuses,         AdjustmentStatus),
+            ('subscription_ids', self.subscription_ids, str),
+            ('transaction_ids',  self.transaction_ids,  str),
+        ]:
+            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.statuses:
+            parameters['status'] = ','.join(map(enum_stringify, self.statuses))
+        if self.customer_ids:
+            parameters['customer_id'] = ','.join(self.customer_ids)
+        if self.transaction_ids:
+            parameters['transaction_id'] = ','.join(self.transaction_ids)
+        if self.subscription_ids:
+            parameters['subscription_id'] = ','.join(self.subscription_ids)
+        if self.action:
+            parameters['action'] = self.action.value
+
+        return parameters

paddle_billing/Resources/Adjustments/Operations/__init__.py

@@ -0,0 +1,3 @@
+from paddle_billing.Resources.Adjustments.Operations.Create.AdjustmentItem import AdjustmentItem as CreateAdjustmentItem
+from paddle_billing.Resources.Adjustments.Operations.CreateAdjustment      import CreateAdjustment
+from paddle_billing.Resources.Adjustments.Operations.ListAdjustments       import ListAdjustments

paddle_billing/Resources/Businesses/BusinessesClient.py

@@ -0,0 +1,58 @@
+from paddle_billing.ResponseParser import ResponseParser
+
+from paddle_billing.Entities.Business    import Business
+from paddle_billing.Entities.Collections import Paginator,  BusinessCollection
+from paddle_billing.Entities.Shared      import Status
+
+from paddle_billing.Resources.Businesses.Operations import CreateBusiness, ListBusinesses, UpdateBusiness
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from paddle_billing.Client import Client
+
+
+class BusinessesClient:
+    def __init__(self, client: 'Client'):
+        self.client   = client
+        self.response = None
+
+
+    def list(self, customer_id: str, operation: ListBusinesses = None) -> BusinessCollection:
+        if operation is None:
+            operation = ListBusinesses()
+
+        self.response = self.client.get_raw(f"/customers/{customer_id}/businesses", operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return BusinessCollection.from_list(
+            parser.get_data(),
+            Paginator(self.client, parser.get_pagination(), BusinessCollection)
+        )
+
+
+    def get(self, customer_id: str, business_id: str) -> Business:
+        self.response = self.client.get_raw(f"/customers/{customer_id}/businesses/{business_id}")
+        parser        = ResponseParser(self.response)
+
+        return Business.from_dict(parser.get_data())
+
+
+    def create(self, customer_id: str, operation: CreateBusiness) -> Business:
+        self.response = self.client.post_raw(f"/customers/{customer_id}/businesses", operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return Business.from_dict(parser.get_data())
+
+
+    def update(self, customer_id: str, business_id: str, operation: UpdateBusiness) -> Business:
+        self.response = self.client.patch_raw(
+            f"/customers/{customer_id}/businesses/{business_id}",
+            operation.get_parameters()
+        )
+        parser = ResponseParser(self.response)
+
+        return Business.from_dict(parser.get_data())
+
+
+    def archive(self, customer_id: str, business_id: str) -> Business:
+        return self.update(customer_id, business_id, UpdateBusiness(status=Status.Archived))

paddle_billing/Resources/Businesses/Operations/CreateBusiness.py

@@ -0,0 +1,17 @@
+from dataclasses import asdict, dataclass
+
+from paddle_billing.Undefined       import Undefined
+from paddle_billing.Entities.Shared import Contacts, CustomData
+
+
+@dataclass
+class CreateBusiness:
+    name:           str
+    company_number: str            | None | Undefined = Undefined()
+    tax_identifier: str            | None | Undefined = Undefined()
+    contacts:       list[Contacts]        | Undefined = Undefined()
+    custom_data:    CustomData     | None | Undefined = Undefined()
+
+
+    def get_parameters(self) -> dict:
+        return asdict(self)

paddle_billing/Resources/Businesses/Operations/ListBusinesses.py

@@ -0,0 +1,45 @@
+from paddle_billing.EnumStringify import enum_stringify
+from paddle_billing.HasParameters import HasParameters
+
+from paddle_billing.Entities.Shared import Status
+
+from paddle_billing.Exceptions.SdkExceptions.InvalidArgumentException import InvalidArgumentException
+
+from paddle_billing.Resources.Shared.Operations import Pager
+
+
+class ListBusinesses(HasParameters):
+    def __init__(
+        self,
+        pager:    Pager | None = None,
+        ids:      list[str]    = None,
+        statuses: list[Status] = None,
+        search:   str | None   = None,
+    ):
+        self.pager    = pager
+        self.search   = search
+        self.ids      = ids      if 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),
+            ('statuses', self.statuses, Status),
+        ]:
+            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.statuses:
+            parameters['status'] = ','.join(map(enum_stringify, self.statuses))
+        if self.search:
+            parameters['search'] = self.search
+
+        return parameters

paddle_billing/Resources/Businesses/Operations/UpdateBusiness.py

@@ -0,0 +1,18 @@
+from dataclasses import asdict, dataclass
+
+from paddle_billing.Undefined       import Undefined
+from paddle_billing.Entities.Shared import Contacts, CustomData, Status
+
+
+@dataclass
+class UpdateBusiness:
+    name:           str                   | Undefined = Undefined
+    company_number: str            | None | Undefined = Undefined()
+    tax_identifier: str            | None | Undefined = Undefined()
+    contacts:       list[Contacts]        | Undefined = Undefined()
+    custom_data:    CustomData     | None | Undefined = Undefined()
+    status:         Status                | Undefined = Undefined()
+
+
+    def get_parameters(self) -> dict:
+        return asdict(self)

paddle_billing/Resources/Businesses/Operations/__init__.py

@@ -0,0 +1,3 @@
+from paddle_billing.Resources.Businesses.Operations.CreateBusiness import CreateBusiness
+from paddle_billing.Resources.Businesses.Operations.ListBusinesses import ListBusinesses
+from paddle_billing.Resources.Businesses.Operations.UpdateBusiness import UpdateBusiness

paddle_billing/Resources/Customers/CustomersClient.py

@@ -0,0 +1,65 @@
+from paddle_billing.ResponseParser import ResponseParser
+
+from paddle_billing.Entities.Collections import Paginator, CreditBalanceCollection, CustomerCollection
+from paddle_billing.Entities.Customer    import Customer
+from paddle_billing.Entities.Shared      import Status
+
+from paddle_billing.Resources.Customers.Operations import CreateCustomer, ListCreditBalances, ListCustomers, UpdateCustomer
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from paddle_billing.Client import Client
+
+
+class CustomersClient:
+    def __init__(self, client: 'Client'):
+        self.client   = client
+        self.response = None
+
+
+    def list(self, operation: ListCustomers = None) -> CustomerCollection:
+        if operation is None:
+            operation = ListCustomers()
+
+        self.response = self.client.get_raw('/customers', operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return CustomerCollection.from_list(
+            parser.get_data(),
+            Paginator(self.client, parser.get_pagination(), CustomerCollection)
+        )
+
+
+    def get(self, customer_id: str) -> Customer:
+        self.response = self.client.get_raw(f"/customers/{customer_id}")
+        parser        = ResponseParser(self.response)
+
+        return Customer.from_dict(parser.get_data())
+
+
+    def create(self, operation: CreateCustomer) -> Customer:
+        self.response = self.client.post_raw('/customers', operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return Customer.from_dict(parser.get_data())
+
+
+    def update(self, customer_id: str, operation: UpdateCustomer) -> Customer:
+        self.response = self.client.patch_raw(f"/customers/{customer_id}", operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return Customer.from_dict(parser.get_data())
+
+
+    def archive(self, customer_id: str) -> Customer:
+        return self.update(customer_id, UpdateCustomer(status=Status.Archived))
+
+
+    def credit_balances(self, customer_id: str, operation: ListCreditBalances = None) -> CreditBalanceCollection:
+        if operation is None:
+            operation = ListCreditBalances()
+
+        self.response = self.client.get_raw(f"/customers/{customer_id}/credit-balances")
+        parser        = ResponseParser(self.response)
+
+        return CreditBalanceCollection.from_list(parser.get_data())

paddle_billing/Resources/Customers/Operations/CreateCustomer.py

@@ -0,0 +1,16 @@
+from dataclasses import asdict, dataclass
+
+from paddle_billing.Undefined       import Undefined
+from paddle_billing.Entities.Shared import CustomData
+
+
+@dataclass
+class CreateCustomer:
+    email:       str
+    name:        str        | None | Undefined = Undefined()
+    custom_data: CustomData | None | Undefined = Undefined()
+    locale:      str               | Undefined = Undefined()
+
+
+    def get_parameters(self) -> dict:
+        return asdict(self)

paddle_billing/Resources/Customers/Operations/ListCreditBalances.py

@@ -0,0 +1,28 @@
+from paddle_billing.EnumStringify import enum_stringify
+from paddle_billing.HasParameters import HasParameters
+
+from paddle_billing.Entities.Shared import CurrencyCode
+
+from paddle_billing.Exceptions.SdkExceptions.InvalidArgumentException import InvalidArgumentException
+
+
+class ListCreditBalances(HasParameters):
+    def __init__(
+        self,
+        currency_code: list[CurrencyCode] = None,
+    ):
+        self.currency_code = currency_code if currency_code is not None else []
+
+        # Validation
+        for field_name, field_value, field_type in [('currency_code', self.currency_code, CurrencyCode)]:
+            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.currency_code:
+            parameters['currency_code'] = ','.join(map(enum_stringify, self.currency_code))
+
+        return parameters

paddle_billing/Resources/Customers/Operations/ListCustomers.py

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

paddle_billing/Resources/Customers/Operations/UpdateCustomer.py

@@ -0,0 +1,17 @@
+from dataclasses import asdict, dataclass
+
+from paddle_billing.Undefined       import Undefined
+from paddle_billing.Entities.Shared import CustomData, Status
+
+
+@dataclass
+class UpdateCustomer:
+    email:       str               | Undefined = Undefined()
+    name:        str        | None | Undefined = Undefined()
+    custom_data: CustomData | None | Undefined = Undefined()
+    locale:      str               | Undefined = Undefined()
+    status:      Status            | Undefined = Undefined()
+
+
+    def get_parameters(self) -> dict:
+        return asdict(self)

paddle_billing/Resources/Customers/Operations/__init__.py

@@ -0,0 +1,4 @@
+from paddle_billing.Resources.Customers.Operations.CreateCustomer     import CreateCustomer
+from paddle_billing.Resources.Customers.Operations.ListCreditBalances import ListCreditBalances
+from paddle_billing.Resources.Customers.Operations.ListCustomers      import ListCustomers
+from paddle_billing.Resources.Customers.Operations.UpdateCustomer     import UpdateCustomer

paddle_billing/Resources/Discounts/DiscountsClient.py

@@ -0,0 +1,55 @@
+from paddle_billing.ResponseParser import ResponseParser
+
+from paddle_billing.Entities.Collections import Paginator, DiscountCollection
+from paddle_billing.Entities.Discount    import Discount
+from paddle_billing.Entities.Discounts   import DiscountStatus
+
+from paddle_billing.Resources.Discounts.Operations   import CreateDiscount, ListDiscounts, UpdateDiscount
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from paddle_billing.Client import Client
+
+
+class DiscountsClient:
+    def __init__(self, client: 'Client'):
+        self.client   = client
+        self.response = None
+
+
+    def list(self, operation: ListDiscounts = None) -> DiscountCollection:
+        if operation is None:
+            operation = ListDiscounts()
+
+        self.response = self.client.get_raw('/discounts', operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return DiscountCollection.from_list(
+            parser.get_data(),
+            Paginator(self.client, parser.get_pagination(), DiscountCollection)
+        )
+
+
+    def get(self, discount_id: str) -> Discount:
+        self.response = self.client.get_raw(f"/discounts/{discount_id}")
+        parser        = ResponseParser(self.response)
+
+        return Discount.from_dict(parser.get_data())
+
+
+    def create(self, operation: CreateDiscount) -> Discount:
+        self.response = self.client.post_raw('/discounts', operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return Discount.from_dict(parser.get_data())
+
+
+    def update(self, discount_id: str, operation: UpdateDiscount) -> Discount:
+        self.response = self.client.patch_raw(f"/discounts/{discount_id}", operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return Discount.from_dict(parser.get_data())
+
+
+    def archive(self, discount_id: str) -> Discount:
+        return self.update(discount_id, UpdateDiscount(status=DiscountStatus.Archived))

paddle_billing/Resources/Discounts/Operations/CreateDiscount.py

@@ -0,0 +1,24 @@
+from dataclasses import asdict, dataclass
+
+from paddle_billing.Undefined          import Undefined
+from paddle_billing.Entities.Discounts import DiscountType
+from paddle_billing.Entities.Shared    import CurrencyCode
+
+
+@dataclass
+class CreateDiscount:
+    amount:                      str
+    description:                 str
+    type:                        DiscountType
+    enabled_for_checkout:        bool
+    recur:                       bool
+    currency_code:               CurrencyCode
+    code:                        str       | None | Undefined = Undefined()
+    maximum_recurring_intervals: int       | None | Undefined = Undefined()
+    usage_limit:                 int       | None | Undefined = Undefined()
+    restrict_to:                 list[str] | None | Undefined = Undefined()
+    expires_at:                  str       | None | Undefined = Undefined()
+
+
+    def get_parameters(self) -> dict:
+        return asdict(self)

paddle_billing/Resources/Discounts/Operations/ListDiscounts.py

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

paddle_billing/Resources/Discounts/Operations/UpdateDiscount.py

@@ -0,0 +1,25 @@
+from dataclasses import asdict, dataclass
+
+from paddle_billing.Undefined          import Undefined
+from paddle_billing.Entities.Discounts import DiscountStatus, DiscountType
+from paddle_billing.Entities.Shared    import CurrencyCode
+
+
+@dataclass
+class UpdateDiscount:
+    amount:                      str                   | Undefined = Undefined()
+    description:                 str                   | Undefined = Undefined()
+    type:                        DiscountType          | Undefined = Undefined()
+    enabled_for_checkout:        bool                  | Undefined = Undefined()
+    recur:                       bool                  | Undefined = Undefined()
+    currency_code:               CurrencyCode          | Undefined = Undefined()
+    code:                        str            | None | Undefined = Undefined()
+    maximum_recurring_intervals: int            | None | Undefined = Undefined()
+    usage_limit:                 int            | None | Undefined = Undefined()
+    restrict_to:                 list[str]      | None | Undefined = Undefined()
+    expires_at:                  str            | None | Undefined = Undefined()
+    status:                      DiscountStatus        | Undefined = Undefined()
+
+
+    def get_parameters(self) -> dict:
+        return asdict(self)

paddle_billing/Resources/Discounts/Operations/__init__.py

@@ -0,0 +1,3 @@
+from paddle_billing.Resources.Discounts.Operations.CreateDiscount import CreateDiscount
+from paddle_billing.Resources.Discounts.Operations.ListDiscounts  import ListDiscounts
+from paddle_billing.Resources.Discounts.Operations.UpdateDiscount import UpdateDiscount