6189311850

Committed 14 Sep 2023 06:12PM UTC coverage: 91.113% (+0.1%) from 91.011%

Build # 6189311850

Build Type

push

github

Committed by

web-flow

Commit Message

Generate explicit nested resource class methods (#1050)

* Generate explicit nested resource class methods

* Test nested resources

* Revert "Test nested resources"

This reverts commit 296ba8e18.

* Add back decorators

Run Details

649 of 875 branches covered (0.0%)

Branch coverage included in aggregate %.

136 of 136 new or added lines in 7 files covered. (100.0%)

6651 of 7137 relevant lines covered (93.19%)

0.93 hits per line

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

90.8

/stripe/api_resources/customer.py

# -*- coding: utf-8 -*-
# File generated from our OpenAPI spec
from __future__ import absolute_import, division, print_function

from stripe import util
from stripe.api_resources.abstract import (
    APIResourceTestHelpers,
    CreateableAPIResource,
    DeletableAPIResource,
    ListableAPIResource,
    SearchableAPIResource,
    UpdateableAPIResource,
    nested_resource_class_methods,
)
from stripe.api_resources.expandable_field import ExpandableField
from stripe.api_resources.list_object import ListObject
from stripe.stripe_object import StripeObject
from typing import Any, Dict, List, Optional, cast
from typing_extensions import Literal, Type
from urllib.parse import quote_plus

from typing_extensions import TYPE_CHECKING

if TYPE_CHECKING:
    from stripe.api_resources.cash_balance import CashBalance
    from stripe.api_resources.discount import Discount
    from stripe.api_resources.subscription import Subscription
    from stripe.api_resources.tax_id import TaxId
    from stripe.api_resources.test_helpers.test_clock import TestClock


@nested_resource_class_methods("balance_transaction")
@nested_resource_class_methods("cash_balance_transaction")
@nested_resource_class_methods("source")
@nested_resource_class_methods("tax_id")
class Customer(
    CreateableAPIResource["Customer"],
    DeletableAPIResource["Customer"],
    ListableAPIResource["Customer"],
    SearchableAPIResource["Customer"],
    UpdateableAPIResource["Customer"],
):
    """
    This object represents a customer of your business. It lets you create recurring charges and track payments that belong to the same customer.

    Related guide: [Save a card during payment](https://stripe.com/docs/payments/save-during-payment)
    """

    OBJECT_NAME = "customer"
    address: Optional[StripeObject]
    balance: int
    cash_balance: Optional["CashBalance"]
    created: int
    currency: Optional[str]
    default_source: Optional[ExpandableField[Any]]
    delinquent: Optional[bool]
    description: Optional[str]
    discount: Optional["Discount"]
    email: Optional[str]
    id: str
    invoice_credit_balance: Dict[str, int]
    invoice_prefix: Optional[str]
    invoice_settings: StripeObject
    livemode: bool
    metadata: Dict[str, str]
    name: Optional[str]
    next_invoice_sequence: int
    object: Literal["customer"]
    phone: Optional[str]
    preferred_locales: Optional[List[str]]
    shipping: Optional[StripeObject]
    sources: ListObject[Any]
    subscriptions: ListObject["Subscription"]
    tax: StripeObject
    tax_exempt: Optional[Literal["exempt", "none", "reverse"]]
    tax_ids: ListObject["TaxId"]
    test_clock: Optional[ExpandableField["TestClock"]]

    @classmethod
    def create(
        cls,
        api_key=None,
        idempotency_key=None,
        stripe_version=None,
        stripe_account=None,
        **params
    ) -> "Customer":
        return cast(
            "Customer",
            cls._static_request(
                "post",
                cls.class_url(),
                api_key,
                idempotency_key,
                stripe_version,
                stripe_account,
                params,
            ),
        )

    @classmethod
    def _cls_create_funding_instructions(
        cls,
        customer,
        api_key=None,
        stripe_version=None,
        stripe_account=None,
        **params
    ):
        return cls._static_request(
            "post",
            "/v1/customers/{customer}/funding_instructions".format(
                customer=util.sanitize_id(customer)
            ),
            api_key=api_key,
            stripe_version=stripe_version,
            stripe_account=stripe_account,
            params=params,
        )

    @util.class_method_variant("_cls_create_funding_instructions")
    def create_funding_instructions(self, idempotency_key=None, **params):
        return self._request(
            "post",
            "/v1/customers/{customer}/funding_instructions".format(
                customer=util.sanitize_id(self.get("id"))
            ),
            idempotency_key=idempotency_key,
            params=params,
        )

    @classmethod
    def _cls_delete(cls, sid, **params) -> "Customer":
        url = "%s/%s" % (cls.class_url(), quote_plus(sid))
        return cast(
            "Customer",
            cls._static_request("delete", url, params=params),
        )

    @util.class_method_variant("_cls_delete")
    def delete(self, **params) -> "Customer":
        return self._request_and_refresh(
            "delete",
            self.instance_url(),
            params=params,
        )

    @classmethod
    def _cls_delete_discount(
        cls,
        customer,
        api_key=None,
        stripe_version=None,
        stripe_account=None,
        **params
    ):
        return cls._static_request(
            "delete",
            "/v1/customers/{customer}/discount".format(
                customer=util.sanitize_id(customer)
            ),
            api_key=api_key,
            stripe_version=stripe_version,
            stripe_account=stripe_account,
            params=params,
        )

    @util.class_method_variant("_cls_delete_discount")
    def delete_discount(self, idempotency_key=None, **params):
        return self._request(
            "delete",
            "/v1/customers/{customer}/discount".format(
                customer=util.sanitize_id(self.get("id"))
            ),
            idempotency_key=idempotency_key,
            params=params,
        )

    @classmethod
    def list(
        cls, api_key=None, stripe_version=None, stripe_account=None, **params
    ) -> ListObject["Customer"]:
        result = cls._static_request(
            "get",
            cls.class_url(),
            api_key=api_key,
            stripe_version=stripe_version,
            stripe_account=stripe_account,
            params=params,
        )
        if not isinstance(result, ListObject):

            raise TypeError(
                "Expected list object from API, got %s"
                % (type(result).__name__)
            )

        return result

    @classmethod
    def _cls_list_payment_methods(
        cls,
        customer,
        api_key=None,
        stripe_version=None,
        stripe_account=None,
        **params
    ):
        return cls._static_request(
            "get",
            "/v1/customers/{customer}/payment_methods".format(
                customer=util.sanitize_id(customer)
            ),
            api_key=api_key,
            stripe_version=stripe_version,
            stripe_account=stripe_account,
            params=params,
        )

    @util.class_method_variant("_cls_list_payment_methods")
    def list_payment_methods(self, idempotency_key=None, **params):
        return self._request(
            "get",
            "/v1/customers/{customer}/payment_methods".format(
                customer=util.sanitize_id(self.get("id"))
            ),
            idempotency_key=idempotency_key,
            params=params,
        )

    @classmethod
    def modify(cls, id, **params) -> "Customer":
        url = "%s/%s" % (cls.class_url(), quote_plus(id))
        return cast(
            "Customer",
            cls._static_request("post", url, params=params),
        )

    @classmethod
    def retrieve(cls, id, api_key=None, **params) -> Any:
        instance = cls(id, api_key, **params)
        instance.refresh()
        return instance

    @classmethod
    def _cls_retrieve_payment_method(
        cls,
        customer,
        payment_method,
        api_key=None,
        stripe_version=None,
        stripe_account=None,
        **params
    ):
        return cls._static_request(
            "get",
            "/v1/customers/{customer}/payment_methods/{payment_method}".format(
                customer=util.sanitize_id(customer),
                payment_method=util.sanitize_id(payment_method),
            ),
            api_key=api_key,
            stripe_version=stripe_version,
            stripe_account=stripe_account,
            params=params,
        )

    @util.class_method_variant("_cls_retrieve_payment_method")
    def retrieve_payment_method(
        self, payment_method, idempotency_key=None, **params
    ):
        return self._request(
            "get",
            "/v1/customers/{customer}/payment_methods/{payment_method}".format(
                customer=util.sanitize_id(self.get("id")),
                payment_method=util.sanitize_id(payment_method),
            ),
            idempotency_key=idempotency_key,
            params=params,
        )

    @classmethod
    def search(cls, *args, **kwargs) -> Any:
        return cls._search(search_url="/v1/customers/search", *args, **kwargs)

    @classmethod
    def search_auto_paging_iter(cls, *args, **kwargs) -> Any:
        return cls.search(*args, **kwargs).auto_paging_iter()

    @classmethod
    def create_balance_transaction(
        cls,
        customer,
        api_key=None,
        stripe_version=None,
        stripe_account=None,
        **params
    ):
        return cls._static_request(
            "post",
            "/v1/customers/{customer}/balance_transactions".format(
                customer=util.sanitize_id(customer)
            ),
            api_key=api_key,
            stripe_version=stripe_version,
            stripe_account=stripe_account,
            params=params,
        )

    @classmethod
    def retrieve_balance_transaction(
        cls,
        customer,
        transaction,
        api_key=None,
        stripe_version=None,
        stripe_account=None,
        **params
    ):
        return cls._static_request(
            "get",
            "/v1/customers/{customer}/balance_transactions/{transaction}".format(
                customer=util.sanitize_id(customer),
                transaction=util.sanitize_id(transaction),
            ),
            api_key=api_key,
            stripe_version=stripe_version,
            stripe_account=stripe_account,
            params=params,
        )

    @classmethod
    def modify_balance_transaction(
        cls,
        customer,
        transaction,
        api_key=None,
        stripe_version=None,
        stripe_account=None,
        **params
    ):
        return cls._static_request(
            "post",
            "/v1/customers/{customer}/balance_transactions/{transaction}".format(
                customer=util.sanitize_id(customer),
                transaction=util.sanitize_id(transaction),
            ),
            api_key=api_key,
            stripe_version=stripe_version,
            stripe_account=stripe_account,
            params=params,
        )

    @classmethod
    def list_balance_transactions(
        cls,
        customer,
        api_key=None,
        stripe_version=None,
        stripe_account=None,
        **params
    ):
        return cls._static_request(
            "get",
            "/v1/customers/{customer}/balance_transactions".format(
                customer=util.sanitize_id(customer)
            ),
            api_key=api_key,
            stripe_version=stripe_version,
            stripe_account=stripe_account,
            params=params,
        )

    @classmethod
    def retrieve_cash_balance_transaction(
        cls,
        customer,
        transaction,
        api_key=None,
        stripe_version=None,
        stripe_account=None,
        **params
    ):
        return cls._static_request(
            "get",
            "/v1/customers/{customer}/cash_balance_transactions/{transaction}".format(
                customer=util.sanitize_id(customer),
                transaction=util.sanitize_id(transaction),
            ),
            api_key=api_key,
            stripe_version=stripe_version,
            stripe_account=stripe_account,
            params=params,
        )

    @classmethod
    def list_cash_balance_transactions(
        cls,
        customer,
        api_key=None,
        stripe_version=None,
        stripe_account=None,
        **params
    ):
        return cls._static_request(
            "get",
            "/v1/customers/{customer}/cash_balance_transactions".format(
                customer=util.sanitize_id(customer)
            ),
            api_key=api_key,
            stripe_version=stripe_version,
            stripe_account=stripe_account,
            params=params,
        )

    @classmethod
    def create_source(
        cls,
        customer,
        api_key=None,
        stripe_version=None,
        stripe_account=None,
        **params
    ):
        return cls._static_request(
            "post",
            "/v1/customers/{customer}/sources".format(
                customer=util.sanitize_id(customer)
            ),
            api_key=api_key,
            stripe_version=stripe_version,
            stripe_account=stripe_account,
            params=params,
        )

    @classmethod
    def retrieve_source(
        cls,
        customer,
        id,
        api_key=None,
        stripe_version=None,
        stripe_account=None,
        **params
    ):
        return cls._static_request(
            "get",
            "/v1/customers/{customer}/sources/{id}".format(
                customer=util.sanitize_id(customer), id=util.sanitize_id(id)
            ),
            api_key=api_key,
            stripe_version=stripe_version,
            stripe_account=stripe_account,
            params=params,
        )

    @classmethod
    def modify_source(
        cls,
        customer,
        id,
        api_key=None,
        stripe_version=None,
        stripe_account=None,
        **params
    ):
        return cls._static_request(
            "post",
            "/v1/customers/{customer}/sources/{id}".format(
                customer=util.sanitize_id(customer), id=util.sanitize_id(id)
            ),
            api_key=api_key,
            stripe_version=stripe_version,
            stripe_account=stripe_account,
            params=params,
        )

    @classmethod
    def delete_source(
        cls,
        customer,
        id,
        api_key=None,
        stripe_version=None,
        stripe_account=None,
        **params
    ):
        return cls._static_request(
            "delete",
            "/v1/customers/{customer}/sources/{id}".format(
                customer=util.sanitize_id(customer), id=util.sanitize_id(id)
            ),
            api_key=api_key,
            stripe_version=stripe_version,
            stripe_account=stripe_account,
            params=params,
        )

    @classmethod
    def list_sources(
        cls,
        customer,
        api_key=None,
        stripe_version=None,
        stripe_account=None,
        **params
    ):
        return cls._static_request(
            "get",
            "/v1/customers/{customer}/sources".format(
                customer=util.sanitize_id(customer)
            ),
            api_key=api_key,
            stripe_version=stripe_version,
            stripe_account=stripe_account,
            params=params,
        )

    @classmethod
    def create_tax_id(
        cls,
        customer,
        api_key=None,
        stripe_version=None,
        stripe_account=None,
        **params
    ):
        return cls._static_request(
            "post",
            "/v1/customers/{customer}/tax_ids".format(
                customer=util.sanitize_id(customer)
            ),
            api_key=api_key,
            stripe_version=stripe_version,
            stripe_account=stripe_account,
            params=params,
        )

    @classmethod
    def retrieve_tax_id(
        cls,
        customer,
        id,
        api_key=None,
        stripe_version=None,
        stripe_account=None,
        **params
    ):
        return cls._static_request(
            "get",
            "/v1/customers/{customer}/tax_ids/{id}".format(
                customer=util.sanitize_id(customer), id=util.sanitize_id(id)
            ),
            api_key=api_key,
            stripe_version=stripe_version,
            stripe_account=stripe_account,
            params=params,
        )

    @classmethod
    def delete_tax_id(
        cls,
        customer,
        id,
        api_key=None,
        stripe_version=None,
        stripe_account=None,
        **params
    ):
        return cls._static_request(
            "delete",
            "/v1/customers/{customer}/tax_ids/{id}".format(
                customer=util.sanitize_id(customer), id=util.sanitize_id(id)
            ),
            api_key=api_key,
            stripe_version=stripe_version,
            stripe_account=stripe_account,
            params=params,
        )

    @classmethod
    def list_tax_ids(
        cls,
        customer,
        api_key=None,
        stripe_version=None,
        stripe_account=None,
        **params
    ):
        return cls._static_request(
            "get",
            "/v1/customers/{customer}/tax_ids".format(
                customer=util.sanitize_id(customer)
            ),
            api_key=api_key,
            stripe_version=stripe_version,
            stripe_account=stripe_account,
            params=params,
        )

    @classmethod
    def modify_cash_balance(
        cls,
        customer,
        api_key=None,
        stripe_version=None,
        stripe_account=None,
        **params
    ):
        return cls._static_request(
            "post",
            "/v1/customers/{customer}/cash_balance".format(
                customer=util.sanitize_id(customer)
            ),
            api_key=api_key,
            stripe_version=stripe_version,
            stripe_account=stripe_account,
            params=params,
        )

    @classmethod
    def retrieve_cash_balance(
        cls,
        customer,
        api_key=None,
        stripe_version=None,
        stripe_account=None,
        **params
    ):
        return cls._static_request(
            "get",
            "/v1/customers/{customer}/cash_balance".format(
                customer=util.sanitize_id(customer)
            ),
            api_key=api_key,
            stripe_version=stripe_version,
            stripe_account=stripe_account,
            params=params,
        )

    class TestHelpers(APIResourceTestHelpers["Customer"]):
        _resource_cls: Type["Customer"]

        @classmethod
        def _cls_fund_cash_balance(
            cls,
            customer,
            api_key=None,
            stripe_version=None,
            stripe_account=None,
            **params
        ):
            return cls._static_request(
                "post",
                "/v1/test_helpers/customers/{customer}/fund_cash_balance".format(
                    customer=util.sanitize_id(customer)
                ),
                api_key=api_key,
                stripe_version=stripe_version,
                stripe_account=stripe_account,
                params=params,
            )

        @util.class_method_variant("_cls_fund_cash_balance")
        def fund_cash_balance(self, idempotency_key=None, **params):
            return self.resource._request(
                "post",
                "/v1/test_helpers/customers/{customer}/fund_cash_balance".format(
                    customer=util.sanitize_id(self.resource.get("id"))
                ),
                idempotency_key=idempotency_key,
                params=params,
            )

    @property
    def test_helpers(self):
        return self.TestHelpers(self)


Customer.TestHelpers._resource_cls = Customer

1	# -- coding: utf-8 --
2	# File generated from our OpenAPI spec
3	from __future__ import absolute_import, division, print_function	1✔
4
5	from stripe import util	1✔
6	from stripe.api_resources.abstract import (	1✔
7	APIResourceTestHelpers,
8	CreateableAPIResource,
9	DeletableAPIResource,
10	ListableAPIResource,
11	SearchableAPIResource,
12	UpdateableAPIResource,
13	nested_resource_class_methods,
14	)
15	from stripe.api_resources.expandable_field import ExpandableField	1✔
16	from stripe.api_resources.list_object import ListObject	1✔
17	from stripe.stripe_object import StripeObject	1✔
18	from typing import Any, Dict, List, Optional, cast	1✔
19	from typing_extensions import Literal, Type	1✔
20	from urllib.parse import quote_plus	1✔
21
22	from typing_extensions import TYPE_CHECKING	1✔
23
24	if TYPE_CHECKING:	1!
25	from stripe.api_resources.cash_balance import CashBalance	×
26	from stripe.api_resources.discount import Discount	×
27	from stripe.api_resources.subscription import Subscription	×
28	from stripe.api_resources.tax_id import TaxId	×
29	from stripe.api_resources.test_helpers.test_clock import TestClock	×
30
31
32	@nested_resource_class_methods("balance_transaction")	1✔
33	@nested_resource_class_methods("cash_balance_transaction")	1✔
34	@nested_resource_class_methods("source")	1✔
35	@nested_resource_class_methods("tax_id")	1✔
36	class Customer(	1✔
37	CreateableAPIResource["Customer"],
38	DeletableAPIResource["Customer"],
39	ListableAPIResource["Customer"],
40	SearchableAPIResource["Customer"],
41	UpdateableAPIResource["Customer"],
42	):
43	"""
44	This object represents a customer of your business. It lets you create recurring charges and track payments that belong to the same customer.
45
46	Related guide: [Save a card during payment](https://stripe.com/docs/payments/save-during-payment)
47	"""
48
49	OBJECT_NAME = "customer"	1✔
50	address: Optional[StripeObject]	1✔
51	balance: int	1✔
52	cash_balance: Optional["CashBalance"]	1✔
53	created: int	1✔
54	currency: Optional[str]	1✔
55	default_source: Optional[ExpandableField[Any]]	1✔
56	delinquent: Optional[bool]	1✔
57	description: Optional[str]	1✔
58	discount: Optional["Discount"]	1✔
59	email: Optional[str]	1✔
60	id: str	1✔
61	invoice_credit_balance: Dict[str, int]	1✔
62	invoice_prefix: Optional[str]	1✔
63	invoice_settings: StripeObject	1✔
64	livemode: bool	1✔
65	metadata: Dict[str, str]	1✔
66	name: Optional[str]	1✔
67	next_invoice_sequence: int	1✔
68	object: Literal["customer"]	1✔
69	phone: Optional[str]	1✔
70	preferred_locales: Optional[List[str]]	1✔
71	shipping: Optional[StripeObject]	1✔
72	sources: ListObject[Any]	1✔
73	subscriptions: ListObject["Subscription"]	1✔
74	tax: StripeObject	1✔
75	tax_exempt: Optional[Literal["exempt", "none", "reverse"]]	1✔
76	tax_ids: ListObject["TaxId"]	1✔
77	test_clock: Optional[ExpandableField["TestClock"]]	1✔
78
79	@classmethod	1✔
80	def create(	1✔
81	cls,
82	api_key=None,
83	idempotency_key=None,
84	stripe_version=None,
85	stripe_account=None,
86	**params
87	) -> "Customer":
88	return cast(	1✔
89	"Customer",
90	cls._static_request(
91	"post",
92	cls.class_url(),
93	api_key,
94	idempotency_key,
95	stripe_version,
96	stripe_account,
97	params,
98	),
99	)
100
101	@classmethod	1✔
102	def _cls_create_funding_instructions(	1✔
103	cls,
104	customer,
105	api_key=None,
106	stripe_version=None,
107	stripe_account=None,
108	**params
109	):
110	return cls._static_request(	1✔
111	"post",
112	"/v1/customers/{customer}/funding_instructions".format(
113	customer=util.sanitize_id(customer)
114	),
115	api_key=api_key,
116	stripe_version=stripe_version,
117	stripe_account=stripe_account,
118	params=params,
119	)
120
121	@util.class_method_variant("_cls_create_funding_instructions")	1✔
122	def create_funding_instructions(self, idempotency_key=None, **params):	1✔
123	return self._request(	×
124	"post",
125	"/v1/customers/{customer}/funding_instructions".format(
126	customer=util.sanitize_id(self.get("id"))
127	),
128	idempotency_key=idempotency_key,
129	params=params,
130	)
131
132	@classmethod	1✔
133	def _cls_delete(cls, sid, **params) -> "Customer":	1✔
134	url = "%s/%s" % (cls.class_url(), quote_plus(sid))	1✔
135	return cast(	1✔
136	"Customer",
137	cls._static_request("delete", url, params=params),
138	)
139
140	@util.class_method_variant("_cls_delete")	1✔
141	def delete(self, **params) -> "Customer":	1✔
142	return self._request_and_refresh(	1✔
143	"delete",
144	self.instance_url(),
145	params=params,
146	)
147
148	@classmethod	1✔
149	def _cls_delete_discount(	1✔
150	cls,
151	customer,
152	api_key=None,
153	stripe_version=None,
154	stripe_account=None,
155	**params
156	):
157	return cls._static_request(	1✔
158	"delete",
159	"/v1/customers/{customer}/discount".format(
160	customer=util.sanitize_id(customer)
161	),
162	api_key=api_key,
163	stripe_version=stripe_version,
164	stripe_account=stripe_account,
165	params=params,
166	)
167
168	@util.class_method_variant("_cls_delete_discount")	1✔
169	def delete_discount(self, idempotency_key=None, **params):	1✔
170	return self._request(	1✔
171	"delete",
172	"/v1/customers/{customer}/discount".format(
173	customer=util.sanitize_id(self.get("id"))
174	),
175	idempotency_key=idempotency_key,
176	params=params,
177	)
178
179	@classmethod	1✔
180	def list(	1✔
181	cls, api_key=None, stripe_version=None, stripe_account=None, **params
182	) -> ListObject["Customer"]:
183	result = cls._static_request(	1✔
184	"get",
185	cls.class_url(),
186	api_key=api_key,
187	stripe_version=stripe_version,
188	stripe_account=stripe_account,
189	params=params,
190	)
191	if not isinstance(result, ListObject):	1!
192
193	raise TypeError(	×
194	"Expected list object from API, got %s"
195	% (type(result).__name__)
196	)
197
198	return result	1✔
199
200	@classmethod	1✔
201	def _cls_list_payment_methods(	1✔
202	cls,
203	customer,
204	api_key=None,
205	stripe_version=None,
206	stripe_account=None,
207	**params
208	):
209	return cls._static_request(	1✔
210	"get",
211	"/v1/customers/{customer}/payment_methods".format(
212	customer=util.sanitize_id(customer)
213	),
214	api_key=api_key,
215	stripe_version=stripe_version,
216	stripe_account=stripe_account,
217	params=params,
218	)
219
220	@util.class_method_variant("_cls_list_payment_methods")	1✔
221	def list_payment_methods(self, idempotency_key=None, **params):	1✔
222	return self._request(	1✔
223	"get",
224	"/v1/customers/{customer}/payment_methods".format(
225	customer=util.sanitize_id(self.get("id"))
226	),
227	idempotency_key=idempotency_key,
228	params=params,
229	)
230
231	@classmethod	1✔
232	def modify(cls, id, **params) -> "Customer":	1✔
233	url = "%s/%s" % (cls.class_url(), quote_plus(id))	1✔
234	return cast(	1✔
235	"Customer",
236	cls._static_request("post", url, params=params),
237	)
238
239	@classmethod	1✔
240	def retrieve(cls, id, api_key=None, **params) -> Any:	1✔
241	instance = cls(id, api_key, **params)	1✔
242	instance.refresh()	1✔
243	return instance	1✔
244
245	@classmethod	1✔
246	def _cls_retrieve_payment_method(	1✔
247	cls,
248	customer,
249	payment_method,
250	api_key=None,
251	stripe_version=None,
252	stripe_account=None,
253	**params
254	):
255	return cls._static_request(	×
256	"get",
257	"/v1/customers/{customer}/payment_methods/{payment_method}".format(
258	customer=util.sanitize_id(customer),
259	payment_method=util.sanitize_id(payment_method),
260	),
261	api_key=api_key,
262	stripe_version=stripe_version,
263	stripe_account=stripe_account,
264	params=params,
265	)
266
267	@util.class_method_variant("_cls_retrieve_payment_method")	1✔
268	def retrieve_payment_method(	1✔
269	self, payment_method, idempotency_key=None, **params
270	):
271	return self._request(	×
272	"get",
273	"/v1/customers/{customer}/payment_methods/{payment_method}".format(
274	customer=util.sanitize_id(self.get("id")),
275	payment_method=util.sanitize_id(payment_method),
276	),
277	idempotency_key=idempotency_key,
278	params=params,
279	)
280
281	@classmethod	1✔
282	def search(cls, args, *kwargs) -> Any:	1✔
283	return cls._search(search_url="/v1/customers/search", args, *kwargs)	1✔
284
285	@classmethod	1✔
286	def search_auto_paging_iter(cls, args, *kwargs) -> Any:	1✔
287	return cls.search(args, *kwargs).auto_paging_iter()	×
288
289	@classmethod	1✔
290	def create_balance_transaction(	1✔
291	cls,
292	customer,
293	api_key=None,
294	stripe_version=None,
295	stripe_account=None,
296	**params
297	):
298	return cls._static_request(	1✔
299	"post",
300	"/v1/customers/{customer}/balance_transactions".format(
301	customer=util.sanitize_id(customer)
302	),
303	api_key=api_key,
304	stripe_version=stripe_version,
305	stripe_account=stripe_account,
306	params=params,
307	)
308
309	@classmethod	1✔
310	def retrieve_balance_transaction(	1✔
311	cls,
312	customer,
313	transaction,
314	api_key=None,
315	stripe_version=None,
316	stripe_account=None,
317	**params
318	):
319	return cls._static_request(	1✔
320	"get",
321	"/v1/customers/{customer}/balance_transactions/{transaction}".format(
322	customer=util.sanitize_id(customer),
323	transaction=util.sanitize_id(transaction),
324	),
325	api_key=api_key,
326	stripe_version=stripe_version,
327	stripe_account=stripe_account,
328	params=params,
329	)
330
331	@classmethod	1✔
332	def modify_balance_transaction(	1✔
333	cls,
334	customer,
335	transaction,
336	api_key=None,
337	stripe_version=None,
338	stripe_account=None,
339	**params
340	):
341	return cls._static_request(	1✔
342	"post",
343	"/v1/customers/{customer}/balance_transactions/{transaction}".format(
344	customer=util.sanitize_id(customer),
345	transaction=util.sanitize_id(transaction),
346	),
347	api_key=api_key,
348	stripe_version=stripe_version,
349	stripe_account=stripe_account,
350	params=params,
351	)
352
353	@classmethod	1✔
354	def list_balance_transactions(	1✔
355	cls,
356	customer,
357	api_key=None,
358	stripe_version=None,
359	stripe_account=None,
360	**params
361	):
362	return cls._static_request(	1✔
363	"get",
364	"/v1/customers/{customer}/balance_transactions".format(
365	customer=util.sanitize_id(customer)
366	),
367	api_key=api_key,
368	stripe_version=stripe_version,
369	stripe_account=stripe_account,
370	params=params,
371	)
372
373	@classmethod	1✔
374	def retrieve_cash_balance_transaction(	1✔
375	cls,
376	customer,
377	transaction,
378	api_key=None,
379	stripe_version=None,
380	stripe_account=None,
381	**params
382	):
383	return cls._static_request(	×
384	"get",
385	"/v1/customers/{customer}/cash_balance_transactions/{transaction}".format(
386	customer=util.sanitize_id(customer),
387	transaction=util.sanitize_id(transaction),
388	),
389	api_key=api_key,
390	stripe_version=stripe_version,
391	stripe_account=stripe_account,
392	params=params,
393	)
394
395	@classmethod	1✔
396	def list_cash_balance_transactions(	1✔
397	cls,
398	customer,
399	api_key=None,
400	stripe_version=None,
401	stripe_account=None,
402	**params
403	):
404	return cls._static_request(	×
405	"get",
406	"/v1/customers/{customer}/cash_balance_transactions".format(
407	customer=util.sanitize_id(customer)
408	),
409	api_key=api_key,
410	stripe_version=stripe_version,
411	stripe_account=stripe_account,
412	params=params,
413	)
414
415	@classmethod	1✔
416	def create_source(	1✔
417	cls,
418	customer,
419	api_key=None,
420	stripe_version=None,
421	stripe_account=None,
422	**params
423	):
424	return cls._static_request(	1✔
425	"post",
426	"/v1/customers/{customer}/sources".format(
427	customer=util.sanitize_id(customer)
428	),
429	api_key=api_key,
430	stripe_version=stripe_version,
431	stripe_account=stripe_account,
432	params=params,
433	)
434
435	@classmethod	1✔
436	def retrieve_source(	1✔
437	cls,
438	customer,
439	id,
440	api_key=None,
441	stripe_version=None,
442	stripe_account=None,
443	**params
444	):
445	return cls._static_request(	1✔
446	"get",
447	"/v1/customers/{customer}/sources/{id}".format(
448	customer=util.sanitize_id(customer), id=util.sanitize_id(id)
449	),
450	api_key=api_key,
451	stripe_version=stripe_version,
452	stripe_account=stripe_account,
453	params=params,
454	)
455
456	@classmethod	1✔
457	def modify_source(	1✔
458	cls,
459	customer,
460	id,
461	api_key=None,
462	stripe_version=None,
463	stripe_account=None,
464	**params
465	):
466	return cls._static_request(	1✔
467	"post",
468	"/v1/customers/{customer}/sources/{id}".format(
469	customer=util.sanitize_id(customer), id=util.sanitize_id(id)
470	),
471	api_key=api_key,
472	stripe_version=stripe_version,
473	stripe_account=stripe_account,
474	params=params,
475	)
476
477	@classmethod	1✔
478	def delete_source(	1✔
479	cls,
480	customer,
481	id,
482	api_key=None,
483	stripe_version=None,
484	stripe_account=None,
485	**params
486	):
487	return cls._static_request(	1✔
488	"delete",
489	"/v1/customers/{customer}/sources/{id}".format(
490	customer=util.sanitize_id(customer), id=util.sanitize_id(id)
491	),
492	api_key=api_key,
493	stripe_version=stripe_version,
494	stripe_account=stripe_account,
495	params=params,
496	)
497
498	@classmethod	1✔
499	def list_sources(	1✔
500	cls,
501	customer,
502	api_key=None,
503	stripe_version=None,
504	stripe_account=None,
505	**params
506	):
507	return cls._static_request(	1✔
508	"get",
509	"/v1/customers/{customer}/sources".format(
510	customer=util.sanitize_id(customer)
511	),
512	api_key=api_key,
513	stripe_version=stripe_version,
514	stripe_account=stripe_account,
515	params=params,
516	)
517
518	@classmethod	1✔
519	def create_tax_id(	1✔
520	cls,
521	customer,
522	api_key=None,
523	stripe_version=None,
524	stripe_account=None,
525	**params
526	):
527	return cls._static_request(	1✔
528	"post",
529	"/v1/customers/{customer}/tax_ids".format(
530	customer=util.sanitize_id(customer)
531	),
532	api_key=api_key,
533	stripe_version=stripe_version,
534	stripe_account=stripe_account,
535	params=params,
536	)
537
538	@classmethod	1✔
539	def retrieve_tax_id(	1✔
540	cls,
541	customer,
542	id,
543	api_key=None,
544	stripe_version=None,
545	stripe_account=None,
546	**params
547	):
548	return cls._static_request(	1✔
549	"get",
550	"/v1/customers/{customer}/tax_ids/{id}".format(
551	customer=util.sanitize_id(customer), id=util.sanitize_id(id)
552	),
553	api_key=api_key,
554	stripe_version=stripe_version,
555	stripe_account=stripe_account,
556	params=params,
557	)
558
559	@classmethod	1✔
560	def delete_tax_id(	1✔
561	cls,
562	customer,
563	id,
564	api_key=None,
565	stripe_version=None,
566	stripe_account=None,
567	**params
568	):
569	return cls._static_request(	1✔
570	"delete",
571	"/v1/customers/{customer}/tax_ids/{id}".format(
572	customer=util.sanitize_id(customer), id=util.sanitize_id(id)
573	),
574	api_key=api_key,
575	stripe_version=stripe_version,
576	stripe_account=stripe_account,
577	params=params,
578	)
579
580	@classmethod	1✔
581	def list_tax_ids(	1✔
582	cls,
583	customer,
584	api_key=None,
585	stripe_version=None,
586	stripe_account=None,
587	**params
588	):
589	return cls._static_request(	1✔
590	"get",
591	"/v1/customers/{customer}/tax_ids".format(
592	customer=util.sanitize_id(customer)
593	),
594	api_key=api_key,
595	stripe_version=stripe_version,
596	stripe_account=stripe_account,
597	params=params,
598	)
599
600	@classmethod	1✔
601	def modify_cash_balance(	1✔
602	cls,
603	customer,
604	api_key=None,
605	stripe_version=None,
606	stripe_account=None,
607	**params
608	):
609	return cls._static_request(	1✔
610	"post",
611	"/v1/customers/{customer}/cash_balance".format(
612	customer=util.sanitize_id(customer)
613	),
614	api_key=api_key,
615	stripe_version=stripe_version,
616	stripe_account=stripe_account,
617	params=params,
618	)
619
620	@classmethod	1✔
621	def retrieve_cash_balance(	1✔
622	cls,
623	customer,
624	api_key=None,
625	stripe_version=None,
626	stripe_account=None,
627	**params
628	):
629	return cls._static_request(	1✔
630	"get",
631	"/v1/customers/{customer}/cash_balance".format(
632	customer=util.sanitize_id(customer)
633	),
634	api_key=api_key,
635	stripe_version=stripe_version,
636	stripe_account=stripe_account,
637	params=params,
638	)
639
640	class TestHelpers(APIResourceTestHelpers["Customer"]):	1✔
641	_resource_cls: Type["Customer"]	1✔
642
643	@classmethod	1✔
644	def _cls_fund_cash_balance(	1✔
645	cls,
646	customer,
647	api_key=None,
648	stripe_version=None,
649	stripe_account=None,
650	**params
651	):
652	return cls._static_request(	1✔
653	"post",
654	"/v1/test_helpers/customers/{customer}/fund_cash_balance".format(
655	customer=util.sanitize_id(customer)
656	),
657	api_key=api_key,
658	stripe_version=stripe_version,
659	stripe_account=stripe_account,
660	params=params,
661	)
662
663	@util.class_method_variant("_cls_fund_cash_balance")	1✔
664	def fund_cash_balance(self, idempotency_key=None, **params):	1✔
665	return self.resource._request(	×
666	"post",
667	"/v1/test_helpers/customers/{customer}/fund_cash_balance".format(
668	customer=util.sanitize_id(self.resource.get("id"))
669	),
670	idempotency_key=idempotency_key,
671	params=params,
672	)
673
674	@property	1✔
675	def test_helpers(self):	1✔
676	return self.TestHelpers(self)	×
677
678
679	Customer.TestHelpers._resource_cls = Customer	1✔

stripe / stripe-python / 6189311850

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