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

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_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_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_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_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_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_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)],
+        )

dime_payments/data_objects/fund_release.py

@@ -0,0 +1,63 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+from ..support.arr import arr_array, arr_bool, arr_int, arr_object, arr_string
+
+
+@dataclass
+class FundRelease:
+    """
+    A request to pay out held funds.
+
+    ``status`` is ``released`` (sent), ``failed`` (declined; nothing moved) or
+    ``unknown`` (no confirmation came back, so it may have gone through — its
+    amount stays held back from ``releasable`` until it is reconciled).
+    ``transaction_info_ids`` is empty when the release was requested by amount.
+    """
+
+    id: int | None = None
+    amount: str | None = None
+    fee: str | None = None
+    status: str | None = None
+    status_label: str | None = None
+    idempotency_key: str | None = None
+    transaction_info_ids: list[str] = field(default_factory=list)
+    failure_reason: str | None = None
+    requested_at: str | None = None
+    completed_at: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'FundRelease':
+        return cls(
+            id=arr_int(data, 'id'),
+            amount=arr_string(data, 'amount'),
+            fee=arr_string(data, 'fee'),
+            status=arr_string(data, 'status'),
+            status_label=arr_string(data, 'status_label'),
+            idempotency_key=arr_string(data, 'idempotency_key'),
+            transaction_info_ids=[str(t) for t in arr_array(data, 'transaction_info_ids') if t is not None],
+            failure_reason=arr_string(data, 'failure_reason'),
+            requested_at=arr_string(data, 'requested_at'),
+            completed_at=arr_string(data, 'completed_at'),
+        )
+
+
+@dataclass
+class FundReleaseResult:
+    """
+    The response to :meth:`Funds.release`. ``replayed`` is true when the
+    ``idempotency_key`` had been used before and the original release is being
+    returned rather than a new one sent.
+    """
+
+    sid: str | None = None
+    replayed: bool = False
+    release: FundRelease = field(default_factory=FundRelease)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'FundReleaseResult':
+        return cls(
+            sid=arr_string(data, 'sid'),
+            replayed=arr_bool(data, 'replayed'),
+            release=FundRelease.from_dict(arr_object(data, 'release')),
+        )

dime_payments/data_objects/held_balance.py

@@ -0,0 +1,50 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_bool, arr_int, arr_string
+
+
+@dataclass
+class HeldBalance:
+    """
+    A held-funds merchant's balance at the processor, in dollars.
+
+    ``releasable`` is the figure that matters and the one a release is checked
+    against: ``available`` less ``at_risk`` (ACH still inside the return window),
+    ``owed_to_split`` (takings promised to another account), ``unresolved``
+    (releases requested and not yet confirmed) and ``release_fee``, never below
+    zero and never above ``ach_out_limit_remaining``.
+
+    Money is kept as strings, consistent with the rest of the SDK, to avoid float
+    rounding.
+    """
+
+    sid: str | None = None
+    available: str | None = None
+    pending: str | None = None
+    reserve: str | None = None
+    at_risk: str | None = None
+    owed_to_split: str | None = None
+    unresolved: str | None = None
+    release_fee: str | None = None
+    releasable: str | None = None
+    ach_settlement_days: int | None = None
+    ach_out_enabled: bool = False
+    ach_out_limit_remaining: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'HeldBalance':
+        return cls(
+            sid=arr_string(data, 'sid'),
+            available=arr_string(data, 'available'),
+            pending=arr_string(data, 'pending'),
+            reserve=arr_string(data, 'reserve'),
+            at_risk=arr_string(data, 'at_risk'),
+            owed_to_split=arr_string(data, 'owed_to_split'),
+            unresolved=arr_string(data, 'unresolved'),
+            release_fee=arr_string(data, 'release_fee'),
+            releasable=arr_string(data, 'releasable'),
+            ach_settlement_days=arr_int(data, 'ach_settlement_days'),
+            ach_out_enabled=arr_bool(data, 'ach_out_enabled'),
+            ach_out_limit_remaining=arr_string(data, 'ach_out_limit_remaining'),
+        )

dime_payments/data_objects/releasable_transactions.py

