8546607976

Committed 03 Apr 2024 11:01PM UTC coverage: 96.335% (-1.1%) from 97.393%

Build # 8546607976

Build Type

push

github

Committed by

web-flow

Commit Message

Port async support from beta to the stable channel (#1288)

* Port async support implementation from beta
---------

Co-authored-by: Den <deniss.paltovs@gmail.com>
Co-authored-by: Joel <oldsneerjaw@gmail.com>

Run Details

1066 of 1642 branches covered (64.92%)

Branch coverage included in aggregate %.

3794 of 4481 new or added lines in 255 files covered. (84.67%)

5 existing lines in 2 files now uncovered.

60726 of 62501 relevant lines covered (97.16%)

0.97 hits per line

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

81.4

/stripe/_apple_pay_domain_service.py

# -*- coding: utf-8 -*-
# File generated from our OpenAPI spec
from stripe._apple_pay_domain import ApplePayDomain
from stripe._list_object import ListObject
from stripe._request_options import RequestOptions
from stripe._stripe_service import StripeService
from stripe._util import sanitize_id
from typing import List, cast
from typing_extensions import NotRequired, TypedDict


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

    class DeleteParams(TypedDict):
        pass

    class ListParams(TypedDict):
        domain_name: NotRequired[str]
        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.
        """
        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.
        """

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

    def delete(
        self,
        domain: str,
        params: "ApplePayDomainService.DeleteParams" = {},
        options: RequestOptions = {},
    ) -> ApplePayDomain:
        """
        Delete an apple pay domain.
        """
        return cast(
            ApplePayDomain,
            self._request(
                "delete",
                "/v1/apple_pay/domains/{domain}".format(
                    domain=sanitize_id(domain),
                ),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    async def delete_async(
        self,
        domain: str,
        params: "ApplePayDomainService.DeleteParams" = {},
        options: RequestOptions = {},
    ) -> ApplePayDomain:
        """
        Delete an apple pay domain.
        """
        return cast(
            ApplePayDomain,
            await self._request_async(
                "delete",
                "/v1/apple_pay/domains/{domain}".format(
                    domain=sanitize_id(domain),
                ),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    def retrieve(
        self,
        domain: str,
        params: "ApplePayDomainService.RetrieveParams" = {},
        options: RequestOptions = {},
    ) -> ApplePayDomain:
        """
        Retrieve an apple pay domain.
        """
        return cast(
            ApplePayDomain,
            self._request(
                "get",
                "/v1/apple_pay/domains/{domain}".format(
                    domain=sanitize_id(domain),
                ),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    async def retrieve_async(
        self,
        domain: str,
        params: "ApplePayDomainService.RetrieveParams" = {},
        options: RequestOptions = {},
    ) -> ApplePayDomain:
        """
        Retrieve an apple pay domain.
        """
        return cast(
            ApplePayDomain,
            await self._request_async(
                "get",
                "/v1/apple_pay/domains/{domain}".format(
                    domain=sanitize_id(domain),
                ),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    def list(
        self,
        params: "ApplePayDomainService.ListParams" = {},
        options: RequestOptions = {},
    ) -> ListObject[ApplePayDomain]:
        """
        List apple pay domains.
        """
        return cast(
            ListObject[ApplePayDomain],
            self._request(
                "get",
                "/v1/apple_pay/domains",
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    async def list_async(
        self,
        params: "ApplePayDomainService.ListParams" = {},
        options: RequestOptions = {},
    ) -> ListObject[ApplePayDomain]:
        """
        List apple pay domains.
        """
        return cast(
            ListObject[ApplePayDomain],
            await self._request_async(
                "get",
                "/v1/apple_pay/domains",
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    def create(
        self,
        params: "ApplePayDomainService.CreateParams",
        options: RequestOptions = {},
    ) -> ApplePayDomain:
        """
        Create an apple pay domain.
        """
        return cast(
            ApplePayDomain,
            self._request(
                "post",
                "/v1/apple_pay/domains",
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    async def create_async(
        self,
        params: "ApplePayDomainService.CreateParams",
        options: RequestOptions = {},
    ) -> ApplePayDomain:
        """
        Create an apple pay domain.
        """
        return cast(
            ApplePayDomain,
            await self._request_async(
                "post",
                "/v1/apple_pay/domains",
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

1	# -- coding: utf-8 --
2	# File generated from our OpenAPI spec
3	from stripe._apple_pay_domain import ApplePayDomain	1✔
4	from stripe._list_object import ListObject	1✔
5	from stripe._request_options import RequestOptions	1✔
6	from stripe._stripe_service import StripeService	1✔
7	from stripe._util import sanitize_id	1✔
8	from typing import List, cast	1✔
9	from typing_extensions import NotRequired, TypedDict	1✔
10
11
12	class ApplePayDomainService(StripeService):	1✔
13	class CreateParams(TypedDict):	1✔
14	domain_name: str	1✔
15	expand: NotRequired[List[str]]	1✔
16	"""	1✔
17	Specifies which fields in the response should be expanded.
18	"""
19
20	class DeleteParams(TypedDict):	1✔
21	pass	1✔
22
23	class ListParams(TypedDict):	1✔
24	domain_name: NotRequired[str]	1✔
25	ending_before: NotRequired[str]	1✔
26	"""	1✔
27	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.
28	"""
29	expand: NotRequired[List[str]]	1✔
30	"""	1✔
31	Specifies which fields in the response should be expanded.
32	"""
33	limit: NotRequired[int]	1✔
34	"""	1✔
35	A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
36	"""
37	starting_after: NotRequired[str]	1✔
38	"""	1✔
39	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.
40	"""
41
42	class RetrieveParams(TypedDict):	1✔
43	expand: NotRequired[List[str]]	1✔
44	"""	1✔
45	Specifies which fields in the response should be expanded.
46	"""
47
48	def delete(	1✔
49	self,
50	domain: str,
51	params: "ApplePayDomainService.DeleteParams" = {},
52	options: RequestOptions = {},
53	) -> ApplePayDomain:
54	"""
55	Delete an apple pay domain.
56	"""
57	return cast(	×
58	ApplePayDomain,
59	self._request(
60	"delete",
61	"/v1/apple_pay/domains/{domain}".format(
62	domain=sanitize_id(domain),
63	),
64	api_mode="V1",
65	base_address="api",
66	params=params,
67	options=options,
68	),
69	)
70
71	async def delete_async(	1✔
72	self,
73	domain: str,
74	params: "ApplePayDomainService.DeleteParams" = {},
75	options: RequestOptions = {},
76	) -> ApplePayDomain:
77	"""
78	Delete an apple pay domain.
79	"""
NEW 80	return cast(	×
81	ApplePayDomain,
82	await self._request_async(
83	"delete",
84	"/v1/apple_pay/domains/{domain}".format(
85	domain=sanitize_id(domain),
86	),
87	api_mode="V1",
88	base_address="api",
89	params=params,
90	options=options,
91	),
92	)
93
94	def retrieve(	1✔
95	self,
96	domain: str,
97	params: "ApplePayDomainService.RetrieveParams" = {},
98	options: RequestOptions = {},
99	) -> ApplePayDomain:
100	"""
101	Retrieve an apple pay domain.
102	"""
103	return cast(	×
104	ApplePayDomain,
105	self._request(
106	"get",
107	"/v1/apple_pay/domains/{domain}".format(
108	domain=sanitize_id(domain),
109	),
110	api_mode="V1",
111	base_address="api",
112	params=params,
113	options=options,
114	),
115	)
116
117	async def retrieve_async(	1✔
118	self,
119	domain: str,
120	params: "ApplePayDomainService.RetrieveParams" = {},
121	options: RequestOptions = {},
122	) -> ApplePayDomain:
123	"""
124	Retrieve an apple pay domain.
125	"""
NEW 126	return cast(	×
127	ApplePayDomain,
128	await self._request_async(
129	"get",
130	"/v1/apple_pay/domains/{domain}".format(
131	domain=sanitize_id(domain),
132	),
133	api_mode="V1",
134	base_address="api",
135	params=params,
136	options=options,
137	),
138	)
139
140	def list(	1✔
141	self,
142	params: "ApplePayDomainService.ListParams" = {},
143	options: RequestOptions = {},
144	) -> ListObject[ApplePayDomain]:
145	"""
146	List apple pay domains.
147	"""
148	return cast(	×
149	ListObject[ApplePayDomain],
150	self._request(
151	"get",
152	"/v1/apple_pay/domains",
153	api_mode="V1",
154	base_address="api",
155	params=params,
156	options=options,
157	),
158	)
159
160	async def list_async(	1✔
161	self,
162	params: "ApplePayDomainService.ListParams" = {},
163	options: RequestOptions = {},
164	) -> ListObject[ApplePayDomain]:
165	"""
166	List apple pay domains.
167	"""
NEW 168	return cast(	×
169	ListObject[ApplePayDomain],
170	await self._request_async(
171	"get",
172	"/v1/apple_pay/domains",
173	api_mode="V1",
174	base_address="api",
175	params=params,
176	options=options,
177	),
178	)
179
180	def create(	1✔
181	self,
182	params: "ApplePayDomainService.CreateParams",
183	options: RequestOptions = {},
184	) -> ApplePayDomain:
185	"""
186	Create an apple pay domain.
187	"""
188	return cast(	×
189	ApplePayDomain,
190	self._request(
191	"post",
192	"/v1/apple_pay/domains",
193	api_mode="V1",
194	base_address="api",
195	params=params,
196	options=options,
197	),
198	)
199
200	async def create_async(	1✔
201	self,
202	params: "ApplePayDomainService.CreateParams",
203	options: RequestOptions = {},
204	) -> ApplePayDomain:
205	"""
206	Create an apple pay domain.
207	"""
NEW 208	return cast(	×
209	ApplePayDomain,
210	await self._request_async(
211	"post",
212	"/v1/apple_pay/domains",
213	api_mode="V1",
214	base_address="api",
215	params=params,
216	options=options,
217	),
218	)

stripe / stripe-python / 8546607976

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