8994490684

Committed 08 May 2024 12:55AM UTC coverage: 96.371% (-0.02%) from 96.393%

Build # 8994490684

Build Type

Pull #1323

github

Committed by

web-flow

Commit Message

Merge bce3cb1a5 into 7e563c565

Pull Request Pull Request #1323: Update generated code

Run Details

1085 of 1678 branches covered (64.66%)

Branch coverage included in aggregate %.

160 of 180 new or added lines in 8 files covered. (88.89%)

1 existing line in 1 file now uncovered.

64222 of 66088 relevant lines covered (97.18%)

0.97 hits per line

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

96.49

/stripe/test_helpers/treasury/_outbound_transfer_service.py

# -*- coding: utf-8 -*-
# File generated from our OpenAPI spec
from stripe._request_options import RequestOptions
from stripe._stripe_service import StripeService
from stripe._util import sanitize_id
from stripe.treasury._outbound_transfer import OutboundTransfer
from typing import List, cast
from typing_extensions import Literal, NotRequired, TypedDict


class OutboundTransferService(StripeService):
    class FailParams(TypedDict):
        expand: NotRequired[List[str]]
        """
        Specifies which fields in the response should be expanded.
        """

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

    class ReturnOutboundTransferParams(TypedDict):
        expand: NotRequired[List[str]]
        """
        Specifies which fields in the response should be expanded.
        """
        returned_details: NotRequired[
            "OutboundTransferService.ReturnOutboundTransferParamsReturnedDetails"
        ]
        """
        Details about a returned OutboundTransfer.
        """

    class ReturnOutboundTransferParamsReturnedDetails(TypedDict):
        code: NotRequired[
            Literal[
                "account_closed",
                "account_frozen",
                "bank_account_restricted",
                "bank_ownership_changed",
                "declined",
                "incorrect_account_holder_name",
                "invalid_account_number",
                "invalid_currency",
                "no_account",
                "other",
            ]
        ]
        """
        Reason for the return.
        """

    class UpdateParams(TypedDict):
        expand: NotRequired[List[str]]
        """
        Specifies which fields in the response should be expanded.
        """
        tracking_details: "OutboundTransferService.UpdateParamsTrackingDetails"
        """
        Details about network-specific tracking information.
        """

    class UpdateParamsTrackingDetails(TypedDict):
        ach: NotRequired[
            "OutboundTransferService.UpdateParamsTrackingDetailsAch"
        ]
        """
        ACH network tracking details.
        """
        type: Literal["ach", "us_domestic_wire"]
        """
        The US bank account network used to send funds.
        """
        us_domestic_wire: NotRequired[
            "OutboundTransferService.UpdateParamsTrackingDetailsUsDomesticWire"
        ]
        """
        US domestic wire network tracking details.
        """

    class UpdateParamsTrackingDetailsAch(TypedDict):
        trace_id: str
        """
        ACH trace ID for funds sent over the `ach` network.
        """

    class UpdateParamsTrackingDetailsUsDomesticWire(TypedDict):
        imad: NotRequired[str]
        """
        IMAD for funds sent over the `us_domestic_wire` network.
        """
        omad: NotRequired[str]
        """
        OMAD for funds sent over the `us_domestic_wire` network.
        """

    def update(
        self,
        outbound_transfer: str,
        params: "OutboundTransferService.UpdateParams",
        options: RequestOptions = {},
    ) -> OutboundTransfer:
        """
        Updates a test mode created OutboundTransfer with tracking details. The OutboundTransfer must not be cancelable, and cannot be in the canceled or failed states.
        """
        return cast(
            OutboundTransfer,
            self._request(
                "post",
                "/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}".format(
                    outbound_transfer=sanitize_id(outbound_transfer),
                ),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    async def update_async(
        self,
        outbound_transfer: str,
        params: "OutboundTransferService.UpdateParams",
        options: RequestOptions = {},
    ) -> OutboundTransfer:
        """
        Updates a test mode created OutboundTransfer with tracking details. The OutboundTransfer must not be cancelable, and cannot be in the canceled or failed states.
        """
        return cast(
            OutboundTransfer,
            await self._request_async(
                "post",
                "/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}".format(
                    outbound_transfer=sanitize_id(outbound_transfer),
                ),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    def fail(
        self,
        outbound_transfer: str,
        params: "OutboundTransferService.FailParams" = {},
        options: RequestOptions = {},
    ) -> OutboundTransfer:
        """
        Transitions a test mode created OutboundTransfer to the failed status. The OutboundTransfer must already be in the processing state.
        """
        return cast(
            OutboundTransfer,
            self._request(
                "post",
                "/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}/fail".format(
                    outbound_transfer=sanitize_id(outbound_transfer),
                ),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    async def fail_async(
        self,
        outbound_transfer: str,
        params: "OutboundTransferService.FailParams" = {},
        options: RequestOptions = {},
    ) -> OutboundTransfer:
        """
        Transitions a test mode created OutboundTransfer to the failed status. The OutboundTransfer must already be in the processing state.
        """
        return cast(
            OutboundTransfer,
            await self._request_async(
                "post",
                "/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}/fail".format(
                    outbound_transfer=sanitize_id(outbound_transfer),
                ),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    def post(
        self,
        outbound_transfer: str,
        params: "OutboundTransferService.PostParams" = {},
        options: RequestOptions = {},
    ) -> OutboundTransfer:
        """
        Transitions a test mode created OutboundTransfer to the posted status. The OutboundTransfer must already be in the processing state.
        """
        return cast(
            OutboundTransfer,
            self._request(
                "post",
                "/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}/post".format(
                    outbound_transfer=sanitize_id(outbound_transfer),
                ),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    async def post_async(
        self,
        outbound_transfer: str,
        params: "OutboundTransferService.PostParams" = {},
        options: RequestOptions = {},
    ) -> OutboundTransfer:
        """
        Transitions a test mode created OutboundTransfer to the posted status. The OutboundTransfer must already be in the processing state.
        """
        return cast(
            OutboundTransfer,
            await self._request_async(
                "post",
                "/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}/post".format(
                    outbound_transfer=sanitize_id(outbound_transfer),
                ),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    def return_outbound_transfer(
        self,
        outbound_transfer: str,
        params: "OutboundTransferService.ReturnOutboundTransferParams" = {},
        options: RequestOptions = {},
    ) -> OutboundTransfer:
        """
        Transitions a test mode created OutboundTransfer to the returned status. The OutboundTransfer must already be in the processing state.
        """
        return cast(
            OutboundTransfer,
            self._request(
                "post",
                "/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}/return".format(
                    outbound_transfer=sanitize_id(outbound_transfer),
                ),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    async def return_outbound_transfer_async(
        self,
        outbound_transfer: str,
        params: "OutboundTransferService.ReturnOutboundTransferParams" = {},
        options: RequestOptions = {},
    ) -> OutboundTransfer:
        """
        Transitions a test mode created OutboundTransfer to the returned status. The OutboundTransfer must already be in the processing state.
        """
        return cast(
            OutboundTransfer,
            await self._request_async(
                "post",
                "/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}/return".format(
                    outbound_transfer=sanitize_id(outbound_transfer),
                ),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

1	# -- coding: utf-8 --
2	# File generated from our OpenAPI spec
3	from stripe._request_options import RequestOptions	1✔
4	from stripe._stripe_service import StripeService	1✔
5	from stripe._util import sanitize_id	1✔
6	from stripe.treasury._outbound_transfer import OutboundTransfer	1✔
7	from typing import List, cast	1✔
8	from typing_extensions import Literal, NotRequired, TypedDict	1✔
9
10
11	class OutboundTransferService(StripeService):	1✔
12	class FailParams(TypedDict):	1✔
13	expand: NotRequired[List[str]]	1✔
14	"""	1✔
15	Specifies which fields in the response should be expanded.
16	"""
17
18	class PostParams(TypedDict):	1✔
19	expand: NotRequired[List[str]]	1✔
20	"""	1✔
21	Specifies which fields in the response should be expanded.
22	"""
23
24	class ReturnOutboundTransferParams(TypedDict):	1✔
25	expand: NotRequired[List[str]]	1✔
26	"""	1✔
27	Specifies which fields in the response should be expanded.
28	"""
29	returned_details: NotRequired[	1✔
30	"OutboundTransferService.ReturnOutboundTransferParamsReturnedDetails"
31	]
32	"""	1✔
33	Details about a returned OutboundTransfer.
34	"""
35
36	class ReturnOutboundTransferParamsReturnedDetails(TypedDict):	1✔
37	code: NotRequired[	1✔
38	Literal[
39	"account_closed",
40	"account_frozen",
41	"bank_account_restricted",
42	"bank_ownership_changed",
43	"declined",
44	"incorrect_account_holder_name",
45	"invalid_account_number",
46	"invalid_currency",
47	"no_account",
48	"other",
49	]
50	]
51	"""	1✔
52	Reason for the return.
53	"""
54
55	class UpdateParams(TypedDict):	1✔
56	expand: NotRequired[List[str]]	1✔
57	"""	1✔
58	Specifies which fields in the response should be expanded.
59	"""
60	tracking_details: "OutboundTransferService.UpdateParamsTrackingDetails"	1✔
61	"""	1✔
62	Details about network-specific tracking information.
63	"""
64
65	class UpdateParamsTrackingDetails(TypedDict):	1✔
66	ach: NotRequired[	1✔
67	"OutboundTransferService.UpdateParamsTrackingDetailsAch"
68	]
69	"""	1✔
70	ACH network tracking details.
71	"""
72	type: Literal["ach", "us_domestic_wire"]	1✔
73	"""	1✔
74	The US bank account network used to send funds.
75	"""
76	us_domestic_wire: NotRequired[	1✔
77	"OutboundTransferService.UpdateParamsTrackingDetailsUsDomesticWire"
78	]
79	"""	1✔
80	US domestic wire network tracking details.
81	"""
82
83	class UpdateParamsTrackingDetailsAch(TypedDict):	1✔
84	trace_id: str	1✔
85	"""	1✔
86	ACH trace ID for funds sent over the `ach` network.
87	"""
88
89	class UpdateParamsTrackingDetailsUsDomesticWire(TypedDict):	1✔
90	imad: NotRequired[str]	1✔
91	"""	1✔
92	IMAD for funds sent over the `us_domestic_wire` network.
93	"""
94	omad: NotRequired[str]	1✔
95	"""	1✔
96	OMAD for funds sent over the `us_domestic_wire` network.
97	"""
98
99	def update(	1✔
100	self,
101	outbound_transfer: str,
102	params: "OutboundTransferService.UpdateParams",
103	options: RequestOptions = {},
104	) -> OutboundTransfer:
105	"""
106	Updates a test mode created OutboundTransfer with tracking details. The OutboundTransfer must not be cancelable, and cannot be in the canceled or failed states.
107	"""
NEW 108	return cast(	×
109	OutboundTransfer,
110	self._request(
111	"post",
112	"/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}".format(
113	outbound_transfer=sanitize_id(outbound_transfer),
114	),
115	api_mode="V1",
116	base_address="api",
117	params=params,
118	options=options,
119	),
120	)
121
122	async def update_async(	1✔
123	self,
124	outbound_transfer: str,
125	params: "OutboundTransferService.UpdateParams",
126	options: RequestOptions = {},
127	) -> OutboundTransfer:
128	"""
129	Updates a test mode created OutboundTransfer with tracking details. The OutboundTransfer must not be cancelable, and cannot be in the canceled or failed states.
130	"""
NEW 131	return cast(	×
132	OutboundTransfer,
133	await self._request_async(
134	"post",
135	"/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}".format(
136	outbound_transfer=sanitize_id(outbound_transfer),
137	),
138	api_mode="V1",
139	base_address="api",
140	params=params,
141	options=options,
142	),
143	)
144
145	def fail(	1✔
146	self,
147	outbound_transfer: str,
148	params: "OutboundTransferService.FailParams" = {},
149	options: RequestOptions = {},
150	) -> OutboundTransfer:
151	"""
152	Transitions a test mode created OutboundTransfer to the failed status. The OutboundTransfer must already be in the processing state.
153	"""
154	return cast(	1✔
155	OutboundTransfer,
156	self._request(
157	"post",
158	"/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}/fail".format(
159	outbound_transfer=sanitize_id(outbound_transfer),
160	),
161	api_mode="V1",
162	base_address="api",
163	params=params,
164	options=options,
165	),
166	)
167
168	async def fail_async(	1✔
169	self,
170	outbound_transfer: str,
171	params: "OutboundTransferService.FailParams" = {},
172	options: RequestOptions = {},
173	) -> OutboundTransfer:
174	"""
175	Transitions a test mode created OutboundTransfer to the failed status. The OutboundTransfer must already be in the processing state.
176	"""
177	return cast(	1✔
178	OutboundTransfer,
179	await self._request_async(
180	"post",
181	"/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}/fail".format(
182	outbound_transfer=sanitize_id(outbound_transfer),
183	),
184	api_mode="V1",
185	base_address="api",
186	params=params,
187	options=options,
188	),
189	)
190
191	def post(	1✔
192	self,
193	outbound_transfer: str,
194	params: "OutboundTransferService.PostParams" = {},
195	options: RequestOptions = {},
196	) -> OutboundTransfer:
197	"""
198	Transitions a test mode created OutboundTransfer to the posted status. The OutboundTransfer must already be in the processing state.
199	"""
200	return cast(	1✔
201	OutboundTransfer,
202	self._request(
203	"post",
204	"/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}/post".format(
205	outbound_transfer=sanitize_id(outbound_transfer),
206	),
207	api_mode="V1",
208	base_address="api",
209	params=params,
210	options=options,
211	),
212	)
213
214	async def post_async(	1✔
215	self,
216	outbound_transfer: str,
217	params: "OutboundTransferService.PostParams" = {},
218	options: RequestOptions = {},
219	) -> OutboundTransfer:
220	"""
221	Transitions a test mode created OutboundTransfer to the posted status. The OutboundTransfer must already be in the processing state.
222	"""
223	return cast(	1✔
224	OutboundTransfer,
225	await self._request_async(
226	"post",
227	"/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}/post".format(
228	outbound_transfer=sanitize_id(outbound_transfer),
229	),
230	api_mode="V1",
231	base_address="api",
232	params=params,
233	options=options,
234	),
235	)
236
237	def return_outbound_transfer(	1✔
238	self,
239	outbound_transfer: str,
240	params: "OutboundTransferService.ReturnOutboundTransferParams" = {},
241	options: RequestOptions = {},
242	) -> OutboundTransfer:
243	"""
244	Transitions a test mode created OutboundTransfer to the returned status. The OutboundTransfer must already be in the processing state.
245	"""
246	return cast(	1✔
247	OutboundTransfer,
248	self._request(
249	"post",
250	"/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}/return".format(
251	outbound_transfer=sanitize_id(outbound_transfer),
252	),
253	api_mode="V1",
254	base_address="api",
255	params=params,
256	options=options,
257	),
258	)
259
260	async def return_outbound_transfer_async(	1✔
261	self,
262	outbound_transfer: str,
263	params: "OutboundTransferService.ReturnOutboundTransferParams" = {},
264	options: RequestOptions = {},
265	) -> OutboundTransfer:
266	"""
267	Transitions a test mode created OutboundTransfer to the returned status. The OutboundTransfer must already be in the processing state.
268	"""
269	return cast(	1✔
270	OutboundTransfer,
271	await self._request_async(
272	"post",
273	"/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}/return".format(
274	outbound_transfer=sanitize_id(outbound_transfer),
275	),
276	api_mode="V1",
277	base_address="api",
278	params=params,
279	options=options,
280	),
281	)

stripe / stripe-python / 8994490684

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