dime-python-sdk 1.0.0__py3-none-any.whl

dime_payments/__init__.py

@@ -0,0 +1,29 @@
+from .client import Client
+from .config import Config
+from .exceptions import (
+    ApiException,
+    AuthenticationException,
+    ConnectionException,
+    DimeException,
+    NotFoundException,
+    PermissionDeniedException,
+    RateLimitException,
+    ServerException,
+    ValidationException,
+)
+from .pagination.cursor_page import CursorPage
+
+__all__ = [
+    'Client',
+    'Config',
+    'CursorPage',
+    'DimeException',
+    'ValidationException',
+    'AuthenticationException',
+    'PermissionDeniedException',
+    'NotFoundException',
+    'RateLimitException',
+    'ServerException',
+    'ApiException',
+    'ConnectionException',
+]

dime_payments/client.py

@@ -0,0 +1,30 @@
+from .config import Config
+from .http.transport import Transport
+from .resources.addresses import Addresses
+from .resources.customers import Customers
+from .resources.deposits import Deposits
+from .resources.merchants import Merchants
+from .resources.payment_methods import PaymentMethods
+from .resources.recurring_payments import RecurringPayments
+from .resources.transactions import Transactions
+
+
+class Client:
+    def __init__(self, token: str | Config, base_url: str = Config.DEFAULT_BASE_URL) -> None:
+        if isinstance(token, Config):
+            self._config = token
+        else:
+            self._config = Config(token=token, base_url=base_url)
+
+        transport = Transport(self._config)
+
+        self.transactions = Transactions(transport)
+        self.customers = Customers(transport)
+        self.payment_methods = PaymentMethods(transport)
+        self.merchants = Merchants(transport)
+        self.addresses = Addresses(transport)
+        self.deposits = Deposits(transport)
+        self.recurring_payments = RecurringPayments(transport)
+
+    def config(self) -> Config:
+        return self._config

dime_payments/config.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Callable
+
+if TYPE_CHECKING:
+    import requests
+
+
+class Config:
+    DEFAULT_BASE_URL = 'https://app.dimepayments.com'
+    VERSION = '1.0.0'
+
+    def __init__(
+        self,
+        token: str,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 30.0,
+        max_retries: int = 2,
+        retry_base_delay: float = 0.5,
+        session: 'requests.Session | None' = None,
+        sleep: Callable[[float], None] | None = None,
+    ) -> None:
+        self.token = token
+        self.base_url = base_url
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.retry_base_delay = retry_base_delay
+        self._session = session
+        self._sleep = sleep
+
+    def base_uri(self) -> str:
+        return self.base_url.rstrip('/') + '/api/'

dime_payments/data_objects/__init__.py

@@ -0,0 +1,31 @@
+from .address import Address
+from .customer import Customer
+from .deposit import Deposit
+from .deposit_group import DepositGroup
+from .deposit_with_transactions import DepositWithTransactions
+from .form_link import FormLink
+from .merchant import Merchant
+from .message_result import MessageResult
+from .payment_method import PaymentMethod
+from .recurring_payment import RecurringPayment
+from .recurring_payment_method import RecurringPaymentMethod
+from .tokenize_result import TokenizeResult
+from .transaction import Transaction
+from .transaction_address import TransactionAddress
+
+__all__ = [
+    'Transaction',
+    'TransactionAddress',
+    'Customer',
+    'PaymentMethod',
+    'Merchant',
+    'Address',
+    'Deposit',
+    'DepositGroup',
+    'DepositWithTransactions',
+    'RecurringPayment',
+    'RecurringPaymentMethod',
+    'TokenizeResult',
+    'MessageResult',
+    'FormLink',
+]

dime_payments/data_objects/address.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_int, arr_string
+
+
+@dataclass
+class Address:
+    id: int | None = None
+    recipient: str | None = None
+    line_one: str | None = None
+    line_two: str | None = None
+    line_three: str | None = None
+    city: str | None = None
+    state: str | None = None
+    zip: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'Address':
+        return cls(
+            # API returns address_id on show, id on list items.
+            id=arr_int(data, 'address_id') or arr_int(data, 'id'),
+            recipient=arr_string(data, 'recipient'),
+            line_one=arr_string(data, 'line_one'),
+            line_two=arr_string(data, 'line_two'),
+            line_three=arr_string(data, 'line_three'),
+            city=arr_string(data, 'city'),
+            state=arr_string(data, 'state'),
+            zip=arr_string(data, 'zip'),
+        )