@@ -0,0 +1,57 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+from ..support.arr import arr_array, arr_bool, arr_string
+
+
+@dataclass
+class ReleasableTransaction:
+    """
+    A held-funds payment that can be released now. ``amount`` is what releasing
+    it would pay the merchant: ``net_amount`` less ``split_amount``. ``type`` is
+    ``CC`` or ``ACH``.
+    """
+
+    transaction_info_id: str | None = None
+    type: str | None = None
+    transaction_date: str | None = None
+    gross_amount: str | None = None
+    net_amount: str | None = None
+    split_amount: str | None = None
+    amount: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'ReleasableTransaction':
+        return cls(
+            transaction_info_id=arr_string(data, 'transaction_info_id'),
+            type=arr_string(data, 'type'),
+            transaction_date=arr_string(data, 'transaction_date'),
+            gross_amount=arr_string(data, 'gross_amount'),
+            net_amount=arr_string(data, 'net_amount'),
+            split_amount=arr_string(data, 'split_amount'),
+            amount=arr_string(data, 'amount'),
+        )
+
+
+@dataclass
+class ReleasableTransactions:
+    """
+    The payments a held-funds merchant can release, newest first, up to 500.
+    ``truncated`` is true when there are more than were listed.
+    """
+
+    sid: str | None = None
+    transactions: list[ReleasableTransaction] = field(default_factory=list)
+    total: str | None = None
+    truncated: bool = False
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'ReleasableTransactions':
+        return cls(
+            sid=arr_string(data, 'sid'),
+            transactions=[
+                ReleasableTransaction.from_dict(t) for t in arr_array(data, 'transactions') if isinstance(t, dict)
+            ],
+            total=arr_string(data, 'total'),
+            truncated=arr_bool(data, 'truncated'),
+        )

dime_payments/data_objects/subscribe_result.py

@@ -0,0 +1,29 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_int, arr_string
+
+
+@dataclass
+class SubscribeResult:
+    """
+    The response to :meth:`SubscriptionPlans.subscribe`: the new subscription's
+    id and status, and the first payment that was charged to start it.
+    Fetch the full record with :meth:`Subscriptions.show`.
+    """
+
+    subscription_id: int | None = None
+    status: str | None = None
+    next_run_date: str | None = None
+    transaction_number: str | None = None
+    amount: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'SubscribeResult':
+        return cls(
+            subscription_id=arr_int(data, 'subscription_id'),
+            status=arr_string(data, 'status'),
+            next_run_date=arr_string(data, 'next_run_date'),
+            transaction_number=arr_string(data, 'transaction_number'),
+            amount=arr_string(data, 'amount'),
+        )

dime_payments/data_objects/subscription.py

@@ -0,0 +1,61 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+from ..support.arr import arr_array, arr_int, arr_object, arr_string
+from .subscription_item import SubscriptionItem
+from .subscription_payment_method import SubscriptionPaymentMethod
+
+
+@dataclass
+class Subscription:
+    """
+    A customer's enrollment in a :class:`SubscriptionPlan`.
+
+    ``status`` is one of ``Active``, ``Failed``, ``Paused``, ``Cancelled`` or
+    ``Ended``. ``items`` is populated by :meth:`Subscriptions.show` only; list
+    and lifecycle responses leave it empty.
+    """
+
+    id: int | None = None
+    subscription_plan_id: int | None = None
+    plan_name: str | None = None
+    amount: str | None = None
+    recurrence_schedule: str | None = None
+    start_date: str | None = None
+    end_date: str | None = None
+    last_run_date: str | None = None
+    last_run_status: str | None = None
+    last_run_failed_count: int | None = None
+    next_run_date: str | None = None
+    status: str | None = None
+    paused_until_date: str | None = None
+    cancelled_at: str | None = None
+    cancelled_by: str | None = None
+    customer_uuid: str | None = None
+    error: str | None = None
+    payment_method: SubscriptionPaymentMethod = field(default_factory=SubscriptionPaymentMethod)
+    items: list[SubscriptionItem] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'Subscription':
+        return cls(
+            id=arr_int(data, 'id'),
+            subscription_plan_id=arr_int(data, 'subscription_plan_id'),
+            plan_name=arr_string(data, 'plan_name'),
+            amount=arr_string(data, 'amount'),
+            recurrence_schedule=arr_string(data, 'recurrence_schedule'),
+            start_date=arr_string(data, 'start_date'),
+            end_date=arr_string(data, 'end_date'),
+            last_run_date=arr_string(data, 'last_run_date'),
+            last_run_status=arr_string(data, 'last_run_status'),
+            last_run_failed_count=arr_int(data, 'last_run_failed_count'),
+            next_run_date=arr_string(data, 'next_run_date'),
+            status=arr_string(data, 'status'),
+            paused_until_date=arr_string(data, 'paused_until_date'),
+            cancelled_at=arr_string(data, 'cancelled_at'),
+            cancelled_by=arr_string(data, 'cancelled_by'),
+            customer_uuid=arr_string(data, 'customer_uuid'),
+            error=arr_string(data, 'error'),
+            payment_method=SubscriptionPaymentMethod.from_dict(arr_object(data, 'payment_method')),
+            items=[SubscriptionItem.from_dict(i) for i in arr_array(data, 'items') if isinstance(i, dict)],
+        )

