8472487790

Committed 28 Mar 2024 07:10PM UTC coverage: 97.393% (-0.05%) from 97.442%

Build # 8472487790

Build Type

push

github

Committed by

web-flow

Commit Message

Update generated code (#1276)

* Update generated code for v907

* Update generated code for v908

* Update generated code for v909

* Update generated code for v910

* Update generated code for v911

---------

Co-authored-by: Stripe OpenAPI <105521251+stripe-openapi[bot]@users.noreply.github.com>

Run Details

903 of 1366 branches covered (66.11%)

Branch coverage included in aggregate %.

460 of 494 new or added lines in 31 files covered. (93.12%)

3 existing lines in 3 files now uncovered.

56971 of 58057 relevant lines covered (98.13%)

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[
217	"account_closed",
218	"account_frozen",
219	"bank_account_restricted",
220	"bank_ownership_changed",
221	"debit_not_authorized",
222	"incorrect_account_holder_address",
223	"incorrect_account_holder_name",
224	"incorrect_account_holder_tax_id",
225	"insufficient_funds",
226	"invalid_account_number",
227	"invalid_currency",
228	"no_account",
229	"other",
230	]
231	]
232	"""	1✔
233	Reason for the failure.
234	"""
235
236	class ListParams(RequestOptions):	1✔
237	ending_before: NotRequired[str]	1✔
238	"""	1✔
239	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.
240	"""
241	expand: NotRequired[List[str]]	1✔
242	"""	1✔
243	Specifies which fields in the response should be expanded.
244	"""
245	financial_account: str	1✔
246	"""	1✔
247	Returns objects associated with this FinancialAccount.
248	"""
249	limit: NotRequired[int]	1✔
250	"""	1✔
251	A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
252	"""
253	starting_after: NotRequired[str]	1✔
254	"""	1✔
255	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.
256	"""
257	status: NotRequired[	1✔
258	Literal["canceled", "failed", "processing", "succeeded"]
259	]
260	"""	1✔
261	Only return InboundTransfers that have the given status: `processing`, `succeeded`, `failed` or `canceled`.
262	"""
263
264	class RetrieveParams(RequestOptions):	1✔
265	expand: NotRequired[List[str]]	1✔
266	"""	1✔
267	Specifies which fields in the response should be expanded.
268	"""
269
270	class ReturnInboundTransferParams(RequestOptions):	1✔
271	expand: NotRequired[List[str]]	1✔
272	"""	1✔
273	Specifies which fields in the response should be expanded.
274	"""
275
276	class SucceedParams(RequestOptions):	1✔
277	expand: NotRequired[List[str]]	1✔
278	"""	1✔
279	Specifies which fields in the response should be expanded.
280	"""
281
282	amount: int	1✔
283	"""	1✔
284	Amount (in cents) transferred.
285	"""
286	cancelable: bool	1✔
287	"""	1✔
288	Returns `true` if the InboundTransfer is able to be canceled.
289	"""
290	created: int	1✔
291	"""	1✔
292	Time at which the object was created. Measured in seconds since the Unix epoch.
293	"""
294	currency: str	1✔
295	"""	1✔
296	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).
297	"""
298	description: Optional[str]	1✔
299	"""	1✔
300	An arbitrary string attached to the object. Often useful for displaying to users.
301	"""
302	failure_details: Optional[FailureDetails]	1✔
303	"""	1✔
304	Details about this InboundTransfer's failure. Only set when status is `failed`.
305	"""
306	financial_account: str	1✔
307	"""	1✔
308	The FinancialAccount that received the funds.
309	"""
310	hosted_regulatory_receipt_url: Optional[str]	1✔
311	"""	1✔
312	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.
313	"""
314	id: str	1✔
315	"""	1✔
316	Unique identifier for the object.
317	"""
318	linked_flows: LinkedFlows	1✔
319	livemode: bool	1✔
320	"""	1✔
321	Has the value `true` if the object exists in live mode or the value `false` if the object exists in test mode.
322	"""
323	metadata: Dict[str, str]	1✔
324	"""	1✔
325	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.
326	"""
327	object: Literal["treasury.inbound_transfer"]	1✔
328	"""	1✔
329	String representing the object's type. Objects of the same type share the same value.
330	"""
331	origin_payment_method: str	1✔
332	"""	1✔
333	The origin payment method to be debited for an InboundTransfer.
334	"""
335	origin_payment_method_details: Optional[OriginPaymentMethodDetails]	1✔
336	"""	1✔
337	Details about the PaymentMethod for an InboundTransfer.
338	"""
339	returned: Optional[bool]	1✔
340	"""	1✔
341	Returns `true` if the funds for an InboundTransfer were returned after the InboundTransfer went to the `succeeded` state.
342	"""
343	statement_descriptor: str	1✔
344	"""	1✔
345	Statement descriptor shown when funds are debited from the source. Not all payment networks support `statement_descriptor`.
346	"""
347	status: Literal["canceled", "failed", "processing", "succeeded"]	1✔
348	"""	1✔
349	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.
350	"""
351	status_transitions: StatusTransitions	1✔
352	transaction: Optional[ExpandableField["Transaction"]]	1✔
353	"""	1✔
354	The Transaction associated with this object.
355	"""
356
357	@classmethod	1✔
358	def _cls_cancel(	1✔
359	cls,
360	inbound_transfer: str,
361	**params: Unpack["InboundTransfer.CancelParams"]
362	) -> "InboundTransfer":
363	"""
364	Cancels an InboundTransfer.
365	"""
366	return cast(	1✔
367	"InboundTransfer",
368	cls._static_request(
369	"post",
370	"/v1/treasury/inbound_transfers/{inbound_transfer}/cancel".format(
371	inbound_transfer=sanitize_id(inbound_transfer)
372	),
373	params=params,
374	),
375	)
376
377	@overload	1✔
378	@staticmethod	1✔
379	def cancel(	1✔
380	inbound_transfer: str, **params: Unpack["InboundTransfer.CancelParams"]
381	) -> "InboundTransfer":
382	"""
383	Cancels an InboundTransfer.
384	"""
385	...	×
386
387	@overload	1✔
388	def cancel(	1✔
389	self, **params: Unpack["InboundTransfer.CancelParams"]
390	) -> "InboundTransfer":
391	"""
392	Cancels an InboundTransfer.
393	"""
394	...	×
395
396	@class_method_variant("_cls_cancel")	1✔
397	def cancel( # pyright: ignore[reportGeneralTypeIssues]	1✔
398	self, **params: Unpack["InboundTransfer.CancelParams"]
399	) -> "InboundTransfer":
400	"""
401	Cancels an InboundTransfer.
402	"""
403	return cast(	×
404	"InboundTransfer",
405	self._request(
406	"post",
407	"/v1/treasury/inbound_transfers/{inbound_transfer}/cancel".format(
408	inbound_transfer=sanitize_id(self.get("id"))
409	),
410	params=params,
411	),
412	)
413
414	@classmethod	1✔
415	def create(	1✔
416	cls, **params: Unpack["InboundTransfer.CreateParams"]
417	) -> "InboundTransfer":
418	"""
419	Creates an InboundTransfer.
420	"""
421	return cast(	1✔
422	"InboundTransfer",
423	cls._static_request(
424	"post",
425	cls.class_url(),
426	params=params,
427	),
428	)
429
430	@classmethod	1✔
431	def list(	1✔
432	cls, **params: Unpack["InboundTransfer.ListParams"]
433	) -> ListObject["InboundTransfer"]:
434	"""
435	Returns a list of InboundTransfers sent from the specified FinancialAccount.
436	"""
437	result = cls._static_request(	1✔
438	"get",
439	cls.class_url(),
440	params=params,
441	)
442	if not isinstance(result, ListObject):	1!
443
444	raise TypeError(	×
445	"Expected list object from API, got %s"
446	% (type(result).__name__)
447	)
448
449	return result	1✔
450
451	@classmethod	1✔
452	def retrieve(	1✔
453	cls, id: str, **params: Unpack["InboundTransfer.RetrieveParams"]
454	) -> "InboundTransfer":
455	"""
456	Retrieves the details of an existing InboundTransfer.
457	"""
458	instance = cls(id, **params)	1✔
459	instance.refresh()	1✔
460	return instance	1✔
461
462	class TestHelpers(APIResourceTestHelpers["InboundTransfer"]):	1✔
463	_resource_cls: Type["InboundTransfer"]	1✔
464
465	@classmethod	1✔
466	def _cls_fail(	1✔
467	cls, id: str, **params: Unpack["InboundTransfer.FailParams"]
468	) -> "InboundTransfer":
469	"""
470	Transitions a test mode created InboundTransfer to the failed status. The InboundTransfer must already be in the processing state.
471	"""
472	return cast(	1✔
473	"InboundTransfer",
474	cls._static_request(
475	"post",
476	"/v1/test_helpers/treasury/inbound_transfers/{id}/fail".format(
477	id=sanitize_id(id)
478	),
479	params=params,
480	),
481	)
482
483	@overload	1✔
484	@staticmethod	1✔
485	def fail(	1✔
486	id: str, **params: Unpack["InboundTransfer.FailParams"]
487	) -> "InboundTransfer":
488	"""
489	Transitions a test mode created InboundTransfer to the failed status. The InboundTransfer must already be in the processing state.
490	"""
491	...	×
492
493	@overload	1✔
494	def fail(	1✔
495	self, **params: Unpack["InboundTransfer.FailParams"]
496	) -> "InboundTransfer":
497	"""
498	Transitions a test mode created InboundTransfer to the failed status. The InboundTransfer must already be in the processing state.
499	"""
500	...	×
501
502	@class_method_variant("_cls_fail")	1✔
503	def fail( # pyright: ignore[reportGeneralTypeIssues]	1✔
504	self, **params: Unpack["InboundTransfer.FailParams"]
505	) -> "InboundTransfer":
506	"""
507	Transitions a test mode created InboundTransfer to the failed status. The InboundTransfer must already be in the processing state.
508	"""
509	return cast(	×
510	"InboundTransfer",
511	self.resource._request(
512	"post",
513	"/v1/test_helpers/treasury/inbound_transfers/{id}/fail".format(
514	id=sanitize_id(self.resource.get("id"))
515	),
516	params=params,
517	),
518	)
519
520	@classmethod	1✔
521	def _cls_return_inbound_transfer(	1✔
522	cls,
523	id: str,
524	**params: Unpack["InboundTransfer.ReturnInboundTransferParams"]
525	) -> "InboundTransfer":
526	"""
527	Marks the test mode InboundTransfer object as returned and links the InboundTransfer to a ReceivedDebit. The InboundTransfer must already be in the succeeded state.
528	"""
529	return cast(	1✔
530	"InboundTransfer",
531	cls._static_request(
532	"post",
533	"/v1/test_helpers/treasury/inbound_transfers/{id}/return".format(
534	id=sanitize_id(id)
535	),
536	params=params,
537	),
538	)
539
540	@overload	1✔
541	@staticmethod	1✔
542	def return_inbound_transfer(	1✔
543	id: str,
544	**params: Unpack["InboundTransfer.ReturnInboundTransferParams"]
545	) -> "InboundTransfer":
546	"""
547	Marks the test mode InboundTransfer object as returned and links the InboundTransfer to a ReceivedDebit. The InboundTransfer must already be in the succeeded state.
548	"""
549	...	×
550
551	@overload	1✔
552	def return_inbound_transfer(	1✔
553	self,
554	**params: Unpack["InboundTransfer.ReturnInboundTransferParams"]
555	) -> "InboundTransfer":
556	"""
557	Marks the test mode InboundTransfer object as returned and links the InboundTransfer to a ReceivedDebit. The InboundTransfer must already be in the succeeded state.
558	"""
559	...	×
560
561	@class_method_variant("_cls_return_inbound_transfer")	1✔
562	def return_inbound_transfer( # pyright: ignore[reportGeneralTypeIssues]	1✔
563	self,
564	**params: Unpack["InboundTransfer.ReturnInboundTransferParams"]
565	) -> "InboundTransfer":
566	"""
567	Marks the test mode InboundTransfer object as returned and links the InboundTransfer to a ReceivedDebit. The InboundTransfer must already be in the succeeded state.
568	"""
569	return cast(	×
570	"InboundTransfer",
571	self.resource._request(
572	"post",
573	"/v1/test_helpers/treasury/inbound_transfers/{id}/return".format(
574	id=sanitize_id(self.resource.get("id"))
575	),
576	params=params,
577	),
578	)
579
580	@classmethod	1✔
581	def _cls_succeed(	1✔
582	cls, id: str, **params: Unpack["InboundTransfer.SucceedParams"]
583	) -> "InboundTransfer":
584	"""
585	Transitions a test mode created InboundTransfer to the succeeded status. The InboundTransfer must already be in the processing state.
586	"""
587	return cast(	1✔
588	"InboundTransfer",
589	cls._static_request(
590	"post",
591	"/v1/test_helpers/treasury/inbound_transfers/{id}/succeed".format(
592	id=sanitize_id(id)
593	),
594	params=params,
595	),
596	)
597
598	@overload	1✔
599	@staticmethod	1✔
600	def succeed(	1✔
601	id: str, **params: Unpack["InboundTransfer.SucceedParams"]
602	) -> "InboundTransfer":
603	"""
604	Transitions a test mode created InboundTransfer to the succeeded status. The InboundTransfer must already be in the processing state.
605	"""
606	...	×
607
608	@overload	1✔
609	def succeed(	1✔
610	self, **params: Unpack["InboundTransfer.SucceedParams"]
611	) -> "InboundTransfer":
612	"""
613	Transitions a test mode created InboundTransfer to the succeeded status. The InboundTransfer must already be in the processing state.
614	"""
615	...	×
616
617	@class_method_variant("_cls_succeed")	1✔
618	def succeed( # pyright: ignore[reportGeneralTypeIssues]	1✔
619	self, **params: Unpack["InboundTransfer.SucceedParams"]
620	) -> "InboundTransfer":
621	"""
622	Transitions a test mode created InboundTransfer to the succeeded status. The InboundTransfer must already be in the processing state.
623	"""
624	return cast(	×
625	"InboundTransfer",
626	self.resource._request(
627	"post",
628	"/v1/test_helpers/treasury/inbound_transfers/{id}/succeed".format(
629	id=sanitize_id(self.resource.get("id"))
630	),
631	params=params,
632	),
633	)
634
635	@property	1✔
636	def test_helpers(self):	1✔
637	return self.TestHelpers(self)	×
638
639	_inner_class_types = {	1✔
640	"failure_details": FailureDetails,
641	"linked_flows": LinkedFlows,
642	"origin_payment_method_details": OriginPaymentMethodDetails,
643	"status_transitions": StatusTransitions,
644	}
645
646
647	InboundTransfer.TestHelpers._resource_cls = InboundTransfer	1✔

stripe / stripe-python / 8472487790

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