8694789149

Committed 15 Apr 2024 07:14PM UTC coverage: 96.406% (+0.002%) from 96.404%

Build # 8694789149

Build Type

Pull #1302

github

Committed by

web-flow

Commit Message

Merge 0d5ba3d75 into 4a517d3df

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

Run Details

1125 of 1784 branches covered (63.06%)

Branch coverage included in aggregate %.

231 of 231 new or added lines in 26 files covered. (100.0%)

274 existing lines in 18 files now uncovered.

81465 of 83885 relevant lines covered (97.12%)

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",
                "amazon_pay",
                "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	"amazon_pay",
37	"au_becs_debit",
38	"bacs_debit",
39	"bancontact",
40	"blik",
41	"boleto",
42	"card",
43	"cashapp",
44	"customer_balance",
45	"eps",
46	"fpx",
47	"giropay",
48	"grabpay",
49	"ideal",
50	"klarna",
51	"konbini",
52	"link",
53	"mobilepay",
54	"multibanco",
55	"oxxo",
56	"p24",
57	"paynow",
58	"paypal",
59	"payto",
60	"pix",
61	"promptpay",
62	"revolut_pay",
63	"sepa_debit",
64	"sofort",
65	"swish",
66	"twint",
67	"us_bank_account",
68	"wechat_pay",
69	"zip",
70	]
71	]
72	"""	1✔
73	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.
74	"""
75
76	class RetrieveParams(TypedDict):	1✔
77	expand: NotRequired[List[str]]	1✔
78	"""	1✔
79	Specifies which fields in the response should be expanded.
80	"""
81
82	def list(	1✔
83	self,
84	customer: str,
85	params: "CustomerPaymentMethodService.ListParams" = {},
86	options: RequestOptions = {},
87	) -> ListObject[PaymentMethod]:
88	"""
89	Returns a list of PaymentMethods for a given Customer
90	"""
91	return cast(	1✔
92	ListObject[PaymentMethod],
93	self._request(
94	"get",
95	"/v1/customers/{customer}/payment_methods".format(
96	customer=sanitize_id(customer),
97	),
98	api_mode="V1",
99	base_address="api",
100	params=params,
101	options=options,
102	),
103	)
104
105	async def list_async(	1✔
106	self,
107	customer: str,
108	params: "CustomerPaymentMethodService.ListParams" = {},
109	options: RequestOptions = {},
110	) -> ListObject[PaymentMethod]:
111	"""
112	Returns a list of PaymentMethods for a given Customer
113	"""
114	return cast(	1✔
115	ListObject[PaymentMethod],
116	await self._request_async(
117	"get",
118	"/v1/customers/{customer}/payment_methods".format(
119	customer=sanitize_id(customer),
120	),
121	api_mode="V1",
122	base_address="api",
123	params=params,
124	options=options,
125	),
126	)
127
128	def retrieve(	1✔
129	self,
130	customer: str,
131	payment_method: str,
132	params: "CustomerPaymentMethodService.RetrieveParams" = {},
133	options: RequestOptions = {},
134	) -> PaymentMethod:
135	"""
136	Retrieves a PaymentMethod object for a given Customer.
137	"""
UNCOV 138	return cast(	×
139	PaymentMethod,
140	self._request(
141	"get",
142	"/v1/customers/{customer}/payment_methods/{payment_method}".format(
143	customer=sanitize_id(customer),
144	payment_method=sanitize_id(payment_method),
145	),
146	api_mode="V1",
147	base_address="api",
148	params=params,
149	options=options,
150	),
151	)
152
153	async def retrieve_async(	1✔
154	self,
155	customer: str,
156	payment_method: str,
157	params: "CustomerPaymentMethodService.RetrieveParams" = {},
158	options: RequestOptions = {},
159	) -> PaymentMethod:
160	"""
161	Retrieves a PaymentMethod object for a given Customer.
162	"""
UNCOV 163	return cast(	×
164	PaymentMethod,
165	await self._request_async(
166	"get",
167	"/v1/customers/{customer}/payment_methods/{payment_method}".format(
168	customer=sanitize_id(customer),
169	payment_method=sanitize_id(payment_method),
170	),
171	api_mode="V1",
172	base_address="api",
173	params=params,
174	options=options,
175	),
176	)

stripe / stripe-python / 8694789149

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