ci: regenerated with OpenAPI Doc 0.1.0, Speakeay CLI 0.18.0

Author: speakeasy-ci

gen.yaml

@@ -1,10 +1,10 @@
 management:
     openapi-checksum: 8e8183d84cace76310a3208e63cd7855
     openapi-version: 0.1.0
-    speakeasy-version: 0.17.4
+    speakeasy-version: 0.18.0
 python:
     author: Speakeasy
     description: Speakeasy API Client SDK for Python
     packagename: speakeasy-client-sdk-python
-    version: 0.9.1
+    version: 0.10.0
 telemetryenabled: null

setup.py

@@ -8,7 +8,7 @@
 
 setuptools.setup(
     name="speakeasy-client-sdk-python",
-    version="0.9.1",
+    version="0.10.0",
     author="Speakeasy",
     description="Speakeasy API Client SDK for Python",
     long_description=long_description,

src/sdk/sdk.py

@@ -33,8 +33,8 @@ class SDK:
     _security: shared.Security
     _server_url: str = SERVERS[SERVER_PROD]
     _language: str = "python"
-    _sdk_version: str = "0.9.1"
-    _gen_version: str = "0.17.4"
+    _sdk_version: str = "0.10.0"
+    _gen_version: str = "0.18.0"
 
     def __init__(self) -> None:
         self._client = requests.Session()

src/sdk/utils/__init__.py

@@ -1 +1,2 @@
-from .utils import *
+from .retries import *
+from .utils import *

src/sdk/utils/retries.py

@@ -0,0 +1,116 @@
+import random
+import time
+
+import requests
+
+
+class BackoffStrategy:
+    initial_interval: int
+    max_interval: int
+    exponent: float
+    max_elapsed_time: int
+
+    def __init__(self, initial_interval: int, max_interval: int, exponent: float, max_elapsed_time: int):
+        self.initial_interval = initial_interval
+        self.max_interval = max_interval
+        self.exponent = exponent
+        self.max_elapsed_time = max_elapsed_time
+
+
+class RetryConfig:
+    strategy: str
+    backoff: BackoffStrategy
+    retry_connection_errors: bool
+
+    def __init__(self, strategy: str, retry_connection_errors: bool):
+        self.strategy = strategy
+        self.retry_connection_errors = retry_connection_errors
+
+
+class Retries:
+    config: RetryConfig
+    status_codes: list[str]
+
+    def __init__(self, config: RetryConfig, status_codes: list[str]):
+        self.config = config
+        self.status_codes = status_codes
+
+
+class TemporaryError(Exception):
+    response: requests.Response
+
+    def __init__(self, response: requests.Response):
+        self.response = response
+
+
+class PermanentError(Exception):
+    inner: Exception
+
+    def __init__(self, inner: Exception):
+        self.inner = inner
+
+
+def retry(fn, retries: Retries):
+    if retries.config.strategy == 'backoff':
+        def do_request():
+            res: requests.Response
+            try:
+                res = fn()
+
+                for code in retries.status_codes:
+                    if "X" in code.upper():
+                        codeRange = int(code[0])
+
+                        s = res.status_code / 100
+
+                        if s >= codeRange and s < codeRange + 1:
+                            raise TemporaryError(res)
+                    else:
+                        parsed_code = int(code)
+
+                        if res.status_code == parsed_code:
+                            raise TemporaryError(res)
+            except requests.exceptions.ConnectionError as e:
+                if not retries.config.config.retry_connection_errors:
+                    raise
+                else:
+                    raise PermanentError(e)
+            except requests.exceptions.Timeout as e:
+                if not retries.config.config.retry_connection_errors:
+                    raise
+                else:
+                    raise PermanentError(e)
+            except TemporaryError:
+                raise
+            except Exception as e:
+                raise PermanentError(e)
+
+            return res
+
+        return retry_with_backoff(do_request, retries.config.backoff.initial_interval, retries.config.backoff.max_interval, retries.config.backoff.exponent, retries.config.backoff.max_elapsed_time)
+    else:
+        fn()
+
+
+def retry_with_backoff(fn, initial_interval=500, max_interval=60000, exponent=1.5, max_elapsed_time=3600000):
+    start = round(time.time()*1000)
+    x = 0
+
+    while True:
+        try:
+            return fn()
+        except PermanentError as e:
+            raise e.inner
+        except Exception as e:
+            now = round(time.time()*1000)
+            if now - start > max_elapsed_time:
+                if isinstance(e, TemporaryError):
+                    return e.response
+                else:
+                    raise
+            sleep = ((initial_interval/1000) *
+                     exponent**x + random.uniform(0, 1))
+            if sleep > max_interval/1000:
+                sleep = max_interval/1000
+            time.sleep(sleep)
+            x += 1

src/sdk/utils/utils.py

@@ -4,7 +4,7 @@
 import re
 from dataclasses import Field, dataclass, fields, is_dataclass, make_dataclass
 from datetime import date, datetime
-from typing import Callable, Tuple, Union, get_args, get_origin, Optional
+from typing import Callable, Optional, Tuple, Union, get_args, get_origin
 from xmlrpc.client import boolean
 
 import requests
@@ -368,7 +368,8 @@ def serialize_json(request: dataclass) -> str:
 
 
 def dict_to_dataclass(orig: dict[str, any], dataclass_type: str):
-    cast_type = str(dataclass_type).replace("typing.Optional[", "").replace("]", "")
+    cast_type = str(dataclass_type).replace(
+        "typing.Optional[", "").replace("]", "")
     cast_module = cast_type.split(".")[:-1]
     module = None
     for m in cast_module:
@@ -439,7 +440,8 @@ def serialize_multipart_form(media_type: str, request: dataclass) -> Tuple[str,
                     content = bytes()
 
                     for file_field in file_fields:
-                        file_metadata = file_field.metadata.get('multipart_form')
+                        file_metadata = file_field.metadata.get(
+                            'multipart_form')
                         if file_metadata is None:
                             continue
                         if file_metadata.get("content") is True:
@@ -458,7 +460,8 @@ def serialize_multipart_form(media_type: str, request: dataclass) -> Tuple[str,
                     form.append(to_append)
                 else:
                     val = getattr(field_value, field_value_f.name)
-                    field_name = field_metadata.get("field_name", field_value_f.name)
+                    field_name = field_metadata.get(
+                        "field_name", field_value_f.name)
                     if isinstance(val, list):
                         for value in val:
                             form.append([field_name + "[]", [None, value]])
@@ -477,7 +480,7 @@ def _get_form_field_name(obj_field: Field) -> str:
 
 
 def serialize_dict(original: dict, explode: bool, field_name, existing: Optional[dict[str, list[str]]]) -> dict[
-    str, list[str]]:
+        str, list[str]]:
     if existing is None:
         existing = []
 
@@ -521,7 +524,8 @@ def serialize_form(data: dataclass, meta_string: str) -> dict[str, any]:
                     if "style" not in metadata or ("json" in metadata and metadata["json"] is True):
                         if f_name not in form:
                             form[f_name] = []
-                        form[f_name].append(json.dumps(getattr(field_value, f_name)))
+                        form[f_name].append(json.dumps(
+                            getattr(field_value, f_name)))
                     else:
                         if "style" in metadata and metadata["style"] == "form":
                             form = form | serialize_form(value, "form")