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

dime_payments/client.py

@@ -3,8 +3,10 @@ from .http.transport import Transport
 from .resources.addresses import Addresses
 from .resources.customers import Customers
 from .resources.deposits import Deposits
+from .resources.invoices import Invoices
 from .resources.merchants import Merchants
 from .resources.payment_methods import PaymentMethods
+from .resources.recurring_invoices import RecurringInvoices
 from .resources.recurring_payments import RecurringPayments
 from .resources.transactions import Transactions
 
@@ -25,6 +27,8 @@ class Client:
         self.addresses = Addresses(transport)
         self.deposits = Deposits(transport)
         self.recurring_payments = RecurringPayments(transport)
+        self.invoices = Invoices(transport)
+        self.recurring_invoices = RecurringInvoices(transport)
 
     def config(self) -> Config:
         return self._config

dime_payments/config.py

@@ -8,7 +8,7 @@ if TYPE_CHECKING:
 
 class Config:
     DEFAULT_BASE_URL = 'https://app.dimepayments.com'
-    VERSION = '1.0.0'
+    VERSION = '1.3.0'
 
     def __init__(
         self,

dime_payments/data_objects/__init__.py

@@ -4,9 +4,17 @@ from .deposit import Deposit
 from .deposit_group import DepositGroup
 from .deposit_with_transactions import DepositWithTransactions
 from .form_link import FormLink
+from .invoice import Invoice
+from .invoice_customer import InvoiceCustomer
+from .invoice_event import InvoiceEvent
+from .invoice_item import InvoiceItem
+from .invoice_link import InvoiceLink
+from .invoice_payment import InvoicePayment
+from .line_item import LineItem
 from .merchant import Merchant
 from .message_result import MessageResult
 from .payment_method import PaymentMethod
+from .recurring_invoice import RecurringInvoice, RecurringInvoiceRun
 from .recurring_payment import RecurringPayment
 from .recurring_payment_method import RecurringPaymentMethod
 from .tokenize_result import TokenizeResult
@@ -28,4 +36,13 @@ __all__ = [
     'TokenizeResult',
     'MessageResult',
     'FormLink',
+    'Invoice',
+    'InvoiceCustomer',
+    'InvoiceEvent',
+    'InvoiceItem',
+    'InvoiceLink',
+    'InvoicePayment',
+    'LineItem',
+    'RecurringInvoice',
+    'RecurringInvoiceRun',
 ]

dime_payments/data_objects/cover_fee_quote.py

@@ -0,0 +1,48 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_object, arr_string
+
+
+@dataclass
+class CoverFeeQuote:
+    """
+    The processing fee a cover-fee invoice adds on top of what the customer pays,
+    quoted for both payment methods.
+
+    Present on an :class:`Invoice` only when ``cover_fee_required`` is true. The fee
+    is NOT a line item and is NOT part of the invoice's ``total``: the merchant is
+    owed ``total``, and the customer is charged ``total`` plus this fee. Card and
+    ACH rates differ, so the amount depends on how the customer chooses to pay —
+    ``cc_total`` is the higher of the two and what the invoice and its emails lead
+    with.
+
+    ``basis`` names what the quote was computed against — currently always
+    ``balance``, the amount still outstanding. Paying a partial amount re-quotes the
+    fee against that amount, so treat these as a quote for settling in full today
+    rather than a fixed charge.
+
+    Money is kept as strings, consistent with the rest of the SDK, to avoid float
+    rounding.
+    """
+
+    basis: str | None = None
+    base: str | None = None
+    cc_fee: str | None = None
+    cc_total: str | None = None
+    ach_fee: str | None = None
+    ach_total: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'CoverFeeQuote':
+        cc = arr_object(data, 'cc')
+        ach = arr_object(data, 'ach')
+
+        return cls(
+            basis=arr_string(data, 'basis'),
+            base=arr_string(data, 'base'),
+            cc_fee=arr_string(cc, 'fee'),
+            cc_total=arr_string(cc, 'total'),
+            ach_fee=arr_string(ach, 'fee'),
+            ach_total=arr_string(ach, 'total'),
+        )

dime_payments/data_objects/invoice.py

@@ -0,0 +1,75 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+from ..support.arr import arr_array, arr_bool, arr_int, arr_object, arr_string
+from .cover_fee_quote import CoverFeeQuote
+from .invoice_customer import InvoiceCustomer
+from .invoice_event import InvoiceEvent
+from .invoice_payment import InvoicePayment
+from .line_item import LineItem
+
+
+@dataclass
+class Invoice:
+    """
+    A full invoice as returned by the show, create, update and action endpoints.
+
+    Money fields arrive as dollar amounts and are kept as strings, consistent
+    with the rest of the SDK, to avoid float rounding.
+
+    When ``cover_fee_required`` is set the customer must also pay the processing
+    fee, which is reported on :attr:`cover_fee_quote` rather than included in
+    ``total`` — so what settles is more than what the invoice says.
+    """
+
+    id: int | None = None
+    token: str | None = None
+    invoice_number: str | None = None
+    status: str | None = None
+    payment_terms: str | None = None
+    issue_date: str | None = None
+    due_date: str | None = None
+    is_overdue: bool = False
+    subtotal: str | None = None
+    total: str | None = None
+    amount_paid: str | None = None
+    balance: str | None = None
+    allow_partial_payment: bool = False
+    cover_fee_required: bool = False
+    cover_fee_quote: CoverFeeQuote | None = None
+    thank_you_note: str | None = None
+    public_url: str | None = None
+    customer: InvoiceCustomer = field(default_factory=InvoiceCustomer)
+    items: list[LineItem] = field(default_factory=list)
+    payments: list[InvoicePayment] = field(default_factory=list)
+    events: list[InvoiceEvent] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'Invoice':
+        return cls(
+            id=arr_int(data, 'id'),
+            token=arr_string(data, 'token'),
+            invoice_number=arr_string(data, 'invoice_number'),
+            status=arr_string(data, 'status'),
+            payment_terms=arr_string(data, 'payment_terms'),
+            issue_date=arr_string(data, 'issue_date'),
+            due_date=arr_string(data, 'due_date'),
+            is_overdue=arr_bool(data, 'is_overdue'),
+            subtotal=arr_string(data, 'subtotal'),
+            total=arr_string(data, 'total'),
+            amount_paid=arr_string(data, 'amount_paid'),
+            balance=arr_string(data, 'balance'),
+            allow_partial_payment=arr_bool(data, 'allow_partial_payment'),
+            cover_fee_required=arr_bool(data, 'cover_fee_required'),
+            cover_fee_quote=(
+                CoverFeeQuote.from_dict(data['cover_fee_quote'])
+                if isinstance(data.get('cover_fee_quote'), dict)
+                else None
+            ),
+            thank_you_note=arr_string(data, 'thank_you_note'),
+            public_url=arr_string(data, 'public_url'),
+            customer=InvoiceCustomer.from_dict(arr_object(data, 'customer')),
+            items=[LineItem.from_dict(i) for i in arr_array(data, 'items') if isinstance(i, dict)],
+            payments=[InvoicePayment.from_dict(p) for p in arr_array(data, 'payments') if isinstance(p, dict)],
+            events=[InvoiceEvent.from_dict(e) for e in arr_array(data, 'events') if isinstance(e, dict)],
+        )

dime_payments/data_objects/invoice_customer.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_int, arr_string
+
+
+@dataclass
+class InvoiceCustomer:
+    """The customer snapshot embedded in an invoice response."""
+
+    id: int | None = None
+    name: str | None = None
+    email: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'InvoiceCustomer':
+        return cls(
+            id=arr_int(data, 'id'),
+            name=arr_string(data, 'name'),
+            email=arr_string(data, 'email'),
+        )

dime_payments/data_objects/invoice_event.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_string
+
+
+@dataclass
+class InvoiceEvent:
+    """An entry in an invoice's history (created, sent, paid, voided, ...)."""
+
+    type: str | None = None
+    label: str | None = None
+    description: str | None = None
+    created_at: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'InvoiceEvent':
+        return cls(
+            type=arr_string(data, 'type'),
+            label=arr_string(data, 'label'),
+            description=arr_string(data, 'description'),
+            created_at=arr_string(data, 'created_at'),
+        )

dime_payments/data_objects/invoice_item.py

@@ -0,0 +1,29 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_bool, arr_int, arr_string
+
+
+@dataclass
+class InvoiceItem:
+    """
+    A Merchant item (fund or designation) that invoice line items reference by
+    ``item_id``. This is the catalog entry, not a line on an invoice — for that,
+    see :class:`LineItem`.
+    """
+
+    id: int | None = None
+    name: str | None = None
+    description: str | None = None
+    price: str | None = None
+    tax_deductible: bool = False
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'InvoiceItem':
+        return cls(
+            id=arr_int(data, 'id'),
+            name=arr_string(data, 'name'),
+            description=arr_string(data, 'description'),
+            price=arr_string(data, 'price'),
+            tax_deductible=arr_bool(data, 'tax_deductible'),
+        )

dime_payments/data_objects/invoice_link.py

@@ -0,0 +1,19 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_string
+
+
+@dataclass
+class InvoiceLink:
+    """The public payment link for an invoice."""
+
+    public_url: str | None = None
+    token: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'InvoiceLink':
+        return cls(
+            public_url=arr_string(data, 'public_url'),
+            token=arr_string(data, 'token'),
+        )

dime_payments/data_objects/invoice_payment.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_int, arr_string
+
+
+@dataclass
+class InvoicePayment:
+    """
+    A payment recorded against an invoice.
+
+    ``amount`` is what was credited to the invoice; ``cover_fee`` is the processing
+    fee charged on top of it, so ``amount + cover_fee`` is what the customer
+    actually paid. It is zero unless the invoice required the customer to cover
+    fees.
+    """
+
+    amount: str | None = None
+    cover_fee: str | None = None
+    paid_at: str | None = None
+    method: str | None = None
+    transaction_id: int | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'InvoicePayment':
+        return cls(
+            amount=arr_string(data, 'amount'),
+            cover_fee=arr_string(data, 'cover_fee'),
+            paid_at=arr_string(data, 'paid_at'),
+            method=arr_string(data, 'method'),
+            transaction_id=arr_int(data, 'transaction_id'),
+        )

dime_payments/data_objects/line_item.py

@@ -0,0 +1,33 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_int, arr_string
+
+
+@dataclass
+class LineItem:
+    """
+    A single line on an invoice. ``item_id`` points at the Merchant item the line
+    was sourced from; ``name`` and ``unit_price`` are snapshotted at creation so
+    later edits to the item do not rewrite history.
+    """
+
+    id: int | None = None
+    item_id: int | None = None
+    name: str | None = None
+    description: str | None = None
+    quantity: str | None = None
+    unit_price: str | None = None
+    amount: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'LineItem':
+        return cls(
+            id=arr_int(data, 'id'),
+            item_id=arr_int(data, 'item_id'),
+            name=arr_string(data, 'name'),
+            description=arr_string(data, 'description'),
+            quantity=arr_string(data, 'quantity'),
+            unit_price=arr_string(data, 'unit_price'),
+            amount=arr_string(data, 'amount'),
+        )

dime_payments/data_objects/recurring_invoice.py

@@ -0,0 +1,70 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+from ..support.arr import arr_array, arr_bool, arr_int, arr_object, arr_string
+from .invoice_customer import InvoiceCustomer
+from .line_item import LineItem
+
+
+@dataclass
+class RecurringInvoiceRun:
+    """A summary of one invoice already emitted by a recurring template."""
+
+    id: int | None = None
+    invoice_number: str | None = None
+    status: str | None = None
+    total: str | None = None
+    issue_date: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'RecurringInvoiceRun':
+        return cls(
+            id=arr_int(data, 'id'),
+            invoice_number=arr_string(data, 'invoice_number'),
+            status=arr_string(data, 'status'),
+            total=arr_string(data, 'total'),
+            issue_date=arr_string(data, 'issue_date'),
+        )
+
+
+@dataclass
+class RecurringInvoice:
+    """
+    A recurring-invoice template. ``recurrence_schedule`` is one of Weekly,
+    Biweekly, FirstFifteenth, Monthly or Yearly.
+    """
+
+    id: int | None = None
+    status: str | None = None
+    recurrence_schedule: str | None = None
+    payment_terms: str | None = None
+    # Copied onto every invoice this template generates.
+    cover_fee_required: bool = False
+    start_date: str | None = None
+    end_date: str | None = None
+    next_run_date: str | None = None
+    last_run_date: str | None = None
+    thank_you_note: str | None = None
+    customer: InvoiceCustomer = field(default_factory=InvoiceCustomer)
+    items: list[LineItem] = field(default_factory=list)
+    upcoming_run_dates: list[str] = field(default_factory=list)
+    invoices: list[RecurringInvoiceRun] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'RecurringInvoice':
+        return cls(
+            id=arr_int(data, 'id'),
+            status=arr_string(data, 'status'),
+            recurrence_schedule=arr_string(data, 'recurrence_schedule'),
+            payment_terms=arr_string(data, 'payment_terms'),
+            cover_fee_required=arr_bool(data, 'cover_fee_required'),
+            start_date=arr_string(data, 'start_date'),
+            end_date=arr_string(data, 'end_date'),
+            next_run_date=arr_string(data, 'next_run_date'),
+            last_run_date=arr_string(data, 'last_run_date'),
+            thank_you_note=arr_string(data, 'thank_you_note'),
+            customer=InvoiceCustomer.from_dict(arr_object(data, 'customer')),
+            items=[LineItem.from_dict(i) for i in arr_array(data, 'items') if isinstance(i, dict)],
+            upcoming_run_dates=[str(d) for d in arr_array(data, 'upcoming_run_dates')],
+            invoices=[RecurringInvoiceRun.from_dict(i) for i in arr_array(data, 'invoices') if isinstance(i, dict)],
+        )

dime_payments/http/transport.py

@@ -11,7 +11,7 @@ from .error_handler import ErrorHandler
 if TYPE_CHECKING:
     from ..config import Config
 
-SDK_VERSION = '1.0.0'
+SDK_VERSION = '1.3.0'
 
 
 class Transport:

dime_payments/resources/invoices.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ..data_objects.invoice import Invoice
+from ..data_objects.invoice_item import InvoiceItem
+from ..data_objects.invoice_link import InvoiceLink
+from ..data_objects.message_result import MessageResult
+from ..pagination.cursor_page import CursorPage
+from .abstract_resource import AbstractResource
+
+
+class Invoices(AbstractResource):
+    """
+    Invoice endpoints.
+
+    Every method takes the merchant ``sid`` explicitly; remaining fields go in an
+    ``attributes`` dict. Identify the customer with ``customer_uuid`` — the same
+    identifier the customer, payment-method and address endpoints use, and the
+    only one :class:`Customer` exposes. ``customer_id`` is still accepted for
+    integrations written against the original contract; supply exactly one.
+
+    Line-item and invoice mutations return the refreshed invoice, so the caller
+    always sees recalculated totals rather than a detached fragment.
+    """
+
+    def list(self, sid: str, filters: dict[str, Any] | None = None) -> CursorPage[Invoice]:
+        body = self._envelope({'sid': sid}, filters or {})
+        return self._paginate('GET', 'invoices', body, Invoice.from_dict)
+
+    def show(self, sid: str, invoice_id: int | str) -> Invoice:
+        body = self._envelope({'sid': sid, 'invoice_id': invoice_id})
+        raw = self._transport.request('GET', 'invoice', body)
+        return Invoice.from_dict(raw.get('data') or {})
+
+    def create(self, sid: str, attributes: dict[str, Any]) -> Invoice:
+        """
+        Create a draft invoice. Requires ``customer_uuid`` (or ``customer_id``),
+        ``customer_name``, ``customer_email``, ``payment_terms``
+        (``due_on_receipt`` | ``net_15`` | ``net_30`` | ``net_60``) and at least
+        one entry in ``lines``, each referencing a Merchant ``item_id``.
+
+        Pass ``cover_fee_required`` to make the customer pay the processing fee. The
+        fee is added on top of the invoice at payment time rather than becoming a
+        line item, so ``total`` stays the amount owed to the merchant — read
+        :attr:`Invoice.cover_fee_quote` for what the customer will actually be
+        charged. Omit it to inherit the Merchant's invoice setting.
+        """
+        body = self._envelope({'sid': sid} | attributes)
+        raw = self._transport.request('POST', 'invoice/create', body)
+        return Invoice.from_dict(raw.get('data') or {})
+
+    def update(self, sid: str, invoice_id: int | str, attributes: dict[str, Any]) -> Invoice:
+        """Update a draft invoice. Passing ``lines`` replaces the existing lines."""
+        body = self._envelope({'sid': sid, 'invoice_id': invoice_id} | attributes)
+        raw = self._transport.request('PATCH', 'invoice/update', body)
+        return Invoice.from_dict(raw.get('data') or {})
+
+    def delete(self, sid: str, invoice_id: int | str) -> MessageResult:
+        body = self._envelope({'sid': sid, 'invoice_id': invoice_id})
+        raw = self._transport.request('POST', 'invoice/delete', body)
+        return MessageResult.from_dict(raw.get('data') or raw)
+
+    def send(self, sid: str, invoice_id: int | str) -> Invoice:
+        """Email the invoice and advance it to Sent."""
+        body = self._envelope({'sid': sid, 'invoice_id': invoice_id})
+        raw = self._transport.request('POST', 'invoice/send', body)
+        return Invoice.from_dict(raw.get('data') or {})
+
+    def mark_sent(self, sid: str, invoice_id: int | str) -> Invoice:
+        """Activate a draft for payment without emailing it."""
+        body = self._envelope({'sid': sid, 'invoice_id': invoice_id})
+        raw = self._transport.request('POST', 'invoice/mark-sent', body)
+        return Invoice.from_dict(raw.get('data') or {})
+
+    def void(self, sid: str, invoice_id: int | str) -> Invoice:
+        body = self._envelope({'sid': sid, 'invoice_id': invoice_id})
+        raw = self._transport.request('PATCH', 'invoice/void', body)
+        return Invoice.from_dict(raw.get('data') or {})
+
+    def duplicate(self, sid: str, invoice_id: int | str) -> Invoice:
+        body = self._envelope({'sid': sid, 'invoice_id': invoice_id})
+        raw = self._transport.request('POST', 'invoice/duplicate', body)
+        return Invoice.from_dict(raw.get('data') or {})
+
+    def pay(self, sid: str, invoice_id: int | str, attributes: dict[str, Any]) -> Invoice:
+        """
+        Record a merchant-initiated (MOTO) payment against an open invoice.
+
+        ``payment_type`` is required and is either ``cc`` or ``ach``. For a card,
+        pass a stored ``token`` or raw ``cardholder_name`` / ``card_number`` /
+        ``expiration_date``; for ACH, pass ``routing_number`` /
+        ``account_number`` / ``account_type`` / ``account_name``. Omit ``amount``
+        to pay the full balance.
+
+        On a cover-fee invoice the processing fee for ``payment_type`` is charged on
+        top of ``amount``, so the card or bank account is debited more than the
+        invoice is credited. The fee lands as ``cover_fee`` on the matching entry in
+        :attr:`Invoice.payments`. Card and ACH rates differ, so the same ``amount``
+        settles differently per ``payment_type``.
+        """
+        body = self._envelope({'sid': sid, 'invoice_id': invoice_id} | attributes)
+        raw = self._transport.request('POST', 'invoice/pay', body)
+        return Invoice.from_dict(raw.get('data') or {})
+
+    def get_link(self, sid: str, invoice_id: int | str) -> InvoiceLink:
+        body = self._envelope({'sid': sid, 'invoice_id': invoice_id})
+        raw = self._transport.request('GET', 'invoice/link', body)
+        return InvoiceLink.from_dict(raw.get('data') or {})
+
+    def list_items(self, sid: str) -> list[InvoiceItem]:
+        """
+        List the Merchant's items (funds/designations) that line items can
+        reference. Scoped to the merchant, not to a single invoice — an
+        invoice's own lines are on :attr:`Invoice.items`.
+        """
+        body = self._envelope({'sid': sid})
+        raw = self._transport.request('GET', 'invoice/items', body)
+        items = raw.get('data', [])
+        if isinstance(items, dict):
+            items = list(items.values())
+        return [InvoiceItem.from_dict(item) for item in items if isinstance(item, dict)]
+
+    def create_item(self, sid: str, attributes: dict[str, Any]) -> InvoiceItem:
+        """
+        Create an invoicing-only Merchant item. ``name`` is required;
+        ``description``, ``price`` and ``tax_deductible`` are optional.
+        """
+        body = self._envelope({'sid': sid} | attributes)
+        raw = self._transport.request('POST', 'invoice/item/create', body)
+        return InvoiceItem.from_dict(raw.get('data') or {})
+
+    def add_line_item(self, sid: str, invoice_id: int | str, attributes: dict[str, Any]) -> Invoice:
+        body = self._envelope({'sid': sid, 'invoice_id': invoice_id} | attributes)
+        raw = self._transport.request('POST', 'invoice/line-item/add', body)
+        return Invoice.from_dict(raw.get('data') or {})
+
+    def update_line_item(
+        self,
+        sid: str,
+        invoice_id: int | str,
+        line_item_id: int | str,
+        attributes: dict[str, Any],
+    ) -> Invoice:
+        body = self._envelope(
+            {'sid': sid, 'invoice_id': invoice_id, 'line_item_id': line_item_id} | attributes
+        )
+        raw = self._transport.request('PATCH', 'invoice/line-item/update', body)
+        return Invoice.from_dict(raw.get('data') or {})
+
+    def delete_line_item(self, sid: str, invoice_id: int | str, line_item_id: int | str) -> Invoice:
+        body = self._envelope(
+            {'sid': sid, 'invoice_id': invoice_id, 'line_item_id': line_item_id}
+        )
+        raw = self._transport.request('POST', 'invoice/line-item/delete', body)
+        return Invoice.from_dict(raw.get('data') or {})

dime_payments/resources/recurring_invoices.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ..data_objects.recurring_invoice import RecurringInvoice
+from ..pagination.cursor_page import CursorPage
+from .abstract_resource import AbstractResource
+
+
+class RecurringInvoices(AbstractResource):
+    def list(self, sid: str, filters: dict[str, Any] | None = None) -> CursorPage[RecurringInvoice]:
+        body = self._envelope({'sid': sid}, filters or {})
+        return self._paginate('GET', 'recurring-invoices', body, RecurringInvoice.from_dict)
+
+    def show(self, sid: str, recurring_invoice_id: int | str) -> RecurringInvoice:
+        body = self._envelope({'sid': sid, 'recurring_invoice_id': recurring_invoice_id})
+        raw = self._transport.request('GET', 'recurring-invoice', body)
+        return RecurringInvoice.from_dict(raw.get('data') or {})
+
+    def create(self, sid: str, attributes: dict[str, Any]) -> RecurringInvoice:
+        """
+        Create a recurring-invoice template. When ``recurring_start_date`` is today
+        the first invoice is generated and sent immediately.
+
+        ``cover_fee_required`` makes the customer cover the processing fee on every
+        invoice this template generates.
+        """
+        body = self._envelope({'sid': sid} | attributes)
+        raw = self._transport.request('POST', 'recurring-invoice/create', body)
+        return RecurringInvoice.from_dict(raw.get('data') or {})
+
+    def cancel(self, sid: str, recurring_invoice_id: int | str) -> RecurringInvoice:
+        body = self._envelope({'sid': sid, 'recurring_invoice_id': recurring_invoice_id})
+        raw = self._transport.request('POST', 'recurring-invoice/cancel', body)
+        return RecurringInvoice.from_dict(raw.get('data') or {})

{dime_python_sdk-1.0.0.dist-info → dime_python_sdk-1.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dime-python-sdk
-Version: 1.0.0
+Version: 1.3.0
 Summary: Python client for the Dime Payments API
 Author: Dime Technology
 License: MIT License
@@ -118,6 +118,8 @@ returned as strings to avoid float rounding.
 | `dime.addresses`                | list, show, create, update, delete                                    |
 | `dime.deposits`                 | list, list_with_transactions, show                                    |
 | `dime.recurring_payments`       | list, show, create, edit, pause, cancel, activate, delete             |
+| `dime.invoices`                 | list, show, create, update, delete, send, mark_sent, void, duplicate, pay, get_link, list_items, add_line_item, update_line_item, delete_line_item, create_item |
+| `dime.recurring_invoices`       | list, show, create, cancel                                            |
 
 ### Transactions
 
@@ -208,6 +210,127 @@ dime.recurring_payments.activate('000010', rp.id)
 dime.recurring_payments.cancel('000010', rp.id)
 ```
 
+### Invoices
+
+Invoices are scoped to a merchant `sid` and built from line items that each reference a merchant
+item (a fund or designation). Draft invoices can be edited; once sent they are locked.
+
+Identify the customer with `customer_uuid` — the same uuid every other resource uses, and the only
+identifier the customer endpoints return. `customer_id` is still accepted for older integrations.
+
+```python
+# Look up (or create) the merchant items a line can reference
+items = dime.invoices.list_items('000010')
+item = dime.invoices.create_item('000010', {
+    'name': 'Consulting',
+    'description': 'Professional services',
+    'price': 125,
+    'tax_deductible': False,
+})
+
+# Create a draft invoice with one or more line items
+invoice = dime.invoices.create('000010', {
+    'customer_uuid': customer.uuid,
+    'customer_name': 'Jane Doe',
+    'customer_email': 'jane@example.com',
+    'payment_terms': 'net_15',  # due_on_receipt | net_15 | net_30 | net_60
+    'lines': [
+        {'item_id': item.id, 'name': 'Consulting', 'description': '2 hours',
+         'quantity': 2, 'unit_price': 125},
+    ],
+})
+
+# Line-item edits return the refreshed invoice, with totals recalculated
+invoice = dime.invoices.add_line_item('000010', invoice.id, {
+    'item_id': item.id, 'name': 'Setup', 'quantity': 1, 'unit_price': 50,
+})
+invoice = dime.invoices.update_line_item('000010', invoice.id, invoice.items[0].id, {'quantity': 3})
+invoice = dime.invoices.delete_line_item('000010', invoice.id, invoice.items[0].id)
+
+# Email it to the customer, or activate the pay link without emailing
+dime.invoices.send('000010', invoice.id)
+dime.invoices.mark_sent('000010', invoice.id)
+
+# Share the public pay link
+link = dime.invoices.get_link('000010', invoice.id)
+print(link.public_url)
+
+# Take a merchant-initiated payment. payment_type is required; omit amount to
+# pay the full balance.
+dime.invoices.pay('000010', invoice.id, {
+    'payment_type': 'cc',  # cc | ach
+    'token': pm.token,
+    'amount': 125,
+})
+
+dime.invoices.void('000010', invoice.id)
+dime.invoices.duplicate('000010', invoice.id)
+```
+
+#### Making the customer cover processing fees
+
+Set `cover_fee_required` and the customer must pay the processing fee — it is not an optional
+checkbox at checkout. The fee is **not** a line item and is **not** part of `total`: the merchant is
+still owed `total`, and the fee is added on top of whatever the customer pays.
+
+Card and ACH rates differ, so the charge depends on how the customer pays. `cover_fee_quote` gives
+you both, quoted against the outstanding balance:
+
+```python
+invoice = dime.invoices.create('000010', {
+    'customer_uuid': customer.uuid,
+    'customer_name': 'Jane Doe',
+    'customer_email': 'jane@example.com',
+    'payment_terms': 'net_15',
+    'cover_fee_required': True,  # omit to inherit the merchant's invoice setting
+    'lines': [
+        {'item_id': item.id, 'name': 'Consulting', 'quantity': 1, 'unit_price': 100},
+    ],
+})
+
+invoice.total                      # '100.00' — what the merchant is owed
+invoice.cover_fee_quote.cc_total   # '104.32' — charged if they pay by card
+invoice.cover_fee_quote.ach_total  # '101.26' — charged if they pay by bank
+```
+
+The card figure is the higher of the two and is what the invoice and its emails lead with. A partial
+payment re-quotes the fee against the partial amount, so treat the quote as "settling in full today"
+rather than a fixed charge. `cover_fee_quote` is `None` when no fee is required.
+
+To reconcile a payment, `amount` was credited to the invoice and `cover_fee` was charged on top:
+
+```python
+payment = invoice.payments[0]
+payment.amount     # '100.00' — applied to the balance
+payment.cover_fee  # '4.32'   — the fee the customer also paid
+# The customer was charged amount + cover_fee.
+```
+
+`pay()` behaves the same way: the fee for the `payment_type` you pass is added to `amount`, so the
+card or bank account is debited more than the invoice is credited.
+
+### Recurring invoices
+
+Templates that emit an invoice on a schedule. `cover_fee_required` is copied onto every invoice a
+template generates.
+
+```python
+ri = dime.recurring_invoices.create('000010', {
+    'customer_uuid': customer.uuid,
+    'payment_terms': 'net_30',
+    'recurring_frequency': 'Monthly',  # Weekly | Biweekly | FirstFifteenth | Monthly | Yearly
+    'recurring_start_date': '2026-09-01',
+    'cover_fee_required': True,  # optional
+    'lines': [
+        {'item_id': item.id, 'name': 'Retainer', 'quantity': 1, 'unit_price': 500},
+    ],
+})
+
+print(ri.next_run_date, ri.upcoming_run_dates)
+
+dime.recurring_invoices.cancel('000010', ri.id)
+```
+
 ## Pagination
 
 List endpoints return a `CursorPage`. Iterate one page, walk pages manually, or stream every
@@ -271,7 +394,9 @@ except DimeException as e:
 ## Notes
 
 - **GET requests carry a JSON body.** The Dime API expects read parameters in the request body
-  even for `GET` endpoints; the SDK handles this transparently.
+  even for `GET` endpoints; the SDK handles this transparently. Point `base_url` at an `https://`
+  origin — an `http://` URL that 301-redirects to `https` will have its request body dropped by the
+  redirect, which surfaces as a `403` "You do not have access to this company." from the API.
 - **No API versioning.** Endpoints live under `/api` with no version prefix.
 
 ## Development

{dime_python_sdk-1.0.0.dist-info → dime_python_sdk-1.3.0.dist-info}/RECORD

@@ -1,16 +1,25 @@
 dime_payments/__init__.py,sha256=nJGtKtehbZMxar3wgdk8RIG_nNPSb6G9rmMyC2PnjqM,638
-dime_payments/client.py,sha256=K4riOAzgJJvZUfICZxuh34fD0q5oUDeqRExNH51xhRA,1120
-dime_payments/config.py,sha256=io97prwhlASHBRl0nm_YwckMuJxXFP2ylpsfbT7Bys8,847
-dime_payments/data_objects/__init__.py,sha256=1t2xoZ5rX7RoAO9r-rAsTHoyHBNsK8_sEzHQ_8o1pWY,888
+dime_payments/client.py,sha256=dX_mH2q_hBZrC2s8B3Y3EYy3AWAvUYgTDNf1M0i9aFM,1328
+dime_payments/config.py,sha256=IEINY3s56MAaIDhVO5Cajx4D_lmUoR5SG8BLO3IOpM4,847
+dime_payments/data_objects/__init__.py,sha256=fuavK4aZ-IFM_PyMpJ8fIZlip7-V5m5LOHTCr2XnZng,1409
 dime_payments/data_objects/address.py,sha256=ocnxRM3JDLr4mDtlnVgsnUb6Hy5u6vNQlWVRFHzuMIw,950
+dime_payments/data_objects/cover_fee_quote.py,sha256=KuS1GMVe-Stixate6crTswvvhnq8e9Jfq3v4C2pRYr0,1717
 dime_payments/data_objects/customer.py,sha256=fSUPB9PynX_R3Jntnjr130ExeZtgrmRZSVfds54rmV0,1141
 dime_payments/data_objects/deposit.py,sha256=b0rQdNgdprMtP0pdMrepsWG3jBt7fJ4FGZ1EuHTRQhA,1139
 dime_payments/data_objects/deposit_group.py,sha256=kmfwnDO0YgmvmlSvIakb4cMFYOMfYDDnXMR4eiabSKA,813
 dime_payments/data_objects/deposit_with_transactions.py,sha256=HjmWB5v2R67z5xgqoZt1rlV5nxvixrTmySS-zzUFA0c,1420
 dime_payments/data_objects/form_link.py,sha256=rPU7cJynsrfb_1QjT8DkZ8ShvXVXUScBqJNZVASeJCI,280
+dime_payments/data_objects/invoice.py,sha256=GQ6g-9e4toNsgJF-2WsnJ0S3mgeizrtYbBYhI3ur46E,3251
+dime_payments/data_objects/invoice_customer.py,sha256=GtnomaFO8xlpRuElMPPAAtlT5DwJLyp3NB5wGqdW9Bc,528
+dime_payments/data_objects/invoice_event.py,sha256=dvKOfcB9sxE6ehFQyB_lsfpA6iMFX3oK5WAUjSIpgDk,646
+dime_payments/data_objects/invoice_item.py,sha256=aVgO0UM7vqJB2VjvtYMBpLsCWXKHus0r7pA9I7UHwxo,856
+dime_payments/data_objects/invoice_link.py,sha256=kiWSXkl4jtsCZ-ODsEaFU12mTk3soe0qZ7ICDJ2MiEE,452
+dime_payments/data_objects/invoice_payment.py,sha256=EPvs8FhhDyxEyRo8RoiVSRZK5LIBEwF5Iwjcw7DM0Ac,983
+dime_payments/data_objects/line_item.py,sha256=EJtpxnSOoCOlZJcrq8jDarieICPHtQK-g6jipTDMDAg,1024
 dime_payments/data_objects/merchant.py,sha256=U6RbP3QJACjOtrSExyodfz9zOzeU2hThXwGD6M0XATI,1900
 dime_payments/data_objects/message_result.py,sha256=2gZYbokwPRdlBUz_vGgYzrJpxMnjMuzwtTdjXhUv1GM,299
 dime_payments/data_objects/payment_method.py,sha256=-3kcHBGoXD12mzHocMoKU0aBwoNJ_9GJFx5eldXUJxA,2460
+dime_payments/data_objects/recurring_invoice.py,sha256=pS4DEZdMnxhA6qwcM3bUH7k-yb0NU8-OvJdrk_cdihA,2785
 dime_payments/data_objects/recurring_payment.py,sha256=E6F3oX6aqWeE2Ek4ePqDDbZ79APdIKKXVip4bTcFU-g,2209
 dime_payments/data_objects/recurring_payment_method.py,sha256=P22ITvvxAUJ4NaEc7MH2ItCFm6wk1mEuxRs4ffSUDrg,402
 dime_payments/data_objects/tokenize_result.py,sha256=i27Hc0A-dFM8cX8s9A71yM95kd48ih25fvnb3SEml54,295
@@ -28,7 +37,7 @@ dime_payments/exceptions/server_exception.py,sha256=SCUubaM1wTwFMW3E9mBSxry4A-0Q
 dime_payments/exceptions/validation_exception.py,sha256=_HGMPN-5iFq6RWJY-06Oaak565MeD-yRf6GnbXp7Sog,689
 dime_payments/http/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dime_payments/http/error_handler.py,sha256=dqClsyDIcCPS6CtiqtGvEwTnORj24m2muXThXfHdhX0,2873
-dime_payments/http/transport.py,sha256=G2dPpXckNBUKjc0MwmzopF8YfACMR3LR3M9RROyX_Nw,2642
+dime_payments/http/transport.py,sha256=tcFR_BLZJqti6mrWYRKKvYIEUJKMYG1mmv5FChA-b9Q,2642
 dime_payments/pagination/__init__.py,sha256=J2k8htn29Nu92KQh4wtEeN0StyMc8cWxVY8jQydF-dQ,62
 dime_payments/pagination/cursor_page.py,sha256=Xpbt33ceBy_HQlqe3wFbxA93bUfx3rHcqXfhVAkOQJ0,2263
 dime_payments/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -36,13 +45,15 @@ dime_payments/resources/abstract_resource.py,sha256=-XmnqJvk2tVNe44JeY_TTAzD4UiU
 dime_payments/resources/addresses.py,sha256=sg0q3YCnkdGlGM0onbBh_UsatrIu4VyzAA1BdZ1QRZ0,1713
 dime_payments/resources/customers.py,sha256=6_9gG9tc2uHN-onhzNFP0NO67NxGOYqbwZmF96vU4bo,1545
 dime_payments/resources/deposits.py,sha256=k8wE7kT_baHjXmXxzN9v6_2BqDb0GSUlINPRVtjmyUI,1213
+dime_payments/resources/invoices.py,sha256=e85DWM2PotddRH-TR-tiWKBtLDxJ8BaSCgsLQSN0HAM,7841
 dime_payments/resources/merchants.py,sha256=blVx7JIAps9ktdpLjjQofEnVkK_KgXOQP8beBPkHrkg,1370
 dime_payments/resources/payment_methods.py,sha256=KJWryjnZadyohG1r6pmULjwPIjPIjScSK7ekQYamvYA,1775
+dime_payments/resources/recurring_invoices.py,sha256=gJ4sNPvxv4qyNppsGZnW_orOfEVw4ROTa6yrN71Ax4g,1726
 dime_payments/resources/recurring_payments.py,sha256=DPihjc-C7oLLfPrP5UveNpEKHmUxayv4k3hFpguJ35c,2940
 dime_payments/resources/transactions.py,sha256=Q0VwYDicdGuM1WQXqxPX_KS313A0KZVCeuVCyKS_G7k,2742
 dime_payments/support/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dime_payments/support/arr.py,sha256=_mboi_q3HGn_Sx_MgU2exkbl-fnP2gdDY8yeSC8hkNc,1722
-dime_python_sdk-1.0.0.dist-info/METADATA,sha256=YdWerOwvU8IBJOFjpxJg3HuuEbrDW-oC19Mp9SJJeBo,9553
-dime_python_sdk-1.0.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-dime_python_sdk-1.0.0.dist-info/licenses/LICENSE,sha256=-Xc5dLgfuFLVQLsSKNYmJKtNZCUU1_9ErffdGiwH-DU,1072
-dime_python_sdk-1.0.0.dist-info/RECORD,,
+dime_python_sdk-1.3.0.dist-info/METADATA,sha256=xPcFnbu29Dk0nUZZythxZw8wRMHBF3j9ZzIhLQX6YSc,14703
+dime_python_sdk-1.3.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+dime_python_sdk-1.3.0.dist-info/licenses/LICENSE,sha256=-Xc5dLgfuFLVQLsSKNYmJKtNZCUU1_9ErffdGiwH-DU,1072
+dime_python_sdk-1.3.0.dist-info/RECORD,,

{dime_python_sdk-1.0.0.dist-info → dime_python_sdk-1.3.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.30.1
+Generator: hatchling 1.31.0
 Root-Is-Purelib: true
 Tag: py3-none-any