12384315441

Committed 18 Dec 2024 01:04AM UTC coverage: 96.284% (+0.008%) from 96.276%

Build # 12384315441

Build Type

Pull #1433

github

Committed by

web-flow

Commit Message

Merge 2bd254d5b into d09a4d17f

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

Run Details

1394 of 2129 branches covered (65.48%)

Branch coverage included in aggregate %.

419 of 432 new or added lines in 14 files covered. (96.99%)

1 existing line in 1 file now uncovered.

91089 of 93923 relevant lines covered (96.98%)

0.97 hits per line

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

96.63

/stripe/_error.py

from typing import Dict, Optional, Union, cast

import stripe  # noqa
from stripe._error_object import ErrorObject


class StripeError(Exception):
    _message: Optional[str]
    http_body: Optional[str]
    http_status: Optional[int]
    json_body: Optional[object]
    headers: Optional[Dict[str, str]]
    code: Optional[str]
    request_id: Optional[str]
    error: Optional["ErrorObject"]

    def __init__(
        self,
        message: Optional[str] = None,
        http_body: Optional[Union[bytes, str]] = None,
        http_status: Optional[int] = None,
        json_body: Optional[object] = None,
        headers: Optional[Dict[str, str]] = None,
        code: Optional[str] = None,
    ):
        super(StripeError, self).__init__(message)

        body: Optional[str] = None
        if http_body:
            # http_body can sometimes be a memoryview which must be cast
            # to a "bytes" before calling decode, so we check for the
            # decode attribute and then cast
            if hasattr(http_body, "decode"):
                try:
                    body = cast(bytes, http_body).decode("utf-8")
                except BaseException:
                    body = (
                        "<Could not decode body as utf-8. "
                        "Please report to support@stripe.com>"
                    )
            elif isinstance(http_body, str):
                body = http_body

        self._message = message
        self.http_body = body
        self.http_status = http_status
        self.json_body = json_body
        self.headers = headers or {}
        self.code = code
        self.request_id = self.headers.get("request-id", None)
        self.error = self._construct_error_object()

    def __str__(self):
        msg = self._message or "<empty message>"
        if self.request_id is not None:
            return "Request {0}: {1}".format(self.request_id, msg)
        else:
            return msg

    # Returns the underlying `Exception` (base class) message, which is usually
    # the raw message returned by Stripe's API. This was previously available
    # in python2 via `error.message`. Unlike `str(error)`, it omits "Request
    # req_..." from the beginning of the string.
    @property
    def user_message(self):
        return self._message

    def __repr__(self):
        return "%s(message=%r, http_status=%r, request_id=%r)" % (
            self.__class__.__name__,
            self._message,
            self.http_status,
            self.request_id,
        )

    def _construct_error_object(self) -> Optional[ErrorObject]:
        if (
            self.json_body is None
            or not isinstance(self.json_body, dict)
            or "error" not in self.json_body
            or not isinstance(self.json_body["error"], dict)
        ):
            return None
        from stripe._error_object import ErrorObject

        return ErrorObject._construct_from(
            values=self.json_body["error"],
            requestor=stripe._APIRequestor._global_instance(),
            # We pass in API mode as "V1" here because it's required,
            # but ErrorObject is reused for both V1 and V2 errors.
            api_mode="V1",
        )


class APIError(StripeError):
    pass


class APIConnectionError(StripeError):
    should_retry: bool

    def __init__(
        self,
        message,
        http_body=None,
        http_status=None,
        json_body=None,
        headers=None,
        code=None,
        should_retry=False,
    ):
        super(APIConnectionError, self).__init__(
            message, http_body, http_status, json_body, headers, code
        )
        self.should_retry = should_retry


class StripeErrorWithParamCode(StripeError):
    def __repr__(self):
        return (
            "%s(message=%r, param=%r, code=%r, http_status=%r, "
            "request_id=%r)"
            % (
                self.__class__.__name__,
                self._message,
                self.param,  # pyright: ignore
                self.code,
                self.http_status,
                self.request_id,
            )
        )


class CardError(StripeErrorWithParamCode):
    def __init__(
        self,
        message,
        param,
        code,
        http_body=None,
        http_status=None,
        json_body=None,
        headers=None,
    ):
        super(CardError, self).__init__(
            message, http_body, http_status, json_body, headers, code
        )
        self.param = param


class IdempotencyError(StripeError):
    pass


class InvalidRequestError(StripeErrorWithParamCode):
    def __init__(
        self,
        message,
        param,
        code=None,
        http_body=None,
        http_status=None,
        json_body=None,
        headers=None,
    ):
        super(InvalidRequestError, self).__init__(
            message, http_body, http_status, json_body, headers, code
        )
        self.param = param


class AuthenticationError(StripeError):
    pass


class PermissionError(StripeError):
    pass


class RateLimitError(StripeError):
    pass


class SignatureVerificationError(StripeError):
    def __init__(self, message, sig_header, http_body=None):
        super(SignatureVerificationError, self).__init__(message, http_body)
        self.sig_header = sig_header


# classDefinitions: The beginning of the section generated from our OpenAPI spec
class TemporarySessionExpiredError(StripeError):
    pass


# classDefinitions: The end of the section generated from our OpenAPI spec

