10307082400

Committed 08 Aug 2024 05:57PM UTC coverage: 96.354% (-0.08%) from 96.432%

Build # 10307082400

Build Type

Pull #1371

github

Committed by

web-flow

Commit Message

Merge 7dd187a4e into 8598672ea

Pull Request Pull Request #1371: Update generated code

Run Details

1293 of 1913 branches covered (67.59%)

Branch coverage included in aggregate %.

254 of 314 new or added lines in 16 files covered. (80.89%)

1 existing line in 1 file now uncovered.

66817 of 68774 relevant lines covered (97.15%)

0.97 hits per line

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

84.62

/stripe/billing/_alert_service.py

# -*- coding: utf-8 -*-
# File generated from our OpenAPI spec
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 stripe.billing._alert import Alert
from typing import List, cast
from typing_extensions import Literal, NotRequired, TypedDict


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

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

    class CreateParams(TypedDict):
        alert_type: Literal["usage_threshold"]
        """
        The type of alert to create.
        """
        expand: NotRequired[List[str]]
        """
        Specifies which fields in the response should be expanded.
        """
        filter: NotRequired["AlertService.CreateParamsFilter"]
        """
        Filters to limit the scope of an alert.
        """
        title: str
        """
        The title of the alert.
        """
        usage_threshold_config: NotRequired[
            "AlertService.CreateParamsUsageThresholdConfig"
        ]
        """
        The configuration of the usage threshold.
        """

    class CreateParamsFilter(TypedDict):
        customer: NotRequired[str]
        """
        Limit the scope to this alert only to this customer.
        """

    class CreateParamsUsageThresholdConfig(TypedDict):
        gte: int
        """
        Defines at which value the alert will fire.
        """
        meter: NotRequired[str]
        """
        The [Billing Meter](https://stripe.com/api/billing/meter) ID whose usage is monitored.
        """
        recurrence: Literal["one_time"]
        """
        Whether the alert should only fire only once, or once per billing cycle.
        """

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

    class ListParams(TypedDict):
        alert_type: NotRequired[Literal["usage_threshold"]]
        """
        Filter results to only include this type of alert.
        """
        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.
        """
        meter: NotRequired[str]
        """
        Filter results to only include alerts with the given meter.
        """
        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 list(
        self,
        params: "AlertService.ListParams" = {},
        options: RequestOptions = {},
    ) -> ListObject[Alert]:
        """
        Lists billing active and inactive alerts
        """
        return cast(
            ListObject[Alert],
            self._request(
                "get",
                "/v1/billing/alerts",
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    async def list_async(
        self,
        params: "AlertService.ListParams" = {},
        options: RequestOptions = {},
    ) -> ListObject[Alert]:
        """
        Lists billing active and inactive alerts
        """
        return cast(
            ListObject[Alert],
            await self._request_async(
                "get",
                "/v1/billing/alerts",
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    def create(
        self, params: "AlertService.CreateParams", options: RequestOptions = {}
    ) -> Alert:
        """
        Creates a billing alert
        """
        return cast(
            Alert,
            self._request(
                "post",
                "/v1/billing/alerts",
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    async def create_async(
        self, params: "AlertService.CreateParams", options: RequestOptions = {}
    ) -> Alert:
        """
        Creates a billing alert
        """
        return cast(
            Alert,
            await self._request_async(
                "post",
                "/v1/billing/alerts",
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    def retrieve(
        self,
        id: str,
        params: "AlertService.RetrieveParams" = {},
        options: RequestOptions = {},
    ) -> Alert:
        """
        Retrieves a billing alert given an ID
        """
        return cast(
            Alert,
            self._request(
                "get",
                "/v1/billing/alerts/{id}".format(id=sanitize_id(id)),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    async def retrieve_async(
        self,
        id: str,
        params: "AlertService.RetrieveParams" = {},
        options: RequestOptions = {},
    ) -> Alert:
        """
        Retrieves a billing alert given an ID
        """
        return cast(
            Alert,
            await self._request_async(
                "get",
                "/v1/billing/alerts/{id}".format(id=sanitize_id(id)),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    def activate(
        self,
        id: str,
        params: "AlertService.ActivateParams" = {},
        options: RequestOptions = {},
    ) -> Alert:
        """
        Reactivates this alert, allowing it to trigger again.
        """
        return cast(
            Alert,
            self._request(
                "post",
                "/v1/billing/alerts/{id}/activate".format(id=sanitize_id(id)),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    async def activate_async(
        self,
        id: str,
        params: "AlertService.ActivateParams" = {},
        options: RequestOptions = {},
    ) -> Alert:
        """
        Reactivates this alert, allowing it to trigger again.
        """
        return cast(
            Alert,
            await self._request_async(
                "post",
                "/v1/billing/alerts/{id}/activate".format(id=sanitize_id(id)),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    def archive(
        self,
        id: str,
        params: "AlertService.ArchiveParams" = {},
        options: RequestOptions = {},
    ) -> Alert:
        """
        Archives this alert, removing it from the list view and APIs. This is non-reversible.
        """
        return cast(
            Alert,
            self._request(
                "post",
                "/v1/billing/alerts/{id}/archive".format(id=sanitize_id(id)),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    async def archive_async(
        self,
        id: str,
        params: "AlertService.ArchiveParams" = {},
        options: RequestOptions = {},
    ) -> Alert:
        """
        Archives this alert, removing it from the list view and APIs. This is non-reversible.
        """
        return cast(
            Alert,
            await self._request_async(
                "post",
                "/v1/billing/alerts/{id}/archive".format(id=sanitize_id(id)),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    def deactivate(
        self,
        id: str,
        params: "AlertService.DeactivateParams" = {},
        options: RequestOptions = {},
    ) -> Alert:
        """
        Deactivates this alert, preventing it from triggering.
        """
        return cast(
            Alert,
            self._request(
                "post",
                "/v1/billing/alerts/{id}/deactivate".format(
                    id=sanitize_id(id)
                ),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    async def deactivate_async(
        self,
        id: str,
        params: "AlertService.DeactivateParams" = {},
        options: RequestOptions = {},
    ) -> Alert:
        """
        Deactivates this alert, preventing it from triggering.
        """
        return cast(
            Alert,
            await self._request_async(
                "post",
                "/v1/billing/alerts/{id}/deactivate".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._list_object import ListObject	1✔
4	from stripe._request_options import RequestOptions	1✔
5	from stripe._stripe_service import StripeService	1✔
6	from stripe._util import sanitize_id	1✔
7	from stripe.billing._alert import Alert	1✔
8	from typing import List, cast	1✔
9	from typing_extensions import Literal, NotRequired, TypedDict	1✔
10
11
12	class AlertService(StripeService):	1✔
13	class ActivateParams(TypedDict):	1✔
14	expand: NotRequired[List[str]]	1✔
15	"""	1✔
16	Specifies which fields in the response should be expanded.
17	"""
18
19	class ArchiveParams(TypedDict):	1✔
20	expand: NotRequired[List[str]]	1✔
21	"""	1✔
22	Specifies which fields in the response should be expanded.
23	"""
24
25	class CreateParams(TypedDict):	1✔
26	alert_type: Literal["usage_threshold"]	1✔
27	"""	1✔
28	The type of alert to create.
29	"""
30	expand: NotRequired[List[str]]	1✔
31	"""	1✔
32	Specifies which fields in the response should be expanded.
33	"""
34	filter: NotRequired["AlertService.CreateParamsFilter"]	1✔
35	"""	1✔
36	Filters to limit the scope of an alert.
37	"""
38	title: str	1✔
39	"""	1✔
40	The title of the alert.
41	"""
42	usage_threshold_config: NotRequired[	1✔
43	"AlertService.CreateParamsUsageThresholdConfig"
44	]
45	"""	1✔
46	The configuration of the usage threshold.
47	"""
48
49	class CreateParamsFilter(TypedDict):	1✔
50	customer: NotRequired[str]	1✔
51	"""	1✔
52	Limit the scope to this alert only to this customer.
53	"""
54
55	class CreateParamsUsageThresholdConfig(TypedDict):	1✔
56	gte: int	1✔
57	"""	1✔
58	Defines at which value the alert will fire.
59	"""
60	meter: NotRequired[str]	1✔
61	"""	1✔
62	The [Billing Meter](https://stripe.com/api/billing/meter) ID whose usage is monitored.
63	"""
64	recurrence: Literal["one_time"]	1✔
65	"""	1✔
66	Whether the alert should only fire only once, or once per billing cycle.
67	"""
68
69	class DeactivateParams(TypedDict):	1✔
70	expand: NotRequired[List[str]]	1✔
71	"""	1✔
72	Specifies which fields in the response should be expanded.
73	"""
74
75	class ListParams(TypedDict):	1✔
76	alert_type: NotRequired[Literal["usage_threshold"]]	1✔
77	"""	1✔
78	Filter results to only include this type of alert.
79	"""
80	ending_before: NotRequired[str]	1✔
81	"""	1✔
82	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.
83	"""
84	expand: NotRequired[List[str]]	1✔
85	"""	1✔
86	Specifies which fields in the response should be expanded.
87	"""
88	limit: NotRequired[int]	1✔
89	"""	1✔
90	A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
91	"""
92	meter: NotRequired[str]	1✔
93	"""	1✔
94	Filter results to only include alerts with the given meter.
95	"""
96	starting_after: NotRequired[str]	1✔
97	"""	1✔
98	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.
99	"""
100
101	class RetrieveParams(TypedDict):	1✔
102	expand: NotRequired[List[str]]	1✔
103	"""	1✔
104	Specifies which fields in the response should be expanded.
105	"""
106
107	def list(	1✔
108	self,
109	params: "AlertService.ListParams" = {},
110	options: RequestOptions = {},
111	) -> ListObject[Alert]:
112	"""
113	Lists billing active and inactive alerts
114	"""
NEW 115	return cast(	×
116	ListObject[Alert],
117	self._request(
118	"get",
119	"/v1/billing/alerts",
120	api_mode="V1",
121	base_address="api",
122	params=params,
123	options=options,
124	),
125	)
126
127	async def list_async(	1✔
128	self,
129	params: "AlertService.ListParams" = {},
130	options: RequestOptions = {},
131	) -> ListObject[Alert]:
132	"""
133	Lists billing active and inactive alerts
134	"""
NEW 135	return cast(	×
136	ListObject[Alert],
137	await self._request_async(
138	"get",
139	"/v1/billing/alerts",
140	api_mode="V1",
141	base_address="api",
142	params=params,
143	options=options,
144	),
145	)
146
147	def create(	1✔
148	self, params: "AlertService.CreateParams", options: RequestOptions = {}
149	) -> Alert:
150	"""
151	Creates a billing alert
152	"""
NEW 153	return cast(	×
154	Alert,
155	self._request(
156	"post",
157	"/v1/billing/alerts",
158	api_mode="V1",
159	base_address="api",
160	params=params,
161	options=options,
162	),
163	)
164
165	async def create_async(	1✔
166	self, params: "AlertService.CreateParams", options: RequestOptions = {}
167	) -> Alert:
168	"""
169	Creates a billing alert
170	"""
NEW 171	return cast(	×
172	Alert,
173	await self._request_async(
174	"post",
175	"/v1/billing/alerts",
176	api_mode="V1",
177	base_address="api",
178	params=params,
179	options=options,
180	),
181	)
182
183	def retrieve(	1✔
184	self,
185	id: str,
186	params: "AlertService.RetrieveParams" = {},
187	options: RequestOptions = {},
188	) -> Alert:
189	"""
190	Retrieves a billing alert given an ID
191	"""
NEW 192	return cast(	×
193	Alert,
194	self._request(
195	"get",
196	"/v1/billing/alerts/{id}".format(id=sanitize_id(id)),
197	api_mode="V1",
198	base_address="api",
199	params=params,
200	options=options,
201	),
202	)
203
204	async def retrieve_async(	1✔
205	self,
206	id: str,
207	params: "AlertService.RetrieveParams" = {},
208	options: RequestOptions = {},
209	) -> Alert:
210	"""
211	Retrieves a billing alert given an ID
212	"""
NEW 213	return cast(	×
214	Alert,
215	await self._request_async(
216	"get",
217	"/v1/billing/alerts/{id}".format(id=sanitize_id(id)),
218	api_mode="V1",
219	base_address="api",
220	params=params,
221	options=options,
222	),
223	)
224
225	def activate(	1✔
226	self,
227	id: str,
228	params: "AlertService.ActivateParams" = {},
229	options: RequestOptions = {},
230	) -> Alert:
231	"""
232	Reactivates this alert, allowing it to trigger again.
233	"""
NEW 234	return cast(	×
235	Alert,
236	self._request(
237	"post",
238	"/v1/billing/alerts/{id}/activate".format(id=sanitize_id(id)),
239	api_mode="V1",
240	base_address="api",
241	params=params,
242	options=options,
243	),
244	)
245
246	async def activate_async(	1✔
247	self,
248	id: str,
249	params: "AlertService.ActivateParams" = {},
250	options: RequestOptions = {},
251	) -> Alert:
252	"""
253	Reactivates this alert, allowing it to trigger again.
254	"""
NEW 255	return cast(	×
256	Alert,
257	await self._request_async(
258	"post",
259	"/v1/billing/alerts/{id}/activate".format(id=sanitize_id(id)),
260	api_mode="V1",
261	base_address="api",
262	params=params,
263	options=options,
264	),
265	)
266
267	def archive(	1✔
268	self,
269	id: str,
270	params: "AlertService.ArchiveParams" = {},
271	options: RequestOptions = {},
272	) -> Alert:
273	"""
274	Archives this alert, removing it from the list view and APIs. This is non-reversible.
275	"""
NEW 276	return cast(	×
277	Alert,
278	self._request(
279	"post",
280	"/v1/billing/alerts/{id}/archive".format(id=sanitize_id(id)),
281	api_mode="V1",
282	base_address="api",
283	params=params,
284	options=options,
285	),
286	)
287
288	async def archive_async(	1✔
289	self,
290	id: str,
291	params: "AlertService.ArchiveParams" = {},
292	options: RequestOptions = {},
293	) -> Alert:
294	"""
295	Archives this alert, removing it from the list view and APIs. This is non-reversible.
296	"""
NEW 297	return cast(	×
298	Alert,
299	await self._request_async(
300	"post",
301	"/v1/billing/alerts/{id}/archive".format(id=sanitize_id(id)),
302	api_mode="V1",
303	base_address="api",
304	params=params,
305	options=options,
306	),
307	)
308
309	def deactivate(	1✔
310	self,
311	id: str,
312	params: "AlertService.DeactivateParams" = {},
313	options: RequestOptions = {},
314	) -> Alert:
315	"""
316	Deactivates this alert, preventing it from triggering.
317	"""
NEW 318	return cast(	×
319	Alert,
320	self._request(
321	"post",
322	"/v1/billing/alerts/{id}/deactivate".format(
323	id=sanitize_id(id)
324	),
325	api_mode="V1",
326	base_address="api",
327	params=params,
328	options=options,
329	),
330	)
331
332	async def deactivate_async(	1✔
333	self,
334	id: str,
335	params: "AlertService.DeactivateParams" = {},
336	options: RequestOptions = {},
337	) -> Alert:
338	"""
339	Deactivates this alert, preventing it from triggering.
340	"""
NEW 341	return cast(	×
342	Alert,
343	await self._request_async(
344	"post",
345	"/v1/billing/alerts/{id}/deactivate".format(
346	id=sanitize_id(id)
347	),
348	api_mode="V1",
349	base_address="api",
350	params=params,
351	options=options,
352	),
353	)

stripe / stripe-python / 10307082400

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