dime_payments/data_objects/customer.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_string
+
+
+@dataclass
+class Customer:
+    uuid: str | None = None
+    first_name: str | None = None
+    last_name: str | None = None
+    phone: str | None = None
+    email: str | None = None
+    addr1: str | None = None
+    addr2: str | None = None
+    addr3: str | None = None
+    city: str | None = None
+    state: str | None = None
+    zip: str | None = None
+    country: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'Customer':
+        return cls(
+            uuid=arr_string(data, 'uuid'),
+            first_name=arr_string(data, 'first_name'),
+            last_name=arr_string(data, 'last_name'),
+            phone=arr_string(data, 'phone'),
+            email=arr_string(data, 'email'),
+            addr1=arr_string(data, 'addr1'),
+            addr2=arr_string(data, 'addr2'),
+            addr3=arr_string(data, 'addr3'),
+            city=arr_string(data, 'city'),
+            state=arr_string(data, 'state'),
+            zip=arr_string(data, 'zip'),
+            country=arr_string(data, 'country'),
+        )

dime_payments/data_objects/deposit.py

@@ -0,0 +1,31 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_string
+
+
+@dataclass
+class Deposit:
+    transaction_date: str | None = None
+    fund_date: str | None = None
+    transaction_info_id: str | None = None
+    transaction_id: str | None = None
+    transaction_detail_account: str | None = None
+    authorization_amount: str | None = None
+    net_amount: str | None = None
+    sweep_id: str | None = None
+    type: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'Deposit':
+        return cls(
+            transaction_date=arr_string(data, 'transaction_date'),
+            fund_date=arr_string(data, 'fund_date'),
+            transaction_info_id=arr_string(data, 'transaction_info_id'),
+            transaction_id=arr_string(data, 'transaction_id'),
+            transaction_detail_account=arr_string(data, 'transaction_detail_account'),
+            authorization_amount=arr_string(data, 'authorization_amount'),
+            net_amount=arr_string(data, 'net_amount'),
+            sweep_id=arr_string(data, 'sweep_id'),
+            type=arr_string(data, 'type'),
+        )

dime_payments/data_objects/deposit_group.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+from ..support.arr import arr_int, arr_string
+from .deposit_with_transactions import DepositWithTransactions
+
+
+@dataclass
+class DepositGroup:
+    sid: str | None = None
+    count: int | None = None
+    deposits: list[DepositWithTransactions] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'DepositGroup':
+        raw_deposits = data.get('deposits', {})
+        if isinstance(raw_deposits, dict):
+            raw_deposits = list(raw_deposits.values())
+        deposits = [DepositWithTransactions.from_dict(d) for d in raw_deposits if isinstance(d, dict)]
+
+        return cls(
+            sid=arr_string(data, 'sid'),
+            count=arr_int(data, 'count'),
+            deposits=deposits,
+        )

dime_payments/data_objects/deposit_with_transactions.py

@@ -0,0 +1,37 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+from ..support.arr import arr_int, arr_object_from, arr_string
+from .transaction import Transaction
+
+
+@dataclass
+class DepositWithTransactions:
+    sid: str | None = None
+    transaction_info_id: str | None = None
+    transaction_id: str | None = None
+    transaction_date: str | None = None
+    fund_date: str | None = None
+    type: str | None = None
+    count_of_transactions: int | None = None
+    trans_total: str | None = None
+    transactions: list[Transaction] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'DepositWithTransactions':
+        raw_txns = data.get('transactions', [])
+        if isinstance(raw_txns, dict):
+            raw_txns = list(raw_txns.values())
+        transactions = [Transaction.from_dict(t) for t in raw_txns if isinstance(t, dict)]
+
+        return cls(
+            sid=arr_string(data, 'sid'),
+            transaction_info_id=arr_string(data, 'transaction_info_id'),
+            transaction_id=arr_string(data, 'transaction_id'),
+            transaction_date=arr_string(data, 'transaction_date'),
+            fund_date=arr_string(data, 'fund_date'),
+            type=arr_string(data, 'type'),
+            count_of_transactions=arr_int(data, 'countOfTransactions'),
+            trans_total=arr_string(data, 'transTotal'),
+            transactions=transactions,
+        )

