dime-python-sdk 1.3.0__tar.gz → 1.4.0__tar.gz

{dime_python_sdk-1.3.0 → dime_python_sdk-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: dime-python-sdk
-Version: 1.3.0
+Version: 1.4.0
 Summary: Python client for the Dime Payments API
 Author: Dime Technology
 License: MIT License
@@ -111,15 +111,20 @@ returned as strings to avoid float rounding.
 
 | Property                        | Endpoints                                                             |
 | ------------------------------- | --------------------------------------------------------------------- |
-| `dime.transactions`             | charge_card, charge_ach, tokenize_card, refund, void, show, list     |
+| `dime.transactions`             | charge_card, charge_card_token, charge_ach, authorize, capture, tokenize_card, refund, void, show, list |
 | `dime.customers`                | list, show, create, update, delete                                    |
 | `dime.payment_methods`          | list, show, create, update, delete                                    |
-| `dime.merchants`                | list, show, create, update, get_form_link                             |
+| `dime.merchants`                | list, show, create, update, get_form_link, application_status         |
 | `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                                            |
+| `dime.chargebacks`              | list, show                                                            |
+| `dime.documents`                | upload, list                                                          |
+| `dime.funds`                    | balance, transactions, release                                        |
+| `dime.subscription_plans`       | list, show, create, edit, delete, publish, archive, unarchive, subscribe |
+| `dime.subscriptions`            | list, show, pause, resume, cancel                                     |
 
 ### Transactions
 
@@ -165,6 +170,35 @@ dime.transactions.void('000010', 'CC', 123456)
 txn = dime.transactions.show('000010', {'transaction_info_id': 123456})
 ```
 
+#### Authorize now, capture later
+
+`authorize()` holds the amount on the card without moving money. Pass its `transaction_number` to
+`capture()` to collect, or to `void()` to release the hold. Capture promptly — the issuer drops an
+uncaptured hold on its own schedule — and only once: a partial capture settles that amount and
+releases the rest. Needs the `transaction:authorize-capture` ability.
+
+```python
+auth = dime.transactions.authorize('000010', {'amount': '100.00', 'token': 'tok_abc123'})
+
+# Collect it: omit the amount to capture the full hold
+dime.transactions.capture('000010', auth.transaction_number, '80.00')
+
+# ...or release the hold instead
+dime.transactions.void('000010', 'CC', auth.transaction_number)
+```
+
+### Merchant onboarding
+
+Follow up an application sent with `get_form_link()`. `status` is the headline; while it is
+`underwriting`, read `application_status` — only `needs_documents` asks you to act. `boarded` says
+whether the merchant can take money. The `application_status_changed` webhook carries the same
+fields, so poll only to reconcile.
+
+```python
+status = dime.merchants.application_status('000010')
+print(status.status, status.application_status, status.boarded)
+```
+
 ### Customers, payment methods, addresses
 
 ```python
@@ -218,6 +252,11 @@ item (a fund or designation). Draft invoices can be edited; once sent they are l
 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.
 
+**Statuses.** `invoice.status` is one of `draft`, `sent`, `viewed`, `partially_paid`, `paid`, `void` or
+`refunded`. `paid` is not always final: if the customer's bank returns an ACH payment, the invoice is
+reopened (back to `partially_paid`, `viewed` or `sent`, with `amount_paid` and `balance` updated) and an
+`invoice_payment_returned` webhook fires. Re-read the invoice rather than caching a `paid` status forever.
+
 ```python
 # Look up (or create) the merchant items a line can reference
 items = dime.invoices.list_items('000010')
@@ -331,6 +370,101 @@ print(ri.next_run_date, ri.upcoming_run_dates)
 dime.recurring_invoices.cancel('000010', ri.id)
 ```
 
+### Chargebacks and documents
+
+Chargebacks arrive from the processor once a day; the chargeback webhooks tell you when one opens or
+changes, and these endpoints let you reconcile. Contest one by uploading evidence as a
+`RetrievalRequest` document against its `transaction_info_id`.
+
+```python
+for cb in dime.chargebacks.list('000010', {'representment_status': 'New'}).auto_paging():
+    print(cb.transaction_info_id, cb.chargeback_amount, cb.representment_date)
+
+cb = dime.chargebacks.show('000010', '8675309')
+
+# Each file is a path or a (filename, bytes-or-file-object) pair. Up to 10 per call,
+# 9 MB each, as PDF, JPG, PNG, DOC, DOCX or RTF.
+result = dime.documents.upload(
+    '000010',
+    'RetrievalRequest',  # Verification | FraudHolds | Underwriting | RetrievalRequest
+    ['receipt.pdf', ('signature.png', png_bytes)],
+    chargeback_transaction_info_id=cb.transaction_info_id,
+)
+for failure in result.failed:  # files are stored independently; re-send only these
+    print(failure.file_name, failure.reason)
+
+docs = dime.documents.list('000010', {'chargeback_transaction_info_id': cb.transaction_info_id})
+```
+
+`upload()` is the one `multipart/form-data` request in the API; the SDK builds it for you. Uploading
+does not forward anything to the processor — Dime reviews the documents and sends them on.
+
+### Held funds
+
+For merchants on a tier that holds their balance rather than sweeping it to the bank. Any other
+merchant gets a `ValidationException` (422). Reading needs `funds:read`; releasing needs
+`funds:release` on an affiliate key.
+
+```python
+balance = dime.funds.balance('000010')
+print(balance.available, balance.releasable)  # release against releasable
+
+# Release by amount...
+result = dime.funds.release('000010', 'payout-2026-10-06-0001', amount='1500.00')
+
+# ...or by payment, all or nothing
+payable = dime.funds.transactions('000010')
+result = dime.funds.release(
+    '000010',
+    'payout-2026-10-06-0002',
+    transaction_info_ids=[t.transaction_info_id for t in payable.transactions],
+)
+
+print(result.release.status)  # released | failed | unknown
+```
+
+Use a fresh `idempotency_key` for every intended release and reuse it when retrying: a repeat
+returns the original release (`result.replayed`) instead of sending money twice. `unknown` means no
+confirmation came back and it may have gone through; its amount stays out of `releasable` until it
+is reconciled, so a later release cannot pay it twice. A release the processor declines is returned
+with status `failed` and a `failure_reason`; nothing moved. A request refused before anything was
+recorded raises: `ValidationException` (422) for more than is releasable or an ineligible payment,
+`ApiException` (409) for a reused key or a release already in flight, and `ServerException` (503)
+when the processor cannot be reached.
+
+### Subscription plans and subscriptions
+
+A plan is a recurring offering built from merchant items. Create it as a draft, publish it, then
+subscribe customers to it; each subscriber keeps their own snapshot, so later edits do not change
+what they pay.
+
+```python
+plan = dime.subscription_plans.create('000010', {
+    'name': 'Monthly Membership',
+    'recurrence_schedule': 'Monthly',  # Weekly | Biweekly | FirstFifteenth | Monthly | Yearly
+    'lines': [
+        {'item_id': item.id, 'name': 'Base membership', 'quantity': 1, 'unit_price': 25},
+    ],
+})
+dime.subscription_plans.publish('000010', plan.id)
+
+# Charges the first payment now; a decline raises ValidationException
+result = dime.subscription_plans.subscribe('000010', plan.id, customer.uuid, pm.id)
+
+sub = dime.subscriptions.show('000010', result.subscription_id)
+dime.subscriptions.pause('000010', sub.id, '2026-12-01')  # omit the date to pause indefinitely
+dime.subscriptions.resume('000010', sub.id)
+dime.subscriptions.cancel('000010', sub.id)
+
+# edit() replaces the plan wholesale, so send every field and line
+dime.subscription_plans.edit('000010', plan.id, {
+    'name': 'Monthly Membership',
+    'recurrence_schedule': 'Monthly',
+    'lines': [{'item_id': item.id, 'name': 'Base membership', 'quantity': 1, 'unit_price': 30}],
+})
+dime.subscription_plans.archive('000010', plan.id)  # stop new sign-ups; unarchive() to reopen as a draft
+```
+
 ## Pagination
 
 List endpoints return a `CursorPage`. Iterate one page, walk pages manually, or stream every
@@ -391,6 +525,9 @@ except DimeException as e:
 | `ConnectionException`        | No HTTP response (DNS, timeout, network error)               |
 | `ApiException`               | Any other non-2xx                                            |
 
+The exception message is the API's own where it sends one. Some list endpoints answer `404` when
+nothing matches: an empty chargeback, document or subscription list raises `NotFoundException`.
+
 ## Notes
 
 - **GET requests carry a JSON body.** The Dime API expects read parameters in the request body

{dime_python_sdk-1.3.0 → dime_python_sdk-1.4.0}/README.md

@@ -67,15 +67,20 @@ returned as strings to avoid float rounding.
 
 | Property                        | Endpoints                                                             |
 | ------------------------------- | --------------------------------------------------------------------- |
-| `dime.transactions`             | charge_card, charge_ach, tokenize_card, refund, void, show, list     |
+| `dime.transactions`             | charge_card, charge_card_token, charge_ach, authorize, capture, tokenize_card, refund, void, show, list |
 | `dime.customers`                | list, show, create, update, delete                                    |
 | `dime.payment_methods`          | list, show, create, update, delete                                    |
-| `dime.merchants`                | list, show, create, update, get_form_link                             |
+| `dime.merchants`                | list, show, create, update, get_form_link, application_status         |
 | `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                                            |
+| `dime.chargebacks`              | list, show                                                            |
+| `dime.documents`                | upload, list                                                          |
+| `dime.funds`                    | balance, transactions, release                                        |
+| `dime.subscription_plans`       | list, show, create, edit, delete, publish, archive, unarchive, subscribe |
+| `dime.subscriptions`            | list, show, pause, resume, cancel                                     |
 
 ### Transactions
 
@@ -121,6 +126,35 @@ dime.transactions.void('000010', 'CC', 123456)
 txn = dime.transactions.show('000010', {'transaction_info_id': 123456})
 ```
 
+#### Authorize now, capture later
+
+`authorize()` holds the amount on the card without moving money. Pass its `transaction_number` to
+`capture()` to collect, or to `void()` to release the hold. Capture promptly — the issuer drops an
+uncaptured hold on its own schedule — and only once: a partial capture settles that amount and
+releases the rest. Needs the `transaction:authorize-capture` ability.
+
+```python
+auth = dime.transactions.authorize('000010', {'amount': '100.00', 'token': 'tok_abc123'})
+
+# Collect it: omit the amount to capture the full hold
+dime.transactions.capture('000010', auth.transaction_number, '80.00')
+
+# ...or release the hold instead
+dime.transactions.void('000010', 'CC', auth.transaction_number)
+```
+
+### Merchant onboarding
+
+Follow up an application sent with `get_form_link()`. `status` is the headline; while it is
+`underwriting`, read `application_status` — only `needs_documents` asks you to act. `boarded` says
+whether the merchant can take money. The `application_status_changed` webhook carries the same
+fields, so poll only to reconcile.
+
+```python
+status = dime.merchants.application_status('000010')
+print(status.status, status.application_status, status.boarded)
+```
+
 ### Customers, payment methods, addresses
 
 ```python
@@ -174,6 +208,11 @@ item (a fund or designation). Draft invoices can be edited; once sent they are l
 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.
 
+**Statuses.** `invoice.status` is one of `draft`, `sent`, `viewed`, `partially_paid`, `paid`, `void` or
+`refunded`. `paid` is not always final: if the customer's bank returns an ACH payment, the invoice is
+reopened (back to `partially_paid`, `viewed` or `sent`, with `amount_paid` and `balance` updated) and an
+`invoice_payment_returned` webhook fires. Re-read the invoice rather than caching a `paid` status forever.
+
 ```python
 # Look up (or create) the merchant items a line can reference
 items = dime.invoices.list_items('000010')
@@ -287,6 +326,101 @@ print(ri.next_run_date, ri.upcoming_run_dates)
 dime.recurring_invoices.cancel('000010', ri.id)
 ```
 
+### Chargebacks and documents
+
+Chargebacks arrive from the processor once a day; the chargeback webhooks tell you when one opens or
+changes, and these endpoints let you reconcile. Contest one by uploading evidence as a
+`RetrievalRequest` document against its `transaction_info_id`.
+
+```python
+for cb in dime.chargebacks.list('000010', {'representment_status': 'New'}).auto_paging():
+    print(cb.transaction_info_id, cb.chargeback_amount, cb.representment_date)
+
+cb = dime.chargebacks.show('000010', '8675309')
+
+# Each file is a path or a (filename, bytes-or-file-object) pair. Up to 10 per call,
+# 9 MB each, as PDF, JPG, PNG, DOC, DOCX or RTF.
+result = dime.documents.upload(
+    '000010',
+    'RetrievalRequest',  # Verification | FraudHolds | Underwriting | RetrievalRequest
+    ['receipt.pdf', ('signature.png', png_bytes)],
+    chargeback_transaction_info_id=cb.transaction_info_id,
+)
+for failure in result.failed:  # files are stored independently; re-send only these
+    print(failure.file_name, failure.reason)
+
+docs = dime.documents.list('000010', {'chargeback_transaction_info_id': cb.transaction_info_id})
+```
+
+`upload()` is the one `multipart/form-data` request in the API; the SDK builds it for you. Uploading
+does not forward anything to the processor — Dime reviews the documents and sends them on.
+
+### Held funds
+
+For merchants on a tier that holds their balance rather than sweeping it to the bank. Any other
+merchant gets a `ValidationException` (422). Reading needs `funds:read`; releasing needs
+`funds:release` on an affiliate key.
+
+```python
+balance = dime.funds.balance('000010')
+print(balance.available, balance.releasable)  # release against releasable
+
+# Release by amount...
+result = dime.funds.release('000010', 'payout-2026-10-06-0001', amount='1500.00')
+
+# ...or by payment, all or nothing
+payable = dime.funds.transactions('000010')
+result = dime.funds.release(
+    '000010',
+    'payout-2026-10-06-0002',
+    transaction_info_ids=[t.transaction_info_id for t in payable.transactions],
+)
+
+print(result.release.status)  # released | failed | unknown
+```
+
+Use a fresh `idempotency_key` for every intended release and reuse it when retrying: a repeat
+returns the original release (`result.replayed`) instead of sending money twice. `unknown` means no
+confirmation came back and it may have gone through; its amount stays out of `releasable` until it
+is reconciled, so a later release cannot pay it twice. A release the processor declines is returned
+with status `failed` and a `failure_reason`; nothing moved. A request refused before anything was
+recorded raises: `ValidationException` (422) for more than is releasable or an ineligible payment,
+`ApiException` (409) for a reused key or a release already in flight, and `ServerException` (503)
+when the processor cannot be reached.
+
+### Subscription plans and subscriptions
+
+A plan is a recurring offering built from merchant items. Create it as a draft, publish it, then
+subscribe customers to it; each subscriber keeps their own snapshot, so later edits do not change
+what they pay.
+
+```python
+plan = dime.subscription_plans.create('000010', {
+    'name': 'Monthly Membership',
+    'recurrence_schedule': 'Monthly',  # Weekly | Biweekly | FirstFifteenth | Monthly | Yearly
+    'lines': [
+        {'item_id': item.id, 'name': 'Base membership', 'quantity': 1, 'unit_price': 25},
+    ],
+})
+dime.subscription_plans.publish('000010', plan.id)
+
+# Charges the first payment now; a decline raises ValidationException
+result = dime.subscription_plans.subscribe('000010', plan.id, customer.uuid, pm.id)
+
+sub = dime.subscriptions.show('000010', result.subscription_id)
+dime.subscriptions.pause('000010', sub.id, '2026-12-01')  # omit the date to pause indefinitely
+dime.subscriptions.resume('000010', sub.id)
+dime.subscriptions.cancel('000010', sub.id)
+
+# edit() replaces the plan wholesale, so send every field and line
+dime.subscription_plans.edit('000010', plan.id, {
+    'name': 'Monthly Membership',
+    'recurrence_schedule': 'Monthly',
+    'lines': [{'item_id': item.id, 'name': 'Base membership', 'quantity': 1, 'unit_price': 30}],
+})
+dime.subscription_plans.archive('000010', plan.id)  # stop new sign-ups; unarchive() to reopen as a draft
+```
+
 ## Pagination
 
 List endpoints return a `CursorPage`. Iterate one page, walk pages manually, or stream every
@@ -347,6 +481,9 @@ except DimeException as e:
 | `ConnectionException`        | No HTTP response (DNS, timeout, network error)               |
 | `ApiException`               | Any other non-2xx                                            |
 
+The exception message is the API's own where it sends one. Some list endpoints answer `404` when
+nothing matches: an empty chargeback, document or subscription list raises `NotFoundException`.
+
 ## Notes
 
 - **GET requests carry a JSON body.** The Dime API expects read parameters in the request body

{dime_python_sdk-1.3.0 → dime_python_sdk-1.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dime-python-sdk"
-version = "1.3.0"
+version = "1.4.0"
 description = "Python client for the Dime Payments API"
 readme = "README.md"
 requires-python = ">=3.10"

{dime_python_sdk-1.3.0 → dime_python_sdk-1.4.0}/src/dime_payments/client.py

@@ -1,13 +1,18 @@
 from .config import Config
 from .http.transport import Transport
 from .resources.addresses import Addresses
+from .resources.chargebacks import Chargebacks
 from .resources.customers import Customers
 from .resources.deposits import Deposits
+from .resources.documents import Documents
+from .resources.funds import Funds
 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.subscription_plans import SubscriptionPlans
+from .resources.subscriptions import Subscriptions
 from .resources.transactions import Transactions
 
 
@@ -29,6 +34,11 @@ class Client:
         self.recurring_payments = RecurringPayments(transport)
         self.invoices = Invoices(transport)
         self.recurring_invoices = RecurringInvoices(transport)
+        self.chargebacks = Chargebacks(transport)
+        self.documents = Documents(transport)
+        self.funds = Funds(transport)
+        self.subscription_plans = SubscriptionPlans(transport)
+        self.subscriptions = Subscriptions(transport)
 
     def config(self) -> Config:
         return self._config

{dime_python_sdk-1.3.0 → dime_python_sdk-1.4.0}/src/dime_payments/config.py

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

{dime_python_sdk-1.3.0 → dime_python_sdk-1.4.0}/src/dime_payments/data_objects/__init__.py

@@ -1,9 +1,15 @@
 from .address import Address
+from .application_status import ApplicationStatus
+from .chargeback import Chargeback
 from .customer import Customer
 from .deposit import Deposit
 from .deposit_group import DepositGroup
 from .deposit_with_transactions import DepositWithTransactions
+from .document import Document
+from .document_upload_result import DocumentUploadFailure, DocumentUploadResult
 from .form_link import FormLink
+from .fund_release import FundRelease, FundReleaseResult
+from .held_balance import HeldBalance
 from .invoice import Invoice
 from .invoice_customer import InvoiceCustomer
 from .invoice_event import InvoiceEvent
@@ -17,6 +23,12 @@ from .payment_method import PaymentMethod
 from .recurring_invoice import RecurringInvoice, RecurringInvoiceRun
 from .recurring_payment import RecurringPayment
 from .recurring_payment_method import RecurringPaymentMethod
+from .releasable_transactions import ReleasableTransaction, ReleasableTransactions
+from .subscribe_result import SubscribeResult
+from .subscription import Subscription
+from .subscription_item import SubscriptionItem
+from .subscription_payment_method import SubscriptionPaymentMethod
+from .subscription_plan import SubscriptionPlan
 from .tokenize_result import TokenizeResult
 from .transaction import Transaction
 from .transaction_address import TransactionAddress
@@ -27,6 +39,7 @@ __all__ = [
     'Customer',
     'PaymentMethod',
     'Merchant',
+    'ApplicationStatus',
     'Address',
     'Deposit',
     'DepositGroup',
@@ -45,4 +58,18 @@ __all__ = [
     'LineItem',
     'RecurringInvoice',
     'RecurringInvoiceRun',
+    'Chargeback',
+    'Document',
+    'DocumentUploadResult',
+    'DocumentUploadFailure',
+    'HeldBalance',
+    'ReleasableTransaction',
+    'ReleasableTransactions',
+    'FundRelease',
+    'FundReleaseResult',
+    'SubscriptionPlan',
+    'Subscription',
+    'SubscriptionItem',
+    'SubscriptionPaymentMethod',
+    'SubscribeResult',
 ]

dime_python_sdk-1.4.0/src/dime_payments/data_objects/application_status.py

@@ -0,0 +1,38 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_bool, arr_string
+
+
+@dataclass
+class ApplicationStatus:
+    """
+    Where a merchant sits in onboarding.
+
+    ``status`` is the headline: one of ``lead``, ``discovery``, ``proposal``,
+    ``application_in_progress``, ``underwriting``, ``live``,
+    ``cancellation_pending``, ``churned`` or ``declined`` (``None`` if onboarding
+    has not started). ``application_status`` is the underlying application —
+    ``draft``, ``pending_review``, ``submitted``, ``approved``,
+    ``needs_documents``, ``failed`` or ``None`` — and is the field to read while
+    ``status`` is ``underwriting``, since only ``needs_documents`` asks you to
+    act. ``boarded`` is the ground truth for whether the merchant can take money.
+    """
+
+    sid: str | None = None
+    name: str | None = None
+    status: str | None = None
+    application_status: str | None = None
+    boarded: bool = False
+    application_submitted_at: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'ApplicationStatus':
+        return cls(
+            sid=arr_string(data, 'sid'),
+            name=arr_string(data, 'name'),
+            status=arr_string(data, 'status'),
+            application_status=arr_string(data, 'application_status'),
+            boarded=arr_bool(data, 'boarded'),
+            application_submitted_at=arr_string(data, 'application_submitted_at'),
+        )

dime_python_sdk-1.4.0/src/dime_payments/data_objects/chargeback.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 Chargeback:
+    """
+    A chargeback raised against a merchant. The same field set the chargeback
+    webhooks carry.
+
+    ``transaction_info_id`` is the processor's stable identifier for the
+    chargeback; ``parent_transaction_info_id`` identifies the disputed payment.
+    ``representment_status`` and ``result`` are free text from the processor;
+    ``resolved`` says whether the dispute has reached a terminal state.
+    """
+
+    transaction_info_id: str | None = None
+    parent_transaction_info_id: str | None = None
+    gateway_transaction_id: str | None = None
+    transaction_number: str | None = None
+    invoice_number: str | None = None
+    chargeback_date: str | None = None
+    merchant_chargeback_date: str | None = None
+    transaction_amount: str | None = None
+    chargeback_amount: str | None = None
+    card_brand: str | None = None
+    cc_last_four: str | None = None
+    payee_name: str | None = None
+    days_to_represent: int | None = None
+    representment_date: str | None = None
+    merchant_representment_date: str | None = None
+    representment_status: str | None = None
+    result: str | None = None
+    chargeback_code: str | None = None
+    chargeback_response_code: str | None = None
+    resolved: bool = False
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'Chargeback':
+        return cls(
+            transaction_info_id=arr_string(data, 'transaction_info_id'),
+            parent_transaction_info_id=arr_string(data, 'parent_transaction_info_id'),
+            gateway_transaction_id=arr_string(data, 'gateway_transaction_id'),
+            transaction_number=arr_string(data, 'transaction_number'),
+            invoice_number=arr_string(data, 'invoice_number'),
+            chargeback_date=arr_string(data, 'chargeback_date'),
+            merchant_chargeback_date=arr_string(data, 'merchant_chargeback_date'),
+            transaction_amount=arr_string(data, 'transaction_amount'),
+            chargeback_amount=arr_string(data, 'chargeback_amount'),
+            card_brand=arr_string(data, 'card_brand'),
+            cc_last_four=arr_string(data, 'cc_last_four'),
+            payee_name=arr_string(data, 'payee_name'),
+            days_to_represent=arr_int(data, 'days_to_represent'),
+            representment_date=arr_string(data, 'representment_date'),
+            merchant_representment_date=arr_string(data, 'merchant_representment_date'),
+            representment_status=arr_string(data, 'representment_status'),
+            result=arr_string(data, 'result'),
+            chargeback_code=arr_string(data, 'chargeback_code'),
+            chargeback_response_code=arr_string(data, 'chargeback_response_code'),
+            resolved=arr_bool(data, 'resolved'),
+        )

dime_python_sdk-1.4.0/src/dime_payments/data_objects/document.py

@@ -0,0 +1,49 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_int, arr_string
+
+
+@dataclass
+class Document:
+    """
+    A document held for a merchant.
+
+    ``doc_type`` is one of ``Verification``, ``FraudHolds``, ``Underwriting`` or
+    ``RetrievalRequest``. ``uploaded_via`` is ``api`` for documents sent through
+    :meth:`Documents.upload`. The upload response carries only ``uuid``,
+    ``file_name``, ``doc_type`` and ``size``; the rest are filled by
+    :meth:`Documents.list`.
+
+    ``sent_to_processor_at`` and ``processor_status`` record when our team
+    forwarded the document to the processor and what it answered. Both are
+    ``None`` until it has been forwarded.
+    """
+
+    uuid: str | None = None
+    file_name: str | None = None
+    doc_type: str | None = None
+    chargeback_transaction_info_id: str | None = None
+    size: int | None = None
+    uploaded_at: str | None = None
+    uploaded_via: str | None = None
+    sent_to_processor_at: str | None = None
+    processor_status: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'Document':
+        # The API reports forwarding as a [timestamp, processor status] pair.
+        sent = data.get('sent_to_processor')
+        pair = dict(zip(('at', 'status'), sent)) if isinstance(sent, list) else {'at': sent}
+
+        return cls(
+            uuid=arr_string(data, 'uuid'),
+            file_name=arr_string(data, 'file_name'),
+            doc_type=arr_string(data, 'doc_type'),
+            chargeback_transaction_info_id=arr_string(data, 'chargeback_transaction_info_id'),
+            size=arr_int(data, 'size'),
+            uploaded_at=arr_string(data, 'uploaded_at'),
+            uploaded_via=arr_string(data, 'uploaded_via'),
+            sent_to_processor_at=arr_string(pair, 'at'),
+            processor_status=arr_string(pair, 'status'),
+        )

dime_python_sdk-1.4.0/src/dime_payments/data_objects/document_upload_result.py

@@ -0,0 +1,42 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+from ..support.arr import arr_array, arr_string
+from .document import Document
+
+
+@dataclass
+class DocumentUploadFailure:
+    """A file from an upload that could not be stored. Re-send just this one."""
+
+    file_name: str | None = None
+    reason: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'DocumentUploadFailure':
+        return cls(
+            file_name=arr_string(data, 'file_name'),
+            reason=arr_string(data, 'reason'),
+        )
+
+
+@dataclass
+class DocumentUploadResult:
+    """
+    The outcome of :meth:`Documents.upload`.
+
+    Files are stored independently, so an upload can partly succeed: ``documents``
+    lists what was stored and ``failed`` what was not.
+    """
+
+    message: str | None = None
+    documents: list[Document] = field(default_factory=list)
+    failed: list[DocumentUploadFailure] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'DocumentUploadResult':
+        return cls(
+            message=arr_string(data, 'message'),
+            documents=[Document.from_dict(d) for d in arr_array(data, 'documents') if isinstance(d, dict)],
+            failed=[DocumentUploadFailure.from_dict(f) for f in arr_array(data, 'failed') if isinstance(f, dict)],
+        )