8472602318

Committed 28 Mar 2024 07:21PM UTC coverage: 96.378% (-0.007%) from 96.385%

Build # 8472602318

Build Type

Pull #1277

github

Committed by

web-flow

Commit Message

Merge 5acece9bb into f33afdb07

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

Run Details

1144 of 1812 branches covered (63.13%)

Branch coverage included in aggregate %.

111 of 111 new or added lines in 6 files covered. (100.0%)

850 existing lines in 53 files now uncovered.

80823 of 83235 relevant lines covered (97.1%)

0.97 hits per line

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

93.33

/stripe/_customer_payment_method_service.py

# -*- coding: utf-8 -*-
# File generated from our OpenAPI spec
from stripe._list_object import ListObject
from stripe._payment_method import PaymentMethod
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 Literal, NotRequired, TypedDict


class CustomerPaymentMethodService(StripeService):
    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.
        """
        type: NotRequired[
            Literal[
                "acss_debit",
                "affirm",
                "afterpay_clearpay",
                "alipay",
                "au_becs_debit",
                "bacs_debit",
                "bancontact",
                "blik",
                "boleto",
                "card",
                "cashapp",
                "customer_balance",
                "eps",
                "fpx",
                "giropay",
                "grabpay",
                "ideal",
                "klarna",
                "konbini",
                "link",
                "mobilepay",
                "multibanco",
                "oxxo",
                "p24",
                "paynow",
                "paypal",
                "payto",
                "pix",
                "promptpay",
                "revolut_pay",
                "sepa_debit",
                "sofort",
                "swish",
                "twint",
                "us_bank_account",
                "wechat_pay",
                "zip",
            ]
        ]
        """
        An optional filter on the list, based on the object `type` field. Without the filter, the list includes all current and future payment method types. If your integration expects only one type of payment method in the response, make sure to provide a type value in the request.
        """

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

    def list(
        self,
        customer: str,
        params: "CustomerPaymentMethodService.ListParams" = {},
        options: RequestOptions = {},
    ) -> ListObject[PaymentMethod]:
        """
        Returns a list of PaymentMethods for a given Customer
        """
        return cast(
            ListObject[PaymentMethod],
            self._request(
                "get",
                "/v1/customers/{customer}/payment_methods".format(
                    customer=sanitize_id(customer),
                ),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    async def list_async(
        self,
        customer: str,
        params: "CustomerPaymentMethodService.ListParams" = {},
        options: RequestOptions = {},
    ) -> ListObject[PaymentMethod]:
        """
        Returns a list of PaymentMethods for a given Customer
        """
        return cast(
            ListObject[PaymentMethod],
            await self._request_async(
                "get",
                "/v1/customers/{customer}/payment_methods".format(
                    customer=sanitize_id(customer),
                ),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    def retrieve(
        self,
        customer: str,
        payment_method: str,
        params: "CustomerPaymentMethodService.RetrieveParams" = {},
        options: RequestOptions = {},
    ) -> PaymentMethod:
        """
        Retrieves a PaymentMethod object for a given Customer.
        """
        return cast(
            PaymentMethod,
            self._request(
                "get",
                "/v1/customers/{customer}/payment_methods/{payment_method}".format(
                    customer=sanitize_id(customer),
                    payment_method=sanitize_id(payment_method),
                ),
                api_mode="V1",
                base_address="api",
                params=params,
                options=options,
            ),
        )

    async def retrieve_async(
        self,
        customer: str,
        payment_method: str,
        params: "CustomerPaymentMethodService.RetrieveParams" = {},
        options: RequestOptions = {},
    ) -> PaymentMethod:
        """
        Retrieves a PaymentMethod object for a given Customer.
        """
        return cast(
            PaymentMethod,
            await self._request_async(
                "get",
                "/v1/customers/{customer}/payment_methods/{payment_method}".format(
                    customer=sanitize_id(customer),
                    payment_method=sanitize_id(payment_method),
                ),
                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._payment_method import PaymentMethod	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 Literal, NotRequired, TypedDict	1✔
10
11
12	class CustomerPaymentMethodService(StripeService):	1✔
13	class ListParams(TypedDict):	1✔
14	ending_before: NotRequired[str]	1✔
15	"""	1✔
16	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.
17	"""
18	expand: NotRequired[List[str]]	1✔
19	"""	1✔
20	Specifies which fields in the response should be expanded.
21	"""
22	limit: NotRequired[int]	1✔
23	"""	1✔
24	A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 10.
25	"""
26	starting_after: NotRequired[str]	1✔
27	"""	1✔
28	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.
29	"""
30	type: NotRequired[	1✔
31	Literal[
32	"acss_debit",
33	"affirm",
34	"afterpay_clearpay",
35	"alipay",
36	"au_becs_debit",
37	"bacs_debit",
38	"bancontact",
39	"blik",
40	"boleto",
41	"card",
42	"cashapp",
43	"customer_balance",
44	"eps",
45	"fpx",
46	"giropay",
47	"grabpay",
48	"ideal",
49	"klarna",
50	"konbini",
51	"link",
52	"mobilepay",
53	"multibanco",
54	"oxxo",
55	"p24",
56	"paynow",
57	"paypal",
58	"payto",
59	"pix",
60	"promptpay",
61	"revolut_pay",
62	"sepa_debit",
63	"sofort",
64	"swish",
65	"twint",
66	"us_bank_account",
67	"wechat_pay",
68	"zip",
69	]
70	]
71	"""	1✔
72	An optional filter on the list, based on the object `type` field. Without the filter, the list includes all current and future payment method types. If your integration expects only one type of payment method in the response, make sure to provide a type value in the request.
73	"""
74
75	class RetrieveParams(TypedDict):	1✔
76	expand: NotRequired[List[str]]	1✔
77	"""	1✔
78	Specifies which fields in the response should be expanded.
79	"""
80
81	def list(	1✔
82	self,
83	customer: str,
84	params: "CustomerPaymentMethodService.ListParams" = {},
85	options: RequestOptions = {},
86	) -> ListObject[PaymentMethod]:
87	"""
88	Returns a list of PaymentMethods for a given Customer
89	"""
90	return cast(	1✔
91	ListObject[PaymentMethod],
92	self._request(
93	"get",
94	"/v1/customers/{customer}/payment_methods".format(
95	customer=sanitize_id(customer),
96	),
97	api_mode="V1",
98	base_address="api",
99	params=params,
100	options=options,
101	),
102	)
103
104	async def list_async(	1✔
105	self,
106	customer: str,
107	params: "CustomerPaymentMethodService.ListParams" = {},
108	options: RequestOptions = {},
109	) -> ListObject[PaymentMethod]:
110	"""
111	Returns a list of PaymentMethods for a given Customer
112	"""
113	return cast(	1✔
114	ListObject[PaymentMethod],
115	await self._request_async(
116	"get",
117	"/v1/customers/{customer}/payment_methods".format(
118	customer=sanitize_id(customer),
119	),
120	api_mode="V1",
121	base_address="api",
122	params=params,
123	options=options,
124	),
125	)
126
127	def retrieve(	1✔
128	self,
129	customer: str,
130	payment_method: str,
131	params: "CustomerPaymentMethodService.RetrieveParams" = {},
132	options: RequestOptions = {},
133	) -> PaymentMethod:
134	"""
135	Retrieves a PaymentMethod object for a given Customer.
136	"""
UNCOV 137	return cast(	×
138	PaymentMethod,
139	self._request(
140	"get",
141	"/v1/customers/{customer}/payment_methods/{payment_method}".format(
142	customer=sanitize_id(customer),
143	payment_method=sanitize_id(payment_method),
144	),
145	api_mode="V1",
146	base_address="api",
147	params=params,
148	options=options,
149	),
150	)
151
152	async def retrieve_async(	1✔
153	self,
154	customer: str,
155	payment_method: str,
156	params: "CustomerPaymentMethodService.RetrieveParams" = {},
157	options: RequestOptions = {},
158	) -> PaymentMethod:
159	"""
160	Retrieves a PaymentMethod object for a given Customer.
161	"""
UNCOV 162	return cast(	×
163	PaymentMethod,
164	await self._request_async(
165	"get",
166	"/v1/customers/{customer}/payment_methods/{payment_method}".format(
167	customer=sanitize_id(customer),
168	payment_method=sanitize_id(payment_method),
169	),
170	api_mode="V1",
171	base_address="api",
172	params=params,
173	options=options,
174	),
175	)

stripe / stripe-python / 8472602318

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