pypaystack2 3.2.0__tar.gz → 3.3.0__tar.gz

{pypaystack2-3.2.0 → pypaystack2-3.3.0}/PKG-INFO

@@ -1,12 +1,11 @@
 Metadata-Version: 2.4
 Name: pypaystack2
-Version: 3.2.0
+Version: 3.3.0
 Summary: A developer-friendly client library for Paystack
 Keywords: paystack-python,pypaystack,paystack,paystackapi
 Author: Gbenga Adeyi
 Author-email: Gbenga Adeyi <adeyigbenga005@gmail.com>
 License-Expression: MIT
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Requires-Dist: httpx>=0.28.1

{pypaystack2-3.2.0 → pypaystack2-3.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pypaystack2"
-version = "3.2.0"
+version = "3.3.0"
 description = "A developer-friendly client library for Paystack"
 readme = "README.md"
 license = "MIT"
@@ -9,7 +9,6 @@ authors = [
 ]
 keywords = ["paystack-python", "pypaystack", "paystack", "paystackapi"]
 classifiers = [
-    "License :: OSI Approved :: MIT License",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
 ]
@@ -32,7 +31,7 @@ webhook = [
 ]
 
 [build-system]
-requires = ["uv_build>=0.9.10,<0.10.0"]
+requires = ["uv_build>=0.11.19,<0.12.0"]
 build-backend = "uv_build"
 
 [dependency-groups]

{pypaystack2-3.2.0 → pypaystack2-3.3.0}/src/pypaystack2/_metadata.py

@@ -1,5 +1,5 @@
 __title__ = "pypaystack2"
-__version__ = "3.2.0"
+__version__ = "3.3.0"
 __author__ = [{"name": "Gbenga Adeyi", "email": "adeyigbenga005@gmail.com"}]
 __license__ = "MIT"
-__copyright__ = "Copyright 2025."
+__copyright__ = "Copyright 2026."

{pypaystack2-3.2.0 → pypaystack2-3.3.0}/src/pypaystack2/fees_calculation_mixin.py

@@ -119,19 +119,33 @@ class FeesCalculationMixin:
             )
         options_model = options_validator_class.model_validate(options)  # type: ignore
 
-        if currency == Currency.NGN:
+        if currency == Currency.NGN and isinstance(
+            options_model, NigeriaServiceFeeOptions
+        ):
             return self._calculate_ngn_fee(amount, options_model)
-        if currency == Currency.GHS:
+        if currency == Currency.GHS and isinstance(
+            options_model, GhanaServiceFeeOptions
+        ):
             return self._calculate_ghs_fee(amount, options_model)
-        if currency == Currency.ZAR:
+        if currency == Currency.ZAR and isinstance(
+            options_model, SouthAfricaServiceFeeOptions
+        ):
             return self._calculate_zar_fee(amount, options_model)
-        if currency == Currency.KES:
+        if currency == Currency.KES and isinstance(
+            options_model, KenyaServiceFeeOptions
+        ):
             return self._calculate_kes_fee(amount, options_model)
-        if currency == Currency.XOF:
+        if currency == Currency.XOF and isinstance(
+            options_model, CoteDIvoreServiceFeeOptions
+        ):
             return self._calculate_xof_fee(amount, options_model)
-        if currency == Currency.RWF:
+        if currency == Currency.RWF and isinstance(
+            options_model, RwandaServiceFeeOptions
+        ):
             return self._calculate_rwf_fee(amount, options_model)
