8975426468

Committed 06 May 2024 08:34PM UTC coverage: 96.373% (-0.02%) from 96.393%

Build # 8975426468

Build Type

Pull #1323

github

Committed by

web-flow

Commit Message

Merge fc3dfcb70 into 7e563c565

Pull Request Pull Request #1323: Update generated code

Run Details

1085 of 1678 branches covered (64.66%)

Branch coverage included in aggregate %.

156 of 176 new or added lines in 6 files covered. (88.64%)

42 existing lines in 3 files now uncovered.

64219 of 66084 relevant lines covered (97.18%)

0.97 hits per line

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

85.96

/stripe/test_helpers/treasury/_outbound_payment_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_payment import OutboundPayment
from typing import List, cast
from typing_extensions import Literal, NotRequired, TypedDict


class OutboundPaymentService(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 ReturnOutboundPaymentParams(TypedDict):
        expand: NotRequired[List[str]]
        """
        Specifies which fields in the response should be expanded.
        """
        returned_details: NotRequired[
            "OutboundPaymentService.ReturnOutboundPaymentParamsReturnedDetails"
        ]
        """
        Optional hash to set the the return code.
        """

    class ReturnOutboundPaymentParamsReturnedDetails(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",
            ]
        ]
        """
        The return code to be set on the OutboundPayment object.
        """

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

    class UpdateParamsTrackingDetails(TypedDict):
        ach: NotRequired[
            "OutboundPaymentService.UpdateParamsTrackingDetailsAch"
        ]
        """
        ACH network tracking details.
        """
        type: Literal["ach", "us_domestic_wire"]
        """
        The US bank account network used to send funds.
        """
        us_domestic_wire: NotRequired[
            "OutboundPaymentService.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,
        id: str,
        params: "OutboundPaymentService.UpdateParams",
        options: RequestOptions = {},
    ) -> OutboundPayment:
        """
        Updates a test mode created OutboundPayment with tracking details. The OutboundPayment must not be cancelable, and cannot be in the canceled or failed states.
        """
        return cast(
            OutboundPayment,
            self._request(
                "post",
                "/v1/test_helpers/treasury/outbound_payments/{id}".format(
                    id=sanitize_id(id),
                ),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

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

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

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

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

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

    def return_outbound_payment(
        self,
        id: str,
        params: "OutboundPaymentService.ReturnOutboundPaymentParams" = {},
        options: RequestOptions = {},
    ) -> OutboundPayment:
        """
        Transitions a test mode created OutboundPayment to the returned status. The OutboundPayment must already be in the processing state.
        """
        return cast(
            OutboundPayment,
            self._request(
                "post",
                "/v1/test_helpers/treasury/outbound_payments/{id}/return".format(
                    id=sanitize_id(id),
                ),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    async def return_outbound_payment_async(
        self,
        id: str,
        params: "OutboundPaymentService.ReturnOutboundPaymentParams" = {},
        options: RequestOptions = {},
    ) -> OutboundPayment:
        """
        Transitions a test mode created OutboundPayment to the returned status. The OutboundPayment must already be in the processing state.
        """
        return cast(
            OutboundPayment,
            await self._request_async(
                "post",
                "/v1/test_helpers/treasury/outbound_payments/{id}/return".format(
                    id=sanitize_id(id),
                ),
                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_payment import OutboundPayment	1✔
7	from typing import List, cast	1✔
8	from typing_extensions import Literal, NotRequired, TypedDict	1✔
9
10
11	class OutboundPaymentService(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 ReturnOutboundPaymentParams(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	"OutboundPaymentService.ReturnOutboundPaymentParamsReturnedDetails"
31	]
32	"""	1✔
33	Optional hash to set the the return code.
34	"""
35
36	class ReturnOutboundPaymentParamsReturnedDetails(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	The return code to be set on the OutboundPayment object.
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: "OutboundPaymentService.UpdateParamsTrackingDetails"	1✔
61	"""	1✔
62	Details about network-specific tracking information.
63	"""
64
65	class UpdateParamsTrackingDetails(TypedDict):	1✔
66	ach: NotRequired[	1✔
67	"OutboundPaymentService.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	"OutboundPaymentService.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	id: str,
102	params: "OutboundPaymentService.UpdateParams",
103	options: RequestOptions = {},
104	) -> OutboundPayment:
105	"""
106	Updates a test mode created OutboundPayment with tracking details. The OutboundPayment must not be cancelable, and cannot be in the canceled or failed states.
107	"""
NEW 108	return cast(	×
109	OutboundPayment,
110	self._request(
111	"post",
112	"/v1/test_helpers/treasury/outbound_payments/{id}".format(
113	id=sanitize_id(id),
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	id: str,
125	params: "OutboundPaymentService.UpdateParams",
126	options: RequestOptions = {},
127	) -> OutboundPayment:
128	"""
129	Updates a test mode created OutboundPayment with tracking details. The OutboundPayment must not be cancelable, and cannot be in the canceled or failed states.
130	"""
NEW 131	return cast(	×
132	OutboundPayment,
133	await self._request_async(
134	"post",
135	"/v1/test_helpers/treasury/outbound_payments/{id}".format(
136	id=sanitize_id(id),
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	id: str,
148	params: "OutboundPaymentService.FailParams" = {},
149	options: RequestOptions = {},
150	) -> OutboundPayment:
151	"""
152	Transitions a test mode created OutboundPayment to the failed status. The OutboundPayment must already be in the processing state.
153	"""
154	return cast(	×
155	OutboundPayment,
156	self._request(
157	"post",
158	"/v1/test_helpers/treasury/outbound_payments/{id}/fail".format(
159	id=sanitize_id(id),
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	id: str,
171	params: "OutboundPaymentService.FailParams" = {},
172	options: RequestOptions = {},
173	) -> OutboundPayment:
174	"""
175	Transitions a test mode created OutboundPayment to the failed status. The OutboundPayment must already be in the processing state.
176	"""
177	return cast(	×
178	OutboundPayment,
179	await self._request_async(
180	"post",
181	"/v1/test_helpers/treasury/outbound_payments/{id}/fail".format(
182	id=sanitize_id(id),
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	id: str,
194	params: "OutboundPaymentService.PostParams" = {},
195	options: RequestOptions = {},
196	) -> OutboundPayment:
197	"""
198	Transitions a test mode created OutboundPayment to the posted status. The OutboundPayment must already be in the processing state.
199	"""
200	return cast(	×
201	OutboundPayment,
202	self._request(
203	"post",
204	"/v1/test_helpers/treasury/outbound_payments/{id}/post".format(
205	id=sanitize_id(id),
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	id: str,
217	params: "OutboundPaymentService.PostParams" = {},
218	options: RequestOptions = {},
219	) -> OutboundPayment:
220	"""
221	Transitions a test mode created OutboundPayment to the posted status. The OutboundPayment must already be in the processing state.
222	"""
223	return cast(	×
224	OutboundPayment,
225	await self._request_async(
226	"post",
227	"/v1/test_helpers/treasury/outbound_payments/{id}/post".format(
228	id=sanitize_id(id),
229	),
230	api_mode="V1",
231	base_address="api",
232	params=params,
233	options=options,
234	),
235	)
236
237	def return_outbound_payment(	1✔
238	self,
239	id: str,
240	params: "OutboundPaymentService.ReturnOutboundPaymentParams" = {},
241	options: RequestOptions = {},
242	) -> OutboundPayment:
243	"""
244	Transitions a test mode created OutboundPayment to the returned status. The OutboundPayment must already be in the processing state.
245	"""
246	return cast(	×
247	OutboundPayment,
248	self._request(
249	"post",
250	"/v1/test_helpers/treasury/outbound_payments/{id}/return".format(
251	id=sanitize_id(id),
252	),
253	api_mode="V1",
254	base_address="api",
255	params=params,
256	options=options,
257	),
258	)
259
260	async def return_outbound_payment_async(	1✔
261	self,
262	id: str,
263	params: "OutboundPaymentService.ReturnOutboundPaymentParams" = {},
264	options: RequestOptions = {},
265	) -> OutboundPayment:
266	"""
267	Transitions a test mode created OutboundPayment to the returned status. The OutboundPayment must already be in the processing state.
268	"""
269	return cast(	×
270	OutboundPayment,
271	await self._request_async(
272	"post",
273	"/v1/test_helpers/treasury/outbound_payments/{id}/return".format(
274	id=sanitize_id(id),
275	),
276	api_mode="V1",
277	base_address="api",
278	params=params,
279	options=options,
280	),
281	)

stripe / stripe-python / 8975426468

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