1	from typing import Dict, Optional, Union, cast	1✔
2
3	import stripe # noqa	1✔
4	from stripe._error_object import ErrorObject	1✔
5
6
7	class StripeError(Exception):	1✔
8	_message: Optional[str]	1✔
9	http_body: Optional[str]	1✔
10	http_status: Optional[int]	1✔
11	json_body: Optional[object]	1✔
12	headers: Optional[Dict[str, str]]	1✔
13	code: Optional[str]	1✔
14	request_id: Optional[str]	1✔
15	error: Optional["ErrorObject"]	1✔
16
17	def __init__(	1✔
18	self,
19	message: Optional[str] = None,
20	http_body: Optional[Union[bytes, str]] = None,
21	http_status: Optional[int] = None,
22	json_body: Optional[object] = None,
23	headers: Optional[Dict[str, str]] = None,
24	code: Optional[str] = None,
25	):
26	super(StripeError, self).__init__(message)	1✔
27
28	body: Optional[str] = None	1✔
29	if http_body:	1✔
30	# http_body can sometimes be a memoryview which must be cast
31	# to a "bytes" before calling decode, so we check for the
32	# decode attribute and then cast
33	if hasattr(http_body, "decode"):	1✔
34	try:	1✔
35	body = cast(bytes, http_body).decode("utf-8")	1✔
NEW 36	except BaseException:	×
NEW 37	body = (	×
38	"<Could not decode body as utf-8. "
39	"Please report to support@stripe.com>"
40	)
41	elif isinstance(http_body, str):	1!
42	body = http_body	1✔
43
44	self._message = message	1✔
45	self.http_body = body	1✔
46	self.http_status = http_status	1✔
47	self.json_body = json_body	1✔
48	self.headers = headers or {}	1✔
49	self.code = code	1✔
50	self.request_id = self.headers.get("request-id", None)	1✔
51	self.error = self._construct_error_object()	1✔
52
53	def __str__(self):	1✔
54	msg = self._message or "<empty message>"	1✔
55	if self.request_id is not None:	1✔
56	return "Request {0}: {1}".format(self.request_id, msg)	1✔
57	else:
58	return msg	1✔
59
60	# Returns the underlying `Exception` (base class) message, which is usually
61	# the raw message returned by Stripe's API. This was previously available
62	# in python2 via `error.message`. Unlike `str(error)`, it omits "Request
63	# req_..." from the beginning of the string.
64	@property	1✔
65	def user_message(self):	1✔
66	return self._message	1✔
67
68	def __repr__(self):	1✔
69	return "%s(message=%r, http_status=%r, request_id=%r)" % (	1✔
70	self.__class__.__name__,
71	self._message,
72	self.http_status,
73	self.request_id,
74	)
75
76	def _construct_error_object(self) -> Optional[ErrorObject]:	1✔
77	if (	1✔
78	self.json_body is None
79	or not isinstance(self.json_body, dict)
80	or "error" not in self.json_body
81	or not isinstance(self.json_body["error"], dict)
82	):
83	return None	1✔
84	from stripe._error_object import ErrorObject	1✔
85
86	return ErrorObject._construct_from(	1✔
87	values=self.json_body["error"],
88	requestor=stripe._APIRequestor._global_instance(),
89	# We pass in API mode as "V1" here because it's required,
90	# but ErrorObject is reused for both V1 and V2 errors.
91	api_mode="V1",
92	)
93
94
95	class APIError(StripeError):	1✔
96	pass	1✔
97
98
99	class APIConnectionError(StripeError):	1✔
100	should_retry: bool	1✔
101
102	def __init__(	1✔
103	self,
104	message,
105	http_body=None,
106	http_status=None,
107	json_body=None,
108	headers=None,
109	code=None,
110	should_retry=False,
111	):
112	super(APIConnectionError, self).__init__(	1✔
113	message, http_body, http_status, json_body, headers, code
114	)
115	self.should_retry = should_retry	1✔
116
117
118	class StripeErrorWithParamCode(StripeError):	1✔
119	def __repr__(self):	1✔
120	return (	1✔
121	"%s(message=%r, param=%r, code=%r, http_status=%r, "
122	"request_id=%r)"
123	% (
124	self.__class__.__name__,
125	self._message,
126	self.param, # pyright: ignore
127	self.code,
128	self.http_status,
129	self.request_id,
130	)
131	)
132
133
134	class CardError(StripeErrorWithParamCode):	1✔
135	def __init__(	1✔
136	self,
137	message,
138	param,
139	code,
140	http_body=None,
141	http_status=None,
142	json_body=None,
143	headers=None,
144	):
145	super(CardError, self).__init__(	1✔
146	message, http_body, http_status, json_body, headers, code
147	)
148	self.param = param	1✔
149
150
151	class IdempotencyError(StripeError):	1✔
152	pass	1✔
153
154
155	class InvalidRequestError(StripeErrorWithParamCode):	1✔
156	def __init__(	1✔
157	self,
158	message,
159	param,
160	code=None,
161	http_body=None,
162	http_status=None,
163	json_body=None,
164	headers=None,
165	):
166	super(InvalidRequestError, self).__init__(	1✔
167	message, http_body, http_status, json_body, headers, code
168	)
169	self.param = param	1✔
170
171
172	class AuthenticationError(StripeError):	1✔
173	pass	1✔
174
175
176	class PermissionError(StripeError):	1✔
177	pass	1✔
178
179
180	class RateLimitError(StripeError):	1✔
181	pass	1✔
182
183
184	class SignatureVerificationError(StripeError):	1✔
185	def __init__(self, message, sig_header, http_body=None):	1✔
186	super(SignatureVerificationError, self).__init__(message, http_body)	1✔
187	self.sig_header = sig_header	1✔
188
189
190	# classDefinitions: The beginning of the section generated from our OpenAPI spec
191	class TemporarySessionExpiredError(StripeError):	1✔
192	pass	1✔
193
194
195	# classDefinitions: The end of the section generated from our OpenAPI spec

stripe / stripe-python / 12384315441

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

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