dime_payments/data_objects/form_link.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_string
+
+
+@dataclass
+class FormLink:
+    link: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'FormLink':
+        return cls(link=arr_string(data, 'link'))

dime_payments/data_objects/merchant.py

@@ -0,0 +1,55 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_bool, arr_string
+
+
+@dataclass
+class Merchant:
+    name: str | None = None
+    sid: str | None = None
+    mcc: str | None = None
+    slug: str | None = None
+    pub_api_key: str | None = None
+    processor_mid: str | None = None
+    active: bool = False
+    active_at: str | None = None
+    g_pay: bool = False
+    a_pay: bool = False
+    pci_compliance: bool = False
+    website: str | None = None
+    addr1: str | None = None
+    addr2: str | None = None
+    city: str | None = None
+    state: str | None = None
+    zip: str | None = None
+    phone: str | None = None
+    primary_phone: str | None = None
+    primary_email: str | None = None
+    primary_name: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'Merchant':
+        return cls(
+            name=arr_string(data, 'name'),
+            sid=arr_string(data, 'sid'),
+            mcc=arr_string(data, 'mcc'),
+            slug=arr_string(data, 'slug'),
+            pub_api_key=arr_string(data, 'pub_api_key'),
+            processor_mid=arr_string(data, 'processor_mid'),
+            active=arr_bool(data, 'active'),
+            active_at=arr_string(data, 'active_at'),
+            g_pay=arr_bool(data, 'g_pay'),
+            a_pay=arr_bool(data, 'a_pay'),
+            pci_compliance=arr_bool(data, 'pci_compliance'),
+            website=arr_string(data, 'website'),
+            addr1=arr_string(data, 'addr1'),
+            addr2=arr_string(data, 'addr2'),
+            city=arr_string(data, 'city'),
+            state=arr_string(data, 'state'),
+            zip=arr_string(data, 'zip'),
+            phone=arr_string(data, 'phone'),
+            primary_phone=arr_string(data, 'primary_phone'),
+            primary_email=arr_string(data, 'primary_email'),
+            primary_name=arr_string(data, 'primary_name'),
+        )

dime_payments/data_objects/message_result.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_string
+
+
+@dataclass
+class MessageResult:
+    message: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'MessageResult':
+        return cls(message=arr_string(data, 'message'))

dime_payments/data_objects/payment_method.py

@@ -0,0 +1,63 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_bool, arr_int, arr_string
+
+
+@dataclass
+class PaymentMethod:
+    id: int | None = None
+    type: str | None = None
+    token: str | None = None
+    first_name: str | None = None
+    last_name: str | None = None
+    cc_name_on_card: str | None = None
+    cc_last_four: str | None = None
+    cc_expiration_date: str | None = None
+    cc_brand: str | None = None
+    ach_bank_account_name: str | None = None
+    ach_routing_number: str | None = None
+    ach_account_number: str | None = None
+    ach_ownership_type: str | None = None
+    ach_account_type: str | None = None
+    ach_bank_name: str | None = None
+    status: str | None = None
+    status_date: str | None = None
+    enabled: bool = False
+    is_default: bool = False
+    addr1: str | None = None
+    addr2: str | None = None
+    addr3: str | None = None
+    city: str | None = None
+    state: str | None = None
+    zip: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'PaymentMethod':
+        return cls(
+            id=arr_int(data, 'id'),
+            type=arr_string(data, 'type'),
+            token=arr_string(data, 'token'),
+            first_name=arr_string(data, 'first_name'),
+            last_name=arr_string(data, 'last_name'),
+            cc_name_on_card=arr_string(data, 'cc_name_on_card'),
+            cc_last_four=arr_string(data, 'cc_last_four'),
+            cc_expiration_date=arr_string(data, 'cc_expiration_date'),
+            cc_brand=arr_string(data, 'cc_brand'),
+            ach_bank_account_name=arr_string(data, 'ach_bank_account_name'),
+            ach_routing_number=arr_string(data, 'ach_routing_number'),
+            ach_account_number=arr_string(data, 'ach_account_number'),
+            ach_ownership_type=arr_string(data, 'ach_ownership_type'),
+            ach_account_type=arr_string(data, 'ach_account_type'),
+            ach_bank_name=arr_string(data, 'ach_bank_name'),
+            status=arr_string(data, 'status'),
+            status_date=arr_string(data, 'status_date'),
+            enabled=arr_bool(data, 'enabled'),
+            is_default=arr_bool(data, 'default'),
+            addr1=arr_string(data, 'addr1'),
+            addr2=arr_string(data, 'addr2'),
+            addr3=arr_string(data, 'addr3'),
+            city=arr_string(data, 'city'),
+            state=arr_string(data, 'state'),
+            zip=arr_string(data, 'zip'),
+        )

