SDK regeneration

Author: fern-api[bot]

.fern/metadata.json

@@ -1,7 +1,7 @@
 {
-  "cliVersion": "4.48.0",
+  "cliVersion": "4.60.0",
   "generatorName": "fernapi/fern-python-sdk",
-  "generatorVersion": "4.63.4",
+  "generatorVersion": "5.2.1",
   "generatorConfig": {
     "pyproject_python_version": "^3.9",
     "inline_request_params": false,
@@ -79,6 +79,6 @@
       }
     ]
   },
-  "originGitCommit": "40f3fd11b9fd6b445b024a2fcf6f2e67f6181147",
-  "sdkVersion": "5.21.2"
+  "originGitCommit": "6feada34ba0a2ce262d54edede0467ac6e99a5c9",
+  "sdkVersion": "5.22.0"
 }

poetry.lock

@@ -4,7 +4,7 @@ dynamic = ["version"]
 
 [tool.poetry]
 name = "cohere"
-version = "5.21.2"
+version = "5.22.0"
 description = ""
 readme = "README.md"
 authors = []
@@ -42,16 +42,16 @@ python = "^3.9"
 fastavro = "^1.9.4"
 httpx = ">=0.21.2"
 pydantic = ">= 1.9.2"
-pydantic-core = ">=2.18.2"
+pydantic-core = ">=2.18.2,<2.44.0"
 requests = "^2.0.0"
 tokenizers = ">=0.15,<1"
 types-requests = "^2.0.0"
 typing_extensions = ">= 4.0.0"
 
 [tool.poetry.group.dev.dependencies]
 mypy = "==1.13.0"
-pytest = "^7.4.0"
-pytest-asyncio = "^0.23.5"
+pytest = "^8.2.0"
+pytest-asyncio = "^1.0.0"
 pytest-xdist = "^3.6.1"
 python-dateutil = "^2.9.0"
 types-python-dateutil = "^2.9.0.20240316"

pyproject.toml

@@ -1,7 +1,7 @@
 fastavro==1.9.4
 httpx>=0.21.2
 pydantic>= 1.9.2
-pydantic-core>=2.18.2
+pydantic-core>=2.18.2,<2.44.0
 requests==2.0.0
 tokenizers>=0.15,<1
 types-requests==2.0.0

requirements.txt

@@ -1604,6 +1604,9 @@ class AsyncBaseCohere:
     headers : typing.Optional[typing.Dict[str, str]]
         Additional headers to send with every request.
 
+    async_token : typing.Optional[typing.Callable[[], typing.Awaitable[str]]]
+        An async callable that returns a bearer token. Use this when token acquisition involves async I/O (e.g., refreshing tokens via an async HTTP client). When provided, this is used instead of the synchronous token for async requests.
+
     timeout : typing.Optional[float]
         The timeout to be used, in seconds, for requests. By default the timeout is 300 seconds, unless a custom httpx client is used, in which case this default is not enforced.
 
