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

paddle_billing/Notifications/Events/SubscriptionPaused.py

@@ -0,0 +1,17 @@
+from datetime import datetime
+
+from paddle_billing.Entities.Event  import Event
+from paddle_billing.Entities.Events import EventTypeName
+
+from paddle_billing.Notifications.Entities.Subscription import Subscription
+
+
+class SubscriptionPaused(Event):
+    def __init__(
+        self,
+        event_id:    str,
+        event_type:  EventTypeName,
+        occurred_at: datetime,
+        data:        Subscription,
+    ):
+        super().__init__(event_id, event_type, occurred_at, data)

paddle_billing/Notifications/Events/SubscriptionResumed.py

@@ -0,0 +1,17 @@
+from datetime import datetime
+
+from paddle_billing.Entities.Event  import Event
+from paddle_billing.Entities.Events import EventTypeName
+
+from paddle_billing.Notifications.Entities.Subscription import Subscription
+
+
+class SubscriptionResumed(Event):
+    def __init__(
+        self,
+        event_id:    str,
+        event_type:  EventTypeName,
+        occurred_at: datetime,
+        data:        Subscription,
+    ):
+        super().__init__(event_id, event_type, occurred_at, data)

paddle_billing/Notifications/Events/SubscriptionTrialing.py

@@ -0,0 +1,17 @@
+from datetime import datetime
+
+from paddle_billing.Entities.Event  import Event
+from paddle_billing.Entities.Events import EventTypeName
+
+from paddle_billing.Notifications.Entities.Subscription import Subscription
+
+
+class SubscriptionTrialing(Event):
+    def __init__(
+        self,
+        event_id:    str,
+        event_type:  EventTypeName,
+        occurred_at: datetime,
+        data:        Subscription,
+    ):
+        super().__init__(event_id, event_type, occurred_at, data)

paddle_billing/Notifications/Events/SubscriptionUpdated.py

@@ -0,0 +1,17 @@
+from datetime import datetime
+
+from paddle_billing.Entities.Event  import Event
+from paddle_billing.Entities.Events import EventTypeName
+
+from paddle_billing.Notifications.Entities.Subscription import Subscription
+
+
+class SubscriptionUpdated(Event):
+    def __init__(
+        self,
+        event_id:    str,
+        event_type:  EventTypeName,
+        occurred_at: datetime,
+        data:        Subscription,
+    ):
+        super().__init__(event_id, event_type, occurred_at, data)

paddle_billing/Notifications/Events/TransactionBilled.py

@@ -0,0 +1,17 @@
+from datetime import datetime
+
+from paddle_billing.Entities.Event  import Event
+from paddle_billing.Entities.Events import EventTypeName
+
+from paddle_billing.Notifications.Entities.Transaction import Transaction
+
+
+class TransactionBilled(Event):
+    def __init__(
+        self,
+        event_id:    str,
+        event_type:  EventTypeName,
+        occurred_at: datetime,
+        data:        Transaction,
+    ):
+        super().__init__(event_id, event_type, occurred_at, data)

paddle_billing/Notifications/Events/TransactionCanceled.py

@@ -0,0 +1,17 @@
+from datetime import datetime
+
+from paddle_billing.Entities.Event  import Event
+from paddle_billing.Entities.Events import EventTypeName
+
+from paddle_billing.Notifications.Entities.Transaction import Transaction
+
+
+class TransactionCanceled(Event):
+    def __init__(
+        self,
+        event_id:    str,
+        event_type:  EventTypeName,
+        occurred_at: datetime,
+        data:        Transaction,
+    ):
+        super().__init__(event_id, event_type, occurred_at, data)

paddle_billing/Notifications/Events/TransactionCompleted.py

@@ -0,0 +1,16 @@
+from datetime import datetime
+
+from paddle_billing.Entities.Event  import Event
+from paddle_billing.Entities.Events import EventTypeName
+
+from paddle_billing.Notifications.Entities.Transaction import Transaction
+
+class TransactionCompleted(Event):
+    def __init__(
+        self,
+        event_id:    str,
+        event_type:  EventTypeName,
+        occurred_at: datetime,
+        data:        Transaction,
+    ):
+        super().__init__(event_id, event_type, occurred_at, data)

paddle_billing/Notifications/Events/TransactionCreated.py

