11016376950

Committed 24 Sep 2024 02:53PM UTC coverage: 96.201% (-0.1%) from 96.314%

Build # 11016376950

Build Type

Pull #1397

github

Committed by

web-flow

Commit Message

Merge ddf9a21fd into 7b6300fde

Pull Request Pull Request #1397: Next major infra

Run Details

1346 of 1989 branches covered (67.67%)

Branch coverage included in aggregate %.

2572 of 2702 new or added lines in 96 files covered. (95.19%)

37 existing lines in 2 files now uncovered.

69575 of 71733 relevant lines covered (96.99%)

0.97 hits per line

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

88.89

/stripe/v2/_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.v2._amount import AmountParam
from stripe.v2._list_object import ListObject
from stripe.v2._outbound_transfer import OutboundTransfer
from typing import Dict, List, cast
from typing_extensions import Literal, NotRequired, TypedDict


class OutboundTransferService(StripeService):
    class CancelParams(TypedDict):
        pass

    _CreateParamsBase = TypedDict(
        "CreateParams",
        {"from": "OutboundTransferService.CreateParamsFrom"},
    )

    class CreateParams(_CreateParamsBase):
        description: NotRequired[str]
        """
        An arbitrary string attached to the OutboundTransfer. Often useful for displaying to users.
        """
        metadata: NotRequired[Dict[str, str]]
        """
        Set of key-value pairs that you can attach to an object. This can be useful for storing additional information about the object in a structured format.
        """
        method: NotRequired["OutboundTransferService.CreateParamsMethod"]
        """
        Method to be used to send the OutboundTransfer.
        """
        money_movement_amounts: (
            "OutboundTransferService.CreateParamsMoneyMovementAmounts"
        )
        """
        Details about the OutboundTransfer, including source and destination amount, and foreign exchange details.
        """
        to: "OutboundTransferService.CreateParamsTo"
        """
        To which outbound destination to send the OutboundTransfer.
        """

    class CreateParamsFrom(TypedDict):
        balance_type: Literal["storage"]
        """
        Closed Enum. The BalanceType that funds were pulled from.
        """
        financial_account: str
        """
        The FinancialAccount that funds were pulled from.
        """

    class CreateParamsMethod(TypedDict):
        bank_account: NotRequired[Literal["automatic", "local", "wire"]]
        """
        Open Enum. Method for bank account.
        """

    class CreateParamsMoneyMovementAmounts(TypedDict):
        destination: NotRequired[AmountParam]
        """
        Monetary amount sent to destination.
        """
        source: NotRequired[AmountParam]
        """
        Monetary amount sent from source financial account.
        """

    class CreateParamsTo(TypedDict):
        destination: str
        """
        The outbound destination to which an OutboundTransfer is sent.
        """

    class ListParams(TypedDict):
        created: NotRequired[str]
        """
        Filter for objects created at the specified timestamp.
        Must be an RFC 3339 date & time value, for example: 2022-09-18T13:22:00Z.
        """
        created_gt: NotRequired[str]
        """
        Filter for objects created after the specified timestamp.
        Must be an RFC 3339 date & time value, for example: 2022-09-18T13:22:00Z.
        """
        created_gte: NotRequired[str]
        """
        Filter for objects created on or after the specified timestamp.
        Must be an RFC 3339 date & time value, for example: 2022-09-18T13:22:00Z.
        """
        created_lt: NotRequired[str]
        """
        Filter for objects created before the specified timestamp.
        Must be an RFC 3339 date & time value, for example: 2022-09-18T13:22:00Z.
        """
        created_lte: NotRequired[str]
        """
        Filter for objects created on or before the specified timestamp.
        Must be an RFC 3339 date & time value, for example: 2022-09-18T13:22:00Z.
        """
        limit: NotRequired[int]
        page: NotRequired[str]
        status: NotRequired[
            List[
                Literal[
                    "canceled", "failed", "posted", "processing", "returned"
                ]
            ]
        ]
        """
        Closed Enum. Only return OutboundTransfers with this status.
        """

    class RetrieveParams(TypedDict):
        pass

    def cancel(
        self,
        id: str,
        params: "OutboundTransferService.CancelParams" = {},
        options: RequestOptions = {},
    ) -> OutboundTransfer:
        """
        Cancels an OutboundTransfer. Only processing OutboundTransfers can be canceled.
        """
        return cast(
            OutboundTransfer,
            self._request(
                "post",
                "/v2/outbound_transfers/{id}/cancel".format(
                    id=sanitize_id(id)
                ),
                base_address="api",
                params=params,
                options=options,
            ),
        )

    async def cancel_async(
        self,
        id: str,
        params: "OutboundTransferService.CancelParams" = {},
        options: RequestOptions = {},
    ) -> OutboundTransfer:
        """
        Cancels an OutboundTransfer. Only processing OutboundTransfers can be canceled.
        """
        return cast(
            OutboundTransfer,
            await self._request_async(
                "post",
                "/v2/outbound_transfers/{id}/cancel".format(
                    id=sanitize_id(id)
                ),
                base_address="api",
                params=params,
                options=options,
            ),
        )

    def create(
        self,
        params: "OutboundTransferService.CreateParams",
        options: RequestOptions = {},
    ) -> OutboundTransfer:
        """
        Creates an OutboundTransfer.
        """
        return cast(
            OutboundTransfer,
            self._request(
                "post",
                "/v2/outbound_transfers",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    async def create_async(
        self,
        params: "OutboundTransferService.CreateParams",
        options: RequestOptions = {},
    ) -> OutboundTransfer:
        """
        Creates an OutboundTransfer.
        """
        return cast(
            OutboundTransfer,
            await self._request_async(
                "post",
                "/v2/outbound_transfers",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    def list(
        self,
        params: "OutboundTransferService.ListParams" = {},
        options: RequestOptions = {},
    ) -> ListObject[OutboundTransfer]:
        """
        Returns a list of OutboundTransfers that match the provided filters.
        """
        return cast(
            ListObject[OutboundTransfer],
            self._request(
                "get",
                "/v2/outbound_transfers",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    async def list_async(
        self,
        params: "OutboundTransferService.ListParams" = {},
        options: RequestOptions = {},
    ) -> ListObject[OutboundTransfer]:
        """
        Returns a list of OutboundTransfers that match the provided filters.
        """
        return cast(
            ListObject[OutboundTransfer],
            await self._request_async(
                "get",
                "/v2/outbound_transfers",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    def retrieve(
        self,
        id: str,
        params: "OutboundTransferService.RetrieveParams" = {},
        options: RequestOptions = {},
    ) -> OutboundTransfer:
        """
        Retrieves the details of an existing OutboundTransfer by passing the unique OutboundTransfer ID from either the OutboundPayment create or list response.
        """
        return cast(
            OutboundTransfer,
            self._request(
                "get",
                "/v2/outbound_transfers/{id}".format(id=sanitize_id(id)),
                base_address="api",
                params=params,
                options=options,
            ),
        )

    async def retrieve_async(
        self,
        id: str,
        params: "OutboundTransferService.RetrieveParams" = {},
        options: RequestOptions = {},
    ) -> OutboundTransfer:
        """
        Retrieves the details of an existing OutboundTransfer by passing the unique OutboundTransfer ID from either the OutboundPayment create or list response.
        """
        return cast(
            OutboundTransfer,
            await self._request_async(
                "get",
                "/v2/outbound_transfers/{id}".format(id=sanitize_id(id)),
                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.v2._amount import AmountParam	1✔
7	from stripe.v2._list_object import ListObject	1✔
8	from stripe.v2._outbound_transfer import OutboundTransfer	1✔
9	from typing import Dict, List, cast	1✔
10	from typing_extensions import Literal, NotRequired, TypedDict	1✔
11
12
13	class OutboundTransferService(StripeService):	1✔
14	class CancelParams(TypedDict):	1✔
15	pass	1✔
16
17	_CreateParamsBase = TypedDict(	1✔
18	"CreateParams",
19	{"from": "OutboundTransferService.CreateParamsFrom"},
20	)
21
22	class CreateParams(_CreateParamsBase):	1✔
23	description: NotRequired[str]	1✔
24	"""	1✔
25	An arbitrary string attached to the OutboundTransfer. Often useful for displaying to users.
26	"""
27	metadata: NotRequired[Dict[str, str]]	1✔
28	"""	1✔
29	Set of key-value pairs that you can attach to an object. This can be useful for storing additional information about the object in a structured format.
30	"""
31	method: NotRequired["OutboundTransferService.CreateParamsMethod"]	1✔
32	"""	1✔
33	Method to be used to send the OutboundTransfer.
34	"""
35	money_movement_amounts: (	1✔
36	"OutboundTransferService.CreateParamsMoneyMovementAmounts"
37	)
38	"""	1✔
39	Details about the OutboundTransfer, including source and destination amount, and foreign exchange details.
40	"""
41	to: "OutboundTransferService.CreateParamsTo"	1✔
42	"""	1✔
43	To which outbound destination to send the OutboundTransfer.
44	"""
45
46	class CreateParamsFrom(TypedDict):	1✔
47	balance_type: Literal["storage"]	1✔
48	"""	1✔
49	Closed Enum. The BalanceType that funds were pulled from.
50	"""
51	financial_account: str	1✔
52	"""	1✔
53	The FinancialAccount that funds were pulled from.
54	"""
55
56	class CreateParamsMethod(TypedDict):	1✔
57	bank_account: NotRequired[Literal["automatic", "local", "wire"]]	1✔
58	"""	1✔
59	Open Enum. Method for bank account.
60	"""
61
62	class CreateParamsMoneyMovementAmounts(TypedDict):	1✔
63	destination: NotRequired[AmountParam]	1✔
64	"""	1✔
65	Monetary amount sent to destination.
66	"""
67	source: NotRequired[AmountParam]	1✔
68	"""	1✔
69	Monetary amount sent from source financial account.
70	"""
71
72	class CreateParamsTo(TypedDict):	1✔
73	destination: str	1✔
74	"""	1✔
75	The outbound destination to which an OutboundTransfer is sent.
76	"""
77
78	class ListParams(TypedDict):	1✔
79	created: NotRequired[str]	1✔
80	"""	1✔
81	Filter for objects created at the specified timestamp.
82	Must be an RFC 3339 date & time value, for example: 2022-09-18T13:22:00Z.
83	"""
84	created_gt: NotRequired[str]	1✔
85	"""	1✔
86	Filter for objects created after the specified timestamp.
87	Must be an RFC 3339 date & time value, for example: 2022-09-18T13:22:00Z.
88	"""
89	created_gte: NotRequired[str]	1✔
90	"""	1✔
91	Filter for objects created on or after the specified timestamp.
92	Must be an RFC 3339 date & time value, for example: 2022-09-18T13:22:00Z.
93	"""
94	created_lt: NotRequired[str]	1✔
95	"""	1✔
96	Filter for objects created before the specified timestamp.
97	Must be an RFC 3339 date & time value, for example: 2022-09-18T13:22:00Z.
98	"""
99	created_lte: NotRequired[str]	1✔
100	"""	1✔
101	Filter for objects created on or before the specified timestamp.
102	Must be an RFC 3339 date & time value, for example: 2022-09-18T13:22:00Z.
103	"""
104	limit: NotRequired[int]	1✔
105	page: NotRequired[str]	1✔
106	status: NotRequired[	1✔
107	List[
108	Literal[
109	"canceled", "failed", "posted", "processing", "returned"
110	]
111	]
112	]
113	"""	1✔
114	Closed Enum. Only return OutboundTransfers with this status.
115	"""
116
117	class RetrieveParams(TypedDict):	1✔
118	pass	1✔
119
120	def cancel(	1✔
121	self,
122	id: str,
123	params: "OutboundTransferService.CancelParams" = {},
124	options: RequestOptions = {},
125	) -> OutboundTransfer:
126	"""
127	Cancels an OutboundTransfer. Only processing OutboundTransfers can be canceled.
128	"""
NEW 129	return cast(	×
130	OutboundTransfer,
131	self._request(
132	"post",
133	"/v2/outbound_transfers/{id}/cancel".format(
134	id=sanitize_id(id)
135	),
136	base_address="api",
137	params=params,
138	options=options,
139	),
140	)
141
142	async def cancel_async(	1✔
143	self,
144	id: str,
145	params: "OutboundTransferService.CancelParams" = {},
146	options: RequestOptions = {},
147	) -> OutboundTransfer:
148	"""
149	Cancels an OutboundTransfer. Only processing OutboundTransfers can be canceled.
150	"""
NEW 151	return cast(	×
152	OutboundTransfer,
153	await self._request_async(
154	"post",
155	"/v2/outbound_transfers/{id}/cancel".format(
156	id=sanitize_id(id)
157	),
158	base_address="api",
159	params=params,
160	options=options,
161	),
162	)
163
164	def create(	1✔
165	self,
166	params: "OutboundTransferService.CreateParams",
167	options: RequestOptions = {},
168	) -> OutboundTransfer:
169	"""
170	Creates an OutboundTransfer.
171	"""
NEW 172	return cast(	×
173	OutboundTransfer,
174	self._request(
175	"post",
176	"/v2/outbound_transfers",
177	base_address="api",
178	params=params,
179	options=options,
180	),
181	)
182
183	async def create_async(	1✔
184	self,
185	params: "OutboundTransferService.CreateParams",
186	options: RequestOptions = {},
187	) -> OutboundTransfer:
188	"""
189	Creates an OutboundTransfer.
190	"""
NEW 191	return cast(	×
192	OutboundTransfer,
193	await self._request_async(
194	"post",
195	"/v2/outbound_transfers",
196	base_address="api",
197	params=params,
198	options=options,
199	),
200	)
201
202	def list(	1✔
203	self,
204	params: "OutboundTransferService.ListParams" = {},
205	options: RequestOptions = {},
206	) -> ListObject[OutboundTransfer]:
207	"""
208	Returns a list of OutboundTransfers that match the provided filters.
209	"""
NEW 210	return cast(	×
211	ListObject[OutboundTransfer],
212	self._request(
213	"get",
214	"/v2/outbound_transfers",
215	base_address="api",
216	params=params,
217	options=options,
218	),
219	)
220
221	async def list_async(	1✔
222	self,
223	params: "OutboundTransferService.ListParams" = {},
224	options: RequestOptions = {},
225	) -> ListObject[OutboundTransfer]:
226	"""
227	Returns a list of OutboundTransfers that match the provided filters.
228	"""
NEW 229	return cast(	×
230	ListObject[OutboundTransfer],
231	await self._request_async(
232	"get",
233	"/v2/outbound_transfers",
234	base_address="api",
235	params=params,
236	options=options,
237	),
238	)
239
240	def retrieve(	1✔
241	self,
242	id: str,
243	params: "OutboundTransferService.RetrieveParams" = {},
244	options: RequestOptions = {},
245	) -> OutboundTransfer:
246	"""
247	Retrieves the details of an existing OutboundTransfer by passing the unique OutboundTransfer ID from either the OutboundPayment create or list response.
248	"""
NEW 249	return cast(	×
250	OutboundTransfer,
251	self._request(
252	"get",
253	"/v2/outbound_transfers/{id}".format(id=sanitize_id(id)),
254	base_address="api",
255	params=params,
256	options=options,
257	),
258	)
259
260	async def retrieve_async(	1✔
261	self,
262	id: str,
263	params: "OutboundTransferService.RetrieveParams" = {},
264	options: RequestOptions = {},
265	) -> OutboundTransfer:
266	"""
267	Retrieves the details of an existing OutboundTransfer by passing the unique OutboundTransfer ID from either the OutboundPayment create or list response.
268	"""
NEW 269	return cast(	×
270	OutboundTransfer,
271	await self._request_async(
272	"get",
273	"/v2/outbound_transfers/{id}".format(id=sanitize_id(id)),
274	base_address="api",
275	params=params,
276	options=options,
277	),
278	)

stripe / stripe-python / 11016376950

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