8365275781

Committed 20 Mar 2024 08:12PM UTC coverage: 96.406% (-0.01%) from 96.419%

Build # 8365275781

Build Type

Pull #1272

github

Committed by

web-flow

Commit Message

Merge b966bcf30 into c71b88d42

Pull Request Pull Request #1272: Update generated code for beta

Run Details

1142 of 1800 branches covered (63.44%)

Branch coverage included in aggregate %.

122 of 136 new or added lines in 15 files covered. (89.71%)

10 existing lines in 2 files now uncovered.

80562 of 82950 relevant lines covered (97.12%)

0.97 hits per line

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

83.33

/stripe/_product_feature_service.py

# -*- coding: utf-8 -*-
# File generated from our OpenAPI spec
from stripe._list_object import ListObject
from stripe._product_feature import ProductFeature
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 ProductFeatureService(StripeService):
    class CreateParams(TypedDict):
        entitlement_feature: str
        """
        The ID of the [Feature](docs/api/entitlements/feature) object attached to this product.
        """
        expand: NotRequired["List[str]"]
        """
        Specifies which fields in the response should be expanded.
        """

    class DeleteParams(TypedDict):
        pass

    class ListParams(TypedDict):
        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.
        """

    def delete(
        self,
        product: str,
        id: str,
        params: "ProductFeatureService.DeleteParams" = {},
        options: RequestOptions = {},
    ) -> ProductFeature:
        """
        Deletes the feature attachment to a product
        """
        return cast(
            ProductFeature,
            self._request(
                "delete",
                "/v1/products/{product}/features/{id}".format(
                    product=sanitize_id(product),
                    id=sanitize_id(id),
                ),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    async def delete_async(
        self,
        product: str,
        id: str,
        params: "ProductFeatureService.DeleteParams" = {},
        options: RequestOptions = {},
    ) -> ProductFeature:
        """
        Deletes the feature attachment to a product
        """
        return cast(
            ProductFeature,
            await self._request_async(
                "delete",
                "/v1/products/{product}/features/{id}".format(
                    product=sanitize_id(product),
                    id=sanitize_id(id),
                ),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    def list(
        self,
        product: str,
        params: "ProductFeatureService.ListParams" = {},
        options: RequestOptions = {},
    ) -> ListObject[ProductFeature]:
        """
        Retrieve a list of features for a product
        """
        return cast(
            ListObject[ProductFeature],
            self._request(
                "get",
                "/v1/products/{product}/features".format(
                    product=sanitize_id(product),
                ),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    async def list_async(
        self,
        product: str,
        params: "ProductFeatureService.ListParams" = {},
        options: RequestOptions = {},
    ) -> ListObject[ProductFeature]:
        """
        Retrieve a list of features for a product
        """
        return cast(
            ListObject[ProductFeature],
            await self._request_async(
                "get",
                "/v1/products/{product}/features".format(
                    product=sanitize_id(product),
                ),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    def create(
        self,
        product: str,
        params: "ProductFeatureService.CreateParams",
        options: RequestOptions = {},
    ) -> ProductFeature:
        """
        Creates a product_feature, which represents a feature attachment to a product
        """
        return cast(
            ProductFeature,
            self._request(
                "post",
                "/v1/products/{product}/features".format(
                    product=sanitize_id(product),
                ),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    async def create_async(
        self,
        product: str,
        params: "ProductFeatureService.CreateParams",
        options: RequestOptions = {},
    ) -> ProductFeature:
        """
        Creates a product_feature, which represents a feature attachment to a product
        """
        return cast(
            ProductFeature,
            await self._request_async(
                "post",
                "/v1/products/{product}/features".format(
                    product=sanitize_id(product),
                ),
                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._product_feature import ProductFeature	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 ProductFeatureService(StripeService):	1✔
13	class CreateParams(TypedDict):	1✔
14	entitlement_feature: str	1✔
15	"""	1✔
16	The ID of the [Feature](docs/api/entitlements/feature) object attached to this product.
17	"""
18	expand: NotRequired["List[str]"]	1✔
19	"""	1✔
20	Specifies which fields in the response should be expanded.
21	"""
22
23	class DeleteParams(TypedDict):	1✔
24	pass	1✔
25
26	class ListParams(TypedDict):	1✔
27	ending_before: NotRequired["str"]	1✔
28	"""	1✔
29	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.
30	"""
31	expand: NotRequired["List[str]"]	1✔
32	"""	1✔
33	Specifies which fields in the response should be expanded.
34	"""
35	limit: NotRequired["int"]	1✔
36	"""	1✔
37	A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
38	"""
39	starting_after: NotRequired["str"]	1✔
40	"""	1✔
41	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.
42	"""
43
44	def delete(	1✔
45	self,
46	product: str,
47	id: str,
48	params: "ProductFeatureService.DeleteParams" = {},
49	options: RequestOptions = {},
50	) -> ProductFeature:
51	"""
52	Deletes the feature attachment to a product
53	"""
NEW 54	return cast(	×
55	ProductFeature,
56	self._request(
57	"delete",
58	"/v1/products/{product}/features/{id}".format(
59	product=sanitize_id(product),
60	id=sanitize_id(id),
61	),
62	api_mode="V1",
63	base_address="api",
64	params=params,
65	options=options,
66	),
67	)
68
69	async def delete_async(	1✔
70	self,
71	product: str,
72	id: str,
73	params: "ProductFeatureService.DeleteParams" = {},
74	options: RequestOptions = {},
75	) -> ProductFeature:
76	"""
77	Deletes the feature attachment to a product
78	"""
NEW 79	return cast(	×
80	ProductFeature,
81	await self._request_async(
82	"delete",
83	"/v1/products/{product}/features/{id}".format(
84	product=sanitize_id(product),
85	id=sanitize_id(id),
86	),
87	api_mode="V1",
88	base_address="api",
89	params=params,
90	options=options,
91	),
92	)
93
94	def list(	1✔
95	self,
96	product: str,
97	params: "ProductFeatureService.ListParams" = {},
98	options: RequestOptions = {},
99	) -> ListObject[ProductFeature]:
100	"""
101	Retrieve a list of features for a product
102	"""
NEW 103	return cast(	×
104	ListObject[ProductFeature],
105	self._request(
106	"get",
107	"/v1/products/{product}/features".format(
108	product=sanitize_id(product),
109	),
110	api_mode="V1",
111	base_address="api",
112	params=params,
113	options=options,
114	),
115	)
116
117	async def list_async(	1✔
118	self,
119	product: str,
120	params: "ProductFeatureService.ListParams" = {},
121	options: RequestOptions = {},
122	) -> ListObject[ProductFeature]:
123	"""
124	Retrieve a list of features for a product
125	"""
NEW 126	return cast(	×
127	ListObject[ProductFeature],
128	await self._request_async(
129	"get",
130	"/v1/products/{product}/features".format(
131	product=sanitize_id(product),
132	),
133	api_mode="V1",
134	base_address="api",
135	params=params,
136	options=options,
137	),
138	)
139
140	def create(	1✔
141	self,
142	product: str,
143	params: "ProductFeatureService.CreateParams",
144	options: RequestOptions = {},
145	) -> ProductFeature:
146	"""
147	Creates a product_feature, which represents a feature attachment to a product
148	"""
NEW 149	return cast(	×
150	ProductFeature,
151	self._request(
152	"post",
153	"/v1/products/{product}/features".format(
154	product=sanitize_id(product),
155	),
156	api_mode="V1",
157	base_address="api",
158	params=params,
159	options=options,
160	),
161	)
162
163	async def create_async(	1✔
164	self,
165	product: str,
166	params: "ProductFeatureService.CreateParams",
167	options: RequestOptions = {},
168	) -> ProductFeature:
169	"""
170	Creates a product_feature, which represents a feature attachment to a product
171	"""
NEW 172	return cast(	×
173	ProductFeature,
174	await self._request_async(
175	"post",
176	"/v1/products/{product}/features".format(
177	product=sanitize_id(product),
178	),
179	api_mode="V1",
180	base_address="api",
181	params=params,
182	options=options,
183	),
184	)

stripe / stripe-python / 8365275781

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