pypaystack2 3.1.0__tar.gz → 3.2.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pypaystack2
-Version: 3.1.0
+Version: 3.2.0
 Summary: A developer-friendly client library for Paystack
 Keywords: paystack-python,pypaystack,paystack,paystackapi
 Author: Gbenga Adeyi
@@ -14,7 +14,6 @@ Requires-Dist: pydantic>=2.12.5
 Requires-Dist: fastapi[standard]>=0.123.10 ; extra == 'webhook'
 Requires-Dist: ngrok>=1.4.0 ; extra == 'webhook'
 Requires-Dist: python-dotenv>=1.2.1 ; extra == 'webhook'
-Requires-Dist: typer-slim[standard]>=0.20.0 ; extra == 'webhook'
 Requires-Python: >=3.11
 Provides-Extra: webhook
 Description-Content-Type: text/markdown
@@ -47,7 +46,7 @@ $ uv add pypaystack2
 # For webhook cli
 $ pip install -U "pypaystack2[webhook]"
 or install with uv
-$ uv add "pypaystack2[webhook"
+$ uv add "pypaystack2[webhook]"
 ```
 
 ## Usage Preview

{pypaystack2-3.1.0 → pypaystack2-3.2.0}/README.md

@@ -26,7 +26,7 @@ $ uv add pypaystack2
 # For webhook cli
 $ pip install -U "pypaystack2[webhook]"
 or install with uv
-$ uv add "pypaystack2[webhook"
+$ uv add "pypaystack2[webhook]"
 ```
 
 ## Usage Preview

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

@@ -1,6 +1,6 @@
 [project]
 name = "pypaystack2"
-version = "3.1.0"
+version = "3.2.0"
 description = "A developer-friendly client library for Paystack"
 readme = "README.md"
 license = "MIT"
@@ -29,7 +29,6 @@ webhook = [
     "fastapi[standard]>=0.123.10",
     "ngrok>=1.4.0",
     "python-dotenv>=1.2.1",
-    "typer-slim[standard]>=0.20.0",
 ]
 
 [build-system]