@@ -0,0 +1,17 @@
+from datetime import datetime
+
+from paddle_billing.Entities.Event  import Event
+from paddle_billing.Entities.Events import EventTypeName
+
+from paddle_billing.Notifications.Entities.Transaction import Transaction
+
+
+class TransactionCreated(Event):
+    def __init__(
+        self,
+        event_id:    str,
+        event_type:  EventTypeName,
+        occurred_at: datetime,
+        data:        Transaction,
+    ):
+        super().__init__(event_id, event_type, occurred_at, data)

paddle_billing/Notifications/Events/TransactionPaid.py

@@ -0,0 +1,17 @@
+from datetime import datetime
+
+from paddle_billing.Entities.Event  import Event
+from paddle_billing.Entities.Events import EventTypeName
+
+from paddle_billing.Notifications.Entities.Transaction import Transaction
+
+
+class TransactionPaid(Event):
+    def __init__(
+        self,
+        event_id:    str,
+        event_type:  EventTypeName,
+        occurred_at: datetime,
+        data:        Transaction,
+    ):
+        super().__init__(event_id, event_type, occurred_at, data)

paddle_billing/Notifications/Events/TransactionPastDue.py

@@ -0,0 +1,17 @@
+from datetime import datetime
+
+from paddle_billing.Entities.Event  import Event
+from paddle_billing.Entities.Events import EventTypeName
+
+from paddle_billing.Notifications.Entities.Transaction import Transaction
+
+
+class TransactionPastDue(Event):
+    def __init__(
+        self,
+        event_id:    str,
+        event_type:  EventTypeName,
+        occurred_at: datetime,
+        data:        Transaction,
+    ):
+        super().__init__(event_id, event_type, occurred_at, data)

paddle_billing/Notifications/Events/TransactionPaymentFailed.py

@@ -0,0 +1,17 @@
+from datetime import datetime
+
+from paddle_billing.Entities.Event  import Event
+from paddle_billing.Entities.Events import EventTypeName
+
+from paddle_billing.Notifications.Entities.Transaction import Transaction
+
+
+class TransactionPaymentFailed(Event):
+    def __init__(
+        self,
+        event_id:    str,
+        event_type:  EventTypeName,
+        occurred_at: datetime,
+        data:        Transaction,
+    ):
+        super().__init__(event_id, event_type, occurred_at, data)

paddle_billing/Notifications/Events/TransactionReady.py

@@ -0,0 +1,17 @@
+from datetime import datetime
+
+from paddle_billing.Entities.Event  import Event
+from paddle_billing.Entities.Events import EventTypeName
+
+from paddle_billing.Notifications.Entities.Transaction import Transaction
+
+
+class TransactionReady(Event):
+    def __init__(
+        self,
+        event_id:    str,
+        event_type:  EventTypeName,
+        occurred_at: datetime,
+        data:        Transaction,
+    ):
+        super().__init__(event_id, event_type, occurred_at, data)

paddle_billing/Notifications/Events/TransactionUpdated.py

@@ -0,0 +1,17 @@
+from datetime import datetime
+
+from paddle_billing.Entities.Event  import Event
+from paddle_billing.Entities.Events import EventTypeName
+
+from paddle_billing.Notifications.Entities.Transaction import Transaction
+
+
+class TransactionUpdated(Event):
+    def __init__(
+        self,
+        event_id:    str,
+        event_type:  EventTypeName,
+        occurred_at: datetime,
+        data:        Transaction,
+    ):
+        super().__init__(event_id, event_type, occurred_at, data)

paddle_billing/Notifications/PaddleSignature.py

