scale-gp-beta 0.1.0a29__py3-none-any.whl → 0.1.0a31__py3-none-any.whl

scale_gp_beta/_utils/__init__.py

@@ -10,7 +10,6 @@ from ._utils import (
     lru_cache as lru_cache,
     is_mapping as is_mapping,
     is_tuple_t as is_tuple_t,
-    parse_date as parse_date,
     is_iterable as is_iterable,
     is_sequence as is_sequence,
     coerce_float as coerce_float,
@@ -23,7 +22,6 @@ from ._utils import (
     coerce_boolean as coerce_boolean,
     coerce_integer as coerce_integer,
     file_from_path as file_from_path,
-    parse_datetime as parse_datetime,
     strip_not_given as strip_not_given,
     deepcopy_minimal as deepcopy_minimal,
     get_async_library as get_async_library,
@@ -32,12 +30,20 @@ from ._utils import (
     maybe_coerce_boolean as maybe_coerce_boolean,
     maybe_coerce_integer as maybe_coerce_integer,
 )
+from ._compat import (
+    get_args as get_args,
+    is_union as is_union,
+    get_origin as get_origin,
+    is_typeddict as is_typeddict,
+    is_literal_type as is_literal_type,
+)
 from ._typing import (
     is_list_type as is_list_type,
     is_union_type as is_union_type,
     extract_type_arg as extract_type_arg,
     is_iterable_type as is_iterable_type,
     is_required_type as is_required_type,
+    is_sequence_type as is_sequence_type,
     is_annotated_type as is_annotated_type,
     is_type_alias_type as is_type_alias_type,
     strip_annotated_type as strip_annotated_type,
@@ -55,3 +61,4 @@ from ._reflection import (
     function_has_argument as function_has_argument,
     assert_signatures_in_sync as assert_signatures_in_sync,
 )
+from ._datetime_parse import parse_date as parse_date, parse_datetime as parse_datetime

scale_gp_beta/_utils/_compat.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import sys
+import typing_extensions
+from typing import Any, Type, Union, Literal, Optional
+from datetime import date, datetime
+from typing_extensions import get_args as _get_args, get_origin as _get_origin
+
+from .._types import StrBytesIntFloat
+from ._datetime_parse import parse_date as _parse_date, parse_datetime as _parse_datetime
+
+_LITERAL_TYPES = {Literal, typing_extensions.Literal}
+
+
+def get_args(tp: type[Any]) -> tuple[Any, ...]:
+    return _get_args(tp)
+
+
+def get_origin(tp: type[Any]) -> type[Any] | None:
+    return _get_origin(tp)
+
+
+def is_union(tp: Optional[Type[Any]]) -> bool:
+    if sys.version_info < (3, 10):
+        return tp is Union  # type: ignore[comparison-overlap]
+    else:
+        import types
+
+        return tp is Union or tp is types.UnionType
+
+
+def is_typeddict(tp: Type[Any]) -> bool:
+    return typing_extensions.is_typeddict(tp)
+
+
+def is_literal_type(tp: Type[Any]) -> bool:
+    return get_origin(tp) in _LITERAL_TYPES
+
+
+def parse_date(value: Union[date, StrBytesIntFloat]) -> date:
+    return _parse_date(value)
+
+
+def parse_datetime(value: Union[datetime, StrBytesIntFloat]) -> datetime:
+    return _parse_datetime(value)

scale_gp_beta/_utils/_datetime_parse.py

@@ -0,0 +1,136 @@
+"""
+This file contains code from https://github.com/pydantic/pydantic/blob/main/pydantic/v1/datetime_parse.py
+without the Pydantic v1 specific errors.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Dict, Union, Optional
+from datetime import date, datetime, timezone, timedelta
+
+from .._types import StrBytesIntFloat
+
+date_expr = r"(?P<year>\d{4})-(?P<month>\d{1,2})-(?P<day>\d{1,2})"
+time_expr = (
+    r"(?P<hour>\d{1,2}):(?P<minute>\d{1,2})"
+    r"(?::(?P<second>\d{1,2})(?:\.(?P<microsecond>\d{1,6})\d{0,6})?)?"
+    r"(?P<tzinfo>Z|[+-]\d{2}(?::?\d{2})?)?$"
+)
+
+date_re = re.compile(f"{date_expr}$")
+datetime_re = re.compile(f"{date_expr}[T ]{time_expr}")
+
+
+EPOCH = datetime(1970, 1, 1)
+# if greater than this, the number is in ms, if less than or equal it's in seconds
+# (in seconds this is 11th October 2603, in ms it's 20th August 1970)
+MS_WATERSHED = int(2e10)
+# slightly more than datetime.max in ns - (datetime.max - EPOCH).total_seconds() * 1e9
+MAX_NUMBER = int(3e20)
+
+
+def _get_numeric(value: StrBytesIntFloat, native_expected_type: str) -> Union[None, int, float]:
+    if isinstance(value, (int, float)):
+        return value
+    try:
+        return float(value)
+    except ValueError:
+        return None
+    except TypeError:
+        raise TypeError(f"invalid type; expected {native_expected_type}, string, bytes, int or float") from None
+
+
+def _from_unix_seconds(seconds: Union[int, float]) -> datetime:
+    if seconds > MAX_NUMBER:
+        return datetime.max
+    elif seconds < -MAX_NUMBER:
+        return datetime.min
+
+    while abs(seconds) > MS_WATERSHED:
+        seconds /= 1000
+    dt = EPOCH + timedelta(seconds=seconds)
+    return dt.replace(tzinfo=timezone.utc)
+
+
+def _parse_timezone(value: Optional[str]) -> Union[None, int, timezone]:
+    if value == "Z":
+        return timezone.utc
+    elif value is not None:
+        offset_mins = int(value[-2:]) if len(value) > 3 else 0
+        offset = 60 * int(value[1:3]) + offset_mins
+        if value[0] == "-":
+            offset = -offset
+        return timezone(timedelta(minutes=offset))
+    else:
+        return None
+
+
+def parse_datetime(value: Union[datetime, StrBytesIntFloat]) -> datetime:
+    """
+    Parse a datetime/int/float/string and return a datetime.datetime.
+
+    This function supports time zone offsets. When the input contains one,
+    the output uses a timezone with a fixed offset from UTC.
+
+    Raise ValueError if the input is well formatted but not a valid datetime.
+    Raise ValueError if the input isn't well formatted.
+    """
+    if isinstance(value, datetime):
+        return value
+
+    number = _get_numeric(value, "datetime")
+    if number is not None:
+        return _from_unix_seconds(number)
+
+    if isinstance(value, bytes):
+        value = value.decode()
+
+    assert not isinstance(value, (float, int))
+
+    match = datetime_re.match(value)
+    if match is None:
+        raise ValueError("invalid datetime format")
+
+    kw = match.groupdict()
+    if kw["microsecond"]:
+        kw["microsecond"] = kw["microsecond"].ljust(6, "0")
+
+    tzinfo = _parse_timezone(kw.pop("tzinfo"))
+    kw_: Dict[str, Union[None, int, timezone]] = {k: int(v) for k, v in kw.items() if v is not None}
+    kw_["tzinfo"] = tzinfo
+
+    return datetime(**kw_)  # type: ignore
+
+
+def parse_date(value: Union[date, StrBytesIntFloat]) -> date:
+    """
+    Parse a date/int/float/string and return a datetime.date.
+
+    Raise ValueError if the input is well formatted but not a valid date.
+    Raise ValueError if the input isn't well formatted.
+    """
+    if isinstance(value, date):
+        if isinstance(value, datetime):
+            return value.date()
+        else:
+            return value
+
+    number = _get_numeric(value, "date")
+    if number is not None:
+        return _from_unix_seconds(number).date()
+
+    if isinstance(value, bytes):
+        value = value.decode()
+
+    assert not isinstance(value, (float, int))
+    match = date_re.match(value)
+    if match is None:
+        raise ValueError("invalid date format")
+
+    kw = {k: int(v) for k, v in match.groupdict().items()}
+
+    try:
+        return date(**kw)
+    except ValueError:
+        raise ValueError("invalid date format") from None

scale_gp_beta/_utils/_transform.py

@@ -16,18 +16,20 @@ from ._utils import (
     lru_cache,
     is_mapping,
     is_iterable,
+    is_sequence,
 )
 from .._files import is_base64_file_input
+from ._compat import get_origin, is_typeddict
 from ._typing import (
     is_list_type,
     is_union_type,
     extract_type_arg,
     is_iterable_type,
     is_required_type,
+    is_sequence_type,
     is_annotated_type,
     strip_annotated_type,
 )
-from .._compat import get_origin, model_dump, is_typeddict
 
 _T = TypeVar("_T")
 
@@ -167,6 +169,8 @@ def _transform_recursive(
 
             Defaults to the same value as the `annotation` argument.
     """
+    from .._compat import model_dump
+
     if inner_type is None:
         inner_type = annotation
 
@@ -184,6 +188,8 @@ def _transform_recursive(
         (is_list_type(stripped_type) and is_list(data))
         # Iterable[T]
         or (is_iterable_type(stripped_type) and is_iterable(data) and not isinstance(data, str))
+        # Sequence[T]
+        or (is_sequence_type(stripped_type) and is_sequence(data) and not isinstance(data, str))
     ):
         # dicts are technically iterable, but it is an iterable on the keys of the dict and is not usually
         # intended as an iterable, so we don't transform it.
@@ -329,6 +335,8 @@ async def _async_transform_recursive(
 
             Defaults to the same value as the `annotation` argument.
     """
+    from .._compat import model_dump
+
     if inner_type is None:
         inner_type = annotation
 
@@ -346,6 +354,8 @@ async def _async_transform_recursive(
         (is_list_type(stripped_type) and is_list(data))
         # Iterable[T]
         or (is_iterable_type(stripped_type) and is_iterable(data) and not isinstance(data, str))
+        # Sequence[T]
+        or (is_sequence_type(stripped_type) and is_sequence(data) and not isinstance(data, str))
     ):
         # dicts are technically iterable, but it is an iterable on the keys of the dict and is not usually
         # intended as an iterable, so we don't transform it.

scale_gp_beta/_utils/_typing.py

@@ -15,7 +15,7 @@ from typing_extensions import (
 
 from ._utils import lru_cache
 from .._types import InheritsGeneric
-from .._compat import is_union as _is_union
+from ._compat import is_union as _is_union
 
 
 def is_annotated_type(typ: type) -> bool:
@@ -26,6 +26,11 @@ def is_list_type(typ: type) -> bool:
     return (get_origin(typ) or typ) == list
 
 
+def is_sequence_type(typ: type) -> bool:
+    origin = get_origin(typ) or typ
+    return origin == typing_extensions.Sequence or origin == typing.Sequence or origin == _c_abc.Sequence
+
+
 def is_iterable_type(typ: type) -> bool:
     """If the given type is `typing.Iterable[T]`"""
     origin = get_origin(typ) or typ

scale_gp_beta/_utils/_utils.py

@@ -22,7 +22,6 @@ from typing_extensions import TypeGuard
 import sniffio
 
 from .._types import NotGiven, FileTypes, NotGivenOr, HeadersLike
-from .._compat import parse_date as parse_date, parse_datetime as parse_datetime
 
 _T = TypeVar("_T")
 _TupleT = TypeVar("_TupleT", bound=Tuple[object, ...])

scale_gp_beta/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "scale_gp_beta"
-__version__ = "0.1.0-alpha.29"  # x-release-please-version
+__version__ = "0.1.0-alpha.31"  # x-release-please-version

scale_gp_beta/lib/CONTRIBUTING.MD

@@ -0,0 +1,53 @@
+# Custom Code Patch
+You can in theory add custom code patches to anywhere in the repo but at the risk of encountering many merge conflicts with Stainless into the future.
+Stainless will never use the `/lib` and `/examples` directories. When possible try to only modify these directories.
+If you have to add custom code elsewhere, please keep the footprint small and create a library for most of the logic.
+
+
+For information on custom code patching with Stainless see [here](https://www.stainless.com/docs/guides/add-custom-code).
+
+# Process for Adding Features
+Checkout the `next` branch and pull, then create a branch from `next`.
+
+> **_NOTE:_** Stainless uses next to "queue up" updates to the SDK.
+> 
+> Stainless will update next with their own logic updates to the SDK along with any changes in the OpenAPI spec and changes to the Stainless
+config on their SaaS platform.
+
+Make any code changes you need. Ensuring all the tests for the library are passing.
+
+There is strict linting in this repo. Use the following commands in order.
+
+```bash
+rye lint --fix
+```
+
+```bash
+rye run lint | grep /specific_file.py
+```
+
+`rye run lint` will not work if there are errors with `rye lint --fix`.
+I am unsure why but I get many errors which are ignorable in the rest of the repo when running `rye run lint` so I usually use it
+with grep to target the file I am developing.
+
+> **_NOTE:_** The strict linting requires all types to be strictly typed. This can be a pain but is worth considering before developing any new solution.
+> Try and avoid using ignore commands when possible, but sometimes it is unavoidable (see OpenAI tracing Plugin).
+
+When commiting, use the [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) spec. Usually this is something like:
+
+```bash
+git commit -m "feat: Added OpenAI tracing processor"
+```
+This allow Stainless to update the release doc with more useful info.
+
+**When creating a PR, you must manually change the destination from `main` to `next`.**
+
+Once merged, Stainless should pick up the changes and update or create a new PR for `main`.
+You will need to accept changes on this PR, Stainless should then auto merge. Note on occasion I have had to manually merge.
+There was no consequence to this.
+
+These PRs Stainless makes have 4 types of changes, all are merged to main via these automatic PR requests:
+1. Custom Code Changes
+2. Stainless SDK logic changes
+3. Changes to the Stainless Config in the SaaS platform
+4. Changes to the OpenAPI schema

scale_gp_beta/lib/tracing/trace_queue_manager.py

@@ -11,6 +11,8 @@ from .util import configure, is_disabled
 from .trace_exporter import TraceExporter
 
 if TYPE_CHECKING:
+    import httpx
+
     from .span import Span
     from .trace import Trace
 
@@ -44,6 +46,7 @@ class TraceQueueManager:
         worker_enabled: Optional[bool] = None,
     ):
         self._client = client
+        self.register_client(client) if client else None
         self._attempted_local_client_creation = False
         self._trigger_queue_size = trigger_queue_size
         self._trigger_cadence = trigger_cadence
@@ -68,6 +71,17 @@ class TraceQueueManager:
         log.info("Registering client")
         self._client = client
 
+        original_prepare_request = self._client._prepare_request
+
+        def custom_prepare_request(request: "httpx.Request") -> None:
+            original_prepare_request(request)
+
+            # TODO: Hook logic here, we should check to see if we are in the scope of a span, if so we should inject
+            # appropriate headers into the request
+            # current_span = Scope.get_current_span()
+
+        self._client._prepare_request = custom_prepare_request  # type: ignore
+
     def shutdown(self, timeout: Optional[float] = None) -> None:
         if not self._worker_enabled:
             log.debug("No worker to shutdown")

scale_gp_beta/resources/__init__.py

@@ -56,6 +56,14 @@ from .questions import (
     QuestionsResourceWithStreamingResponse,
     AsyncQuestionsResourceWithStreamingResponse,
 )
+from .responses import (
+    ResponsesResource,
+    AsyncResponsesResource,
+    ResponsesResourceWithRawResponse,
+    AsyncResponsesResourceWithRawResponse,
+    ResponsesResourceWithStreamingResponse,
+    AsyncResponsesResourceWithStreamingResponse,
+)
 from .completions import (
     CompletionsResource,
     AsyncCompletionsResource,
@@ -90,6 +98,12 @@ from .evaluation_items import (
 )
 
 __all__ = [
+    "ResponsesResource",
+    "AsyncResponsesResource",
+    "ResponsesResourceWithRawResponse",
+    "AsyncResponsesResourceWithRawResponse",
+    "ResponsesResourceWithStreamingResponse",
+    "AsyncResponsesResourceWithStreamingResponse",
     "CompletionsResource",
     "AsyncCompletionsResource",
     "CompletionsResourceWithRawResponse",
@@ -132,18 +146,18 @@ __all__ = [
     "AsyncDatasetsResourceWithRawResponse",
     "DatasetsResourceWithStreamingResponse",
     "AsyncDatasetsResourceWithStreamingResponse",
-    "EvaluationsResource",
-    "AsyncEvaluationsResource",
-    "EvaluationsResourceWithRawResponse",
-    "AsyncEvaluationsResourceWithRawResponse",
-    "EvaluationsResourceWithStreamingResponse",
-    "AsyncEvaluationsResourceWithStreamingResponse",
     "DatasetItemsResource",
     "AsyncDatasetItemsResource",
     "DatasetItemsResourceWithRawResponse",
     "AsyncDatasetItemsResourceWithRawResponse",
     "DatasetItemsResourceWithStreamingResponse",
     "AsyncDatasetItemsResourceWithStreamingResponse",
+    "EvaluationsResource",
+    "AsyncEvaluationsResource",
+    "EvaluationsResourceWithRawResponse",
+    "AsyncEvaluationsResourceWithRawResponse",
+    "EvaluationsResourceWithStreamingResponse",
+    "AsyncEvaluationsResourceWithStreamingResponse",
     "EvaluationItemsResource",
     "AsyncEvaluationItemsResource",
     "EvaluationItemsResourceWithRawResponse",

scale_gp_beta/resources/chat/completions.py

@@ -2,12 +2,12 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict, List, Union, Iterable, cast
+from typing import Any, Dict, Union, Iterable, cast
 from typing_extensions import Literal, overload
 
 import httpx
 
-from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven, SequenceNotStr
 from ..._utils import required_args, maybe_transform, async_maybe_transform
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
@@ -62,7 +62,7 @@ class CompletionsResource(SyncAPIResource):
         max_completion_tokens: int | NotGiven = NOT_GIVEN,
         max_tokens: int | NotGiven = NOT_GIVEN,
         metadata: Dict[str, str] | NotGiven = NOT_GIVEN,
-        modalities: List[str] | NotGiven = NOT_GIVEN,
+        modalities: SequenceNotStr[str] | NotGiven = NOT_GIVEN,
         n: int | NotGiven = NOT_GIVEN,
         parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
         prediction: Dict[str, object] | NotGiven = NOT_GIVEN,
@@ -70,7 +70,7 @@ class CompletionsResource(SyncAPIResource):
         reasoning_effort: str | NotGiven = NOT_GIVEN,
         response_format: Dict[str, object] | NotGiven = NOT_GIVEN,
         seed: int | NotGiven = NOT_GIVEN,
-        stop: Union[str, List[str]] | NotGiven = NOT_GIVEN,
+        stop: Union[str, SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         store: bool | NotGiven = NOT_GIVEN,
         stream: Literal[False] | NotGiven = NOT_GIVEN,
         stream_options: Dict[str, object] | NotGiven = NOT_GIVEN,
@@ -191,7 +191,7 @@ class CompletionsResource(SyncAPIResource):
         max_completion_tokens: int | NotGiven = NOT_GIVEN,
         max_tokens: int | NotGiven = NOT_GIVEN,
         metadata: Dict[str, str] | NotGiven = NOT_GIVEN,
-        modalities: List[str] | NotGiven = NOT_GIVEN,
+        modalities: SequenceNotStr[str] | NotGiven = NOT_GIVEN,
         n: int | NotGiven = NOT_GIVEN,
         parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
         prediction: Dict[str, object] | NotGiven = NOT_GIVEN,
@@ -199,7 +199,7 @@ class CompletionsResource(SyncAPIResource):
         reasoning_effort: str | NotGiven = NOT_GIVEN,
         response_format: Dict[str, object] | NotGiven = NOT_GIVEN,
         seed: int | NotGiven = NOT_GIVEN,
-        stop: Union[str, List[str]] | NotGiven = NOT_GIVEN,
+        stop: Union[str, SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         store: bool | NotGiven = NOT_GIVEN,
         stream_options: Dict[str, object] | NotGiven = NOT_GIVEN,
         temperature: float | NotGiven = NOT_GIVEN,
@@ -319,7 +319,7 @@ class CompletionsResource(SyncAPIResource):
         max_completion_tokens: int | NotGiven = NOT_GIVEN,
         max_tokens: int | NotGiven = NOT_GIVEN,
         metadata: Dict[str, str] | NotGiven = NOT_GIVEN,
-        modalities: List[str] | NotGiven = NOT_GIVEN,
+        modalities: SequenceNotStr[str] | NotGiven = NOT_GIVEN,
         n: int | NotGiven = NOT_GIVEN,
         parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
         prediction: Dict[str, object] | NotGiven = NOT_GIVEN,
@@ -327,7 +327,7 @@ class CompletionsResource(SyncAPIResource):
         reasoning_effort: str | NotGiven = NOT_GIVEN,
         response_format: Dict[str, object] | NotGiven = NOT_GIVEN,
         seed: int | NotGiven = NOT_GIVEN,
-        stop: Union[str, List[str]] | NotGiven = NOT_GIVEN,
+        stop: Union[str, SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         store: bool | NotGiven = NOT_GIVEN,
         stream_options: Dict[str, object] | NotGiven = NOT_GIVEN,
         temperature: float | NotGiven = NOT_GIVEN,
@@ -446,7 +446,7 @@ class CompletionsResource(SyncAPIResource):
         max_completion_tokens: int | NotGiven = NOT_GIVEN,
         max_tokens: int | NotGiven = NOT_GIVEN,
         metadata: Dict[str, str] | NotGiven = NOT_GIVEN,
-        modalities: List[str] | NotGiven = NOT_GIVEN,
+        modalities: SequenceNotStr[str] | NotGiven = NOT_GIVEN,
         n: int | NotGiven = NOT_GIVEN,
         parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
         prediction: Dict[str, object] | NotGiven = NOT_GIVEN,
@@ -454,7 +454,7 @@ class CompletionsResource(SyncAPIResource):
         reasoning_effort: str | NotGiven = NOT_GIVEN,
         response_format: Dict[str, object] | NotGiven = NOT_GIVEN,
         seed: int | NotGiven = NOT_GIVEN,
-        stop: Union[str, List[str]] | NotGiven = NOT_GIVEN,
+        stop: Union[str, SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         store: bool | NotGiven = NOT_GIVEN,
         stream: Literal[False] | Literal[True] | NotGiven = NOT_GIVEN,
         stream_options: Dict[str, object] | NotGiven = NOT_GIVEN,
@@ -522,6 +522,7 @@ class CompletionsResource(SyncAPIResource):
     def models(
         self,
         *,
+        check_availability: bool | NotGiven = NOT_GIVEN,
         ending_before: str | NotGiven = NOT_GIVEN,
         limit: int | NotGiven = NOT_GIVEN,
         model_vendor: Literal[
@@ -569,6 +570,7 @@ class CompletionsResource(SyncAPIResource):
                 timeout=timeout,
                 query=maybe_transform(
                     {
+                        "check_availability": check_availability,
                         "ending_before": ending_before,
                         "limit": limit,
                         "model_vendor": model_vendor,
@@ -617,7 +619,7 @@ class AsyncCompletionsResource(AsyncAPIResource):
         max_completion_tokens: int | NotGiven = NOT_GIVEN,
         max_tokens: int | NotGiven = NOT_GIVEN,
         metadata: Dict[str, str] | NotGiven = NOT_GIVEN,
-        modalities: List[str] | NotGiven = NOT_GIVEN,
+        modalities: SequenceNotStr[str] | NotGiven = NOT_GIVEN,
         n: int | NotGiven = NOT_GIVEN,
         parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
         prediction: Dict[str, object] | NotGiven = NOT_GIVEN,
@@ -625,7 +627,7 @@ class AsyncCompletionsResource(AsyncAPIResource):
         reasoning_effort: str | NotGiven = NOT_GIVEN,
         response_format: Dict[str, object] | NotGiven = NOT_GIVEN,
         seed: int | NotGiven = NOT_GIVEN,
-        stop: Union[str, List[str]] | NotGiven = NOT_GIVEN,
+        stop: Union[str, SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         store: bool | NotGiven = NOT_GIVEN,
         stream: Literal[False] | NotGiven = NOT_GIVEN,
         stream_options: Dict[str, object] | NotGiven = NOT_GIVEN,
@@ -746,7 +748,7 @@ class AsyncCompletionsResource(AsyncAPIResource):
         max_completion_tokens: int | NotGiven = NOT_GIVEN,
         max_tokens: int | NotGiven = NOT_GIVEN,
         metadata: Dict[str, str] | NotGiven = NOT_GIVEN,
-        modalities: List[str] | NotGiven = NOT_GIVEN,
+        modalities: SequenceNotStr[str] | NotGiven = NOT_GIVEN,
         n: int | NotGiven = NOT_GIVEN,
         parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
         prediction: Dict[str, object] | NotGiven = NOT_GIVEN,
@@ -754,7 +756,7 @@ class AsyncCompletionsResource(AsyncAPIResource):
         reasoning_effort: str | NotGiven = NOT_GIVEN,
         response_format: Dict[str, object] | NotGiven = NOT_GIVEN,
         seed: int | NotGiven = NOT_GIVEN,
-        stop: Union[str, List[str]] | NotGiven = NOT_GIVEN,
+        stop: Union[str, SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         store: bool | NotGiven = NOT_GIVEN,
         stream_options: Dict[str, object] | NotGiven = NOT_GIVEN,
         temperature: float | NotGiven = NOT_GIVEN,
@@ -874,7 +876,7 @@ class AsyncCompletionsResource(AsyncAPIResource):
         max_completion_tokens: int | NotGiven = NOT_GIVEN,
         max_tokens: int | NotGiven = NOT_GIVEN,
         metadata: Dict[str, str] | NotGiven = NOT_GIVEN,
-        modalities: List[str] | NotGiven = NOT_GIVEN,
+        modalities: SequenceNotStr[str] | NotGiven = NOT_GIVEN,
         n: int | NotGiven = NOT_GIVEN,
         parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
         prediction: Dict[str, object] | NotGiven = NOT_GIVEN,
@@ -882,7 +884,7 @@ class AsyncCompletionsResource(AsyncAPIResource):
         reasoning_effort: str | NotGiven = NOT_GIVEN,
         response_format: Dict[str, object] | NotGiven = NOT_GIVEN,
         seed: int | NotGiven = NOT_GIVEN,
-        stop: Union[str, List[str]] | NotGiven = NOT_GIVEN,
+        stop: Union[str, SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         store: bool | NotGiven = NOT_GIVEN,
         stream_options: Dict[str, object] | NotGiven = NOT_GIVEN,
         temperature: float | NotGiven = NOT_GIVEN,
@@ -1001,7 +1003,7 @@ class AsyncCompletionsResource(AsyncAPIResource):
         max_completion_tokens: int | NotGiven = NOT_GIVEN,
         max_tokens: int | NotGiven = NOT_GIVEN,
         metadata: Dict[str, str] | NotGiven = NOT_GIVEN,
-        modalities: List[str] | NotGiven = NOT_GIVEN,
+        modalities: SequenceNotStr[str] | NotGiven = NOT_GIVEN,
         n: int | NotGiven = NOT_GIVEN,
         parallel_tool_calls: bool | NotGiven = NOT_GIVEN,
         prediction: Dict[str, object] | NotGiven = NOT_GIVEN,
@@ -1009,7 +1011,7 @@ class AsyncCompletionsResource(AsyncAPIResource):
         reasoning_effort: str | NotGiven = NOT_GIVEN,
         response_format: Dict[str, object] | NotGiven = NOT_GIVEN,
         seed: int | NotGiven = NOT_GIVEN,
-        stop: Union[str, List[str]] | NotGiven = NOT_GIVEN,
+        stop: Union[str, SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         store: bool | NotGiven = NOT_GIVEN,
         stream: Literal[False] | Literal[True] | NotGiven = NOT_GIVEN,
         stream_options: Dict[str, object] | NotGiven = NOT_GIVEN,
@@ -1077,6 +1079,7 @@ class AsyncCompletionsResource(AsyncAPIResource):
     async def models(
         self,
         *,
+        check_availability: bool | NotGiven = NOT_GIVEN,
         ending_before: str | NotGiven = NOT_GIVEN,
         limit: int | NotGiven = NOT_GIVEN,
         model_vendor: Literal[
@@ -1124,6 +1127,7 @@ class AsyncCompletionsResource(AsyncAPIResource):
                 timeout=timeout,
                 query=await async_maybe_transform(
                     {
+                        "check_availability": check_availability,
                         "ending_before": ending_before,
                         "limit": limit,
                         "model_vendor": model_vendor,