@@ -49,7 +48,6 @@ format = [
 test = [
     "python-dotenv>=1.2.1",
     "tomli>=2.3.0",
-    "typer-slim[standard]>=0.20.0",
 ]
 coverage = []
 doc = [

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

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

{pypaystack2-3.1.0 → pypaystack2-3.2.0}/src/pypaystack2/base_clients.py

@@ -11,7 +11,7 @@ from json import JSONDecodeError
 from typing import Any, Type, cast
 
 import httpx
-from httpx import NetworkError
+from httpx import HTTPError
 from pydantic import ValidationError
 
 from pypaystack2._metadata import __version__
@@ -287,7 +287,7 @@ class BaseAPIClient(AbstractAPIClient):
 
         try:
             response = http_method_handler(**request_kwargs)  # type: ignore
-        except NetworkError as error:
+        except HTTPError as error:
             raise ClientNetworkError(f"network error occurred: {error}", error)
         return self._deserialize_response(
             response, response_data_model_class, raise_serialization_exception
@@ -327,7 +327,7 @@ class BaseAsyncAPIClient(AbstractAPIClient):
                 raise ValueError("HTTP Request method not recognised or implemented")
             try:
                 response = await http_method_handler(**request_kwargs)
-            except NetworkError as error:
+            except HTTPError as error:
                 raise ClientNetworkError(f"network error occurred: {error}", error)
 
         return self._deserialize_response(

{pypaystack2-3.1.0 → pypaystack2-3.2.0}/src/pypaystack2/enums.py

@@ -44,10 +44,13 @@ class Channel(StrEnum):
 
     CARD = "card"
     BANK = "bank"
+    APPLE_PAY = "apple_pay"
     USSD = "ussd"
     QR = "qr"
     MOBILE_MONEY = "mobile_money"
     BANK_TRANSFER = "bank_transfer"
+    EFT = "eft"
+    PAYATTITUDE = "payattitude"
 
 
 class Bearer(StrEnum):

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

@@ -1,3 +1,9 @@
+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 (
+    AsyncVirtualTerminalClient,
+)
+from pypaystack2.sub_clients.sync_clients.virtual_terminals import VirtualTerminalClient
 from pypaystack2.base_clients import BaseAPIClient, BaseAsyncAPIClient
 from pypaystack2.sub_clients import (
     ApplePayClient,
@@ -102,6 +108,10 @@ class PaystackClient(BaseAPIClient):
             Transfers control API e.g. `PaystackClient.transfer_control.check_balance`.
         verification: A binding to `VerificationClient` providing methods for interacting Paystack's Verification API
             e.g. `PaystackClient.verification.resolve_account_number`.
+        virtual_terminals: A binding to `VirtualTerminalClient` providing methods for interacting with Paystack's
+            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`.
     """
 
     def __init__(self, secret_key: str | None = None):
@@ -157,6 +167,8 @@ class PaystackClient(BaseAPIClient):
         self.verification: VerificationClient = VerificationClient(
             secret_key=self._secret_key
         )
+        self.virtual_terminals = VirtualTerminalClient(secret_key=self._secret_key)
+        self.direct_debits = DirectDebitClient(secret_key=self._secret_key)
 
 
 class AsyncPaystackClient(BaseAsyncAPIClient):
@@ -167,51 +179,56 @@ class AsyncPaystackClient(BaseAsyncAPIClient):
 
     Attributes:
         apple_pay: A binding to `AsyncApplePayClient` providing methods for interacting Paystack's Apple Pay API
-            e.g. `PaystackClient.apple_pay.get_domains`.
+            e.g. `AsyncPaystackClient.apple_pay.get_domains`.
         bulk_charges: A binding to `AsyncBulkChargeClient` providing methods for interacting Paystack's Bulk charge API
-            e.g. `PaystackClient.bulk_charges.initiate`.
+            e.g. `AsyncPaystackClient.bulk_charges.initiate`.
         charge: A binding to `AsyncChargeClient` providing methods for interacting Paystack's Charge API
-            e.g. `PaystackClient.charge.charge`.
+            e.g. `AsyncPaystackClient.charge.charge`.
         integration: A binding to `AsyncIntegrationClient` providing methods for interacting Paystack's Integration API
-            e.g. `PaystackClient.integration.get_payment_session_timeout`.
+            e.g. `AsyncPaystackClient.integration.get_payment_session_timeout`.
         customers: A binding to `AsyncCustomerClient` providing methods for interacting Paystack's Customer API
-            e.g. `PaystackClient.customers.create`.
+            e.g. `AsyncPaystackClient.customers.create`.
         dedicated_accounts: A binding to `AsyncDedicatedAccountClient` providing methods for interacting
             Paystack's Dedicated account API e.g. `PaystackClient.dedicated_accounts.create`.
         disputes: A binding to `AsyncDisputeClient` providing methods for interacting Paystack's Dispute API
-            e.g. `PaystackClient.disputes.`.
+            e.g. `AsyncPaystackClient.disputes.`.
         payment_requests: A binding to `AsyncPaymentRequestClient` providing methods for interacting Paystack's Payment
-            request API e.g. `PaystackClient.payment_requests.create`.
+            request API e.g. `AsyncPaystackClient.payment_requests.create`.
         miscellaneous: A binding to `AsyncApplePayClient` providing methods for interacting Paystack's Apple Pay API
-            e.g. `PaystackClient.miscellaneous.get_banks`.
+            e.g. `AsyncPaystackClient.miscellaneous.get_banks`.
         payment_pages: A binding to `AsyncPaymentPageClient` providing methods for interacting Paystack's Payment Page
             API e.g. `PaystackClient.payment_pages.create`.
         plans: A binding to `AsyncPlanClient` providing methods for interacting Paystack's Plan API
-            e.g. `PaystackClient.plans.get_plans`.
+            e.g. `AsyncPaystackClient.plans.get_plans`.
         products: A binding to `AsyncProductClient` providing methods for interacting Paystack's Product API
             e.g. `PaystackClient.products.get_product`.
         refunds: A binding to `AsyncRefundClient` providing methods for interacting Paystack's Refund API
-            e.g. `PaystackClient.refunds.create`.
+            e.g. `AsyncPaystackClient.refunds.create`.
         settlements: A binding to `AsyncSettlementClient` providing methods for interacting Paystack's Settlement API
-            e.g. `PaystackClient.settlements.get_settlements`.
+            e.g. `AsyncPaystackClient.settlements.get_settlements`.
         splits: A binding to `AsyncTransactionSplitClient` providing methods for interacting Paystack's Transaction
-            split API e.g. `PaystackClient.splits.create`.
+            split API e.g. `AsyncPaystackClient.splits.create`.
         subaccounts: A binding to `AsyncSubAccountClient` providing methods for interacting Paystack's subaccount API
-            e.g. `PaystackClient.subaccounts.create`.
+            e.g. `AsyncPaystackClient.subaccounts.create`.
         subscriptions: A binding to `AsyncSubscriptionClient` providing methods for interacting Paystack's Subscription
-            API e.g. `PaystackClient.subscriptions.create`.
+            API e.g. `AsyncPaystackClient.subscriptions.create`.
         terminals: A binding to `AsyncTerminalClient` providing methods for interacting Paystack's Terminal API
-            e.g. `PaystackClient.terminals.send_event`.
+            e.g. `AsyncPaystackClient.terminals.send_event`.
         transactions: A binding to `AsyncTransactionClient` providing methods for interacting Paystack's Transaction
-            API e.g. `PaystackClient.transactions.initiate`.
+            API e.g. `AsyncPaystackClient.transactions.initiate`.
         transfer_recipients: A binding to `AsyncTransferRecipientClient` providing methods for interacting Paystack's
-            Transfer recipients API e.g. `PaystackClient.transfer_recipients.create`.
+            Transfer recipients API e.g. `AsyncPaystackClient.transfer_recipients.create`.
         transfers: A binding to `AsyncTransferClient` providing methods for interacting Paystack's Transfer API
             e.g. `PaystackClient.transfers.finalize`.
         transfer_control: A binding to `AsyncTransferControlClient` providing methods for interacting Paystack's
-            Transfers control API e.g. `PaystackClient.transfer_control.check_balance`.
+            Transfers control API e.g. `AsyncPaystackClient.transfer_control.check_balance`.
         verification: A binding to `AsyncVerificationClient` providing methods for interacting Paystack's Verification
-            API e.g. `PaystackClient.verification.resolve_account_number`.
+            API e.g. `AsyncPaystackClient.verification.resolve_account_number`.
+        virtual_terminals: A binding to `VirtualTerminalClient` providing methods for interacting with Paystack's
+            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`.
+
     """
 
     def __init__(self, secret_key: str | None = None):
@@ -243,3 +260,5 @@ class AsyncPaystackClient(BaseAsyncAPIClient):
         self.transfers = AsyncTransferClient(secret_key=self._secret_key)
         self.transfer_control = AsyncTransferControlClient(secret_key=self._secret_key)
         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)

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

@@ -1,5 +1,6 @@
 # ruff: noqa: F401
 from pypaystack2.models.payload_models import (
+    RefundAccount,
     BulkChargeInstruction,
     LineItem,
     Tax,

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

@@ -5,6 +5,22 @@ from pydantic import BaseModel, model_validator
 from pypaystack2.enums import RecipientType, Currency
 
 
+class RefundAccount(BaseModel):
+    """A dataclass for representing refund account
+    details
+
+    Attributes:
+        currency:The currency of the customer's bank account.
+            It should be the same as the currency the payment was made
+        account_number: The customer's account number
+        bank_id: The ID representing the customer's bank.
+    """
+
+    currency: Currency
+    account_number: str
+    bank_id: str
+
+
 class BulkChargeInstruction(BaseModel):
     """A dataclass for bulk charge instruction.
 

{pypaystack2-3.1.0 → pypaystack2-3.2.0}/src/pypaystack2/sub_clients/async_clients/charge.py

@@ -1,5 +1,5 @@
 from http import HTTPMethod
-from typing import Any
+from typing import Any, Literal
 
 from pypaystack2.base_clients import BaseAsyncAPIClient, add_to_payload
 from pypaystack2.models import Response
@@ -19,14 +19,19 @@ class AsyncChargeClient(BaseAsyncAPIClient):
         self,
         email: str,
         amount: int,
+        split_code: str | None = None,
+        subaccount: str | None = None,
+        transaction_charge: str | None = None,
+        bearer: Literal["account", "subaccount"] | None = "account",
         bank: dict[str, Any] | None = None,
         bank_transfer: dict[str, Any] | None = None,
+        ussd: dict[str, Any] | None = None,
+        mobile_money: dict[str, Any] | None = None,
+        qr: dict[str, Any] | None = None,
         auth_code: str | None = None,
         pin: str | None = None,
         metadata: dict[str, Any] | None = None,
         reference: str | None = None,
-        ussd: dict[str, Any] | None = None,
-        mobile_money: dict[str, Any] | None = None,
         device_id: str | None = None,
         alternate_model_class: type[PaystackDataModel] | None = None,
     ) -> Response[ChargeStep] | Response[PaystackDataModel]:
@@ -36,15 +41,21 @@ class AsyncChargeClient(BaseAsyncAPIClient):
             email: Customer's email address
             amount: Amount should be in kobo if currency is NGN, pesewas, if currency is GHS,
                 and cents, if currency is ZAR
+            split_code: The split code of a previously created split. e.g. `SPL_98WF13Eb3w`
+            subaccount: The code for the subaccount that owns the payment. e.g. `ACCT_8f4s1eq7ml6rlzj`
+            transaction_charge: An amount used to override the split configuration for a single split payment.
+                If set, the amount specified goes to the main account regardless of the split configuration.
+            bearer: Use this param to indicate who bears the transaction charges.
             bank: Bank account to charge (don't send if charging an authorization code)
             bank_transfer: Takes the settings for the Pay with Transfer (PwT) channel. Pass in the
                 account_expires_at param to set the expiry time.
+            ussd: USSD type to charge (don't send if charging an authorization code, bank or card)
+            mobile_money: Mobile details (don't send if charging an authorization code, bank or card)
+            qr: Takes a provider parameter with the value set to: scan-to-pay. Currently supported in South Africa only.
             auth_code: An authorization code to charge (don't send if charging a bank account)
             pin: 4-digit PIN (send with a non-reusable authorization code)
             metadata: A dictionary of data.
             reference: Unique transaction reference. Only -, .\\`, = and alphanumeric characters allowed.
-            ussd: USSD type to charge (don't send if charging an authorization code, bank or card)
-            mobile_money: Mobile details (don't send if charging an authorization code, bank or card)
             device_id: This is the unique identifier of the device a user uses in making payment. Only -, .\\`,
                 = and alphanumeric characters allowed.
             alternate_model_class: A pydantic model class to use instead of the
@@ -66,14 +77,19 @@ class AsyncChargeClient(BaseAsyncAPIClient):
 
         payload = {"email": email, "amount": amount}
         optional_params = [
+            ("split_code", split_code),
+            ("subaccount", subaccount),
+            ("transaction_charge", transaction_charge),
+            ("bearer", bearer),
             ("bank", bank),
             ("bank_transfer", bank_transfer),
+            ("ussd", ussd),
+            ("mobile_money", mobile_money),
+            ("qr", qr),
             ("authorization_code", auth_code),
             ("pin", pin),
             ("metadata", metadata),
             ("reference", reference),
-            ("ussd", ussd),
-            ("mobile_money", mobile_money),
             ("device_id", device_id),
         ]
         payload = add_to_payload(optional_params, payload)

{pypaystack2-3.1.0 → pypaystack2-3.2.0}/src/pypaystack2/sub_clients/async_clients/customers.py

@@ -329,6 +329,198 @@ class AsyncCustomerClient(BaseAsyncAPIClient):
             response_data_model_class=alternate_model_class or Customer,
         )
 
+    async def initialize_authorization(
+        self,
+        email: str,
+        callback_url: str | None = None,
+        account: dict[str, Any] | None = None,
+        address: dict[str, Any] | None = None,
+        channel: str = "direct-debit",
+        alternate_model_class: type[PaystackDataModel] | None = None,
+    ):
+        """Initiate a request to create a reusable authorization code for recurring transactions.
+
+        Args:
+            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("/customer/authorization/initialize")
+        payload = {
+            "email": email,
+            "channel": channel,
+        }
+        optional_params = [
+            ("callback_url", callback_url),
+            ("account", account),
+            ("address", address),
+        ]
+        payload = add_to_payload(optional_params, payload)
+        return await self._handle_request(
+            HTTPMethod.POST,
+            url,
+            payload,
+            response_data_model_class=alternate_model_class,
+        )
+
+    async def verify_authorization(
+        self,
+        reference: str,
+        alternate_model_class: type[PaystackDataModel] | None = None,
+    ):
+        """Check the status of an authorization request.
+
+        Args:
+            reference: The reference returned in the initialization response
+            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"/customer/authorization/verify/{reference}")
+        return await self._handle_request(
+            HTTPMethod.GET,
+            url,
+            response_data_model_class=alternate_model_class,
+        )
+
+    async def initialize_direct_debit(
+        self,
+        customer_id: str | int,
+        account: dict[str, Any],
+        address: dict[str, Any],
+        alternate_model_class: type[PaystackDataModel] | None = None,
+    ):
+        """Initialize the process of linking an account to a customer for Direct Debit transactions.
+
+        Args:
+            customer_id: The id of the customer.
+            account: the customer's acount details. it should have a key `number`
+                with a value that is the customer's account number, a key `bank_code`
+                that is the code representing the customer's bank.
+            address: the customer's address information. it should have the keys
+                `street`, `city` and `state` that is the customer's address information
+            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"/customer/{customer_id}/initialize-direct-debit")
+        payload = {
+            "account": account,
+            "address": address,
+        }
+        return await self._handle_request(
+            HTTPMethod.POST,
+            url,
+            payload,
+            response_data_model_class=alternate_model_class,
+        )
+
+    async def trigger_activation_charge(
+        self,
+        customer_id: str | int,
+        authorization_id: str | int,
+        alternate_model_class: type[PaystackDataModel] | None = None,
+    ):
+        """Trigger an activation charge on an inactive mandate on behalf of your customer.
+
+        Args:
+            customer_id: The customer ID attacted to the authorization
+            authorization_id: The authorization ID gotten from the initiation response
+            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"/customer/{customer_id}/directdebit-activation-charge")
+        payload = {
+            "authorization_id": authorization_id,
+        }
+        return await self._handle_request(
+            HTTPMethod.PUT,
+            url,
+            payload,
+            response_data_model_class=alternate_model_class,
+        )
+
+    async def get_mandate_authorizations(
+        self,
+        id_: str | int,
+        alternate_model_class: type[PaystackDataModel] | None = None,
+    ):
+        """Get the list of direct debit mandates associated with a customer.
+
+        Args:
+            id_: The customer ID for the authorizations to fetch
+            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"/customer/{id_}/directdebit-mandate-authorizations")
+        return await self._handle_request(
+            HTTPMethod.GET,
+            url,
+            response_data_model_class=alternate_model_class,
+        )
+
     async def deactivate(
         self,
         auth_code: str,
@@ -355,7 +547,7 @@ class AsyncCustomerClient(BaseAsyncAPIClient):
             A pydantic model containing the response gotten from paystack's server.
         """
 
-        url = self._full_url("/customer/deactivate_authorization")
+        url = self._full_url("/customer/authorization/deactivate")
         payload = {
             "authorization_code": auth_code,
         }

pypaystack2-3.2.0/src/pypaystack2/sub_clients/async_clients/direct_debits.py

@@ -0,0 +1,91 @@
+from typing import Literal
+from http import HTTPMethod
+from pypaystack2.types import PaystackDataModel
+from pypaystack2.base_clients import BaseAsyncAPIClient, append_query_params
+
+
+class AsyncDirectDebitClient(BaseAsyncAPIClient):
+    """This client provides API for interacting with Paystack's Direct Debit API
+
+    The Direct Debit API allows you manage the authorization on your customer's bank accounts.
+    """
+
+    async def trigger_activation_charge(
+        self,
+        customer_ids: list[str | int],
+        alternate_model_class: type[PaystackDataModel] | None = None,
+    ):
+        """Trigger an activation charge on an inactive mandate on behalf of your customer.
+
+        Args:
+            customer_ids: A list of customer IDs with pending mandate authorizations.
+            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("/directdebit/activation-charge")
+        payload = {
+            "customer_ids": customer_ids,
+        }
+        return await self._handle_request(
+            HTTPMethod.PUT,
+            url,
+            payload,
+            response_data_model_class=alternate_model_class,
+        )
+
+    async def get_mandate_authorizations(
+        self,
+        cursor: str | None = None,
+        status: Literal["pending", "active", "revoked"] | None = None,
+        pagination: int = 50,
+        alternate_model_class: type[PaystackDataModel] | None = None,
+    ):
+        """Get the list of direct debit mandates associated with a customer.
+
+        Args:
+            cursor: The cursor value of the next set of authorizations to fetch.
+                You can get this from the meta object of the response
+            status: Filter by the authorization status.
+            pagination: The number of authorizations to fetch per call
+            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 = [
+            ("cursor", cursor),
+            ("status", status),
+        ]
+        url = self._full_url(
+            f"/directdebit/mandate-authorizations?per_page={pagination}"
+        )
+        url = append_query_params(query_params, url)
+        return await self._handle_request(
+            HTTPMethod.GET,
+            url,
+            response_data_model_class=alternate_model_class,
+        )

{pypaystack2-3.1.0 → pypaystack2-3.2.0}/src/pypaystack2/sub_clients/async_clients/miscellaneous.py

@@ -26,6 +26,7 @@ class AsyncMiscellaneousClient(BaseAsyncAPIClient):
         pay_with_bank_transfer: bool | None = None,
         pay_with_bank: bool | None = None,
         include_nip_sort_code: bool | None = None,
+        enabled_for_verificaton: bool | None = None,
         pagination: int = 50,
         alternate_model_class: type[PaystackDataModel] | None = None,
     ) -> Response[list[Bank]] | Response[PaystackDataModel]:
@@ -44,6 +45,8 @@ class AsyncMiscellaneousClient(BaseAsyncAPIClient):
             pay_with_bank_transfer: A flag to filter for available banks a customer can make a transfer to
                 complete a payment
             pay_with_bank: A flag to filter for banks a customer can pay directly from
+            enabled_for_verificaton: A flag to filter the banks that are supported for account verification in South Africa.
+                You need to combine this with either the currency or country filter.
             pagination: The number of objects to return per page. Defaults to 50, and limited to 100 records per page.
             alternate_model_class: A pydantic model class to use instead of the
                 default pydantic model used by the library to present the data in
@@ -77,6 +80,7 @@ class AsyncMiscellaneousClient(BaseAsyncAPIClient):
             ("pay_with_bank_transfer", pay_with_bank_transfer),
             ("pay_with_bank", pay_with_bank),
             ("include_nip_sort_code", include_nip_sort_code),
+            ("enabled_for_verificaton", enabled_for_verificaton),
         ]
         url = append_query_params(query_params, url)
         return await self._handle_request(  # type: ignore