@@ -0,0 +1,128 @@
+from hashlib import sha256
+from hmac    import HMAC, compare_digest, new as hmac_new
+
+from paddle_billing.Logger import get_logger
+
+from paddle_billing.Notifications.Secret import Secret
+
+
+class PaddleSignature:
+    def __init__(self):
+        """
+        Verifies the integrity of a Paddle signature
+        """
+        self.log = get_logger()
+
+
+    @property
+    def HASH_ALGORITHM_1(self):  # noqa N802
+        return 'h1'
+
+    @property
+    def HEADER(self):  # noqa N802
+        return 'Paddle-Signature'
+
+    @property
+    def TIMESTAMP(self):  # noqa N802
+        return 'ts'
+
+
+    @staticmethod
+    def parse(signature_header: str) -> tuple:
+        """
+        Parse the Paddle-Signature header to extract the timestamp and signature
+
+        :param   signature_header: The Paddle-Signature key=value from the webhook event's headers
+        :return:                   A tuple containing (timestamp, signature)
+        """
+        components = {
+            PaddleSignature().TIMESTAMP: 0,
+            'hashes':                    {PaddleSignature().HASH_ALGORITHM_1: []},
+        }
+
+        for key_value_pair in signature_header.split(";"):
+            if '=' in key_value_pair:
+                key, value = key_value_pair.split('=')
+
+                if key == PaddleSignature().TIMESTAMP:
+                    components[PaddleSignature().TIMESTAMP] = value
+                elif key == PaddleSignature().HASH_ALGORITHM_1:
+                    components['hashes'][PaddleSignature().HASH_ALGORITHM_1].append(value)
+                else:
+                    raise ValueError(f"Unrecognized Paddle-Signature key")
+
+        return int(components[PaddleSignature().TIMESTAMP]), components['hashes']
+
+
+    @staticmethod
+    def calculate_hmac(secret_key: str, data: bytes) -> HMAC:
+        return hmac_new(secret_key.encode('utf-8'), data, sha256)
+
+
+    def __do_comparison(self, generated_signature: str, signature: str) -> bool:
+        self.log.debug(f"Comparing received Paddle signature '{signature}' to our calculated signature: '{generated_signature}'")
+
+        return compare_digest(generated_signature, signature)
+
+
+    def __do_verify(self, timestamp: str, signatures: list[str], raw_body: str, secret_key: Secret) -> bool:
+        """
+        Verifies an individual secret key against a Paddle-Signature header.
+        Called by PaddleSignature.verify()
+
+        :param signatures: The Paddle-Signature header
+        :param raw_body:   Raw body of the webhook request
+        :param secret_key: A Paddle secret key: https://developer.paddle.com/webhooks/signature-verification#get-secret-key
+        :return:           True on verification success, False on verification failure
+        """
+        new_body_to_verify  = f"{timestamp}:{raw_body}".encode('utf-8')
+        generated_signature = PaddleSignature.calculate_hmac(secret_key.secret_key, new_body_to_verify).hexdigest()
+        integrity           = False
+
+        for signature in signatures:
+            integrity_result = self.__do_comparison(generated_signature, signature)
+            if integrity_result is True:
+                integrity = True
+                break
+
+        self.log.info(f"Paddle signature integrity {'passed' if integrity else 'failed'}")
+        return integrity
+
+
+    def verify(self, signature_header: str, raw_body: str, secrets: list[Secret] | Secret) -> bool:
+        """
+        https://developer.paddle.com/webhooks/signature-verification
+        Performs an integrity check on a Paddle webhook's signature against one or more Secrets
+        Handling multiple Secrets is needed because of key rotation situations
+
+        :param signature_header: The Paddle-Signature header
+        :param raw_body:         Raw body of the webhook request
+        :param secrets:          One or more Paddle secret key(s): https://developer.paddle.com/webhooks/signature-verification#get-secret-key
+        :return:                 True if any secret key passes verification success. Raises a ConnectionRefusedError if all secret keys fail verification
+        """
+        is_list   = type(secrets) is list
+        key_count = 'multiple secret keys' if is_list else 'one secret key'
+        self.log.info(f"Verifying Paddle signature integrity against {key_count}")
+
+        timestamp, signature = PaddleSignature.parse(signature_header)
+
+        if not is_list:
+            return self.__do_verify(
+                timestamp  = timestamp,
+                signatures = signature[PaddleSignature().HASH_ALGORITHM_1],
+                raw_body   = raw_body,
+                secret_key = secrets,
+            )
+
+        for secret in secrets:
+            verification_result = self.__do_verify(
+                timestamp  = timestamp,
+                signatures = signature[PaddleSignature().HASH_ALGORITHM_1],
+                raw_body   = raw_body,
+                secret_key = secret,
+            )
+            if verification_result is True:
+                return True
+
+        # If we got this far then none of the provided secrets passed verification
+        raise ConnectionRefusedError(f"Paddle signature failed integrity check")

paddle_billing/Notifications/Secret.py

@@ -0,0 +1,8 @@
+class Secret:
+    def __init__(self, secret_key: str):
+        self.__secret_key = secret_key
+
+
+    @property
+    def secret_key(self):
+        return self.__secret_key

paddle_billing/Notifications/Verifier.py

