Bachs SDK (Python)

An unofficial python client SDK for BACHS

Features

• Fully Typed.
• Pydantic for payload and response data modeling.
• Custom response data model injection.
• Synchronous and Asynchronous clients

Installation

Requires Python version >=3.11

With uv

uv add bachs-sdk

With pip

pip install bachs-sdk

Usage

# You may provide your credentials through environment variables.
# The client automatically loads the following variables:
#
# BACHS_API_KEY="<your bachs api key>"
#
# Credentials passed to the client on instantiation take precedence over
# environment variables.

from bachs_sdk import BachsClient, AsyncBachsClient, Enviroment, CreateCheckoutSessionBody

# Instantiate the client
# Credentials may be passed directly if they are not available
# in the environment.
# May raise `MissingCredentialError` if no credentials was passed in 
# on instantiation or found in the environmental variables.
client = BachsClient()
# In a async context, you may use the async client
aclient = AsyncBachsClient()
# NOTE: The clients are configured to work in the sandboxed mode by default,
# you have to explicitly pass in `Enviroment.PRODUCTION` and use your production
# secret key i.e. `client = BachsClient(environment=Enviroment.PRODUCTION)`

# Now we create a payload for creating a checkout session.
body_data = {
            "customer": {"email": "adeyigbenga005@gmail.com", "name": "Gbenga Adeyi"},
            "product_cart": [
                {"product_id": "prod_199e781a66b04446a74d", "quantity": 1}
            ],
        }
body = CreateCheckoutSessionBody.model_validate(body_data)
# NOTE: `body` parameter of client methods are all pydantic models and you may 
# choose to instantiate it however you please. They follow a naming convention 
# of converting the method name (i.e. `create` in this case),and resource 
# (i.e. checkout sessions in this case ) and appending `body` to it after which
# the resulting string is converted to PascalCase.
# "create" + "checkout_session" + "body" = "CreateCheckoutSessionBody"

# Now we call our client method designated for creating a checkout session
# with our payload. (Calling a client method that makes a request, may raise 
# `ClientError` You need to handle this. `client.checkout_sessions` has methods
# that maps to enpoints from the official API reference)
response = client.checkout_sessions.create(body)
# If you're using the async clients, the method names remain the same, they just
# need to be awaited (This only works in a async context. Note that we're using 
# `aclient `and not `client`).
response =await aclient.checkout_sessions.create(body)

# Use the response data in your application
print(response)
# NOTE: responses are pydantic models of type `APIResponse[T]` where `T` is the
# type of the `data` field. The response also includes fields like `http_status`
# `request_id` and `raw` when the request is successful else the response is of
# type `APIErrorResponse` which is also a pydantic model with the details of what
# went wrong with the request. The `raw` field of `APIResponse[T]`
# which is the exact response data gotten from Bachs without any serialization.
# It's also worth noting that you may pass a custom response model while calling
# the client method via the `response_model_class` parameter, for the most part,
# you'll only need to change the `T` of the `APIResponse` e.g if i have
# `MyCustomResponseData`, then `response_model_class=APIResponse[MyCustomResponseData]`.
# When the client is unable to serialize the data returned by Bachs, it sets the
# `data` field to unserialized data and logs a warning if `raise_serialization_error=False`,
# which is the default otherwise it raises a `ResponseSerializationError`, 
# the original data is still present in the `raw` field.

# Another example creating a test product
# Update your imports
from bachs_sdk import (
    BachsClient, 
    AsyncBachsClient, 
    Enviroment, 
    Currency, # newly added
    PriceType, # newly added
)

body_data = {
            "name": "Aura Farming Course edition 01",
            "description": "A demo product",
            "price": {
                "currency": Currency.NGN,
                "price_type": PriceType.FIXED,
                "amount": "1500.50",
                "currency_options": [],
            },
        }
body = CreateProductBody.model_validate(body_data)
response = client.products.create(body)

Client bindings have the same name on both BachsClient and AsyncBachsClient

NOTE

This SDK is still under active development and the APIs may change. All you'll ever need to import from the SDK, can be imported from the top level (i.e.from bachs_sdk import x,y,z) for ease of you but might change if the need arises. Doc strings documentation coming soon.

Issues and Contributions

If you discover bugs, missing endpoints, incorrect typings, or any other issues, please open an issue or submit a pull request. Contributions are welcome.