8425714545

Committed 25 Mar 2024 07:15PM UTC coverage: 97.438% (-0.004%) from 97.442%

Build # 8425714545

Build Type

Pull #1276

github

Committed by

web-flow

Commit Message

Merge 63f8a2d09 into cd6c5b3e2

Pull Request Pull Request #1276: Update generated code

Run Details

895 of 1350 branches covered (66.3%)

Branch coverage included in aggregate %.

25 of 28 new or added lines in 8 files covered. (89.29%)

3 existing lines in 3 files now uncovered.

56536 of 57591 relevant lines covered (98.17%)

0.98 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.37

/stripe/treasury/_inbound_transfer.py

# -*- coding: utf-8 -*-
# File generated from our OpenAPI spec
from stripe._createable_api_resource import CreateableAPIResource
from stripe._expandable_field import ExpandableField
from stripe._list_object import ListObject
from stripe._listable_api_resource import ListableAPIResource
from stripe._request_options import RequestOptions
from stripe._stripe_object import StripeObject
from stripe._test_helpers import APIResourceTestHelpers
from stripe._util import class_method_variant, sanitize_id
from typing import ClassVar, Dict, List, Optional, cast, overload
from typing_extensions import (
    Literal,
    NotRequired,
    Type,
    TypedDict,
    Unpack,
    TYPE_CHECKING,
)

if TYPE_CHECKING:
    from stripe._mandate import Mandate
    from stripe.treasury._transaction import Transaction