@@ -0,0 +1,55 @@
+import requests
+
+from os   import getenv
+from time import time
+
+from paddle_billing.Logger import get_logger
+
+from paddle_billing.Notifications.Secret          import Secret
+from paddle_billing.Notifications.PaddleSignature import PaddleSignature
+
+
+class Verifier:
+    def __init__(self, maximum_variance: int | None = 5):
+        """"""
+        self.__maximum_variance = maximum_variance
+        self.log                = get_logger()
+        self.paddle_signature   = PaddleSignature()
+
+
+    @property
+    def maximum_variance(self) -> int:
+        return self.__maximum_variance
+
+
+    def verify(self, request: requests, secrets: list[Secret] | Secret, verify_time_drift = True):
+        """
+        :param request:           The request object to verify
+        :param secrets:           One or more Secrets to use for verifying the request
+        :param verify_time_drift: Defaults to True. Set False to disable time drift verification (NOT RECOMMENDED, counters MITM attacks)
+        :return:                  True on verification success, False on verification failure
+        """
+        self.log.info(f"Attempting to verify the authenticity of a request")
+
+        if getenv('TEST_MODE') is not None:
+            verify_time_drift = not bool(int(getenv('TEST_MODE', '0')))  # Intentional bool(int())
+
+        signature_header = request.headers.get(PaddleSignature().HEADER, None)
+        if not signature_header:
+            self.log.critical(f"Unable to extract the '{PaddleSignature().HEADER}' header from the request")
+            return False
+
+        timestamp, signature = PaddleSignature.parse(signature_header)
+        if verify_time_drift and self.maximum_variance > 0 and time() > int(timestamp + self.maximum_variance):
+            self.log.critical(f"Too much time has elapsed between the request and this process")
+            return False
+
+        raw_body = None
+        if hasattr(request, 'body'):
+            raw_body = request.body.decode('utf-8')
+        elif hasattr(request, 'content'):
+            raw_body = request.content.decode('utf-8')
+        elif hasattr(request, 'data'):
+            raw_body = request.data.decode('utf-8')
+
+        return self.paddle_signature.verify(signature_header, raw_body, secrets)

paddle_billing/Notifications/__init__.py

@@ -0,0 +1,3 @@
+from paddle_billing.Notifications.Secret          import Secret
+from paddle_billing.Notifications.PaddleSignature import PaddleSignature
+from paddle_billing.Notifications.Verifier        import Verifier

paddle_billing/Options.py

@@ -0,0 +1,10 @@
+from __future__  import annotations
+from dataclasses import dataclass
+
+from paddle_billing.Environment import Environment
+
+
+@dataclass
+class Options:
+    environment: Environment = Environment.PRODUCTION
+    retries:     int         = 1

paddle_billing/PaddleStrEnum.py

@@ -0,0 +1,44 @@
+from enum import EnumMeta, StrEnum
+
+from paddle_billing.Undefined import Undefined
+
+
+# Copied from enum.py because IDE complains when calling protected class super()._is_dunder
+def _is_dunder(name):
+    """
+    Returns True if a __dunder__ name, False otherwise.
+    """
+    return (
+            len(name) > 4 and
+            name[:2] == name[-2:] == '__' and
+            name[2] != '_' and
+            name[-3] != '_'
+    )
+
+
+
+class PaddleStrEnumMeta(EnumMeta):
+    """
+    Returns Undefined() by default when a property doesn't exist
+    This provides some flexibility for the SDK to handle Paddle adding new properties to their APIspec
+    """
+
+    def __getattr__(cls, name):
+        if _is_dunder(name):
+            raise AttributeError(name)
+
+        try:
+            return super().__getattr__(name)
+        except AttributeError:
+            return Undefined()
+
+
+
+class PaddleStrEnum(StrEnum, metaclass=PaddleStrEnumMeta):
+    """
+    Subclass of StrEnum but uses PaddleStrEnumMeta metaclass to set Undefined() value to undefined enum keys
+    """
+
+    @classmethod
+    def is_known(cls) -> bool:
+        """Not yet implemented"""

paddle_billing/RecursivelyRemoveKey.py

@@ -0,0 +1,14 @@
+def recursively_remove_key(data: list | dict | None, key_to_remove: str):
+    """Remove key recursively from a dict or list"""
+
+    if data is None:
+        return
+
+    if isinstance(data, dict):
+        if key_to_remove in data:
+            del data[key_to_remove]
+        for value in data.values():
+            recursively_remove_key(value, key_to_remove)
+    elif isinstance(data, list):
+        for item in data:
+            recursively_remove_key(item, key_to_remove)