@@ -1634,6 +1637,7 @@ def __init__(
         client_name: typing.Optional[str] = None,
         token: typing.Optional[typing.Union[str, typing.Callable[[], str]]] = os.getenv("CO_API_KEY"),
         headers: typing.Optional[typing.Dict[str, str]] = None,
+        async_token: typing.Optional[typing.Callable[[], typing.Awaitable[str]]] = None,
         timeout: typing.Optional[float] = None,
         follow_redirects: typing.Optional[bool] = True,
         httpx_client: typing.Optional[httpx.AsyncClient] = None,
@@ -1649,6 +1653,7 @@ def __init__(
             client_name=client_name,
             token=token,
             headers=headers,
+            async_token=async_token,
             httpx_client=httpx_client
             if httpx_client is not None
             else httpx.AsyncClient(timeout=_defaulted_timeout, follow_redirects=follow_redirects)

src/cohere/base_client.py

@@ -3,3 +3,6 @@
 import typing
 
 CancelBatchResponse = typing.Dict[str, typing.Any]
+"""
+Response to a request to cancel a batch.
+"""

src/cohere/batches/types/cancel_batch_response.py

@@ -29,12 +29,12 @@ def get_headers(self) -> typing.Dict[str, str]:
         import platform
 
         headers: typing.Dict[str, str] = {
-            "User-Agent": "cohere/5.21.2",
+            "User-Agent": "cohere/5.22.0",
             "X-Fern-Language": "Python",
             "X-Fern-Runtime": f"python/{platform.python_version()}",
             "X-Fern-Platform": f"{platform.system().lower()}/{platform.release()}",
             "X-Fern-SDK-Name": "cohere",
-            "X-Fern-SDK-Version": "5.21.2",
+            "X-Fern-SDK-Version": "5.22.0",
             **(self.get_custom_headers() or {}),
         }
         if self._client_name is not None:

src/cohere/core/client_wrapper.py

@@ -118,6 +118,12 @@ def _retry_timeout(response: httpx.Response, retries: int) -> float:
     return _add_symmetric_jitter(backoff)
 
 
+def _retry_timeout_from_retries(retries: int) -> float:
+    """Determine retry timeout using exponential backoff when no response is available."""
+    backoff = min(INITIAL_RETRY_DELAY_SECONDS * pow(2.0, retries), MAX_RETRY_DELAY_SECONDS)
+    return _add_symmetric_jitter(backoff)
+
+
 def _should_retry(response: httpx.Response) -> bool:
     retryable_400s = [429, 408, 409]
     return response.status_code >= 500 or response.status_code in retryable_400s
@@ -265,11 +271,13 @@ def __init__(
         base_timeout: typing.Callable[[], typing.Optional[float]],
         base_headers: typing.Callable[[], typing.Dict[str, str]],
         base_url: typing.Optional[typing.Callable[[], str]] = None,
+        base_max_retries: int = 2,
         logging_config: typing.Optional[typing.Union[LogConfig, Logger]] = None,
     ):
         self.base_url = base_url
         self.base_timeout = base_timeout
         self.base_headers = base_headers
+        self.base_max_retries = base_max_retries
         self.httpx_client = httpx_client
         self.logger = create_logger(logging_config)
 
@@ -364,19 +372,44 @@ def request(
                 has_body=json_body is not None or data_body is not None,
             )
 
-        response = self.httpx_client.request(
-            method=method,
-            url=_request_url,
-            headers=_request_headers,
-            params=_encoded_params if _encoded_params else None,
-            json=json_body,
-            data=data_body,
-            content=content,
-            files=request_files,
-            timeout=timeout,
+        max_retries: int = (
+            request_options.get("max_retries", self.base_max_retries)
+            if request_options is not None
+            else self.base_max_retries
         )
 
-        max_retries: int = request_options.get("max_retries", 2) if request_options is not None else 2
+        try:
+            response = self.httpx_client.request(
+                method=method,
+                url=_request_url,
+                headers=_request_headers,
+                params=_encoded_params if _encoded_params else None,
+                json=json_body,
+                data=data_body,
+                content=content,
+                files=request_files,
+                timeout=timeout,
+            )
+        except (httpx.ConnectError, httpx.RemoteProtocolError):
+            if retries < max_retries:
+                time.sleep(_retry_timeout_from_retries(retries=retries))
+                return self.request(
+                    path=path,
+                    method=method,
+                    base_url=base_url,
+                    params=params,
+                    json=json,
+                    data=data,
+                    content=content,
+                    files=files,
+                    headers=headers,
+                    request_options=request_options,
+                    retries=retries + 1,
+                    omit=omit,
+                    force_multipart=force_multipart,
+                )
+            raise
+
         if _should_retry(response=response):
             if retries < max_retries:
                 time.sleep(_retry_timeout(response=response, retries=retries))
@@ -386,12 +419,14 @@ def request(
                     base_url=base_url,
                     params=params,
                     json=json,
+                    data=data,
                     content=content,
                     files=files,
                     headers=headers,
                     request_options=request_options,
                     retries=retries + 1,
                     omit=omit,
+                    force_multipart=force_multipart,
                 )
 
         if self.logger.is_debug():
@@ -518,12 +553,14 @@ def __init__(
         base_timeout: typing.Callable[[], typing.Optional[float]],
         base_headers: typing.Callable[[], typing.Dict[str, str]],
         base_url: typing.Optional[typing.Callable[[], str]] = None,
+        base_max_retries: int = 2,
         async_base_headers: typing.Optional[typing.Callable[[], typing.Awaitable[typing.Dict[str, str]]]] = None,
         logging_config: typing.Optional[typing.Union[LogConfig, Logger]] = None,
     ):
         self.base_url = base_url
         self.base_timeout = base_timeout
         self.base_headers = base_headers
+        self.base_max_retries = base_max_retries
         self.async_base_headers = async_base_headers
         self.httpx_client = httpx_client
         self.logger = create_logger(logging_config)
@@ -627,19 +664,44 @@ async def request(
                 has_body=json_body is not None or data_body is not None,
             )
 
-        response = await self.httpx_client.request(
-            method=method,
-            url=_request_url,
-            headers=_request_headers,
-            params=_encoded_params if _encoded_params else None,
-            json=json_body,
-            data=data_body,
-            content=content,
-            files=request_files,
-            timeout=timeout,
+        max_retries: int = (
+            request_options.get("max_retries", self.base_max_retries)
+            if request_options is not None
+            else self.base_max_retries
         )
 
-        max_retries: int = request_options.get("max_retries", 2) if request_options is not None else 2
+        try:
+            response = await self.httpx_client.request(
+                method=method,
+                url=_request_url,
+                headers=_request_headers,
+                params=_encoded_params if _encoded_params else None,
+                json=json_body,
+                data=data_body,
+                content=content,
+                files=request_files,
+                timeout=timeout,
+            )
+        except (httpx.ConnectError, httpx.RemoteProtocolError):
+            if retries < max_retries:
+                await asyncio.sleep(_retry_timeout_from_retries(retries=retries))
+                return await self.request(
+                    path=path,
+                    method=method,
+                    base_url=base_url,
+                    params=params,
+                    json=json,
+                    data=data,
+                    content=content,
+                    files=files,
+                    headers=headers,
+                    request_options=request_options,
+                    retries=retries + 1,
+                    omit=omit,
+                    force_multipart=force_multipart,
+                )
+            raise
+
         if _should_retry(response=response):
             if retries < max_retries:
                 await asyncio.sleep(_retry_timeout(response=response, retries=retries))
@@ -649,12 +711,14 @@ async def request(
                     base_url=base_url,
                     params=params,
                     json=json,
+                    data=data,
                     content=content,
                     files=files,
                     headers=headers,
                     request_options=request_options,
                     retries=retries + 1,
                     omit=omit,
+                    force_multipart=force_multipart,
                 )
 
         if self.logger.is_debug():