class InboundTransfer(
    CreateableAPIResource["InboundTransfer"],
    ListableAPIResource["InboundTransfer"],
):
    """
    Use [InboundTransfers](https://stripe.com/docs/treasury/moving-money/financial-accounts/into/inbound-transfers) to add funds to your [FinancialAccount](https://stripe.com/docs/api#financial_accounts) via a PaymentMethod that is owned by you. The funds will be transferred via an ACH debit.
    """

    OBJECT_NAME: ClassVar[
        Literal["treasury.inbound_transfer"]
    ] = "treasury.inbound_transfer"

    class FailureDetails(StripeObject):
        code: Literal[
            "account_closed",
            "account_frozen",
            "bank_account_restricted",
            "bank_ownership_changed",
            "debit_not_authorized",
            "incorrect_account_holder_address",
            "incorrect_account_holder_name",
            "incorrect_account_holder_tax_id",
            "insufficient_funds",
            "invalid_account_number",
            "invalid_currency",
            "no_account",
            "other",
        ]
        """
        Reason for the failure.
        """

    class LinkedFlows(StripeObject):
        received_debit: Optional[str]
        """
        If funds for this flow were returned after the flow went to the `succeeded` state, this field contains a reference to the ReceivedDebit return.
        """

    class OriginPaymentMethodDetails(StripeObject):
        class BillingDetails(StripeObject):
            class Address(StripeObject):
                city: Optional[str]
                """
                City, district, suburb, town, or village.
                """
                country: Optional[str]
                """
                Two-letter country code ([ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2)).
                """
                line1: Optional[str]
                """
                Address line 1 (e.g., street, PO Box, or company name).
                """
                line2: Optional[str]
                """
                Address line 2 (e.g., apartment, suite, unit, or building).
                """
                postal_code: Optional[str]
                """
                ZIP or postal code.
                """
                state: Optional[str]
                """
                State, county, province, or region.
                """

            address: Address
            email: Optional[str]
            """
            Email address.
            """
            name: Optional[str]
            """
            Full name.
            """
            _inner_class_types = {"address": Address}

        class UsBankAccount(StripeObject):
            account_holder_type: Optional[Literal["company", "individual"]]
            """
            Account holder type: individual or company.
            """
            account_type: Optional[Literal["checking", "savings"]]
            """
            Account type: checkings or savings. Defaults to checking if omitted.
            """
            bank_name: Optional[str]
            """
            Name of the bank associated with the bank account.
            """
            fingerprint: Optional[str]
            """
            Uniquely identifies this particular bank account. You can use this attribute to check whether two bank accounts are the same.
            """
            last4: Optional[str]
            """
            Last four digits of the bank account number.
            """
            mandate: Optional[ExpandableField["Mandate"]]
            """
            ID of the mandate used to make this payment.
            """
            network: Literal["ach"]
            """
            The network rails used. See the [docs](https://stripe.com/docs/treasury/money-movement/timelines) to learn more about money movement timelines for each network type.
            """
            routing_number: Optional[str]
            """
            Routing number of the bank account.
            """

        billing_details: BillingDetails
        type: Literal["us_bank_account"]
        """
        The type of the payment method used in the InboundTransfer.
        """
        us_bank_account: Optional[UsBankAccount]
        _inner_class_types = {
            "billing_details": BillingDetails,
            "us_bank_account": UsBankAccount,
        }

    class StatusTransitions(StripeObject):
        canceled_at: Optional[int]
        """
        Timestamp describing when an InboundTransfer changed status to `canceled`.
        """
        failed_at: Optional[int]
        """
        Timestamp describing when an InboundTransfer changed status to `failed`.
        """
        succeeded_at: Optional[int]
        """
        Timestamp describing when an InboundTransfer changed status to `succeeded`.
        """

    class CancelParams(RequestOptions):
        expand: NotRequired["List[str]"]
        """
        Specifies which fields in the response should be expanded.
        """

    class CreateParams(RequestOptions):
        amount: int
        """
        Amount (in cents) to be transferred.
        """
        currency: str
        """
        Three-letter [ISO currency code](https://www.iso.org/iso-4217-currency-codes.html), in lowercase. Must be a [supported currency](https://stripe.com/docs/currencies).
        """
        description: NotRequired["str"]
        """
        An arbitrary string attached to the object. Often useful for displaying to users.
        """
        expand: NotRequired["List[str]"]
        """
        Specifies which fields in the response should be expanded.
        """
        financial_account: str
        """
        The FinancialAccount to send funds to.
        """
        metadata: NotRequired["Dict[str, str]"]
        """
        Set of [key-value pairs](https://stripe.com/docs/api/metadata) that you can attach to an object. This can be useful for storing additional information about the object in a structured format. Individual keys can be unset by posting an empty value to them. All keys can be unset by posting an empty value to `metadata`.
        """
        origin_payment_method: str
        """
        The origin payment method to be debited for the InboundTransfer.
        """
        statement_descriptor: NotRequired["str"]
        """
        The complete description that appears on your customers' statements. Maximum 10 characters.
        """

    class FailParams(RequestOptions):
        expand: NotRequired["List[str]"]
        """
        Specifies which fields in the response should be expanded.
        """
        failure_details: NotRequired[
            "InboundTransfer.FailParamsFailureDetails"
        ]
        """
        Details about a failed InboundTransfer.
        """

    class FailParamsFailureDetails(TypedDict):
        code: NotRequired[
            "Literal['account_closed', 'account_frozen', 'bank_account_restricted', 'bank_ownership_changed', 'debit_not_authorized', 'incorrect_account_holder_address', 'incorrect_account_holder_name', 'incorrect_account_holder_tax_id', 'insufficient_funds', 'invalid_account_number', 'invalid_currency', 'no_account', 'other']"
        ]
        """
        Reason for the failure.
        """

    class ListParams(RequestOptions):
        ending_before: NotRequired["str"]
        """
        A cursor for use in pagination. `ending_before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with `obj_bar`, your subsequent call can include `ending_before=obj_bar` in order to fetch the previous page of the list.
        """
        expand: NotRequired["List[str]"]
        """
        Specifies which fields in the response should be expanded.
        """
        financial_account: str
        """
        Returns objects associated with this FinancialAccount.
        """
        limit: NotRequired["int"]
        """
        A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
        """
        starting_after: NotRequired["str"]
        """
        A cursor for use in pagination. `starting_after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with `obj_foo`, your subsequent call can include `starting_after=obj_foo` in order to fetch the next page of the list.
        """
        status: NotRequired[
            "Literal['canceled', 'failed', 'processing', 'succeeded']"
        ]
        """
        Only return InboundTransfers that have the given status: `processing`, `succeeded`, `failed` or `canceled`.
        """

    class RetrieveParams(RequestOptions):
        expand: NotRequired["List[str]"]
        """
        Specifies which fields in the response should be expanded.
        """

    class ReturnInboundTransferParams(RequestOptions):
        expand: NotRequired["List[str]"]
        """
        Specifies which fields in the response should be expanded.
        """

    class SucceedParams(RequestOptions):
        expand: NotRequired["List[str]"]
        """
        Specifies which fields in the response should be expanded.
        """

    amount: int
    """
    Amount (in cents) transferred.
    """
    cancelable: bool
    """
    Returns `true` if the InboundTransfer is able to be canceled.
    """
    created: int
    """
    Time at which the object was created. Measured in seconds since the Unix epoch.
    """
    currency: str
    """
    Three-letter [ISO currency code](https://www.iso.org/iso-4217-currency-codes.html), in lowercase. Must be a [supported currency](https://stripe.com/docs/currencies).
    """
    description: Optional[str]
    """
    An arbitrary string attached to the object. Often useful for displaying to users.
    """
    failure_details: Optional[FailureDetails]
    """
    Details about this InboundTransfer's failure. Only set when status is `failed`.
    """
    financial_account: str
    """
    The FinancialAccount that received the funds.
    """
    hosted_regulatory_receipt_url: Optional[str]
    """
    A [hosted transaction receipt](https://stripe.com/docs/treasury/moving-money/regulatory-receipts) URL that is provided when money movement is considered regulated under Stripe's money transmission licenses.
    """
    id: str
    """
    Unique identifier for the object.
    """
    linked_flows: LinkedFlows
    livemode: bool
    """
    Has the value `true` if the object exists in live mode or the value `false` if the object exists in test mode.
    """
    metadata: Dict[str, str]
    """
    Set of [key-value pairs](https://stripe.com/docs/api/metadata) that you can attach to an object. This can be useful for storing additional information about the object in a structured format.
    """
    object: Literal["treasury.inbound_transfer"]
    """
    String representing the object's type. Objects of the same type share the same value.
    """
    origin_payment_method: str
    """
    The origin payment method to be debited for an InboundTransfer.
    """
    origin_payment_method_details: Optional[OriginPaymentMethodDetails]
    """
    Details about the PaymentMethod for an InboundTransfer.
    """
    returned: Optional[bool]
    """
    Returns `true` if the funds for an InboundTransfer were returned after the InboundTransfer went to the `succeeded` state.
    """
    statement_descriptor: str
    """
    Statement descriptor shown when funds are debited from the source. Not all payment networks support `statement_descriptor`.
    """
    status: Literal["canceled", "failed", "processing", "succeeded"]
    """
    Status of the InboundTransfer: `processing`, `succeeded`, `failed`, and `canceled`. An InboundTransfer is `processing` if it is created and pending. The status changes to `succeeded` once the funds have been "confirmed" and a `transaction` is created and posted. The status changes to `failed` if the transfer fails.
    """
    status_transitions: StatusTransitions
    transaction: Optional[ExpandableField["Transaction"]]
    """
    The Transaction associated with this object.
    """

    @classmethod
    def _cls_cancel(
        cls,
        inbound_transfer: str,
        **params: Unpack["InboundTransfer.CancelParams"]
    ) -> "InboundTransfer":
        """
        Cancels an InboundTransfer.
        """
        return cast(
            "InboundTransfer",
            cls._static_request(
                "post",
                "/v1/treasury/inbound_transfers/{inbound_transfer}/cancel".format(
                    inbound_transfer=sanitize_id(inbound_transfer)
                ),
                params=params,
            ),
        )

    @overload
    @staticmethod
    def cancel(
        inbound_transfer: str, **params: Unpack["InboundTransfer.CancelParams"]
    ) -> "InboundTransfer":
        """
        Cancels an InboundTransfer.
        """
        ...

    @overload
    def cancel(
        self, **params: Unpack["InboundTransfer.CancelParams"]
    ) -> "InboundTransfer":
        """
        Cancels an InboundTransfer.
        """
        ...

    @class_method_variant("_cls_cancel")
    def cancel(  # pyright: ignore[reportGeneralTypeIssues]
        self, **params: Unpack["InboundTransfer.CancelParams"]
    ) -> "InboundTransfer":
        """
        Cancels an InboundTransfer.
        """
        return cast(
            "InboundTransfer",
            self._request(
                "post",
                "/v1/treasury/inbound_transfers/{inbound_transfer}/cancel".format(
                    inbound_transfer=sanitize_id(self.get("id"))
                ),
                params=params,
            ),
        )

    @classmethod
    def create(
        cls, **params: Unpack["InboundTransfer.CreateParams"]
    ) -> "InboundTransfer":
        """
        Creates an InboundTransfer.
        """
        return cast(
            "InboundTransfer",
            cls._static_request(
                "post",
                cls.class_url(),
                params=params,
            ),
        )

    @classmethod
    def list(
        cls, **params: Unpack["InboundTransfer.ListParams"]
    ) -> ListObject["InboundTransfer"]:
        """
        Returns a list of InboundTransfers sent from the specified FinancialAccount.
        """
        result = cls._static_request(
            "get",
            cls.class_url(),
            params=params,
        )
        if not isinstance(result, ListObject):

            raise TypeError(
                "Expected list object from API, got %s"
                % (type(result).__name__)
            )

        return result

    @classmethod
    def retrieve(
        cls, id: str, **params: Unpack["InboundTransfer.RetrieveParams"]
    ) -> "InboundTransfer":
        """
        Retrieves the details of an existing InboundTransfer.
        """
        instance = cls(id, **params)
        instance.refresh()
        return instance

    class TestHelpers(APIResourceTestHelpers["InboundTransfer"]):
        _resource_cls: Type["InboundTransfer"]

        @classmethod
        def _cls_fail(
            cls, id: str, **params: Unpack["InboundTransfer.FailParams"]
        ) -> "InboundTransfer":
            """
            Transitions a test mode created InboundTransfer to the failed status. The InboundTransfer must already be in the processing state.
            """
            return cast(
                "InboundTransfer",
                cls._static_request(
                    "post",
                    "/v1/test_helpers/treasury/inbound_transfers/{id}/fail".format(
                        id=sanitize_id(id)
                    ),
                    params=params,
                ),
            )

        @overload
        @staticmethod
        def fail(
            id: str, **params: Unpack["InboundTransfer.FailParams"]
        ) -> "InboundTransfer":
            """
            Transitions a test mode created InboundTransfer to the failed status. The InboundTransfer must already be in the processing state.
            """
            ...

        @overload
        def fail(
            self, **params: Unpack["InboundTransfer.FailParams"]
        ) -> "InboundTransfer":
            """
            Transitions a test mode created InboundTransfer to the failed status. The InboundTransfer must already be in the processing state.
            """
            ...

        @class_method_variant("_cls_fail")
        def fail(  # pyright: ignore[reportGeneralTypeIssues]
            self, **params: Unpack["InboundTransfer.FailParams"]
        ) -> "InboundTransfer":
            """
            Transitions a test mode created InboundTransfer to the failed status. The InboundTransfer must already be in the processing state.
            """
            return cast(
                "InboundTransfer",
                self.resource._request(
                    "post",
                    "/v1/test_helpers/treasury/inbound_transfers/{id}/fail".format(
                        id=sanitize_id(self.resource.get("id"))
                    ),
                    params=params,
                ),
            )

        @classmethod
        def _cls_return_inbound_transfer(
            cls,
            id: str,
            **params: Unpack["InboundTransfer.ReturnInboundTransferParams"]
        ) -> "InboundTransfer":
            """
            Marks the test mode InboundTransfer object as returned and links the InboundTransfer to a ReceivedDebit. The InboundTransfer must already be in the succeeded state.
            """
            return cast(
                "InboundTransfer",
                cls._static_request(
                    "post",
                    "/v1/test_helpers/treasury/inbound_transfers/{id}/return".format(
                        id=sanitize_id(id)
                    ),
                    params=params,
                ),
            )

        @overload
        @staticmethod
        def return_inbound_transfer(
            id: str,
            **params: Unpack["InboundTransfer.ReturnInboundTransferParams"]
        ) -> "InboundTransfer":
            """
            Marks the test mode InboundTransfer object as returned and links the InboundTransfer to a ReceivedDebit. The InboundTransfer must already be in the succeeded state.
            """
            ...

        @overload
        def return_inbound_transfer(
            self,
            **params: Unpack["InboundTransfer.ReturnInboundTransferParams"]
        ) -> "InboundTransfer":
            """
            Marks the test mode InboundTransfer object as returned and links the InboundTransfer to a ReceivedDebit. The InboundTransfer must already be in the succeeded state.
            """
            ...

        @class_method_variant("_cls_return_inbound_transfer")
        def return_inbound_transfer(  # pyright: ignore[reportGeneralTypeIssues]
            self,
            **params: Unpack["InboundTransfer.ReturnInboundTransferParams"]
        ) -> "InboundTransfer":
            """
            Marks the test mode InboundTransfer object as returned and links the InboundTransfer to a ReceivedDebit. The InboundTransfer must already be in the succeeded state.
            """
            return cast(
                "InboundTransfer",
                self.resource._request(
                    "post",
                    "/v1/test_helpers/treasury/inbound_transfers/{id}/return".format(
                        id=sanitize_id(self.resource.get("id"))
                    ),
                    params=params,
                ),
            )

        @classmethod
        def _cls_succeed(
            cls, id: str, **params: Unpack["InboundTransfer.SucceedParams"]
        ) -> "InboundTransfer":
            """
            Transitions a test mode created InboundTransfer to the succeeded status. The InboundTransfer must already be in the processing state.
            """
            return cast(
                "InboundTransfer",
                cls._static_request(
                    "post",
                    "/v1/test_helpers/treasury/inbound_transfers/{id}/succeed".format(
                        id=sanitize_id(id)
                    ),
                    params=params,
                ),
            )

        @overload
        @staticmethod
        def succeed(
            id: str, **params: Unpack["InboundTransfer.SucceedParams"]
        ) -> "InboundTransfer":
            """
            Transitions a test mode created InboundTransfer to the succeeded status. The InboundTransfer must already be in the processing state.
            """
            ...

        @overload
        def succeed(
            self, **params: Unpack["InboundTransfer.SucceedParams"]
        ) -> "InboundTransfer":
            """
            Transitions a test mode created InboundTransfer to the succeeded status. The InboundTransfer must already be in the processing state.
            """
            ...

        @class_method_variant("_cls_succeed")
        def succeed(  # pyright: ignore[reportGeneralTypeIssues]
            self, **params: Unpack["InboundTransfer.SucceedParams"]
        ) -> "InboundTransfer":
            """
            Transitions a test mode created InboundTransfer to the succeeded status. The InboundTransfer must already be in the processing state.
            """
            return cast(
                "InboundTransfer",
                self.resource._request(
                    "post",
                    "/v1/test_helpers/treasury/inbound_transfers/{id}/succeed".format(
                        id=sanitize_id(self.resource.get("id"))
                    ),
                    params=params,
                ),
            )

    @property
    def test_helpers(self):
        return self.TestHelpers(self)

    _inner_class_types = {
        "failure_details": FailureDetails,
        "linked_flows": LinkedFlows,
        "origin_payment_method_details": OriginPaymentMethodDetails,
        "status_transitions": StatusTransitions,
    }