paddle_billing/Resources/Addresses/AddressesClient.py

@@ -0,0 +1,58 @@
+from paddle_billing.ResponseParser import ResponseParser
+
+from paddle_billing.Entities.Address     import Address
+from paddle_billing.Entities.Collections import Paginator, AddressCollection
+from paddle_billing.Entities.Shared      import Status
+
+from paddle_billing.Resources.Addresses.Operations import CreateAddress, ListAddresses, UpdateAddress
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from paddle_billing.Client import Client
+
+
+class AddressesClient:
+    def __init__(self, client: 'Client'):
+        self.client   = client
+        self.response = None
+
+
+    def list(self, customer_id: str, operation: ListAddresses = None) -> AddressCollection:
+        if operation is None:
+            operation = ListAddresses()
+
+        self.response = self.client.get_raw(f"/customers/{customer_id}/addresses", operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return AddressCollection.from_list(
+            parser.get_data(),
+            Paginator(self.client, parser.get_pagination(), AddressCollection)
+        )
+
+
+    def get(self, customer_id: str, address_id: str) -> Address:
+        self.response = self.client.get_raw(f"/customers/{customer_id}/addresses/{address_id}")
+        parser        = ResponseParser(self.response)
+
+        return Address.from_dict(parser.get_data())
+
+
+    def create(self, customer_id: str, operation: CreateAddress) -> Address:
+        self.response = self.client.post_raw(f"/customers/{customer_id}/addresses", operation.get_parameters())
+        parser        = ResponseParser(self.response)
+
+        return Address.from_dict(parser.get_data())
+
+
+    def update(self, customer_id: str, address_id: str, operation: UpdateAddress) -> Address:
+        self.response = self.client.patch_raw(
+            f"/customers/{customer_id}/addresses/{address_id}",
+            operation.get_parameters()
+        )
+        parser = ResponseParser(self.response)
+
+        return Address.from_dict(parser.get_data())
+
+
+    def archive(self, customer_id: str, address_id: str) -> Address:
+        return self.update(customer_id, address_id, UpdateAddress(status=Status.Archived))

paddle_billing/Resources/Addresses/Operations/CreateAddress.py

@@ -0,0 +1,20 @@
+from dataclasses import asdict, dataclass
+
+from paddle_billing.Undefined       import Undefined
+from paddle_billing.Entities.Shared import CountryCode, CustomData
+
+
+@dataclass
+class CreateAddress:
+    country_code: CountryCode
+    description:  str        | None = Undefined()
+    first_line:   str        | None = Undefined()
+    second_line:  str        | None = Undefined()
+    city:         str        | None = Undefined()
+    postal_code:  str        | None = Undefined()
+    region:       str        | None = Undefined()
+    custom_data:  CustomData | None = Undefined()
+
+
+    def get_parameters(self) -> dict:
+        return asdict(self)

paddle_billing/Resources/Addresses/Operations/ListAddresses.py

@@ -0,0 +1,42 @@
+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 ListAddresses(HasParameters):
+    def __init__(
+            self,
+            pager:    Pager        | None = None,
+            ids:      list[str]    | None = None,
+            statuses: list[Status] | None = 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
+        if any(not isinstance(aid, str) for aid in self.ids):
+            raise InvalidArgumentException('ids', 'string')
+        if any(not isinstance(status, Status) for status in self.statuses):
+            raise InvalidArgumentException('statuses', Status.__name__)
+
+
+    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/Addresses/Operations/UpdateAddress.py

@@ -0,0 +1,21 @@
+from dataclasses import asdict, dataclass
+
+from paddle_billing.Undefined       import Undefined
+from paddle_billing.Entities.Shared import CountryCode, CustomData, Status
+
+
+@dataclass
+class UpdateAddress:
+    country_code: CountryCode       | 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()
+    custom_data:  CustomData | None | Undefined = Undefined()
+    status:       Status     | None | Undefined = Undefined()
+
+
+    def get_parameters(self) -> dict:
+        return asdict(self)

paddle_billing/Resources/Addresses/Operations/__init__.py

@@ -0,0 +1,3 @@
+from paddle_billing.Resources.Addresses.Operations.CreateAddress import CreateAddress
+from paddle_billing.Resources.Addresses.Operations.ListAddresses import ListAddresses
+from paddle_billing.Resources.Addresses.Operations.UpdateAddress import UpdateAddress