diff --git a/stripe/api_resources/abstract/api_resource.py b/stripe/api_resources/abstract/api_resource.py index 52b3ed9ee..664ea1c93 100644 --- a/stripe/api_resources/abstract/api_resource.py +++ b/stripe/api_resources/abstract/api_resource.py @@ -13,8 +13,7 @@ def retrieve(cls, id, api_key=None, **params): return instance def refresh(self): - self.refresh_from(self.request("get", self.instance_url())) - return self + return self._request_and_refresh("get", self.instance_url()) @classmethod def class_url(cls): @@ -44,6 +43,65 @@ def instance_url(self): extn = quote_plus(id) return "%s/%s" % (base, extn) + # The `method_` and `url_` arguments are suffixed with an underscore to + # avoid conflicting with actual request parameters in `params`. + def _request( + self, + method_, + url_, + api_key=None, + idempotency_key=None, + stripe_version=None, + stripe_account=None, + headers=None, + params=None, + ): + obj = StripeObject._request( + self, + method_, + url_, + api_key, + idempotency_key, + stripe_version, + stripe_account, + headers, + params, + ) + + if type(self) is type(obj): + self.refresh_from(obj) + return self + else: + return obj + + # The `method_` and `url_` arguments are suffixed with an underscore to + # avoid conflicting with actual request parameters in `params`. + def _request_and_refresh( + self, + method_, + url_, + api_key=None, + idempotency_key=None, + stripe_version=None, + stripe_account=None, + headers=None, + params=None, + ): + obj = StripeObject._request( + self, + method_, + url_, + api_key, + idempotency_key, + stripe_version, + stripe_account, + headers, + params, + ) + + self.refresh_from(obj) + return self + # The `method_` and `url_` arguments are suffixed with an underscore to # avoid conflicting with actual request parameters in `params`. @classmethod @@ -55,7 +113,7 @@ def _static_request( idempotency_key=None, stripe_version=None, stripe_account=None, - **params + params=None, ): requestor = api_requestor.APIRequestor( api_key, api_version=stripe_version, account=stripe_account @@ -63,7 +121,7 @@ def _static_request( headers = util.populate_headers(idempotency_key) response, api_key = requestor.request(method_, url_, params, headers) return util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account + response, api_key, stripe_version, stripe_account, params ) # The `method_` and `url_` arguments are suffixed with an underscore to @@ -77,7 +135,7 @@ def _static_request_stream( idempotency_key=None, stripe_version=None, stripe_account=None, - **params + params=None, ): requestor = api_requestor.APIRequestor( api_key, api_version=stripe_version, account=stripe_account diff --git a/stripe/api_resources/abstract/createable_api_resource.py b/stripe/api_resources/abstract/createable_api_resource.py index cbfe83738..112c79bee 100644 --- a/stripe/api_resources/abstract/createable_api_resource.py +++ b/stripe/api_resources/abstract/createable_api_resource.py @@ -1,7 +1,6 @@ from __future__ import absolute_import, division, print_function from stripe.api_resources.abstract.api_resource import APIResource -from stripe import api_requestor, util class CreateableAPIResource(APIResource): @@ -14,13 +13,12 @@ def create( stripe_account=None, **params ): - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account - ) - url = cls.class_url() - headers = util.populate_headers(idempotency_key) - response, api_key = requestor.request("post", url, params, headers) - - return util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account + return cls._static_request( + "post", + cls.class_url(), + api_key, + idempotency_key, + stripe_version, + stripe_account, + params, ) diff --git a/stripe/api_resources/abstract/custom_method.py b/stripe/api_resources/abstract/custom_method.py index ca0cf93d0..67be6e2f7 100644 --- a/stripe/api_resources/abstract/custom_method.py +++ b/stripe/api_resources/abstract/custom_method.py @@ -20,7 +20,7 @@ def custom_method_request(cls, sid, **params): quote_plus(util.utf8(sid)), http_path, ) - obj = cls._static_request(http_verb, url, **params) + obj = cls._static_request(http_verb, url, params=params) # For list objects, we have to attach the parameters so that they # can be referenced in auto-pagination and ensure consistency. @@ -35,7 +35,7 @@ def custom_method_request_stream(cls, sid, **params): quote_plus(util.utf8(sid)), http_path, ) - return cls._static_request_stream(http_verb, url, **params) + return cls._static_request_stream(http_verb, url, params=params) if is_streaming: class_method_impl = classmethod(custom_method_request_stream) diff --git a/stripe/api_resources/abstract/deletable_api_resource.py b/stripe/api_resources/abstract/deletable_api_resource.py index fd5100f1a..fe9473df1 100644 --- a/stripe/api_resources/abstract/deletable_api_resource.py +++ b/stripe/api_resources/abstract/deletable_api_resource.py @@ -9,9 +9,10 @@ class DeletableAPIResource(APIResource): @classmethod def _cls_delete(cls, sid, **params): url = "%s/%s" % (cls.class_url(), quote_plus(util.utf8(sid))) - return cls._static_request("delete", url, **params) + return cls._static_request("delete", url, params=params) @util.class_method_variant("_cls_delete") def delete(self, **params): - self.refresh_from(self.request("delete", self.instance_url(), params)) - return self + return self._request_and_refresh( + "delete", self.instance_url(), params=params + ) diff --git a/stripe/api_resources/abstract/listable_api_resource.py b/stripe/api_resources/abstract/listable_api_resource.py index df7f971c9..dc94cd9a5 100644 --- a/stripe/api_resources/abstract/listable_api_resource.py +++ b/stripe/api_resources/abstract/listable_api_resource.py @@ -1,6 +1,5 @@ from __future__ import absolute_import, division, print_function -from stripe import api_requestor, util from stripe.api_resources.abstract.api_resource import APIResource @@ -13,16 +12,11 @@ def auto_paging_iter(cls, *args, **params): def list( cls, api_key=None, stripe_version=None, stripe_account=None, **params ): - requestor = api_requestor.APIRequestor( - api_key, - api_base=cls.api_base(), - api_version=stripe_version, - account=stripe_account, + return cls._static_request( + "get", + cls.class_url(), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - url = cls.class_url() - response, api_key = requestor.request("get", url, params) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account - ) - stripe_object._retrieve_params = params - return stripe_object diff --git a/stripe/api_resources/abstract/nested_resource_class_methods.py b/stripe/api_resources/abstract/nested_resource_class_methods.py index e1bcf9fab..2065c1ce5 100644 --- a/stripe/api_resources/abstract/nested_resource_class_methods.py +++ b/stripe/api_resources/abstract/nested_resource_class_methods.py @@ -1,8 +1,9 @@ from __future__ import absolute_import, division, print_function -from stripe import api_requestor, util from stripe.six.moves.urllib.parse import quote_plus +from stripe.api_resources.abstract import APIResource + def nested_resource_class_methods( resource, path=None, operations=None, resource_plural=None @@ -38,13 +39,14 @@ def nested_resource_request( stripe_account=None, **params ): - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account - ) - headers = util.populate_headers(idempotency_key) - response, api_key = requestor.request(method, url, params, headers) - return util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account + return APIResource._static_request( + method, + url, + api_key=api_key, + idempotency_key=idempotency_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) resource_request_method = "%ss_request" % resource diff --git a/stripe/api_resources/abstract/searchable_api_resource.py b/stripe/api_resources/abstract/searchable_api_resource.py index 10f17d792..7b625ef4e 100644 --- a/stripe/api_resources/abstract/searchable_api_resource.py +++ b/stripe/api_resources/abstract/searchable_api_resource.py @@ -1,6 +1,5 @@ from __future__ import absolute_import, division, print_function -from stripe import api_requestor, util from stripe.api_resources.abstract.api_resource import APIResource @@ -14,15 +13,11 @@ def _search( stripe_account=None, **params ): - requestor = api_requestor.APIRequestor( - api_key, - api_base=cls.api_base(), - api_version=stripe_version, - account=stripe_account, + return cls._static_request( + "get", + search_url, + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - response, api_key = requestor.request("get", search_url, params) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account - ) - stripe_object._retrieve_params = params - return stripe_object diff --git a/stripe/api_resources/abstract/updateable_api_resource.py b/stripe/api_resources/abstract/updateable_api_resource.py index e253faad0..981b6ecdb 100644 --- a/stripe/api_resources/abstract/updateable_api_resource.py +++ b/stripe/api_resources/abstract/updateable_api_resource.py @@ -9,17 +9,16 @@ class UpdateableAPIResource(APIResource): @classmethod def modify(cls, sid, **params): url = "%s/%s" % (cls.class_url(), quote_plus(util.utf8(sid))) - return cls._static_request("post", url, **params) + return cls._static_request("post", url, params=params) def save(self, idempotency_key=None): updated_params = self.serialize(None) - headers = util.populate_headers(idempotency_key) - if updated_params: - self.refresh_from( - self.request( - "post", self.instance_url(), updated_params, headers - ) + self._request_and_refresh( + "post", + self.instance_url(), + idempotency_key=idempotency_key, + params=updated_params, ) else: util.logger.debug("Trying to save already saved object %r", self) diff --git a/stripe/api_resources/abstract/verify_mixin.py b/stripe/api_resources/abstract/verify_mixin.py index 9a0be204f..ba58236eb 100644 --- a/stripe/api_resources/abstract/verify_mixin.py +++ b/stripe/api_resources/abstract/verify_mixin.py @@ -1,11 +1,9 @@ from __future__ import absolute_import, division, print_function -from stripe import util - class VerifyMixin(object): def verify(self, idempotency_key=None, **params): url = self.instance_url() + "/verify" - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self + return self._request( + "post", url, idempotency_key=idempotency_key, params=params + ) diff --git a/stripe/api_resources/account.py b/stripe/api_resources/account.py index 40e8057f0..fd5ff77e0 100644 --- a/stripe/api_resources/account.py +++ b/stripe/api_resources/account.py @@ -8,13 +8,10 @@ from stripe.api_resources.abstract import DeletableAPIResource from stripe.api_resources.abstract import ListableAPIResource from stripe.api_resources.abstract import UpdateableAPIResource -from stripe.api_resources.abstract import custom_method from stripe.api_resources.abstract import nested_resource_class_methods from stripe.six.moves.urllib.parse import quote_plus -@custom_method("persons", http_verb="get") -@custom_method("reject", http_verb="post") @nested_resource_class_methods( "capability", operations=["retrieve", "update", "list"], @@ -37,23 +34,67 @@ class Account( ): OBJECT_NAME = "account" + @classmethod + def _cls_persons( + cls, + account, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "get", + "/v1/accounts/{account}/persons".format( + account=util.sanitize_id(account) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_persons") def persons(self, idempotency_key=None, **params): - url = "/v1/accounts/{account}/persons".format( - account=util.sanitize_id(self.get("id")) + return self._request( + "get", + "/v1/accounts/{account}/persons".format( + account=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, + ) + + @classmethod + def _cls_reject( + cls, + account, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/accounts/{account}/reject".format( + account=util.sanitize_id(account) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - headers = util.populate_headers(idempotency_key) - resp = self.request("get", url, params, headers) - stripe_object = util.convert_to_stripe_object(resp) - stripe_object._retrieve_params = params - return stripe_object + @util.class_method_variant("_cls_reject") def reject(self, idempotency_key=None, **params): - url = "/v1/accounts/{account}/reject".format( - account=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/accounts/{account}/reject".format( + account=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self # We are not adding a helper for capabilities here as the Account object already has a # capabilities property which is a hash and not the sub-list of capabilities. @@ -67,7 +108,7 @@ def retrieve(cls, id=None, api_key=None, **params): @classmethod def modify(cls, id=None, **params): url = cls._build_instance_url(id) - return cls._static_request("post", url, **params) + return cls._static_request("post", url, params=params) @classmethod def _build_instance_url(cls, sid): diff --git a/stripe/api_resources/alipay_account.py b/stripe/api_resources/alipay_account.py index a11da90c9..5bd743f7b 100644 --- a/stripe/api_resources/alipay_account.py +++ b/stripe/api_resources/alipay_account.py @@ -28,7 +28,7 @@ def instance_url(self): @classmethod def modify(cls, customer, id, **params): url = cls._build_instance_url(customer, id) - return cls._static_request("post", url, **params) + return cls._static_request("post", url, params=params) @classmethod def retrieve( diff --git a/stripe/api_resources/application_fee_refund.py b/stripe/api_resources/application_fee_refund.py index fbda378bb..271140c8e 100644 --- a/stripe/api_resources/application_fee_refund.py +++ b/stripe/api_resources/application_fee_refund.py @@ -22,7 +22,7 @@ def _build_instance_url(cls, fee, sid): @classmethod def modify(cls, fee, sid, **params): url = cls._build_instance_url(fee, sid) - return cls._static_request("post", url, **params) + return cls._static_request("post", url, params=params) def instance_url(self): return self._build_instance_url(self.fee, self.id) diff --git a/stripe/api_resources/apps/secret.py b/stripe/api_resources/apps/secret.py index f0b9dd2cf..7e7df6a98 100644 --- a/stripe/api_resources/apps/secret.py +++ b/stripe/api_resources/apps/secret.py @@ -1,8 +1,6 @@ # File generated from our OpenAPI spec from __future__ import absolute_import, division, print_function -from stripe import api_requestor -from stripe import util from stripe.api_resources.abstract import CreateableAPIResource from stripe.api_resources.abstract import ListableAPIResource @@ -14,26 +12,24 @@ class Secret(CreateableAPIResource, ListableAPIResource): def delete_where( cls, api_key=None, stripe_version=None, stripe_account=None, **params ): - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account + return cls._static_request( + "post", + "/v1/apps/secrets/delete", + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - url = "/v1/apps/secrets/delete" - response, api_key = requestor.request("post", url, params) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account - ) - return stripe_object @classmethod def find( cls, api_key=None, stripe_version=None, stripe_account=None, **params ): - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account - ) - url = "/v1/apps/secrets/find" - response, api_key = requestor.request("get", url, params) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account + return cls._static_request( + "get", + "/v1/apps/secrets/find", + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - return stripe_object diff --git a/stripe/api_resources/charge.py b/stripe/api_resources/charge.py index bd8dc9925..c47bba753 100644 --- a/stripe/api_resources/charge.py +++ b/stripe/api_resources/charge.py @@ -7,10 +7,8 @@ from stripe.api_resources.abstract import ListableAPIResource from stripe.api_resources.abstract import SearchableAPIResource from stripe.api_resources.abstract import UpdateableAPIResource -from stripe.api_resources.abstract import custom_method -@custom_method("capture", http_verb="post") class Charge( CreateableAPIResource, ListableAPIResource, @@ -19,13 +17,36 @@ class Charge( ): OBJECT_NAME = "charge" + @classmethod + def _cls_capture( + cls, + charge, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/charges/{charge}/capture".format( + charge=util.sanitize_id(charge) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_capture") def capture(self, idempotency_key=None, **params): - url = "/v1/charges/{charge}/capture".format( - charge=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/charges/{charge}/capture".format( + charge=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self @classmethod def search(cls, *args, **kwargs): diff --git a/stripe/api_resources/checkout/session.py b/stripe/api_resources/checkout/session.py index a544ea9a5..d484fd252 100644 --- a/stripe/api_resources/checkout/session.py +++ b/stripe/api_resources/checkout/session.py @@ -4,28 +4,69 @@ from stripe import util from stripe.api_resources.abstract import CreateableAPIResource from stripe.api_resources.abstract import ListableAPIResource -from stripe.api_resources.abstract import custom_method -@custom_method("expire", http_verb="post") -@custom_method("list_line_items", http_verb="get", http_path="line_items") class Session(CreateableAPIResource, ListableAPIResource): OBJECT_NAME = "checkout.session" + @classmethod + def _cls_expire( + cls, + session, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/checkout/sessions/{session}/expire".format( + session=util.sanitize_id(session) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_expire") def expire(self, idempotency_key=None, **params): - url = "/v1/checkout/sessions/{session}/expire".format( - session=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/checkout/sessions/{session}/expire".format( + session=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, + ) + + @classmethod + def _cls_list_line_items( + cls, + session, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "get", + "/v1/checkout/sessions/{session}/line_items".format( + session=util.sanitize_id(session) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self + @util.class_method_variant("_cls_list_line_items") def list_line_items(self, idempotency_key=None, **params): - url = "/v1/checkout/sessions/{session}/line_items".format( - session=util.sanitize_id(self.get("id")) + return self._request( + "get", + "/v1/checkout/sessions/{session}/line_items".format( + session=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - resp = self.request("get", url, params, headers) - stripe_object = util.convert_to_stripe_object(resp) - stripe_object._retrieve_params = params - return stripe_object diff --git a/stripe/api_resources/credit_note.py b/stripe/api_resources/credit_note.py index 01d2b0a15..0eabc74da 100644 --- a/stripe/api_resources/credit_note.py +++ b/stripe/api_resources/credit_note.py @@ -1,15 +1,12 @@ # File generated from our OpenAPI spec from __future__ import absolute_import, division, print_function -from stripe import api_requestor from stripe import util from stripe.api_resources.abstract import CreateableAPIResource from stripe.api_resources.abstract import ListableAPIResource from stripe.api_resources.abstract import UpdateableAPIResource -from stripe.api_resources.abstract import custom_method -@custom_method("void_credit_note", http_verb="post", http_path="void") class CreditNote( CreateableAPIResource, ListableAPIResource, @@ -21,20 +18,40 @@ class CreditNote( def preview( cls, api_key=None, stripe_version=None, stripe_account=None, **params ): - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account + return cls._static_request( + "get", + "/v1/credit_notes/preview", + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - url = "/v1/credit_notes/preview" - response, api_key = requestor.request("get", url, params) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account + + @classmethod + def _cls_void_credit_note( + cls, + id, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/credit_notes/{id}/void".format(id=util.sanitize_id(id)), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - return stripe_object + @util.class_method_variant("_cls_void_credit_note") def void_credit_note(self, idempotency_key=None, **params): - url = "/v1/credit_notes/{id}/void".format( - id=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/credit_notes/{id}/void".format( + id=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self diff --git a/stripe/api_resources/customer.py b/stripe/api_resources/customer.py index a37fb967a..f4bdd63b8 100644 --- a/stripe/api_resources/customer.py +++ b/stripe/api_resources/customer.py @@ -16,16 +16,6 @@ @custom_method("delete_discount", http_verb="delete", http_path="discount") @test_helpers -@custom_method( - "create_funding_instructions", - http_verb="post", - http_path="funding_instructions", -) -@custom_method( - "list_payment_methods", - http_verb="get", - http_path="payment_methods", -) @nested_resource_class_methods( "balance_transaction", operations=["create", "retrieve", "update", "list"], @@ -47,24 +37,67 @@ class Customer( ): OBJECT_NAME = "customer" + @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): - url = "/v1/customers/{customer}/funding_instructions".format( - customer=util.sanitize_id(self.get("id")) + 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_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, ) - headers = util.populate_headers(idempotency_key) - resp = self.request("post", url, params, headers) - stripe_object = util.convert_to_stripe_object(resp) - return stripe_object + @util.class_method_variant("_cls_list_payment_methods") def list_payment_methods(self, idempotency_key=None, **params): - url = "/v1/customers/{customer}/payment_methods".format( - customer=util.sanitize_id(self.get("id")) + return self._request( + "get", + "/v1/customers/{customer}/payment_methods".format( + customer=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - resp = self.request("get", url, params, headers) - stripe_object = util.convert_to_stripe_object(resp) - stripe_object._retrieve_params = params - return stripe_object @classmethod def _cls_retrieve_payment_method( @@ -76,35 +109,31 @@ def _cls_retrieve_payment_method( stripe_account=None, **params ): - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account - ) - url = ( + 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), - ) - ) - response, api_key = requestor.request("get", url, params) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - return stripe_object @util.class_method_variant("_cls_retrieve_payment_method") def retrieve_payment_method( self, payment_method, idempotency_key=None, **params ): - url = ( + 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, ) - headers = util.populate_headers(idempotency_key) - resp = self.request("get", url, params, headers) - stripe_object = util.convert_to_stripe_object(resp) - return stripe_object @classmethod def search(cls, *args, **kwargs): @@ -128,47 +157,41 @@ def delete_discount(self, **params): def retrieve_cash_balance( cls, customer, - nested_id=None, api_key=None, stripe_version=None, stripe_account=None, **params ): - # The nested_id parameter is required for backwards compatibility purposes and is ignored. - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account - ) - url = "/v1/customers/{customer}/cash_balance".format( - customer=util.sanitize_id(customer) - ) - response, api_key = requestor.request("get", url, params) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account + 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, ) - return stripe_object @classmethod def modify_cash_balance( cls, customer, - nested_id=None, api_key=None, stripe_version=None, stripe_account=None, **params ): - # The nested_id parameter is required for backwards compatibility purposes and is ignored. - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account - ) - url = "/v1/customers/{customer}/cash_balance".format( - customer=util.sanitize_id(customer) - ) - response, api_key = requestor.request("post", url, params) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account + 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, ) - return stripe_object class TestHelpers(APIResourceTestHelpers): @classmethod @@ -180,25 +203,24 @@ def _cls_fund_cash_balance( stripe_account=None, **params ): - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account + 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, ) - url = "/v1/test_helpers/customers/{customer}/fund_cash_balance".format( - customer=util.sanitize_id(customer) - ) - response, api_key = requestor.request("post", url, params) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account - ) - return stripe_object @util.class_method_variant("_cls_fund_cash_balance") def fund_cash_balance(self, idempotency_key=None, **params): - url = "/v1/test_helpers/customers/{customer}/fund_cash_balance".format( - customer=util.sanitize_id(self.get("id")) - ) - headers = util.populate_headers(idempotency_key) - self.resource.refresh_from( - self.resource.request("post", url, params, headers) + 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, ) - return self.resource diff --git a/stripe/api_resources/dispute.py b/stripe/api_resources/dispute.py index 8f8b43973..7acb3dc02 100644 --- a/stripe/api_resources/dispute.py +++ b/stripe/api_resources/dispute.py @@ -4,17 +4,38 @@ from stripe import util from stripe.api_resources.abstract import ListableAPIResource from stripe.api_resources.abstract import UpdateableAPIResource -from stripe.api_resources.abstract import custom_method -@custom_method("close", http_verb="post") class Dispute(ListableAPIResource, UpdateableAPIResource): OBJECT_NAME = "dispute" + @classmethod + def _cls_close( + cls, + dispute, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/disputes/{dispute}/close".format( + dispute=util.sanitize_id(dispute) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_close") def close(self, idempotency_key=None, **params): - url = "/v1/disputes/{dispute}/close".format( - dispute=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/disputes/{dispute}/close".format( + dispute=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self diff --git a/stripe/api_resources/financial_connections/account.py b/stripe/api_resources/financial_connections/account.py index c009769fe..0ad616727 100644 --- a/stripe/api_resources/financial_connections/account.py +++ b/stripe/api_resources/financial_connections/account.py @@ -3,37 +3,100 @@ from stripe import util from stripe.api_resources.abstract import ListableAPIResource -from stripe.api_resources.abstract import custom_method -@custom_method("disconnect", http_verb="post") -@custom_method("list_owners", http_verb="get", http_path="owners") -@custom_method("refresh_account", http_verb="post", http_path="refresh") class Account(ListableAPIResource): OBJECT_NAME = "financial_connections.account" + @classmethod + def _cls_disconnect( + cls, + account, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/financial_connections/accounts/{account}/disconnect".format( + account=util.sanitize_id(account) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_disconnect") def disconnect(self, idempotency_key=None, **params): - url = "/v1/financial_connections/accounts/{account}/disconnect".format( - account=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/financial_connections/accounts/{account}/disconnect".format( + account=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, + ) + + @classmethod + def _cls_list_owners( + cls, + account, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "get", + "/v1/financial_connections/accounts/{account}/owners".format( + account=util.sanitize_id(account) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self + @util.class_method_variant("_cls_list_owners") def list_owners(self, idempotency_key=None, **params): - url = "/v1/financial_connections/accounts/{account}/owners".format( - account=util.sanitize_id(self.get("id")) + return self._request( + "get", + "/v1/financial_connections/accounts/{account}/owners".format( + account=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, + ) + + @classmethod + def _cls_refresh_account( + cls, + account, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/financial_connections/accounts/{account}/refresh".format( + account=util.sanitize_id(account) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - headers = util.populate_headers(idempotency_key) - resp = self.request("get", url, params, headers) - stripe_object = util.convert_to_stripe_object(resp) - stripe_object._retrieve_params = params - return stripe_object + @util.class_method_variant("_cls_refresh_account") def refresh_account(self, idempotency_key=None, **params): - url = "/v1/financial_connections/accounts/{account}/refresh".format( - account=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/financial_connections/accounts/{account}/refresh".format( + account=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self diff --git a/stripe/api_resources/identity/verification_session.py b/stripe/api_resources/identity/verification_session.py index 4fdcc8b7a..74ecc880a 100644 --- a/stripe/api_resources/identity/verification_session.py +++ b/stripe/api_resources/identity/verification_session.py @@ -5,11 +5,8 @@ from stripe.api_resources.abstract import CreateableAPIResource from stripe.api_resources.abstract import ListableAPIResource from stripe.api_resources.abstract import UpdateableAPIResource -from stripe.api_resources.abstract import custom_method -@custom_method("cancel", http_verb="post") -@custom_method("redact", http_verb="post") class VerificationSession( CreateableAPIResource, ListableAPIResource, @@ -17,18 +14,64 @@ class VerificationSession( ): OBJECT_NAME = "identity.verification_session" + @classmethod + def _cls_cancel( + cls, + session, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/identity/verification_sessions/{session}/cancel".format( + session=util.sanitize_id(session) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_cancel") def cancel(self, idempotency_key=None, **params): - url = "/v1/identity/verification_sessions/{session}/cancel".format( - session=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/identity/verification_sessions/{session}/cancel".format( + session=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, + ) + + @classmethod + def _cls_redact( + cls, + session, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/identity/verification_sessions/{session}/redact".format( + session=util.sanitize_id(session) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self + @util.class_method_variant("_cls_redact") def redact(self, idempotency_key=None, **params): - url = "/v1/identity/verification_sessions/{session}/redact".format( - session=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/identity/verification_sessions/{session}/redact".format( + session=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self diff --git a/stripe/api_resources/invoice.py b/stripe/api_resources/invoice.py index 5864e4a68..65ee6116a 100644 --- a/stripe/api_resources/invoice.py +++ b/stripe/api_resources/invoice.py @@ -1,21 +1,14 @@ # File generated from our OpenAPI spec from __future__ import absolute_import, division, print_function -from stripe import api_requestor from stripe import util from stripe.api_resources.abstract import CreateableAPIResource from stripe.api_resources.abstract import DeletableAPIResource from stripe.api_resources.abstract import ListableAPIResource from stripe.api_resources.abstract import SearchableAPIResource from stripe.api_resources.abstract import UpdateableAPIResource -from stripe.api_resources.abstract import custom_method -@custom_method("finalize_invoice", http_verb="post", http_path="finalize") -@custom_method("mark_uncollectible", http_verb="post") -@custom_method("pay", http_verb="post") -@custom_method("send_invoice", http_verb="post", http_path="send") -@custom_method("void_invoice", http_verb="post", http_path="void") class Invoice( CreateableAPIResource, DeletableAPIResource, @@ -25,59 +18,173 @@ class Invoice( ): OBJECT_NAME = "invoice" + @classmethod + def _cls_finalize_invoice( + cls, + invoice, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/invoices/{invoice}/finalize".format( + invoice=util.sanitize_id(invoice) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_finalize_invoice") def finalize_invoice(self, idempotency_key=None, **params): - url = "/v1/invoices/{invoice}/finalize".format( - invoice=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/invoices/{invoice}/finalize".format( + invoice=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, + ) + + @classmethod + def _cls_mark_uncollectible( + cls, + invoice, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/invoices/{invoice}/mark_uncollectible".format( + invoice=util.sanitize_id(invoice) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self + @util.class_method_variant("_cls_mark_uncollectible") def mark_uncollectible(self, idempotency_key=None, **params): - url = "/v1/invoices/{invoice}/mark_uncollectible".format( - invoice=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/invoices/{invoice}/mark_uncollectible".format( + invoice=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self + @classmethod + def _cls_pay( + cls, + invoice, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/invoices/{invoice}/pay".format( + invoice=util.sanitize_id(invoice) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_pay") def pay(self, idempotency_key=None, **params): - url = "/v1/invoices/{invoice}/pay".format( - invoice=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/invoices/{invoice}/pay".format( + invoice=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self + @classmethod + def _cls_send_invoice( + cls, + invoice, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/invoices/{invoice}/send".format( + invoice=util.sanitize_id(invoice) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_send_invoice") def send_invoice(self, idempotency_key=None, **params): - url = "/v1/invoices/{invoice}/send".format( - invoice=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/invoices/{invoice}/send".format( + invoice=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self @classmethod def upcoming( cls, api_key=None, stripe_version=None, stripe_account=None, **params ): - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account + return cls._static_request( + "get", + "/v1/invoices/upcoming", + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - url = "/v1/invoices/upcoming" - response, api_key = requestor.request("get", url, params) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account + + @classmethod + def _cls_void_invoice( + cls, + invoice, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/invoices/{invoice}/void".format( + invoice=util.sanitize_id(invoice) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - return stripe_object + @util.class_method_variant("_cls_void_invoice") def void_invoice(self, idempotency_key=None, **params): - url = "/v1/invoices/{invoice}/void".format( - invoice=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/invoices/{invoice}/void".format( + invoice=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self @classmethod def search(cls, *args, **kwargs): diff --git a/stripe/api_resources/issuing/authorization.py b/stripe/api_resources/issuing/authorization.py index e1e95ddb3..c7419fbd2 100644 --- a/stripe/api_resources/issuing/authorization.py +++ b/stripe/api_resources/issuing/authorization.py @@ -4,26 +4,69 @@ from stripe import util from stripe.api_resources.abstract import ListableAPIResource from stripe.api_resources.abstract import UpdateableAPIResource -from stripe.api_resources.abstract import custom_method -@custom_method("approve", http_verb="post") -@custom_method("decline", http_verb="post") class Authorization(ListableAPIResource, UpdateableAPIResource): OBJECT_NAME = "issuing.authorization" + @classmethod + def _cls_approve( + cls, + authorization, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/issuing/authorizations/{authorization}/approve".format( + authorization=util.sanitize_id(authorization) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_approve") def approve(self, idempotency_key=None, **params): - url = "/v1/issuing/authorizations/{authorization}/approve".format( - authorization=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/issuing/authorizations/{authorization}/approve".format( + authorization=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, + ) + + @classmethod + def _cls_decline( + cls, + authorization, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/issuing/authorizations/{authorization}/decline".format( + authorization=util.sanitize_id(authorization) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self + @util.class_method_variant("_cls_decline") def decline(self, idempotency_key=None, **params): - url = "/v1/issuing/authorizations/{authorization}/decline".format( - authorization=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/issuing/authorizations/{authorization}/decline".format( + authorization=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self diff --git a/stripe/api_resources/issuing/card.py b/stripe/api_resources/issuing/card.py index f51e29e31..12c1fb908 100644 --- a/stripe/api_resources/issuing/card.py +++ b/stripe/api_resources/issuing/card.py @@ -1,7 +1,6 @@ # File generated from our OpenAPI spec from __future__ import absolute_import, division, print_function -from stripe import api_requestor from stripe import util from stripe.api_resources.abstract import APIResourceTestHelpers from stripe.api_resources.abstract import CreateableAPIResource @@ -29,28 +28,27 @@ def _cls_deliver_card( stripe_account=None, **params ): - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account - ) - url = "/v1/test_helpers/issuing/cards/{card}/shipping/deliver".format( - card=util.sanitize_id(card) - ) - response, api_key = requestor.request("post", url, params) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account + return cls._static_request( + "post", + "/v1/test_helpers/issuing/cards/{card}/shipping/deliver".format( + card=util.sanitize_id(card) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - return stripe_object @util.class_method_variant("_cls_deliver_card") def deliver_card(self, idempotency_key=None, **params): - url = "/v1/test_helpers/issuing/cards/{card}/shipping/deliver".format( - card=util.sanitize_id(self.get("id")) - ) - headers = util.populate_headers(idempotency_key) - self.resource.refresh_from( - self.resource.request("post", url, params, headers) + return self.resource._request( + "post", + "/v1/test_helpers/issuing/cards/{card}/shipping/deliver".format( + card=util.sanitize_id(self.resource.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - return self.resource @classmethod def _cls_fail_card( @@ -61,28 +59,27 @@ def _cls_fail_card( stripe_account=None, **params ): - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account - ) - url = "/v1/test_helpers/issuing/cards/{card}/shipping/fail".format( - card=util.sanitize_id(card) - ) - response, api_key = requestor.request("post", url, params) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account + return cls._static_request( + "post", + "/v1/test_helpers/issuing/cards/{card}/shipping/fail".format( + card=util.sanitize_id(card) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - return stripe_object @util.class_method_variant("_cls_fail_card") def fail_card(self, idempotency_key=None, **params): - url = "/v1/test_helpers/issuing/cards/{card}/shipping/fail".format( - card=util.sanitize_id(self.get("id")) - ) - headers = util.populate_headers(idempotency_key) - self.resource.refresh_from( - self.resource.request("post", url, params, headers) + return self.resource._request( + "post", + "/v1/test_helpers/issuing/cards/{card}/shipping/fail".format( + card=util.sanitize_id(self.resource.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - return self.resource @classmethod def _cls_return_card( @@ -93,32 +90,27 @@ def _cls_return_card( stripe_account=None, **params ): - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account - ) - url = ( + return cls._static_request( + "post", "/v1/test_helpers/issuing/cards/{card}/shipping/return".format( card=util.sanitize_id(card) - ) - ) - response, api_key = requestor.request("post", url, params) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - return stripe_object @util.class_method_variant("_cls_return_card") def return_card(self, idempotency_key=None, **params): - url = ( + return self.resource._request( + "post", "/v1/test_helpers/issuing/cards/{card}/shipping/return".format( - card=util.sanitize_id(self.get("id")) - ) + card=util.sanitize_id(self.resource.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.resource.refresh_from( - self.resource.request("post", url, params, headers) - ) - return self.resource @classmethod def _cls_ship_card( @@ -129,25 +121,24 @@ def _cls_ship_card( stripe_account=None, **params ): - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account - ) - url = "/v1/test_helpers/issuing/cards/{card}/shipping/ship".format( - card=util.sanitize_id(card) - ) - response, api_key = requestor.request("post", url, params) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account + return cls._static_request( + "post", + "/v1/test_helpers/issuing/cards/{card}/shipping/ship".format( + card=util.sanitize_id(card) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - return stripe_object @util.class_method_variant("_cls_ship_card") def ship_card(self, idempotency_key=None, **params): - url = "/v1/test_helpers/issuing/cards/{card}/shipping/ship".format( - card=util.sanitize_id(self.get("id")) - ) - headers = util.populate_headers(idempotency_key) - self.resource.refresh_from( - self.resource.request("post", url, params, headers) + return self.resource._request( + "post", + "/v1/test_helpers/issuing/cards/{card}/shipping/ship".format( + card=util.sanitize_id(self.resource.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - return self.resource diff --git a/stripe/api_resources/issuing/dispute.py b/stripe/api_resources/issuing/dispute.py index 33ba913c1..ad601be90 100644 --- a/stripe/api_resources/issuing/dispute.py +++ b/stripe/api_resources/issuing/dispute.py @@ -5,10 +5,8 @@ from stripe.api_resources.abstract import CreateableAPIResource from stripe.api_resources.abstract import ListableAPIResource from stripe.api_resources.abstract import UpdateableAPIResource -from stripe.api_resources.abstract import custom_method -@custom_method("submit", http_verb="post") class Dispute( CreateableAPIResource, ListableAPIResource, @@ -16,10 +14,33 @@ class Dispute( ): OBJECT_NAME = "issuing.dispute" + @classmethod + def _cls_submit( + cls, + dispute, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/issuing/disputes/{dispute}/submit".format( + dispute=util.sanitize_id(dispute) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_submit") def submit(self, idempotency_key=None, **params): - url = "/v1/issuing/disputes/{dispute}/submit".format( - dispute=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/issuing/disputes/{dispute}/submit".format( + dispute=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self diff --git a/stripe/api_resources/list_object.py b/stripe/api_resources/list_object.py index af2af033f..b452d34d4 100644 --- a/stripe/api_resources/list_object.py +++ b/stripe/api_resources/list_object.py @@ -1,6 +1,6 @@ from __future__ import absolute_import, division, print_function -from stripe import api_requestor, six, util +from stripe import six, util from stripe.stripe_object import StripeObject from stripe.six.moves.urllib.parse import quote_plus @@ -12,16 +12,14 @@ class ListObject(StripeObject): def list( self, api_key=None, stripe_version=None, stripe_account=None, **params ): - stripe_object = self._request( + return self._request( "get", self.get("url"), api_key=api_key, stripe_version=stripe_version, stripe_account=stripe_account, - **params + params=params, ) - stripe_object._retrieve_params = params - return stripe_object def create( self, @@ -38,7 +36,7 @@ def create( idempotency_key=idempotency_key, stripe_version=stripe_version, stripe_account=stripe_account, - **params + params=params, ) def retrieve( @@ -56,32 +54,8 @@ def retrieve( api_key=api_key, stripe_version=stripe_version, stripe_account=stripe_account, - **params - ) - - def _request( - self, - method_, - url_, - api_key=None, - idempotency_key=None, - stripe_version=None, - stripe_account=None, - **params - ): - api_key = api_key or self.api_key - stripe_version = stripe_version or self.stripe_version - stripe_account = stripe_account or self.stripe_account - - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account - ) - headers = util.populate_headers(idempotency_key) - response, api_key = requestor.request(method_, url_, params, headers) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account + params=params, ) - return stripe_object def __getitem__(self, k): if isinstance(k, six.string_types): diff --git a/stripe/api_resources/order.py b/stripe/api_resources/order.py index 1a0bb3088..83100ae9c 100644 --- a/stripe/api_resources/order.py +++ b/stripe/api_resources/order.py @@ -5,46 +5,123 @@ from stripe.api_resources.abstract import CreateableAPIResource from stripe.api_resources.abstract import ListableAPIResource from stripe.api_resources.abstract import UpdateableAPIResource -from stripe.api_resources.abstract import custom_method -@custom_method("cancel", http_verb="post") -@custom_method("list_line_items", http_verb="get", http_path="line_items") -@custom_method("reopen", http_verb="post") -@custom_method("submit", http_verb="post") class Order(CreateableAPIResource, ListableAPIResource, UpdateableAPIResource): OBJECT_NAME = "order" + @classmethod + def _cls_cancel( + cls, + id, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/orders/{id}/cancel".format(id=util.sanitize_id(id)), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_cancel") def cancel(self, idempotency_key=None, **params): - url = "/v1/orders/{id}/cancel".format( - id=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/orders/{id}/cancel".format( + id=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, + ) + + @classmethod + def _cls_list_line_items( + cls, + id, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "get", + "/v1/orders/{id}/line_items".format(id=util.sanitize_id(id)), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self + @util.class_method_variant("_cls_list_line_items") def list_line_items(self, idempotency_key=None, **params): - url = "/v1/orders/{id}/line_items".format( - id=util.sanitize_id(self.get("id")) + return self._request( + "get", + "/v1/orders/{id}/line_items".format( + id=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - resp = self.request("get", url, params, headers) - stripe_object = util.convert_to_stripe_object(resp) - stripe_object._retrieve_params = params - return stripe_object + @classmethod + def _cls_reopen( + cls, + id, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/orders/{id}/reopen".format(id=util.sanitize_id(id)), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_reopen") def reopen(self, idempotency_key=None, **params): - url = "/v1/orders/{id}/reopen".format( - id=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/orders/{id}/reopen".format( + id=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, + ) + + @classmethod + def _cls_submit( + cls, + id, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/orders/{id}/submit".format(id=util.sanitize_id(id)), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self + @util.class_method_variant("_cls_submit") def submit(self, idempotency_key=None, **params): - url = "/v1/orders/{id}/submit".format( - id=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/orders/{id}/submit".format( + id=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self diff --git a/stripe/api_resources/payment_intent.py b/stripe/api_resources/payment_intent.py index 65f864c2b..e4656d259 100644 --- a/stripe/api_resources/payment_intent.py +++ b/stripe/api_resources/payment_intent.py @@ -6,15 +6,8 @@ from stripe.api_resources.abstract import ListableAPIResource from stripe.api_resources.abstract import SearchableAPIResource from stripe.api_resources.abstract import UpdateableAPIResource -from stripe.api_resources.abstract import custom_method -@custom_method("apply_customer_balance", http_verb="post") -@custom_method("cancel", http_verb="post") -@custom_method("capture", http_verb="post") -@custom_method("confirm", http_verb="post") -@custom_method("increment_authorization", http_verb="post") -@custom_method("verify_microdeposits", http_verb="post") class PaymentIntent( CreateableAPIResource, ListableAPIResource, @@ -23,53 +16,191 @@ class PaymentIntent( ): OBJECT_NAME = "payment_intent" + @classmethod + def _cls_apply_customer_balance( + cls, + intent, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/payment_intents/{intent}/apply_customer_balance".format( + intent=util.sanitize_id(intent) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_apply_customer_balance") def apply_customer_balance(self, idempotency_key=None, **params): - url = "/v1/payment_intents/{intent}/apply_customer_balance".format( - intent=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/payment_intents/{intent}/apply_customer_balance".format( + intent=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self + @classmethod + def _cls_cancel( + cls, + intent, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/payment_intents/{intent}/cancel".format( + intent=util.sanitize_id(intent) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_cancel") def cancel(self, idempotency_key=None, **params): - url = "/v1/payment_intents/{intent}/cancel".format( - intent=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/payment_intents/{intent}/cancel".format( + intent=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, + ) + + @classmethod + def _cls_capture( + cls, + intent, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/payment_intents/{intent}/capture".format( + intent=util.sanitize_id(intent) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self + @util.class_method_variant("_cls_capture") def capture(self, idempotency_key=None, **params): - url = "/v1/payment_intents/{intent}/capture".format( - intent=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/payment_intents/{intent}/capture".format( + intent=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self + @classmethod + def _cls_confirm( + cls, + intent, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/payment_intents/{intent}/confirm".format( + intent=util.sanitize_id(intent) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_confirm") def confirm(self, idempotency_key=None, **params): - url = "/v1/payment_intents/{intent}/confirm".format( - intent=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/payment_intents/{intent}/confirm".format( + intent=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self + @classmethod + def _cls_increment_authorization( + cls, + intent, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/payment_intents/{intent}/increment_authorization".format( + intent=util.sanitize_id(intent) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_increment_authorization") def increment_authorization(self, idempotency_key=None, **params): - url = "/v1/payment_intents/{intent}/increment_authorization".format( - intent=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/payment_intents/{intent}/increment_authorization".format( + intent=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, + ) + + @classmethod + def _cls_verify_microdeposits( + cls, + intent, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/payment_intents/{intent}/verify_microdeposits".format( + intent=util.sanitize_id(intent) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self + @util.class_method_variant("_cls_verify_microdeposits") def verify_microdeposits(self, idempotency_key=None, **params): - url = "/v1/payment_intents/{intent}/verify_microdeposits".format( - intent=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/payment_intents/{intent}/verify_microdeposits".format( + intent=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self @classmethod def search(cls, *args, **kwargs): diff --git a/stripe/api_resources/payment_link.py b/stripe/api_resources/payment_link.py index 424e47e1f..b9cb485ad 100644 --- a/stripe/api_resources/payment_link.py +++ b/stripe/api_resources/payment_link.py @@ -5,10 +5,8 @@ from stripe.api_resources.abstract import CreateableAPIResource from stripe.api_resources.abstract import ListableAPIResource from stripe.api_resources.abstract import UpdateableAPIResource -from stripe.api_resources.abstract import custom_method -@custom_method("list_line_items", http_verb="get", http_path="line_items") class PaymentLink( CreateableAPIResource, ListableAPIResource, @@ -16,12 +14,33 @@ class PaymentLink( ): OBJECT_NAME = "payment_link" + @classmethod + def _cls_list_line_items( + cls, + payment_link, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "get", + "/v1/payment_links/{payment_link}/line_items".format( + payment_link=util.sanitize_id(payment_link) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_list_line_items") def list_line_items(self, idempotency_key=None, **params): - url = "/v1/payment_links/{payment_link}/line_items".format( - payment_link=util.sanitize_id(self.get("id")) + return self._request( + "get", + "/v1/payment_links/{payment_link}/line_items".format( + payment_link=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - resp = self.request("get", url, params, headers) - stripe_object = util.convert_to_stripe_object(resp) - stripe_object._retrieve_params = params - return stripe_object diff --git a/stripe/api_resources/payment_method.py b/stripe/api_resources/payment_method.py index a2a612960..057018cbd 100644 --- a/stripe/api_resources/payment_method.py +++ b/stripe/api_resources/payment_method.py @@ -5,11 +5,8 @@ from stripe.api_resources.abstract import CreateableAPIResource from stripe.api_resources.abstract import ListableAPIResource from stripe.api_resources.abstract import UpdateableAPIResource -from stripe.api_resources.abstract import custom_method -@custom_method("attach", http_verb="post") -@custom_method("detach", http_verb="post") class PaymentMethod( CreateableAPIResource, ListableAPIResource, @@ -17,18 +14,64 @@ class PaymentMethod( ): OBJECT_NAME = "payment_method" + @classmethod + def _cls_attach( + cls, + payment_method, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/payment_methods/{payment_method}/attach".format( + 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_attach") def attach(self, idempotency_key=None, **params): - url = "/v1/payment_methods/{payment_method}/attach".format( - payment_method=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/payment_methods/{payment_method}/attach".format( + payment_method=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, + ) + + @classmethod + def _cls_detach( + cls, + payment_method, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/payment_methods/{payment_method}/detach".format( + payment_method=util.sanitize_id(payment_method) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self + @util.class_method_variant("_cls_detach") def detach(self, idempotency_key=None, **params): - url = "/v1/payment_methods/{payment_method}/detach".format( - payment_method=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/payment_methods/{payment_method}/detach".format( + payment_method=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self diff --git a/stripe/api_resources/payout.py b/stripe/api_resources/payout.py index e87a36ed9..6b0a9a236 100644 --- a/stripe/api_resources/payout.py +++ b/stripe/api_resources/payout.py @@ -5,28 +5,71 @@ from stripe.api_resources.abstract import CreateableAPIResource from stripe.api_resources.abstract import ListableAPIResource from stripe.api_resources.abstract import UpdateableAPIResource -from stripe.api_resources.abstract import custom_method -@custom_method("cancel", http_verb="post") -@custom_method("reverse", http_verb="post") class Payout( CreateableAPIResource, ListableAPIResource, UpdateableAPIResource ): OBJECT_NAME = "payout" + @classmethod + def _cls_cancel( + cls, + payout, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/payouts/{payout}/cancel".format( + payout=util.sanitize_id(payout) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_cancel") def cancel(self, idempotency_key=None, **params): - url = "/v1/payouts/{payout}/cancel".format( - payout=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/payouts/{payout}/cancel".format( + payout=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, + ) + + @classmethod + def _cls_reverse( + cls, + payout, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/payouts/{payout}/reverse".format( + payout=util.sanitize_id(payout) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self + @util.class_method_variant("_cls_reverse") def reverse(self, idempotency_key=None, **params): - url = "/v1/payouts/{payout}/reverse".format( - payout=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/payouts/{payout}/reverse".format( + payout=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self diff --git a/stripe/api_resources/quote.py b/stripe/api_resources/quote.py index 81f266cbe..608f5b7ab 100644 --- a/stripe/api_resources/quote.py +++ b/stripe/api_resources/quote.py @@ -7,65 +7,162 @@ from stripe.api_resources.abstract import CreateableAPIResource from stripe.api_resources.abstract import ListableAPIResource from stripe.api_resources.abstract import UpdateableAPIResource -from stripe.api_resources.abstract import custom_method from stripe.six.moves.urllib.parse import quote_plus -@custom_method("accept", http_verb="post") -@custom_method("cancel", http_verb="post") -@custom_method("finalize_quote", http_verb="post", http_path="finalize") -@custom_method( - "list_computed_upfront_line_items", - http_verb="get", - http_path="computed_upfront_line_items", -) -@custom_method("list_line_items", http_verb="get", http_path="line_items") class Quote(CreateableAPIResource, ListableAPIResource, UpdateableAPIResource): OBJECT_NAME = "quote" + @classmethod + def _cls_accept( + cls, + quote, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/quotes/{quote}/accept".format(quote=util.sanitize_id(quote)), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_accept") def accept(self, idempotency_key=None, **params): - url = "/v1/quotes/{quote}/accept".format( - quote=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/quotes/{quote}/accept".format( + quote=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self + @classmethod + def _cls_cancel( + cls, + quote, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/quotes/{quote}/cancel".format(quote=util.sanitize_id(quote)), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_cancel") def cancel(self, idempotency_key=None, **params): - url = "/v1/quotes/{quote}/cancel".format( - quote=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/quotes/{quote}/cancel".format( + quote=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, + ) + + @classmethod + def _cls_finalize_quote( + cls, + quote, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/quotes/{quote}/finalize".format( + quote=util.sanitize_id(quote) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self + @util.class_method_variant("_cls_finalize_quote") def finalize_quote(self, idempotency_key=None, **params): - url = "/v1/quotes/{quote}/finalize".format( - quote=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/quotes/{quote}/finalize".format( + quote=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self + @classmethod + def _cls_list_computed_upfront_line_items( + cls, + quote, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "get", + "/v1/quotes/{quote}/computed_upfront_line_items".format( + quote=util.sanitize_id(quote) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_list_computed_upfront_line_items") def list_computed_upfront_line_items(self, idempotency_key=None, **params): - url = "/v1/quotes/{quote}/computed_upfront_line_items".format( - quote=util.sanitize_id(self.get("id")) + return self._request( + "get", + "/v1/quotes/{quote}/computed_upfront_line_items".format( + quote=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, + ) + + @classmethod + def _cls_list_line_items( + cls, + quote, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "get", + "/v1/quotes/{quote}/line_items".format( + quote=util.sanitize_id(quote) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - headers = util.populate_headers(idempotency_key) - resp = self.request("get", url, params, headers) - stripe_object = util.convert_to_stripe_object(resp) - stripe_object._retrieve_params = params - return stripe_object + @util.class_method_variant("_cls_list_line_items") def list_line_items(self, idempotency_key=None, **params): - url = "/v1/quotes/{quote}/line_items".format( - quote=util.sanitize_id(self.get("id")) + return self._request( + "get", + "/v1/quotes/{quote}/line_items".format( + quote=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - resp = self.request("get", url, params, headers) - stripe_object = util.convert_to_stripe_object(resp) - stripe_object._retrieve_params = params - return stripe_object @classmethod def _cls_pdf( diff --git a/stripe/api_resources/refund.py b/stripe/api_resources/refund.py index 8877072b6..332b1f1bc 100644 --- a/stripe/api_resources/refund.py +++ b/stripe/api_resources/refund.py @@ -1,30 +1,50 @@ # File generated from our OpenAPI spec from __future__ import absolute_import, division, print_function -from stripe import api_requestor from stripe import util from stripe.api_resources.abstract import APIResourceTestHelpers from stripe.api_resources.abstract import CreateableAPIResource from stripe.api_resources.abstract import ListableAPIResource from stripe.api_resources.abstract import UpdateableAPIResource -from stripe.api_resources.abstract import custom_method from stripe.api_resources.abstract import test_helpers @test_helpers -@custom_method("cancel", http_verb="post") class Refund( CreateableAPIResource, ListableAPIResource, UpdateableAPIResource ): OBJECT_NAME = "refund" + @classmethod + def _cls_cancel( + cls, + refund, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/refunds/{refund}/cancel".format( + refund=util.sanitize_id(refund) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_cancel") def cancel(self, idempotency_key=None, **params): - url = "/v1/refunds/{refund}/cancel".format( - refund=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/refunds/{refund}/cancel".format( + refund=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self class TestHelpers(APIResourceTestHelpers): @classmethod @@ -36,25 +56,24 @@ def _cls_expire( stripe_account=None, **params ): - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account + return cls._static_request( + "post", + "/v1/test_helpers/refunds/{refund}/expire".format( + refund=util.sanitize_id(refund) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - url = "/v1/test_helpers/refunds/{refund}/expire".format( - refund=util.sanitize_id(refund) - ) - response, api_key = requestor.request("post", url, params) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account - ) - return stripe_object @util.class_method_variant("_cls_expire") def expire(self, idempotency_key=None, **params): - url = "/v1/test_helpers/refunds/{refund}/expire".format( - refund=util.sanitize_id(self.get("id")) - ) - headers = util.populate_headers(idempotency_key) - self.resource.refresh_from( - self.resource.request("post", url, params, headers) + return self.resource._request( + "post", + "/v1/test_helpers/refunds/{refund}/expire".format( + refund=util.sanitize_id(self.resource.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - return self.resource diff --git a/stripe/api_resources/review.py b/stripe/api_resources/review.py index b3e3b87f2..a05e5c907 100644 --- a/stripe/api_resources/review.py +++ b/stripe/api_resources/review.py @@ -3,17 +3,38 @@ from stripe import util from stripe.api_resources.abstract import ListableAPIResource -from stripe.api_resources.abstract import custom_method -@custom_method("approve", http_verb="post") class Review(ListableAPIResource): OBJECT_NAME = "review" + @classmethod + def _cls_approve( + cls, + review, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/reviews/{review}/approve".format( + review=util.sanitize_id(review) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_approve") def approve(self, idempotency_key=None, **params): - url = "/v1/reviews/{review}/approve".format( - review=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/reviews/{review}/approve".format( + review=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self diff --git a/stripe/api_resources/search_result_object.py b/stripe/api_resources/search_result_object.py index c2f781942..4a3563e25 100644 --- a/stripe/api_resources/search_result_object.py +++ b/stripe/api_resources/search_result_object.py @@ -1,6 +1,6 @@ from __future__ import absolute_import, division, print_function -from stripe import api_requestor, six, util +from stripe import six from stripe.stripe_object import StripeObject @@ -10,40 +10,14 @@ class SearchResultObject(StripeObject): def search( self, api_key=None, stripe_version=None, stripe_account=None, **params ): - stripe_object = self._request( + return self._request( "get", self.get("url"), api_key=api_key, stripe_version=stripe_version, stripe_account=stripe_account, - **params + params=params, ) - stripe_object._retrieve_params = params - return stripe_object - - def _request( - self, - method_, - url_, - api_key=None, - idempotency_key=None, - stripe_version=None, - stripe_account=None, - **params - ): - api_key = api_key or self.api_key - stripe_version = stripe_version or self.stripe_version - stripe_account = stripe_account or self.stripe_account - - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account - ) - headers = util.populate_headers(idempotency_key) - response, api_key = requestor.request(method_, url_, params, headers) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account - ) - return stripe_object def __getitem__(self, k): if isinstance(k, six.string_types): diff --git a/stripe/api_resources/setup_intent.py b/stripe/api_resources/setup_intent.py index 83c1010c6..d07004ca2 100644 --- a/stripe/api_resources/setup_intent.py +++ b/stripe/api_resources/setup_intent.py @@ -5,12 +5,8 @@ from stripe.api_resources.abstract import CreateableAPIResource from stripe.api_resources.abstract import ListableAPIResource from stripe.api_resources.abstract import UpdateableAPIResource -from stripe.api_resources.abstract import custom_method -@custom_method("cancel", http_verb="post") -@custom_method("confirm", http_verb="post") -@custom_method("verify_microdeposits", http_verb="post") class SetupIntent( CreateableAPIResource, ListableAPIResource, @@ -18,26 +14,95 @@ class SetupIntent( ): OBJECT_NAME = "setup_intent" + @classmethod + def _cls_cancel( + cls, + intent, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/setup_intents/{intent}/cancel".format( + intent=util.sanitize_id(intent) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_cancel") def cancel(self, idempotency_key=None, **params): - url = "/v1/setup_intents/{intent}/cancel".format( - intent=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/setup_intents/{intent}/cancel".format( + intent=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, + ) + + @classmethod + def _cls_confirm( + cls, + intent, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/setup_intents/{intent}/confirm".format( + intent=util.sanitize_id(intent) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self + @util.class_method_variant("_cls_confirm") def confirm(self, idempotency_key=None, **params): - url = "/v1/setup_intents/{intent}/confirm".format( - intent=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/setup_intents/{intent}/confirm".format( + intent=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, + ) + + @classmethod + def _cls_verify_microdeposits( + cls, + intent, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/setup_intents/{intent}/verify_microdeposits".format( + intent=util.sanitize_id(intent) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self + @util.class_method_variant("_cls_verify_microdeposits") def verify_microdeposits(self, idempotency_key=None, **params): - url = "/v1/setup_intents/{intent}/verify_microdeposits".format( - intent=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/setup_intents/{intent}/verify_microdeposits".format( + intent=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self diff --git a/stripe/api_resources/source.py b/stripe/api_resources/source.py index d0bed0803..4960ef05d 100644 --- a/stripe/api_resources/source.py +++ b/stripe/api_resources/source.py @@ -6,23 +6,44 @@ from stripe.api_resources import Customer from stripe.api_resources.abstract import CreateableAPIResource from stripe.api_resources.abstract import UpdateableAPIResource -from stripe.api_resources.abstract import custom_method from stripe.api_resources.abstract import nested_resource_class_methods from stripe.six.moves.urllib.parse import quote_plus -@custom_method("verify", http_verb="post") @nested_resource_class_methods("source_transaction", operations=["list"]) class Source(CreateableAPIResource, UpdateableAPIResource): OBJECT_NAME = "source" + @classmethod + def _cls_verify( + cls, + source, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/sources/{source}/verify".format( + source=util.sanitize_id(source) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_verify") def verify(self, idempotency_key=None, **params): - url = "/v1/sources/{source}/verify".format( - source=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/sources/{source}/verify".format( + source=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self def detach(self, idempotency_key=None, **params): token = util.utf8(self.id) diff --git a/stripe/api_resources/subscription_schedule.py b/stripe/api_resources/subscription_schedule.py index 36ab50087..1247b352e 100644 --- a/stripe/api_resources/subscription_schedule.py +++ b/stripe/api_resources/subscription_schedule.py @@ -5,11 +5,8 @@ from stripe.api_resources.abstract import CreateableAPIResource from stripe.api_resources.abstract import ListableAPIResource from stripe.api_resources.abstract import UpdateableAPIResource -from stripe.api_resources.abstract import custom_method -@custom_method("cancel", http_verb="post") -@custom_method("release", http_verb="post") class SubscriptionSchedule( CreateableAPIResource, ListableAPIResource, @@ -17,18 +14,64 @@ class SubscriptionSchedule( ): OBJECT_NAME = "subscription_schedule" + @classmethod + def _cls_cancel( + cls, + schedule, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/subscription_schedules/{schedule}/cancel".format( + schedule=util.sanitize_id(schedule) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_cancel") def cancel(self, idempotency_key=None, **params): - url = "/v1/subscription_schedules/{schedule}/cancel".format( - schedule=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/subscription_schedules/{schedule}/cancel".format( + schedule=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, + ) + + @classmethod + def _cls_release( + cls, + schedule, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/subscription_schedules/{schedule}/release".format( + schedule=util.sanitize_id(schedule) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self + @util.class_method_variant("_cls_release") def release(self, idempotency_key=None, **params): - url = "/v1/subscription_schedules/{schedule}/release".format( - schedule=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/subscription_schedules/{schedule}/release".format( + schedule=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self diff --git a/stripe/api_resources/terminal/reader.py b/stripe/api_resources/terminal/reader.py index 2e0769635..018466a6b 100644 --- a/stripe/api_resources/terminal/reader.py +++ b/stripe/api_resources/terminal/reader.py @@ -1,22 +1,16 @@ # File generated from our OpenAPI spec from __future__ import absolute_import, division, print_function -from stripe import api_requestor from stripe import util from stripe.api_resources.abstract import APIResourceTestHelpers from stripe.api_resources.abstract import CreateableAPIResource from stripe.api_resources.abstract import DeletableAPIResource from stripe.api_resources.abstract import ListableAPIResource from stripe.api_resources.abstract import UpdateableAPIResource -from stripe.api_resources.abstract import custom_method from stripe.api_resources.abstract import test_helpers @test_helpers -@custom_method("cancel_action", http_verb="post") -@custom_method("process_payment_intent", http_verb="post") -@custom_method("process_setup_intent", http_verb="post") -@custom_method("set_reader_display", http_verb="post") class Reader( CreateableAPIResource, DeletableAPIResource, @@ -25,37 +19,129 @@ class Reader( ): OBJECT_NAME = "terminal.reader" + @classmethod + def _cls_cancel_action( + cls, + reader, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/terminal/readers/{reader}/cancel_action".format( + reader=util.sanitize_id(reader) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_cancel_action") def cancel_action(self, idempotency_key=None, **params): - url = "/v1/terminal/readers/{reader}/cancel_action".format( - reader=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/terminal/readers/{reader}/cancel_action".format( + reader=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self + @classmethod + def _cls_process_payment_intent( + cls, + reader, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/terminal/readers/{reader}/process_payment_intent".format( + reader=util.sanitize_id(reader) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_process_payment_intent") def process_payment_intent(self, idempotency_key=None, **params): - url = "/v1/terminal/readers/{reader}/process_payment_intent".format( - reader=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/terminal/readers/{reader}/process_payment_intent".format( + reader=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, + ) + + @classmethod + def _cls_process_setup_intent( + cls, + reader, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/terminal/readers/{reader}/process_setup_intent".format( + reader=util.sanitize_id(reader) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self + @util.class_method_variant("_cls_process_setup_intent") def process_setup_intent(self, idempotency_key=None, **params): - url = "/v1/terminal/readers/{reader}/process_setup_intent".format( - reader=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/terminal/readers/{reader}/process_setup_intent".format( + reader=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self + @classmethod + def _cls_set_reader_display( + cls, + reader, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/terminal/readers/{reader}/set_reader_display".format( + reader=util.sanitize_id(reader) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_set_reader_display") def set_reader_display(self, idempotency_key=None, **params): - url = "/v1/terminal/readers/{reader}/set_reader_display".format( - reader=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/terminal/readers/{reader}/set_reader_display".format( + reader=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self class TestHelpers(APIResourceTestHelpers): @classmethod @@ -67,25 +153,24 @@ def _cls_present_payment_method( stripe_account=None, **params ): - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account + return cls._static_request( + "post", + "/v1/test_helpers/terminal/readers/{reader}/present_payment_method".format( + reader=util.sanitize_id(reader) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - url = "/v1/test_helpers/terminal/readers/{reader}/present_payment_method".format( - reader=util.sanitize_id(reader) - ) - response, api_key = requestor.request("post", url, params) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account - ) - return stripe_object @util.class_method_variant("_cls_present_payment_method") def present_payment_method(self, idempotency_key=None, **params): - url = "/v1/test_helpers/terminal/readers/{reader}/present_payment_method".format( - reader=util.sanitize_id(self.get("id")) - ) - headers = util.populate_headers(idempotency_key) - self.resource.refresh_from( - self.resource.request("post", url, params, headers) + return self.resource._request( + "post", + "/v1/test_helpers/terminal/readers/{reader}/present_payment_method".format( + reader=util.sanitize_id(self.resource.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - return self.resource diff --git a/stripe/api_resources/test_helpers/test_clock.py b/stripe/api_resources/test_helpers/test_clock.py index c22abe9c6..f3ae02d46 100644 --- a/stripe/api_resources/test_helpers/test_clock.py +++ b/stripe/api_resources/test_helpers/test_clock.py @@ -5,10 +5,8 @@ from stripe.api_resources.abstract import CreateableAPIResource from stripe.api_resources.abstract import DeletableAPIResource from stripe.api_resources.abstract import ListableAPIResource -from stripe.api_resources.abstract import custom_method -@custom_method("advance", http_verb="post") class TestClock( CreateableAPIResource, DeletableAPIResource, @@ -16,10 +14,33 @@ class TestClock( ): OBJECT_NAME = "test_helpers.test_clock" + @classmethod + def _cls_advance( + cls, + test_clock, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/test_helpers/test_clocks/{test_clock}/advance".format( + test_clock=util.sanitize_id(test_clock) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_advance") def advance(self, idempotency_key=None, **params): - url = "/v1/test_helpers/test_clocks/{test_clock}/advance".format( - test_clock=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/test_helpers/test_clocks/{test_clock}/advance".format( + test_clock=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self diff --git a/stripe/api_resources/topup.py b/stripe/api_resources/topup.py index 5b748fa86..3f6dca70a 100644 --- a/stripe/api_resources/topup.py +++ b/stripe/api_resources/topup.py @@ -5,17 +5,36 @@ from stripe.api_resources.abstract import CreateableAPIResource from stripe.api_resources.abstract import ListableAPIResource from stripe.api_resources.abstract import UpdateableAPIResource -from stripe.api_resources.abstract import custom_method -@custom_method("cancel", http_verb="post") class Topup(CreateableAPIResource, ListableAPIResource, UpdateableAPIResource): OBJECT_NAME = "topup" + @classmethod + def _cls_cancel( + cls, + topup, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/topups/{topup}/cancel".format(topup=util.sanitize_id(topup)), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_cancel") def cancel(self, idempotency_key=None, **params): - url = "/v1/topups/{topup}/cancel".format( - topup=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/topups/{topup}/cancel".format( + topup=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self diff --git a/stripe/api_resources/treasury/financial_account.py b/stripe/api_resources/treasury/financial_account.py index 9ab775c26..3cb1bda58 100644 --- a/stripe/api_resources/treasury/financial_account.py +++ b/stripe/api_resources/treasury/financial_account.py @@ -5,11 +5,8 @@ from stripe.api_resources.abstract import CreateableAPIResource from stripe.api_resources.abstract import ListableAPIResource from stripe.api_resources.abstract import UpdateableAPIResource -from stripe.api_resources.abstract import custom_method -@custom_method("retrieve_features", http_verb="get", http_path="features") -@custom_method("update_features", http_verb="post", http_path="features") class FinancialAccount( CreateableAPIResource, ListableAPIResource, @@ -17,20 +14,64 @@ class FinancialAccount( ): OBJECT_NAME = "treasury.financial_account" + @classmethod + def _cls_retrieve_features( + cls, + financial_account, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "get", + "/v1/treasury/financial_accounts/{financial_account}/features".format( + financial_account=util.sanitize_id(financial_account) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_retrieve_features") def retrieve_features(self, idempotency_key=None, **params): - url = "/v1/treasury/financial_accounts/{financial_account}/features".format( - financial_account=util.sanitize_id(self.get("id")) + return self._request( + "get", + "/v1/treasury/financial_accounts/{financial_account}/features".format( + financial_account=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, + ) + + @classmethod + def _cls_update_features( + cls, + financial_account, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/treasury/financial_accounts/{financial_account}/features".format( + financial_account=util.sanitize_id(financial_account) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - headers = util.populate_headers(idempotency_key) - resp = self.request("get", url, params, headers) - stripe_object = util.convert_to_stripe_object(resp) - return stripe_object + @util.class_method_variant("_cls_update_features") def update_features(self, idempotency_key=None, **params): - url = "/v1/treasury/financial_accounts/{financial_account}/features".format( - financial_account=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/treasury/financial_accounts/{financial_account}/features".format( + financial_account=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - resp = self.request("post", url, params, headers) - stripe_object = util.convert_to_stripe_object(resp) - return stripe_object diff --git a/stripe/api_resources/treasury/inbound_transfer.py b/stripe/api_resources/treasury/inbound_transfer.py index 23c62a70b..3297ce431 100644 --- a/stripe/api_resources/treasury/inbound_transfer.py +++ b/stripe/api_resources/treasury/inbound_transfer.py @@ -1,29 +1,47 @@ # File generated from our OpenAPI spec from __future__ import absolute_import, division, print_function -from stripe import api_requestor from stripe import util from stripe.api_resources.abstract import APIResourceTestHelpers from stripe.api_resources.abstract import CreateableAPIResource from stripe.api_resources.abstract import ListableAPIResource -from stripe.api_resources.abstract import custom_method from stripe.api_resources.abstract import test_helpers @test_helpers -@custom_method("cancel", http_verb="post") class InboundTransfer(CreateableAPIResource, ListableAPIResource): OBJECT_NAME = "treasury.inbound_transfer" + @classmethod + def _cls_cancel( + cls, + inbound_transfer, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/treasury/inbound_transfers/{inbound_transfer}/cancel".format( + inbound_transfer=util.sanitize_id(inbound_transfer) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_cancel") def cancel(self, idempotency_key=None, **params): - url = ( + return self._request( + "post", "/v1/treasury/inbound_transfers/{inbound_transfer}/cancel".format( inbound_transfer=util.sanitize_id(self.get("id")) - ) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self class TestHelpers(APIResourceTestHelpers): @classmethod @@ -35,32 +53,27 @@ def _cls_fail( stripe_account=None, **params ): - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account - ) - url = ( + return cls._static_request( + "post", "/v1/test_helpers/treasury/inbound_transfers/{id}/fail".format( id=util.sanitize_id(id) - ) - ) - response, api_key = requestor.request("post", url, params) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - return stripe_object @util.class_method_variant("_cls_fail") def fail(self, idempotency_key=None, **params): - url = ( + return self.resource._request( + "post", "/v1/test_helpers/treasury/inbound_transfers/{id}/fail".format( - id=util.sanitize_id(self.get("id")) - ) + id=util.sanitize_id(self.resource.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.resource.refresh_from( - self.resource.request("post", url, params, headers) - ) - return self.resource @classmethod def _cls_return_inbound_transfer( @@ -71,28 +84,27 @@ def _cls_return_inbound_transfer( stripe_account=None, **params ): - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account - ) - url = "/v1/test_helpers/treasury/inbound_transfers/{id}/return".format( - id=util.sanitize_id(id) - ) - response, api_key = requestor.request("post", url, params) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account + return cls._static_request( + "post", + "/v1/test_helpers/treasury/inbound_transfers/{id}/return".format( + id=util.sanitize_id(id) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - return stripe_object @util.class_method_variant("_cls_return_inbound_transfer") def return_inbound_transfer(self, idempotency_key=None, **params): - url = "/v1/test_helpers/treasury/inbound_transfers/{id}/return".format( - id=util.sanitize_id(self.get("id")) + return self.resource._request( + "post", + "/v1/test_helpers/treasury/inbound_transfers/{id}/return".format( + id=util.sanitize_id(self.resource.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.resource.refresh_from( - self.resource.request("post", url, params, headers) - ) - return self.resource @classmethod def _cls_succeed( @@ -103,25 +115,24 @@ def _cls_succeed( stripe_account=None, **params ): - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account - ) - url = "/v1/test_helpers/treasury/inbound_transfers/{id}/succeed".format( - id=util.sanitize_id(id) - ) - response, api_key = requestor.request("post", url, params) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account + return cls._static_request( + "post", + "/v1/test_helpers/treasury/inbound_transfers/{id}/succeed".format( + id=util.sanitize_id(id) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - return stripe_object @util.class_method_variant("_cls_succeed") def succeed(self, idempotency_key=None, **params): - url = "/v1/test_helpers/treasury/inbound_transfers/{id}/succeed".format( - id=util.sanitize_id(self.get("id")) - ) - headers = util.populate_headers(idempotency_key) - self.resource.refresh_from( - self.resource.request("post", url, params, headers) + return self.resource._request( + "post", + "/v1/test_helpers/treasury/inbound_transfers/{id}/succeed".format( + id=util.sanitize_id(self.resource.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - return self.resource diff --git a/stripe/api_resources/treasury/outbound_payment.py b/stripe/api_resources/treasury/outbound_payment.py index fe65f21e8..7669bed9b 100644 --- a/stripe/api_resources/treasury/outbound_payment.py +++ b/stripe/api_resources/treasury/outbound_payment.py @@ -1,27 +1,47 @@ # File generated from our OpenAPI spec from __future__ import absolute_import, division, print_function -from stripe import api_requestor from stripe import util from stripe.api_resources.abstract import APIResourceTestHelpers from stripe.api_resources.abstract import CreateableAPIResource from stripe.api_resources.abstract import ListableAPIResource -from stripe.api_resources.abstract import custom_method from stripe.api_resources.abstract import test_helpers @test_helpers -@custom_method("cancel", http_verb="post") class OutboundPayment(CreateableAPIResource, ListableAPIResource): OBJECT_NAME = "treasury.outbound_payment" + @classmethod + def _cls_cancel( + cls, + id, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/treasury/outbound_payments/{id}/cancel".format( + id=util.sanitize_id(id) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_cancel") def cancel(self, idempotency_key=None, **params): - url = "/v1/treasury/outbound_payments/{id}/cancel".format( - id=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/treasury/outbound_payments/{id}/cancel".format( + id=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self class TestHelpers(APIResourceTestHelpers): @classmethod @@ -33,32 +53,27 @@ def _cls_fail( stripe_account=None, **params ): - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account - ) - url = ( + return cls._static_request( + "post", "/v1/test_helpers/treasury/outbound_payments/{id}/fail".format( id=util.sanitize_id(id) - ) - ) - response, api_key = requestor.request("post", url, params) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - return stripe_object @util.class_method_variant("_cls_fail") def fail(self, idempotency_key=None, **params): - url = ( + return self.resource._request( + "post", "/v1/test_helpers/treasury/outbound_payments/{id}/fail".format( - id=util.sanitize_id(self.get("id")) - ) + id=util.sanitize_id(self.resource.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.resource.refresh_from( - self.resource.request("post", url, params, headers) - ) - return self.resource @classmethod def _cls_post( @@ -69,32 +84,27 @@ def _cls_post( stripe_account=None, **params ): - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account - ) - url = ( + return cls._static_request( + "post", "/v1/test_helpers/treasury/outbound_payments/{id}/post".format( id=util.sanitize_id(id) - ) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - response, api_key = requestor.request("post", url, params) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account - ) - return stripe_object @util.class_method_variant("_cls_post") def post(self, idempotency_key=None, **params): - url = ( + return self.resource._request( + "post", "/v1/test_helpers/treasury/outbound_payments/{id}/post".format( - id=util.sanitize_id(self.get("id")) - ) - ) - headers = util.populate_headers(idempotency_key) - self.resource.refresh_from( - self.resource.request("post", url, params, headers) + id=util.sanitize_id(self.resource.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - return self.resource @classmethod def _cls_return_outbound_payment( @@ -105,25 +115,24 @@ def _cls_return_outbound_payment( stripe_account=None, **params ): - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account - ) - url = "/v1/test_helpers/treasury/outbound_payments/{id}/return".format( - id=util.sanitize_id(id) - ) - response, api_key = requestor.request("post", url, params) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account + return cls._static_request( + "post", + "/v1/test_helpers/treasury/outbound_payments/{id}/return".format( + id=util.sanitize_id(id) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - return stripe_object @util.class_method_variant("_cls_return_outbound_payment") def return_outbound_payment(self, idempotency_key=None, **params): - url = "/v1/test_helpers/treasury/outbound_payments/{id}/return".format( - id=util.sanitize_id(self.get("id")) - ) - headers = util.populate_headers(idempotency_key) - self.resource.refresh_from( - self.resource.request("post", url, params, headers) + return self.resource._request( + "post", + "/v1/test_helpers/treasury/outbound_payments/{id}/return".format( + id=util.sanitize_id(self.resource.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - return self.resource diff --git a/stripe/api_resources/treasury/outbound_transfer.py b/stripe/api_resources/treasury/outbound_transfer.py index a3d06ee84..92cc81bf8 100644 --- a/stripe/api_resources/treasury/outbound_transfer.py +++ b/stripe/api_resources/treasury/outbound_transfer.py @@ -1,27 +1,47 @@ # File generated from our OpenAPI spec from __future__ import absolute_import, division, print_function -from stripe import api_requestor from stripe import util from stripe.api_resources.abstract import APIResourceTestHelpers from stripe.api_resources.abstract import CreateableAPIResource from stripe.api_resources.abstract import ListableAPIResource -from stripe.api_resources.abstract import custom_method from stripe.api_resources.abstract import test_helpers @test_helpers -@custom_method("cancel", http_verb="post") class OutboundTransfer(CreateableAPIResource, ListableAPIResource): OBJECT_NAME = "treasury.outbound_transfer" + @classmethod + def _cls_cancel( + cls, + outbound_transfer, + api_key=None, + stripe_version=None, + stripe_account=None, + **params + ): + return cls._static_request( + "post", + "/v1/treasury/outbound_transfers/{outbound_transfer}/cancel".format( + outbound_transfer=util.sanitize_id(outbound_transfer) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, + ) + + @util.class_method_variant("_cls_cancel") def cancel(self, idempotency_key=None, **params): - url = "/v1/treasury/outbound_transfers/{outbound_transfer}/cancel".format( - outbound_transfer=util.sanitize_id(self.get("id")) + return self._request( + "post", + "/v1/treasury/outbound_transfers/{outbound_transfer}/cancel".format( + outbound_transfer=util.sanitize_id(self.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.refresh_from(self.request("post", url, params, headers)) - return self class TestHelpers(APIResourceTestHelpers): @classmethod @@ -33,28 +53,27 @@ def _cls_fail( stripe_account=None, **params ): - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account - ) - url = "/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}/fail".format( - outbound_transfer=util.sanitize_id(outbound_transfer) - ) - response, api_key = requestor.request("post", url, params) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account + return cls._static_request( + "post", + "/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}/fail".format( + outbound_transfer=util.sanitize_id(outbound_transfer) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - return stripe_object @util.class_method_variant("_cls_fail") def fail(self, idempotency_key=None, **params): - url = "/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}/fail".format( - outbound_transfer=util.sanitize_id(self.get("id")) + return self.resource._request( + "post", + "/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}/fail".format( + outbound_transfer=util.sanitize_id(self.resource.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.resource.refresh_from( - self.resource.request("post", url, params, headers) - ) - return self.resource @classmethod def _cls_post( @@ -65,28 +84,27 @@ def _cls_post( stripe_account=None, **params ): - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account + return cls._static_request( + "post", + "/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}/post".format( + outbound_transfer=util.sanitize_id(outbound_transfer) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - url = "/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}/post".format( - outbound_transfer=util.sanitize_id(outbound_transfer) - ) - response, api_key = requestor.request("post", url, params) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account - ) - return stripe_object @util.class_method_variant("_cls_post") def post(self, idempotency_key=None, **params): - url = "/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}/post".format( - outbound_transfer=util.sanitize_id(self.get("id")) + return self.resource._request( + "post", + "/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}/post".format( + outbound_transfer=util.sanitize_id(self.resource.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - headers = util.populate_headers(idempotency_key) - self.resource.refresh_from( - self.resource.request("post", url, params, headers) - ) - return self.resource @classmethod def _cls_return_outbound_transfer( @@ -97,25 +115,24 @@ def _cls_return_outbound_transfer( stripe_account=None, **params ): - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account + return cls._static_request( + "post", + "/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}/return".format( + outbound_transfer=util.sanitize_id(outbound_transfer) + ), + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - url = "/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}/return".format( - outbound_transfer=util.sanitize_id(outbound_transfer) - ) - response, api_key = requestor.request("post", url, params) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account - ) - return stripe_object @util.class_method_variant("_cls_return_outbound_transfer") def return_outbound_transfer(self, idempotency_key=None, **params): - url = "/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}/return".format( - outbound_transfer=util.sanitize_id(self.get("id")) - ) - headers = util.populate_headers(idempotency_key) - self.resource.refresh_from( - self.resource.request("post", url, params, headers) + return self.resource._request( + "post", + "/v1/test_helpers/treasury/outbound_transfers/{outbound_transfer}/return".format( + outbound_transfer=util.sanitize_id(self.resource.get("id")) + ), + idempotency_key=idempotency_key, + params=params, ) - return self.resource diff --git a/stripe/api_resources/treasury/received_credit.py b/stripe/api_resources/treasury/received_credit.py index bf7a47e76..2cfb6a886 100644 --- a/stripe/api_resources/treasury/received_credit.py +++ b/stripe/api_resources/treasury/received_credit.py @@ -1,8 +1,6 @@ # File generated from our OpenAPI spec from __future__ import absolute_import, division, print_function -from stripe import api_requestor -from stripe import util from stripe.api_resources.abstract import APIResourceTestHelpers from stripe.api_resources.abstract import ListableAPIResource from stripe.api_resources.abstract import test_helpers @@ -21,12 +19,11 @@ def create( stripe_account=None, **params ): - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account + return cls._static_request( + "post", + "/v1/test_helpers/treasury/received_credits", + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - url = "/v1/test_helpers/treasury/received_credits" - response, api_key = requestor.request("post", url, params) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account - ) - return stripe_object diff --git a/stripe/api_resources/treasury/received_debit.py b/stripe/api_resources/treasury/received_debit.py index 38b9c86f0..6187e1a38 100644 --- a/stripe/api_resources/treasury/received_debit.py +++ b/stripe/api_resources/treasury/received_debit.py @@ -1,8 +1,6 @@ # File generated from our OpenAPI spec from __future__ import absolute_import, division, print_function -from stripe import api_requestor -from stripe import util from stripe.api_resources.abstract import APIResourceTestHelpers from stripe.api_resources.abstract import ListableAPIResource from stripe.api_resources.abstract import test_helpers @@ -21,12 +19,11 @@ def create( stripe_account=None, **params ): - requestor = api_requestor.APIRequestor( - api_key, api_version=stripe_version, account=stripe_account + return cls._static_request( + "post", + "/v1/test_helpers/treasury/received_debits", + api_key=api_key, + stripe_version=stripe_version, + stripe_account=stripe_account, + params=params, ) - url = "/v1/test_helpers/treasury/received_debits" - response, api_key = requestor.request("post", url, params) - stripe_object = util.convert_to_stripe_object( - response, api_key, stripe_version, stripe_account - ) - return stripe_object diff --git a/stripe/stripe_object.py b/stripe/stripe_object.py index 03f992f5b..a06cedd2e 100644 --- a/stripe/stripe_object.py +++ b/stripe/stripe_object.py @@ -102,7 +102,7 @@ def __setitem__(self, k, v): raise ValueError( "You cannot set %s to an empty string on this object. " "The empty string is treated specially in our requests. " - "If you'd like to delete the property using the save() method on this object, you may set %s.%s = None. " + "If you'd like to delete the property using the save() method on this object, you may set %s.%s=None. " "Alternatively, you can pass %s='' to delete the property when using a resource method such as modify()." % (k, str(self), k, k) ) @@ -233,18 +233,43 @@ def api_base(cls): return None def request(self, method, url, params=None, headers=None): - if params is None: - params = self._retrieve_params + return StripeObject._request( + self, method, url, headers=headers, params=params + ) + + # The `method_` and `url_` arguments are suffixed with an underscore to + # avoid conflicting with actual request parameters in `params`. + def _request( + self, + method_, + url_, + api_key=None, + idempotency_key=None, + stripe_version=None, + stripe_account=None, + headers=None, + params=None, + ): + stripe_account = stripe_account or self.stripe_account + stripe_version = stripe_version or self.stripe_version + api_key = api_key or self.api_key + params = params or self._retrieve_params + requestor = api_requestor.APIRequestor( - key=self.api_key, + key=api_key, api_base=self.api_base(), - api_version=self.stripe_version, - account=self.stripe_account, + api_version=stripe_version, + account=stripe_account, ) - response, api_key = requestor.request(method, url, params, headers) + + if idempotency_key is not None: + headers = {} if headers is None else headers.copy() + headers.update(util.populate_headers(idempotency_key)) + + response, api_key = requestor.request(method_, url_, params, headers) return util.convert_to_stripe_object( - response, api_key, self.stripe_version, self.stripe_account + response, api_key, stripe_version, stripe_account, params ) def request_stream(self, method, url, params=None, headers=None): diff --git a/stripe/util.py b/stripe/util.py index da5be7259..619f9cb1f 100644 --- a/stripe/util.py +++ b/stripe/util.py @@ -136,7 +136,7 @@ def get_object_classes(): def convert_to_stripe_object( - resp, api_key=None, stripe_version=None, stripe_account=None + resp, api_key=None, stripe_version=None, stripe_account=None, params=None ): # If we get a StripeResponse, we'll want to return a # StripeObject with the last_response field filled out with @@ -166,13 +166,20 @@ def convert_to_stripe_object( else: klass = stripe.stripe_object.StripeObject - return klass.construct_from( + obj = klass.construct_from( resp, api_key, stripe_version=stripe_version, stripe_account=stripe_account, last_response=stripe_response, ) + + if hasattr(obj, "object") and ( + (obj.object == "list") or (obj.object == "search_result") + ): + obj._retrieve_params = params + + return obj else: return resp diff --git a/tests/api_resources/abstract/test_updateable_api_resource.py b/tests/api_resources/abstract/test_updateable_api_resource.py index 89a6b3b49..21c577459 100644 --- a/tests/api_resources/abstract/test_updateable_api_resource.py +++ b/tests/api_resources/abstract/test_updateable_api_resource.py @@ -24,6 +24,7 @@ def obj(self, request_mock): "foo": "bar", "baz": "boz", "metadata": {"size": "l", "score": 4, "height": 10}, + "object": "obj", }, "mykey", )