dime_payments/data_objects/recurring_payment.py

@@ -0,0 +1,53 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+from ..support.arr import arr_int, arr_object_from, arr_string
+from .recurring_payment_method import RecurringPaymentMethod
+from .transaction_address import TransactionAddress
+
+
+@dataclass
+class RecurringPayment:
+    id: int | None = None
+    name: str | None = None
+    amount: str | None = None
+    start_date: str | None = None
+    end_date: str | None = None
+    recurrence_schedule: str | None = None
+    last_run_date: str | None = None
+    last_run_status: str | None = None
+    last_run_failed_count: int | None = None
+    next_run_date: str | None = None
+    status: str | None = None
+    paused_until_date: str | None = None
+    customer_uuid: str | None = None
+    cancelled_at: str | None = None
+    error: str | None = None
+    payment_method: RecurringPaymentMethod = field(default_factory=RecurringPaymentMethod)
+    shipping_address: TransactionAddress = field(default_factory=TransactionAddress)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'RecurringPayment':
+        return cls(
+            id=arr_int(data, 'id'),
+            name=arr_string(data, 'name'),
+            amount=arr_string(data, 'amount'),
+            start_date=arr_string(data, 'start_date'),
+            end_date=arr_string(data, 'end_date'),
+            recurrence_schedule=arr_string(data, 'recurrence_schedule'),
+            last_run_date=arr_string(data, 'last_run_date'),
+            last_run_status=arr_string(data, 'last_run_status'),
+            last_run_failed_count=arr_int(data, 'last_run_failed_count'),
+            next_run_date=arr_string(data, 'next_run_date'),
+            status=arr_string(data, 'status'),
+            paused_until_date=arr_string(data, 'paused_until_date'),
+            customer_uuid=arr_string(data, 'customer_uuid'),
+            cancelled_at=arr_string(data, 'cancelled_at'),
+            error=arr_string(data, 'error'),
+            payment_method=RecurringPaymentMethod.from_dict(
+                arr_object_from(data, ['payment_method'])
+            ),
+            shipping_address=TransactionAddress.from_dict(
+                arr_object_from(data, ['shipping_address'])
+            ),
+        )

dime_payments/data_objects/recurring_payment_method.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_int, arr_string
+
+
+@dataclass
+class RecurringPaymentMethod:
+    id: int | None = None
+    type: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'RecurringPaymentMethod':
+        return cls(
+            id=arr_int(data, 'id'),
+            type=arr_string(data, 'type'),
+        )

dime_payments/data_objects/tokenize_result.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_string
+
+
+@dataclass
+class TokenizeResult:
+    token: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'TokenizeResult':
+        return cls(token=arr_string(data, 'token'))

dime_payments/data_objects/transaction.py