-        if currency == Currency.EGP:
+        if currency == Currency.EGP and isinstance(
+            options_model, EgyptServiceFeeOptions
+        ):
             return self._calculate_egp_fee(amount, options_model)
         raise ValueError(
             f"calculations not supported for the provided currency {currency}"

{pypaystack2-3.2.0 → pypaystack2-3.3.0}/src/pypaystack2/main_clients.py

@@ -1,3 +1,15 @@
+from pypaystack2.sub_clients.async_clients.storefronts import AsyncStorefrontClient
+from pypaystack2.sub_clients.async_clients.orders import AsyncOrderClient
+from pypaystack2.sub_clients.async_clients.preauthorizations import (
+    AsyncPreauthorizationClient,
+)
+from pypaystack2.sub_clients.sync_clients.preauthorizations import (
+    PreauthorizationClient,
+)
+from pypaystack2.sub_clients.sync_clients.orders import OrderClient
+from pypaystack2.sub_clients.sync_clients.storefronts import StorefrontClient
+from http import HTTPMethod
+from pypaystack2.types import PaystackDataModel
 from pypaystack2.sub_clients.async_clients.direct_debits import AsyncDirectDebitClient
 from pypaystack2.sub_clients.sync_clients.direct_debits import DirectDebitClient
 from pypaystack2.sub_clients.async_clients.virtual_terminals import (
@@ -112,6 +124,12 @@ class PaystackClient(BaseAPIClient):
             Virtual Terminal API e.g. `VirtualTerminalClient.list`.
         direct_debits: A binding to `DirectDebitClient` providing methods for interacting with Paystack's
             Direct Debit API e.g. `DirectDebitClient.trigger_activation_charge`.
+        storefronts: A binding to `StorefrontClient` providing methods for interacting with Paystack's
+            Storefront API e.g. `StorefrontClient.create`.
+        orders: A binding to `OrderClient` providing methods for interacting with Paystack's
+            Order API e.g. `OrderClient.create`.
+        preauthorizations: A binding to `PreauthorizationClient` providing methods for interacting with Paystack's
+            Preauthorization API e.g. `PreauthorizationClient.initialize`.
     """
 
     def __init__(self, secret_key: str | None = None):
@@ -169,6 +187,41 @@ class PaystackClient(BaseAPIClient):
         )
         self.virtual_terminals = VirtualTerminalClient(secret_key=self._secret_key)
         self.direct_debits = DirectDebitClient(secret_key=self._secret_key)
+        self.storefronts = StorefrontClient(secret_key=self._secret_key)
+        self.orders = OrderClient(secret_key=self._secret_key)
+        self.preauthorizations = PreauthorizationClient(secret_key=self._secret_key)
+
+    def get_capitec_pay_transaction(
+        self,
+        reference: str,
+        alternate_model_class: type[PaystackDataModel] | None = None,
+    ):
+        """Check the status of a charge made with Capitec Pay.
+
+        Args:
+            reference: The transaction reference from the previously initiated charge request
+            alternate_model_class: A pydantic model class to use instead of the
+            default pydantic model used by the library to present the data in
+            the `Response.data`. The default behaviour of the library is to
+            set  `Response.data` to `None` if it fails to serialize the data
+            returned from paystack with the model provided in the library.
+            Providing a pydantic model class via this parameter overrides
+            the library default model with the model class you provide.
+            This can come in handy when the models in the library do not
+            accurately represent the data returned, and you prefer working with the
+            data as a pydantic model instead of as a dict of the response returned
+            by  paystack before it is serialized with pydantic models, The original
+            data can be accessed via `Response.raw`.
+
+        Returns:
+            A pydantic model containing the response gotten from paystack's server.
+        """
+        url = self._full_url(f"/capitec-pay/requery/{reference}")
+        return self._handle_request(
+            HTTPMethod.POST,
+            url,
+            response_data_model_class=alternate_model_class,
+        )
 
 
 class AsyncPaystackClient(BaseAsyncAPIClient):
@@ -228,6 +281,12 @@ class AsyncPaystackClient(BaseAsyncAPIClient):
             Virtual Terminal API e.g. `AsyncVirtualTerminalClient.list`.
         direct_debits: A binding to `AsyncDirectDebitClient` providing methods for interacting with Paystack's
             Direct Debit API e.g. `AsyncDirectDebitClient.trigger_activation_charge`.
+        storefronts: A binding to `AsyncStorefrontClient` providing methods for interacting with Paystack's
+            Storefront API e.g. `AsyncStorefrontClient.create`.
+        orders: A binding to `AsyncOrderClient` providing methods for interacting with Paystack's
+            Order API e.g. `AsyncOrderClient.create`.
+        preauthorizations: A binding to `AsyncPreauthorizationClient` providing methods for interacting with Paystack's
+            Preauthorization API e.g. `AsyncPreauthorizationClient.initialize`.
 
     """
 
@@ -262,3 +321,40 @@ class AsyncPaystackClient(BaseAsyncAPIClient):
         self.verification = AsyncVerificationClient(secret_key=self._secret_key)
         self.virtual_terminals = AsyncVirtualTerminalClient(secret_key=self._secret_key)
         self.direct_debits = AsyncDirectDebitClient(secret_key=self._secret_key)
+        self.storefronts = AsyncStorefrontClient(secret_key=self._secret_key)
+        self.orders = AsyncOrderClient(secret_key=self._secret_key)
+        self.preauthorizations = AsyncPreauthorizationClient(
+            secret_key=self._secret_key
+        )
+
+    async def get_capitec_pay_transaction(
+        self,
+        reference: str,
+        alternate_model_class: type[PaystackDataModel] | None = None,
+    ):
+        """Check the status of a charge made with Capitec Pay.
+
+        Args:
+            reference: The transaction reference from the previously initiated charge request
+            alternate_model_class: A pydantic model class to use instead of the
+            default pydantic model used by the library to present the data in
+            the `Response.data`. The default behaviour of the library is to
+            set  `Response.data` to `None` if it fails to serialize the data
+            returned from paystack with the model provided in the library.
+            Providing a pydantic model class via this parameter overrides
+            the library default model with the model class you provide.
+            This can come in handy when the models in the library do not
+            accurately represent the data returned, and you prefer working with the
+            data as a pydantic model instead of as a dict of the response returned
+            by  paystack before it is serialized with pydantic models, The original
+            data can be accessed via `Response.raw`.
+
+        Returns:
+            A pydantic model containing the response gotten from paystack's server.
+        """
+        url = self._full_url(f"/capitec-pay/requery/{reference}")
+        return await self._handle_request(
+            HTTPMethod.POST,
+            url,
+            response_data_model_class=alternate_model_class,
+        )

{pypaystack2-3.2.0 → pypaystack2-3.3.0}/src/pypaystack2/models/__init__.py

@@ -3,6 +3,7 @@ from pypaystack2.models.payload_models import (
     RefundAccount,
     BulkChargeInstruction,
     LineItem,
+    OrderLineItem,
     Tax,
     SplitAccount,
     Recipient,
@@ -90,6 +91,7 @@ __all__ = [
     #     payload models
     "BulkChargeInstruction",
     "LineItem",
+    "OrderLineItem",
     "Tax",
     "SplitAccount",
     "Recipient",

{pypaystack2-3.2.0 → pypaystack2-3.3.0}/src/pypaystack2/models/payload_models.py

@@ -1,12 +1,12 @@
 from typing import Any, Optional, Literal, Self
 
-from pydantic import BaseModel, model_validator
+from pydantic import BaseModel, model_validator, Field
 
 from pypaystack2.enums import RecipientType, Currency
 
 
 class RefundAccount(BaseModel):
-    """A dataclass for representing refund account
+    """A pydantic model for representing refund account
     details
 
     Attributes:
@@ -22,7 +22,7 @@ class RefundAccount(BaseModel):
 
 
 class BulkChargeInstruction(BaseModel):
-    """A dataclass for bulk charge instruction.
+    """A pydantic model for bulk charge instruction.
 
     Attributes:
         authorization: The authorization code of the customer you want to charge.
@@ -36,7 +36,7 @@ class BulkChargeInstruction(BaseModel):
 
 
 class LineItem(BaseModel):
-    """A dataclass for LineItem.
+    """A pydantic model for LineItem.
 
     Attributes:
         name: The name of the product.
@@ -49,8 +49,20 @@ class LineItem(BaseModel):
     quantity: int
 
 
+class OrderLineItem(BaseModel):
+    """A pydantic model for representing a line item in an order
+
+    Attributes:
+        product: The ID of the product
+        quantity: The quantity of of the product
+    """
+
+    product: int
+    quantity: int = Field(1, ge=1)
+
+
 class Tax(BaseModel):
-    """A dataclass for Tax.
+    """A pydantic model for Tax.
 
     Attributes:
         name: The name of the tax.
@@ -62,7 +74,7 @@ class Tax(BaseModel):
 
 
 class SplitAccount(BaseModel):
-    """A dataclass for SplitAccount.
+    """A pydantic model for SplitAccount.
 
     Attributes:
         subaccount: The id of the sub account.
@@ -99,7 +111,7 @@ class Recipient(BaseModel):
 
 
 class TransferInstruction(BaseModel):
-    """A dataclass for TransferInstruction.
+    """A pydantic model for TransferInstruction.
 
     Attributes:
         amount: The amount to be transferred.

{pypaystack2-3.2.0 → pypaystack2-3.3.0}/src/pypaystack2/models/response_models.py

@@ -352,7 +352,7 @@ class PaymentRequestNotification(BaseModel):
 
 class PaymentRequest(BaseModel):
     id: int
-    integration: int | Integration
+    integration: int | Integration | None = None
     domain: Domain
     amount: int
     currency: Currency
@@ -368,7 +368,7 @@ class PaymentRequest(BaseModel):
     paid: bool
     paid_at: datetime | None = None
     metadata: dict[str, Any] | None = None
-    notifications: list[PaymentRequestNotification]
+    notifications: list[PaymentRequestNotification] | str
     offline_reference: str
     customer: Customer | int
     created_at: datetime
@@ -751,6 +751,7 @@ class Refund(BaseModel):
     refund_channel: str | None = None
     session_id: Any | None = None
     collect_account_number: bool | None = None
+    created_at: datetime | None = None
 
 
 class CardBin(BaseModel):

pypaystack2-3.3.0/src/pypaystack2/sub_clients/async_clients/orders.py

@@ -0,0 +1,191 @@
+from http import HTTPMethod
+from pypaystack2.models import Response
+from pypaystack2.types import PaystackDataModel
+from pypaystack2.models.payload_models import OrderLineItem
+from pypaystack2.base_clients import append_query_params, BaseAsyncAPIClient
+
+
+class AsyncOrderClient(BaseAsyncAPIClient):
+    """Provides a wrapper for paystack Orders API
+
+    The Orders API allows you to create and manage orders for your products.
+    """
+
+    async def create(
+        self,
+        customer: int | str,
+        line_items: list[OrderLineItem],
+        alternate_model_class: type[PaystackDataModel] | None = None,
+    ) -> Response[PaystackDataModel]:
+        """Create an order for selected items
+
+        Args:
+            customer: The customer code or ID whom the order belongs to
+            line_items: The items in the order, it is a list of pydantic model
+                `OrderLineItem` that contains the fields `product` which is the
+                id of the product and `quantity` which is the amount of that product
+                the customer ordered.
+            alternate_model_class: A pydantic model class to use instead of the
+                default pydantic model used by the library to present the data in
+                the `Response.data`. The default behaviour of the library is to
+                set  `Response.data` to `None` if it fails to serialize the data
+                returned from paystack with the model provided in the library.
+                Providing a pydantic model class via this parameter overrides
+                the library default model with the model class you provide.
+                This can come in handy when the models in the library do not
+                accurately represent the data returned, and you prefer working with the
+                data as a pydantic model instead of as a dict of the response returned
+                by  paystack before it is serialized with pydantic models, The original
+                data can be accessed via `Response.raw`.
+
+        Returns:
+            A pydantic model containing the response gotten from paystack's server.
+        """
+        _line_items = [item.model_dump(mode="json") for item in line_items]
+        payload = {
+            "customer": customer,
+            "line_items": _line_items,
+        }
+        url = self._full_url("/order")
+        return await self._handle_request(  # type: ignore
+            HTTPMethod.POST,
+            url,
+            data=payload,
+            response_data_model_class=alternate_model_class,
+        )
+
+    async def get_orders(
+        self,
+        pagination: int = 50,
+        page: int = 1,
+        start_date: str | None = None,
+        end_date: str | None = None,
+        alternate_model_class: type[PaystackDataModel] | None = None,
+    ) -> Response[PaystackDataModel]:
+        """List the orders available on your integration
+
+        Args:
+            pagination: Specifies how many orders you want to retrieve call.
+            page: Specifies the page to retrieve from the pagination.
+            start_date: A timestamp at which to start listing orders e.g. `2016-09-24T00:00:05.000Z`, `2016-09-21`
+            end_date: A timestamp at which to stop listing orders e.g. `2016-09-24T00:00:05.000Z`, `2016-09-21`
+            alternate_model_class: A pydantic model class to use instead of the
+                default pydantic model used by the library to present the data in
+                the `Response.data`. The default behaviour of the library is to
+                set  `Response.data` to `None` if it fails to serialize the data
+                returned from paystack with the model provided in the library.
+                Providing a pydantic model class via this parameter overrides
+                the library default model with the model class you provide.
+                This can come in handy when the models in the library do not
+                accurately represent the data returned, and you prefer working with the
+                data as a pydantic model instead of as a dict of the response returned
+                by  paystack before it is serialized with pydantic models, The original
+                data can be accessed via `Response.raw`.
+
+        Returns:
+            A pydantic model containing the response gotten from paystack's server.
+        """
+        query_params = [("page", page), ("from", start_date), ("to", end_date)]
+        url = self._full_url(f"/order/?perPage={pagination}")
+        url = append_query_params(query_params, url)
+        return await self._handle_request(  # type: ignore
+            HTTPMethod.GET,
+            url,
+            response_data_model_class=alternate_model_class,
+        )
+
+    async def get_order(
+        self,
+        id: int,
+        alternate_model_class: type[PaystackDataModel] | None = None,
+    ) -> Response[PaystackDataModel]:
+        """Fetch the details of an order on your integration
+
+        Args:
+            id: The ID of the order you want to retrieve.
+            alternate_model_class: A pydantic model class to use instead of the
+                default pydantic model used by the library to present the data in
+                the `Response.data`. The default behaviour of the library is to
+                set  `Response.data` to `None` if it fails to serialize the data
+                returned from paystack with the model provided in the library.
+                Providing a pydantic model class via this parameter overrides
+                the library default model with the model class you provide.
+                This can come in handy when the models in the library do not
+                accurately represent the data returned, and you prefer working with the
+                data as a pydantic model instead of as a dict of the response returned
+                by  paystack before it is serialized with pydantic models, The original
+                data can be accessed via `Response.raw`.
+
+        Returns:
+            A pydantic model containing the response gotten from paystack's server.
+        """
+        url = self._full_url(f"/order/{id}")
+        return await self._handle_request(  # type: ignore
+            HTTPMethod.GET,
+            url,
+            response_data_model_class=alternate_model_class,
+        )
+
+    async def get_product_orders(
+        self,
+        id: int,
+        alternate_model_class: type[PaystackDataModel] | None = None,
+    ) -> Response[PaystackDataModel]:
+        """Fetch all orders for a particular product
+
+        Args:
+            id: The id of the product you want to retrieve associated orders for.
+            alternate_model_class: A pydantic model class to use instead of the
+                default pydantic model used by the library to present the data in
+                the `Response.data`. The default behaviour of the library is to
+                set  `Response.data` to `None` if it fails to serialize the data
+                returned from paystack with the model provided in the library.
+                Providing a pydantic model class via this parameter overrides
+                the library default model with the model class you provide.
+                This can come in handy when the models in the library do not
+                accurately represent the data returned, and you prefer working with the
+                data as a pydantic model instead of as a dict of the response returned
+                by  paystack before it is serialized with pydantic models, The original
+                data can be accessed via `Response.raw`.
+
+        Returns:
+            A pydantic model containing the response gotten from paystack's server.
+        """
+        url = self._full_url(f"/order/product/{id}")
+        return await self._handle_request(  # type: ignore
+            HTTPMethod.GET,
+            url,
+            response_data_model_class=alternate_model_class,
+        )
+
+    async def validate(
+        self,
+        code: str,
+        alternate_model_class: type[PaystackDataModel] | None = None,
+    ) -> Response[PaystackDataModel]:
+        """Validate a pay for me order
+
+        Args:
+            code: The code for the order you want to validate.
+            alternate_model_class: A pydantic model class to use instead of the
+                default pydantic model used by the library to present the data in
+                the `Response.data`. The default behaviour of the library is to
+                set  `Response.data` to `None` if it fails to serialize the data
+                returned from paystack with the model provided in the library.
+                Providing a pydantic model class via this parameter overrides
+                the library default model with the model class you provide.
+                This can come in handy when the models in the library do not
+                accurately represent the data returned, and you prefer working with the
+                data as a pydantic model instead of as a dict of the response returned
+                by  paystack before it is serialized with pydantic models, The original
+                data can be accessed via `Response.raw`.
+
+        Returns:
+            A pydantic model containing the response gotten from paystack's server.
+        """
+        url = self._full_url(f"/order/{code}/validate")
+        return await self._handle_request(  # type: ignore
+            HTTPMethod.GET,
+            url,
+            response_data_model_class=alternate_model_class,
+        )

{pypaystack2-3.2.0 → pypaystack2-3.3.0}/src/pypaystack2/sub_clients/async_clients/payment_requests.py

@@ -34,6 +34,7 @@ class AsyncPaymentRequestClient(BaseAsyncAPIClient):
         has_invoice: bool | None = None,
         invoice_number: int | None = None,
         split_code: str | None = None,
+        metadata: dict[str, Any] | None = None,
         alternate_model_class: type[PaystackDataModel] | None = None,
     ) -> Response[PaymentRequest] | Response[PaystackDataModel]:
         """Create a payment request for a transaction on your integration
@@ -54,6 +55,7 @@ class AsyncPaymentRequestClient(BaseAsyncAPIClient):
                 This field is to help override whatever value Paystack decides. Auto increment for
                 subsequent invoices continue from this point.
             split_code: The split code of the transaction split. e.g. SPL_98WF13Eb3w
+            metadata: Additional informations to the request
             alternate_model_class: A pydantic model class to use instead of the
                 default pydantic model used by the library to present the data in
                 the `Response.data`. The default behaviour of the library is to
@@ -91,6 +93,7 @@ class AsyncPaymentRequestClient(BaseAsyncAPIClient):
             ("has_invoice", has_invoice),
             ("invoice_number", invoice_number),
             ("split_code", split_code),
+            ("metadata", metadata),
         ]
         payload = add_to_payload(optional_params, payload)
         return await self._handle_request(  # type: ignore
@@ -336,6 +339,7 @@ class AsyncPaymentRequestClient(BaseAsyncAPIClient):
         draft: bool | None = None,
         invoice_number: int | None = None,
         split_code: str | None = None,
+        metadata: dict[str, Any] | None = None,
         alternate_model_class: type[PaystackDataModel] | None = None,
     ) -> Response[PaymentRequest] | Response[PaystackDataModel]:
         """Update a payment request details on your integration
@@ -356,6 +360,7 @@ class AsyncPaymentRequestClient(BaseAsyncAPIClient):
                 This field is to help override whatever value Paystack decides. Auto increment for
                 subsequent invoices continue from this point.
             split_code: The split code of the transaction split. e.g. SPL_98WF13Eb3w
+            metadata: Additional informations to the request
             alternate_model_class: A pydantic model class to use instead of the
                 default pydantic model used by the library to present the data in
                 the `Response.data`. The default behaviour of the library is to
@@ -395,6 +400,7 @@ class AsyncPaymentRequestClient(BaseAsyncAPIClient):
             ("draft", draft),
             ("invoice_number", invoice_number),
             ("split_code", split_code),
+            ("metadata", metadata),
         ]
         payload = add_to_payload(optional_params, payload)
         return await self._handle_request(  # type: ignore