dime_payments/data_objects/subscription_item.py

@@ -0,0 +1,29 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_string
+
+
+@dataclass
+class SubscriptionItem:
+    """
+    A line on a subscription plan or subscription. ``amount`` (quantity times
+    unit price) is reported on a :class:`Subscription`'s items only; it is
+    ``None`` on a :class:`SubscriptionPlan`'s.
+    """
+
+    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]) -> 'SubscriptionItem':
+        return cls(
+            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/subscription_payment_method.py

@@ -0,0 +1,31 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_int, arr_string
+
+
+@dataclass
+class SubscriptionPaymentMethod:
+    """
+    The saved payment method a subscription charges. ``type`` is ``cc`` or
+    ``ach``; ``last_four`` and ``expiration`` are set for a card, ``bank_name``
+    and ``account_type`` for a bank account.
+    """
+
+    id: int | None = None
+    type: str | None = None
+    last_four: str | None = None
+    expiration: str | None = None
+    bank_name: str | None = None
+    account_type: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'SubscriptionPaymentMethod':
+        return cls(
+            id=arr_int(data, 'id'),
+            type=arr_string(data, 'type'),
+            last_four=arr_string(data, 'last_four'),
+            expiration=arr_string(data, 'expiration'),
+            bank_name=arr_string(data, 'bank_name'),
+            account_type=arr_string(data, 'account_type'),
+        )

dime_payments/data_objects/subscription_plan.py

@@ -0,0 +1,46 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+from ..support.arr import arr_array, arr_bool, arr_int, arr_string
+from .subscription_item import SubscriptionItem
+
+
+@dataclass
+class SubscriptionPlan:
+    """
+    A recurring offering customers subscribe to.
+
+    ``status`` is ``draft``, ``active`` or ``archived``; only an active plan
+    accepts new subscribers. ``recurrence_schedule`` is one of ``Weekly``,
+    ``Biweekly``, ``FirstFifteenth``, ``Monthly`` or ``Yearly``.
+    """
+
+    id: int | None = None
+    name: str | None = None
+    description: str | None = None
+    recurrence_schedule: str | None = None
+    status: str | None = None
+    subtotal: str | None = None
+    total: str | None = None
+    token: str | None = None
+    public_url: str | None = None
+    allow_public: bool = False
+    created_at: str | None = None
+    items: list[SubscriptionItem] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'SubscriptionPlan':
+        return cls(
+            id=arr_int(data, 'id'),
+            name=arr_string(data, 'name'),
+            description=arr_string(data, 'description'),
+            recurrence_schedule=arr_string(data, 'recurrence_schedule'),
+            status=arr_string(data, 'status'),
+            subtotal=arr_string(data, 'subtotal'),
+            total=arr_string(data, 'total'),
+            token=arr_string(data, 'token'),
+            public_url=arr_string(data, 'public_url'),
+            allow_public=arr_bool(data, 'allow_public'),
+            created_at=arr_string(data, 'created_at'),
+            items=[SubscriptionItem.from_dict(i) for i in arr_array(data, 'items') if isinstance(i, dict)],
+        )