@@ -0,0 +1,57 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+from ..support.arr import arr_bool, arr_object_from, arr_string
+from .transaction_address import TransactionAddress
+
+
+@dataclass
+class Transaction:
+    transaction_type: str | None = None
+    transaction_status: str | None = None
+    transaction_status_description: str | None = None
+    transaction_number: str | None = None
+    transaction_date: str | None = None
+    fund_date: str | None = None
+    settle_date: str | None = None
+    amount: str | None = None
+    description: str | None = None
+    status_code: str | None = None
+    status_text: str | None = None
+    email: str | None = None
+    phone: str | None = None
+    customer_uuid: str | None = None
+    multi_use_token: str | None = None
+    pending: bool = False
+    transaction_info_id: str | None = None
+    parent_transaction_info_id: str | None = None
+    billing_address: TransactionAddress = field(default_factory=TransactionAddress)
+    shipping_address: TransactionAddress = field(default_factory=TransactionAddress)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'Transaction':
+        return cls(
+            transaction_type=arr_string(data, 'transaction_type'),
+            transaction_status=arr_string(data, 'transaction_status'),
+            transaction_status_description=arr_string(data, 'transaction_status_description'),
+            transaction_number=arr_string(data, 'transaction_number'),
+            transaction_date=arr_string(data, 'transaction_date'),
+            fund_date=arr_string(data, 'fund_date'),
+            settle_date=arr_string(data, 'settle_date'),
+            amount=arr_string(data, 'amount'),
+            description=arr_string(data, 'description'),
+            status_code=arr_string(data, 'status_code'),
+            status_text=arr_string(data, 'status_text'),
+            email=arr_string(data, 'email'),
+            phone=arr_string(data, 'phone'),
+            customer_uuid=arr_string(data, 'customer_uuid'),
+            multi_use_token=arr_string(data, 'multi_use_token'),
+            pending=arr_bool(data, 'pending'),
+            transaction_info_id=arr_string(data, 'transaction_info_id'),
+            parent_transaction_info_id=arr_string(data, 'parent_transaction_info_id'),
+            billing_address=TransactionAddress.from_dict(arr_object_from(data, ['billing_address'])),
+            # API sometimes returns shipping under camelCase key; accept both.
+            shipping_address=TransactionAddress.from_dict(
+                arr_object_from(data, ['shippingAddress', 'shipping_address'])
+            ),
+        )

dime_payments/data_objects/transaction_address.py

@@ -0,0 +1,27 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_string
+
+
+@dataclass
+class TransactionAddress:
+    first_name: str | None = None
+    last_name: str | None = None
+    addr1: str | None = None
+    addr2: str | None = None
+    city: str | None = None
+    state: str | None = None
+    zip: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'TransactionAddress':
+        return cls(
+            first_name=arr_string(data, 'first_name'),
+            last_name=arr_string(data, 'last_name'),
+            addr1=arr_string(data, 'addr1'),
+            addr2=arr_string(data, 'addr2'),
+            city=arr_string(data, 'city'),
+            state=arr_string(data, 'state'),
+            zip=arr_string(data, 'zip'),
+        )

dime_payments/exceptions/__init__.py

@@ -0,0 +1,21 @@
+from .api_exception import ApiException
+from .authentication_exception import AuthenticationException
+from .connection_exception import ConnectionException
+from .dime_exception import DimeException
+from .not_found_exception import NotFoundException
+from .permission_denied_exception import PermissionDeniedException
+from .rate_limit_exception import RateLimitException
+from .server_exception import ServerException
+from .validation_exception import ValidationException
+
+__all__ = [
+    'DimeException',
+    'ValidationException',
+    'AuthenticationException',
+    'PermissionDeniedException',
+    'NotFoundException',
+    'RateLimitException',
+    'ServerException',
+    'ApiException',
+    'ConnectionException',
+]

dime_payments/exceptions/api_exception.py

@@ -0,0 +1,5 @@
+from .dime_exception import DimeException
+
+
+class ApiException(DimeException):
+    pass

dime_payments/exceptions/authentication_exception.py

@@ -0,0 +1,5 @@
+from .dime_exception import DimeException
+
+
+class AuthenticationException(DimeException):
+    pass

dime_payments/exceptions/connection_exception.py

@@ -0,0 +1,5 @@
+from .dime_exception import DimeException
+
+
+class ConnectionException(DimeException):
+    pass

dime_payments/exceptions/dime_exception.py

@@ -0,0 +1,19 @@
+from typing import Any
+
+
+class DimeException(Exception):
+    def __init__(
+        self,
+        message: str,
+        status_code: int | None = None,
+        response_body: dict[str, Any] | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.response_body: dict[str, Any] = response_body or {}
+
+    def get_status_code(self) -> int | None:
+        return self.status_code
+
+    def get_response_body(self) -> dict[str, Any]:
+        return self.response_body