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

dime_python_sdk-1.3.0/.github/workflows/publish.yml

@@ -0,0 +1,62 @@
+name: Publish
+
+# Publishing is driven by GitHub Releases: tag, write the release notes, hit
+# publish, and this ships the tag to PyPI. workflow_dispatch is the escape hatch
+# for republishing a tag whose release already exists — select the tag as the
+# ref when dispatching.
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  publish:
+    name: Publish to PyPI
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      contents: read
+      id-token: write # required for PyPI trusted publishing
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      # The SDK carries its version in three places and they drift silently.
+      # v1.0.0 sat on PyPI for ten weeks while main had moved on, so fail loudly
+      # rather than publish a package that misreports itself in X-Dime-Sdk.
+      - name: Verify the tag matches every declared version
+        env:
+          TAG_NAME: ${{ github.event.release.tag_name || github.ref_name }}
+        run: |
+          tag="${TAG_NAME#v}"
+          proj=$(python -c "import tomllib; print(tomllib.load(open('pyproject.toml','rb'))['project']['version'])")
+          cfg=$(python -c "import re; print(re.search(r\"VERSION = '([^']+)'\", open('src/dime_payments/config.py').read()).group(1))")
+          trn=$(python -c "import re; print(re.search(r\"SDK_VERSION = '([^']+)'\", open('src/dime_payments/http/transport.py').read()).group(1))")
+          echo "tag=$tag  pyproject.toml=$proj  config.py=$cfg  transport.py=$trn"
+          [ "$tag" = "$proj" ] || { echo "::error::pyproject.toml ($proj) does not match tag ($tag)"; exit 1; }
+          [ "$tag" = "$cfg" ]  || { echo "::error::config.py ($cfg) does not match tag ($tag)"; exit 1; }
+          [ "$tag" = "$trn" ]  || { echo "::error::transport.py ($trn) does not match tag ($tag)"; exit 1; }
+
+      - name: Install and test
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[dev]"
+          pytest
+
+      - name: Build distributions
+        run: |
+          pip install build
+          python -m build
+
+      # Trusted publishing — authenticates via OIDC, so there is no PyPI token
+      # to store or rotate. Requires a trusted publisher configured on PyPI for
+      # this repo, this workflow filename, and the "pypi" environment.
+      - name: Publish
+        uses: pypa/gh-action-pypi-publish@release/v1

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

@@ -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 → dime_python_sdk-1.3.0}/README.md

@@ -74,6 +74,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
 
@@ -164,6 +166,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
@@ -227,7 +350,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 → dime_python_sdk-1.3.0}/pyproject.toml

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

{dime_python_sdk-1.0.0 → dime_python_sdk-1.3.0}/src/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_python_sdk-1.0.0 → dime_python_sdk-1.3.0}/src/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_python_sdk-1.0.0 → dime_python_sdk-1.3.0}/src/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_python_sdk-1.3.0/src/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_python_sdk-1.3.0/src/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_python_sdk-1.3.0/src/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_python_sdk-1.3.0/src/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_python_sdk-1.3.0/src/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_python_sdk-1.3.0/src/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'),
+        )