InboundTransfer.TestHelpers._resource_cls = InboundTransfer

1	# -- coding: utf-8 --
2	# File generated from our OpenAPI spec
3	from stripe._createable_api_resource import CreateableAPIResource	1✔
4	from stripe._expandable_field import ExpandableField	1✔
5	from stripe._list_object import ListObject	1✔
6	from stripe._listable_api_resource import ListableAPIResource	1✔
7	from stripe._request_options import RequestOptions	1✔
8	from stripe._stripe_object import StripeObject	1✔
9	from stripe._test_helpers import APIResourceTestHelpers	1✔
10	from stripe._util import class_method_variant, sanitize_id	1✔
11	from typing import ClassVar, Dict, List, Optional, cast, overload	1✔
12	from typing_extensions import (	1✔
13	Literal,
14	NotRequired,
15	Type,
16	TypedDict,
17	Unpack,
18	TYPE_CHECKING,
19	)
20
21	if TYPE_CHECKING:	1!
NEW 22	from stripe._mandate import Mandate	×
UNCOV 23	from stripe.treasury._transaction import Transaction	×
24
25
26	class InboundTransfer(	1✔
27	CreateableAPIResource["InboundTransfer"],
28	ListableAPIResource["InboundTransfer"],
29	):
30	"""
31	Use [InboundTransfers](https://stripe.com/docs/treasury/moving-money/financial-accounts/into/inbound-transfers) to add funds to your [FinancialAccount](https://stripe.com/docs/api#financial_accounts) via a PaymentMethod that is owned by you. The funds will be transferred via an ACH debit.
32	"""
33
34	OBJECT_NAME: ClassVar[	1✔
35	Literal["treasury.inbound_transfer"]
36	] = "treasury.inbound_transfer"
37
38	class FailureDetails(StripeObject):	1✔
39	code: Literal[	1✔
40	"account_closed",
41	"account_frozen",
42	"bank_account_restricted",
43	"bank_ownership_changed",
44	"debit_not_authorized",
45	"incorrect_account_holder_address",
46	"incorrect_account_holder_name",
47	"incorrect_account_holder_tax_id",
48	"insufficient_funds",
49	"invalid_account_number",
50	"invalid_currency",
51	"no_account",
52	"other",
53	]
54	"""	1✔
55	Reason for the failure.
56	"""
57
58	class LinkedFlows(StripeObject):	1✔
59	received_debit: Optional[str]	1✔
60	"""	1✔
61	If funds for this flow were returned after the flow went to the `succeeded` state, this field contains a reference to the ReceivedDebit return.
62	"""
63
64	class OriginPaymentMethodDetails(StripeObject):	1✔
65	class BillingDetails(StripeObject):	1✔
66	class Address(StripeObject):	1✔
67	city: Optional[str]	1✔
68	"""	1✔
69	City, district, suburb, town, or village.
70	"""
71	country: Optional[str]	1✔
72	"""	1✔
73	Two-letter country code ([ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2)).
74	"""
75	line1: Optional[str]	1✔
76	"""	1✔
77	Address line 1 (e.g., street, PO Box, or company name).
78	"""
79	line2: Optional[str]	1✔
80	"""	1✔
81	Address line 2 (e.g., apartment, suite, unit, or building).
82	"""
83	postal_code: Optional[str]	1✔
84	"""	1✔
85	ZIP or postal code.
86	"""
87	state: Optional[str]	1✔
88	"""	1✔
89	State, county, province, or region.
90	"""
91
92	address: Address	1✔
93	email: Optional[str]	1✔
94	"""	1✔
95	Email address.
96	"""
97	name: Optional[str]	1✔
98	"""	1✔
99	Full name.
100	"""
101	_inner_class_types = {"address": Address}	1✔
102
103	class UsBankAccount(StripeObject):	1✔
104	account_holder_type: Optional[Literal["company", "individual"]]	1✔
105	"""	1✔
106	Account holder type: individual or company.
107	"""
108	account_type: Optional[Literal["checking", "savings"]]	1✔
109	"""	1✔
110	Account type: checkings or savings. Defaults to checking if omitted.
111	"""
112	bank_name: Optional[str]	1✔
113	"""	1✔
114	Name of the bank associated with the bank account.
115	"""
116	fingerprint: Optional[str]	1✔
117	"""	1✔
118	Uniquely identifies this particular bank account. You can use this attribute to check whether two bank accounts are the same.
119	"""
120	last4: Optional[str]	1✔
121	"""	1✔
122	Last four digits of the bank account number.
123	"""
124	mandate: Optional[ExpandableField["Mandate"]]	1✔
125	"""	1✔
126	ID of the mandate used to make this payment.
127	"""
128	network: Literal["ach"]	1✔
129	"""	1✔
130	The network rails used. See the [docs](https://stripe.com/docs/treasury/money-movement/timelines) to learn more about money movement timelines for each network type.
131	"""
132	routing_number: Optional[str]	1✔
133	"""	1✔
134	Routing number of the bank account.
135	"""
136
137	billing_details: BillingDetails	1✔
138	type: Literal["us_bank_account"]	1✔
139	"""	1✔
140	The type of the payment method used in the InboundTransfer.
141	"""
142	us_bank_account: Optional[UsBankAccount]	1✔
143	_inner_class_types = {	1✔
144	"billing_details": BillingDetails,
145	"us_bank_account": UsBankAccount,
146	}
147
148	class StatusTransitions(StripeObject):	1✔
149	canceled_at: Optional[int]	1✔
150	"""	1✔
151	Timestamp describing when an InboundTransfer changed status to `canceled`.
152	"""
153	failed_at: Optional[int]	1✔
154	"""	1✔
155	Timestamp describing when an InboundTransfer changed status to `failed`.
156	"""
157	succeeded_at: Optional[int]	1✔
158	"""	1✔
159	Timestamp describing when an InboundTransfer changed status to `succeeded`.
160	"""
161
162	class CancelParams(RequestOptions):	1✔
163	expand: NotRequired["List[str]"]	1✔
164	"""	1✔
165	Specifies which fields in the response should be expanded.
166	"""
167
168	class CreateParams(RequestOptions):	1✔
169	amount: int	1✔
170	"""	1✔
171	Amount (in cents) to be transferred.
172	"""
173	currency: str	1✔
174	"""	1✔
175	Three-letter [ISO currency code](https://www.iso.org/iso-4217-currency-codes.html), in lowercase. Must be a [supported currency](https://stripe.com/docs/currencies).
176	"""
177	description: NotRequired["str"]	1✔
178	"""	1✔
179	An arbitrary string attached to the object. Often useful for displaying to users.
180	"""
181	expand: NotRequired["List[str]"]	1✔
182	"""	1✔
183	Specifies which fields in the response should be expanded.
184	"""
185	financial_account: str	1✔
186	"""	1✔
187	The FinancialAccount to send funds to.
188	"""
189	metadata: NotRequired["Dict[str, str]"]	1✔
190	"""	1✔
191	Set of [key-value pairs](https://stripe.com/docs/api/metadata) that you can attach to an object. This can be useful for storing additional information about the object in a structured format. Individual keys can be unset by posting an empty value to them. All keys can be unset by posting an empty value to `metadata`.
192	"""
193	origin_payment_method: str	1✔
194	"""	1✔
195	The origin payment method to be debited for the InboundTransfer.
196	"""
197	statement_descriptor: NotRequired["str"]	1✔
198	"""	1✔
199	The complete description that appears on your customers' statements. Maximum 10 characters.
200	"""
201
202	class FailParams(RequestOptions):	1✔
203	expand: NotRequired["List[str]"]	1✔
204	"""	1✔
205	Specifies which fields in the response should be expanded.
206	"""
207	failure_details: NotRequired[	1✔
208	"InboundTransfer.FailParamsFailureDetails"
209	]
210	"""	1✔
211	Details about a failed InboundTransfer.
212	"""
213
214	class FailParamsFailureDetails(TypedDict):	1✔
215	code: NotRequired[	1✔
216	"Literal['account_closed', 'account_frozen', 'bank_account_restricted', 'bank_ownership_changed', 'debit_not_authorized', 'incorrect_account_holder_address', 'incorrect_account_holder_name', 'incorrect_account_holder_tax_id', 'insufficient_funds', 'invalid_account_number', 'invalid_currency', 'no_account', 'other']"
217	]
218	"""	1✔
219	Reason for the failure.
220	"""
221
222	class ListParams(RequestOptions):	1✔
223	ending_before: NotRequired["str"]	1✔
224	"""	1✔
225	A cursor for use in pagination. `ending_before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, starting with `obj_bar`, your subsequent call can include `ending_before=obj_bar` in order to fetch the previous page of the list.
226	"""
227	expand: NotRequired["List[str]"]	1✔
228	"""	1✔
229	Specifies which fields in the response should be expanded.
230	"""
231	financial_account: str	1✔
232	"""	1✔
233	Returns objects associated with this FinancialAccount.
234	"""
235	limit: NotRequired["int"]	1✔
236	"""	1✔
237	A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
238	"""
239	starting_after: NotRequired["str"]	1✔
240	"""	1✔
241	A cursor for use in pagination. `starting_after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with `obj_foo`, your subsequent call can include `starting_after=obj_foo` in order to fetch the next page of the list.
242	"""
243	status: NotRequired[	1✔
244	"Literal['canceled', 'failed', 'processing', 'succeeded']"
245	]
246	"""	1✔
247	Only return InboundTransfers that have the given status: `processing`, `succeeded`, `failed` or `canceled`.
248	"""
249
250	class RetrieveParams(RequestOptions):	1✔
251	expand: NotRequired["List[str]"]	1✔
252	"""	1✔
253	Specifies which fields in the response should be expanded.
254	"""
255
256	class ReturnInboundTransferParams(RequestOptions):	1✔
257	expand: NotRequired["List[str]"]	1✔
258	"""	1✔
259	Specifies which fields in the response should be expanded.
260	"""
261
262	class SucceedParams(RequestOptions):	1✔
263	expand: NotRequired["List[str]"]	1✔
264	"""	1✔
265	Specifies which fields in the response should be expanded.
266	"""
267
268	amount: int	1✔
269	"""	1✔
270	Amount (in cents) transferred.
271	"""
272	cancelable: bool	1✔
273	"""	1✔
274	Returns `true` if the InboundTransfer is able to be canceled.
275	"""
276	created: int	1✔
277	"""	1✔
278	Time at which the object was created. Measured in seconds since the Unix epoch.
279	"""
280	currency: str	1✔
281	"""	1✔
282	Three-letter [ISO currency code](https://www.iso.org/iso-4217-currency-codes.html), in lowercase. Must be a [supported currency](https://stripe.com/docs/currencies).
283	"""
284	description: Optional[str]	1✔
285	"""	1✔
286	An arbitrary string attached to the object. Often useful for displaying to users.
287	"""
288	failure_details: Optional[FailureDetails]	1✔
289	"""	1✔
290	Details about this InboundTransfer's failure. Only set when status is `failed`.
291	"""
292	financial_account: str	1✔
293	"""	1✔
294	The FinancialAccount that received the funds.
295	"""
296	hosted_regulatory_receipt_url: Optional[str]	1✔
297	"""	1✔
298	A [hosted transaction receipt](https://stripe.com/docs/treasury/moving-money/regulatory-receipts) URL that is provided when money movement is considered regulated under Stripe's money transmission licenses.
299	"""
300	id: str	1✔
301	"""	1✔
302	Unique identifier for the object.
303	"""
304	linked_flows: LinkedFlows	1✔
305	livemode: bool	1✔
306	"""	1✔
307	Has the value `true` if the object exists in live mode or the value `false` if the object exists in test mode.
308	"""
309	metadata: Dict[str, str]	1✔
310	"""	1✔
311	Set of [key-value pairs](https://stripe.com/docs/api/metadata) that you can attach to an object. This can be useful for storing additional information about the object in a structured format.
312	"""
313	object: Literal["treasury.inbound_transfer"]	1✔
314	"""	1✔
315	String representing the object's type. Objects of the same type share the same value.
316	"""
317	origin_payment_method: str	1✔
318	"""	1✔
319	The origin payment method to be debited for an InboundTransfer.
320	"""
321	origin_payment_method_details: Optional[OriginPaymentMethodDetails]	1✔
322	"""	1✔
323	Details about the PaymentMethod for an InboundTransfer.
324	"""
325	returned: Optional[bool]	1✔
326	"""	1✔
327	Returns `true` if the funds for an InboundTransfer were returned after the InboundTransfer went to the `succeeded` state.
328	"""
329	statement_descriptor: str	1✔
330	"""	1✔
331	Statement descriptor shown when funds are debited from the source. Not all payment networks support `statement_descriptor`.
332	"""
333	status: Literal["canceled", "failed", "processing", "succeeded"]	1✔
334	"""	1✔
335	Status of the InboundTransfer: `processing`, `succeeded`, `failed`, and `canceled`. An InboundTransfer is `processing` if it is created and pending. The status changes to `succeeded` once the funds have been "confirmed" and a `transaction` is created and posted. The status changes to `failed` if the transfer fails.
336	"""
337	status_transitions: StatusTransitions	1✔
338	transaction: Optional[ExpandableField["Transaction"]]	1✔
339	"""	1✔
340	The Transaction associated with this object.
341	"""
342
343	@classmethod	1✔
344	def _cls_cancel(	1✔
345	cls,
346	inbound_transfer: str,
347	**params: Unpack["InboundTransfer.CancelParams"]
348	) -> "InboundTransfer":
349	"""
350	Cancels an InboundTransfer.
351	"""
352	return cast(	1✔
353	"InboundTransfer",
354	cls._static_request(
355	"post",
356	"/v1/treasury/inbound_transfers/{inbound_transfer}/cancel".format(
357	inbound_transfer=sanitize_id(inbound_transfer)
358	),
359	params=params,
360	),
361	)
362
363	@overload	1✔
364	@staticmethod	1✔
365	def cancel(	1✔
366	inbound_transfer: str, **params: Unpack["InboundTransfer.CancelParams"]
367	) -> "InboundTransfer":
368	"""
369	Cancels an InboundTransfer.
370	"""
371	...	×
372
373	@overload	1✔
374	def cancel(	1✔
375	self, **params: Unpack["InboundTransfer.CancelParams"]
376	) -> "InboundTransfer":
377	"""
378	Cancels an InboundTransfer.
379	"""
380	...	×
381
382	@class_method_variant("_cls_cancel")	1✔
383	def cancel( # pyright: ignore[reportGeneralTypeIssues]	1✔
384	self, **params: Unpack["InboundTransfer.CancelParams"]
385	) -> "InboundTransfer":
386	"""
387	Cancels an InboundTransfer.
388	"""
389	return cast(	×
390	"InboundTransfer",
391	self._request(
392	"post",
393	"/v1/treasury/inbound_transfers/{inbound_transfer}/cancel".format(
394	inbound_transfer=sanitize_id(self.get("id"))
395	),
396	params=params,
397	),
398	)
399
400	@classmethod	1✔
401	def create(	1✔
402	cls, **params: Unpack["InboundTransfer.CreateParams"]
403	) -> "InboundTransfer":
404	"""
405	Creates an InboundTransfer.
406	"""
407	return cast(	1✔
408	"InboundTransfer",
409	cls._static_request(
410	"post",
411	cls.class_url(),
412	params=params,
413	),
414	)
415
416	@classmethod	1✔
417	def list(	1✔
418	cls, **params: Unpack["InboundTransfer.ListParams"]
419	) -> ListObject["InboundTransfer"]:
420	"""
421	Returns a list of InboundTransfers sent from the specified FinancialAccount.
422	"""
423	result = cls._static_request(	1✔
424	"get",
425	cls.class_url(),
426	params=params,
427	)
428	if not isinstance(result, ListObject):	1!
429
430	raise TypeError(	×
431	"Expected list object from API, got %s"
432	% (type(result).__name__)
433	)
434
435	return result	1✔
436
437	@classmethod	1✔
438	def retrieve(	1✔
439	cls, id: str, **params: Unpack["InboundTransfer.RetrieveParams"]
440	) -> "InboundTransfer":
441	"""
442	Retrieves the details of an existing InboundTransfer.
443	"""
444	instance = cls(id, **params)	1✔
445	instance.refresh()	1✔
446	return instance	1✔
447
448	class TestHelpers(APIResourceTestHelpers["InboundTransfer"]):	1✔
449	_resource_cls: Type["InboundTransfer"]	1✔
450
451	@classmethod	1✔
452	def _cls_fail(	1✔
453	cls, id: str, **params: Unpack["InboundTransfer.FailParams"]
454	) -> "InboundTransfer":
455	"""
456	Transitions a test mode created InboundTransfer to the failed status. The InboundTransfer must already be in the processing state.
457	"""
458	return cast(	1✔
459	"InboundTransfer",
460	cls._static_request(
461	"post",
462	"/v1/test_helpers/treasury/inbound_transfers/{id}/fail".format(
463	id=sanitize_id(id)
464	),
465	params=params,
466	),
467	)
468
469	@overload	1✔
470	@staticmethod	1✔
471	def fail(	1✔
472	id: str, **params: Unpack["InboundTransfer.FailParams"]
473	) -> "InboundTransfer":
474	"""
475	Transitions a test mode created InboundTransfer to the failed status. The InboundTransfer must already be in the processing state.
476	"""
477	...	×
478
479	@overload	1✔
480	def fail(	1✔
481	self, **params: Unpack["InboundTransfer.FailParams"]
482	) -> "InboundTransfer":
483	"""
484	Transitions a test mode created InboundTransfer to the failed status. The InboundTransfer must already be in the processing state.
485	"""
486	...	×
487
488	@class_method_variant("_cls_fail")	1✔
489	def fail( # pyright: ignore[reportGeneralTypeIssues]	1✔
490	self, **params: Unpack["InboundTransfer.FailParams"]
491	) -> "InboundTransfer":
492	"""
493	Transitions a test mode created InboundTransfer to the failed status. The InboundTransfer must already be in the processing state.
494	"""
495	return cast(	×
496	"InboundTransfer",
497	self.resource._request(
498	"post",
499	"/v1/test_helpers/treasury/inbound_transfers/{id}/fail".format(
500	id=sanitize_id(self.resource.get("id"))
501	),
502	params=params,
503	),
504	)
505
506	@classmethod	1✔
507	def _cls_return_inbound_transfer(	1✔
508	cls,
509	id: str,
510	**params: Unpack["InboundTransfer.ReturnInboundTransferParams"]
511	) -> "InboundTransfer":
512	"""
513	Marks the test mode InboundTransfer object as returned and links the InboundTransfer to a ReceivedDebit. The InboundTransfer must already be in the succeeded state.
514	"""
515	return cast(	1✔
516	"InboundTransfer",
517	cls._static_request(
518	"post",
519	"/v1/test_helpers/treasury/inbound_transfers/{id}/return".format(
520	id=sanitize_id(id)
521	),
522	params=params,
523	),
524	)
525
526	@overload	1✔
527	@staticmethod	1✔
528	def return_inbound_transfer(	1✔
529	id: str,
530	**params: Unpack["InboundTransfer.ReturnInboundTransferParams"]
531	) -> "InboundTransfer":
532	"""
533	Marks the test mode InboundTransfer object as returned and links the InboundTransfer to a ReceivedDebit. The InboundTransfer must already be in the succeeded state.
534	"""
535	...	×
536
537	@overload	1✔
538	def return_inbound_transfer(	1✔
539	self,
540	**params: Unpack["InboundTransfer.ReturnInboundTransferParams"]
541	) -> "InboundTransfer":
542	"""
543	Marks the test mode InboundTransfer object as returned and links the InboundTransfer to a ReceivedDebit. The InboundTransfer must already be in the succeeded state.
544	"""
545	...	×
546
547	@class_method_variant("_cls_return_inbound_transfer")	1✔
548	def return_inbound_transfer( # pyright: ignore[reportGeneralTypeIssues]	1✔
549	self,
550	**params: Unpack["InboundTransfer.ReturnInboundTransferParams"]
551	) -> "InboundTransfer":
552	"""
553	Marks the test mode InboundTransfer object as returned and links the InboundTransfer to a ReceivedDebit. The InboundTransfer must already be in the succeeded state.
554	"""
555	return cast(	×
556	"InboundTransfer",
557	self.resource._request(
558	"post",
559	"/v1/test_helpers/treasury/inbound_transfers/{id}/return".format(
560	id=sanitize_id(self.resource.get("id"))
561	),
562	params=params,
563	),
564	)
565
566	@classmethod	1✔
567	def _cls_succeed(	1✔
568	cls, id: str, **params: Unpack["InboundTransfer.SucceedParams"]
569	) -> "InboundTransfer":
570	"""
571	Transitions a test mode created InboundTransfer to the succeeded status. The InboundTransfer must already be in the processing state.
572	"""
573	return cast(	1✔
574	"InboundTransfer",
575	cls._static_request(
576	"post",
577	"/v1/test_helpers/treasury/inbound_transfers/{id}/succeed".format(
578	id=sanitize_id(id)
579	),
580	params=params,
581	),
582	)
583
584	@overload	1✔
585	@staticmethod	1✔
586	def succeed(	1✔
587	id: str, **params: Unpack["InboundTransfer.SucceedParams"]
588	) -> "InboundTransfer":
589	"""
590	Transitions a test mode created InboundTransfer to the succeeded status. The InboundTransfer must already be in the processing state.
591	"""
592	...	×
593
594	@overload	1✔
595	def succeed(	1✔
596	self, **params: Unpack["InboundTransfer.SucceedParams"]
597	) -> "InboundTransfer":
598	"""
599	Transitions a test mode created InboundTransfer to the succeeded status. The InboundTransfer must already be in the processing state.
600	"""
601	...	×
602
603	@class_method_variant("_cls_succeed")	1✔
604	def succeed( # pyright: ignore[reportGeneralTypeIssues]	1✔
605	self, **params: Unpack["InboundTransfer.SucceedParams"]
606	) -> "InboundTransfer":
607	"""
608	Transitions a test mode created InboundTransfer to the succeeded status. The InboundTransfer must already be in the processing state.
609	"""
610	return cast(	×
611	"InboundTransfer",
612	self.resource._request(
613	"post",
614	"/v1/test_helpers/treasury/inbound_transfers/{id}/succeed".format(
615	id=sanitize_id(self.resource.get("id"))
616	),
617	params=params,
618	),
619	)
620
621	@property	1✔
622	def test_helpers(self):	1✔
623	return self.TestHelpers(self)	×
624
625	_inner_class_types = {	1✔
626	"failure_details": FailureDetails,
627	"linked_flows": LinkedFlows,
628	"origin_payment_method_details": OriginPaymentMethodDetails,
629	"status_transitions": StatusTransitions,
630	}
631
632
633	InboundTransfer.TestHelpers._resource_cls = InboundTransfer	1✔

stripe / stripe-python / 8425714545

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous