chore: configure new SDK language

.github/workflows/ci.yml

@@ -36,13 +36,13 @@ jobs:
         run: ./scripts/lint
 
   build:
-    if: github.repository == 'stainless-sdks/hanzo-ai-python' && (github.event_name == 'push' || github.event.pull_request.head.repo.fork)
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.fork
     timeout-minutes: 10
     name: build
     permissions:
       contents: read
       id-token: write
-    runs-on: depot-ubuntu-24.04
+    runs-on: ${{ github.repository == 'stainless-sdks/hanzo-ai-python' && 'depot-ubuntu-24.04' || 'ubuntu-latest' }}
     steps:
       - uses: actions/checkout@v4
 
@@ -61,12 +61,14 @@ jobs:
         run: rye build
 
       - name: Get GitHub OIDC Token
+        if: github.repository == 'stainless-sdks/hanzo-ai-python'
         id: github-oidc
         uses: actions/github-script@v6
         with:
           script: core.setOutput('github_token', await core.getIDToken());
 
       - name: Upload tarball
+        if: github.repository == 'stainless-sdks/hanzo-ai-python'
         env:
           URL: https://pkg.stainless.com/s
           AUTH: ${{ steps.github-oidc.outputs.github_token }}

.gitignore

@@ -1,5 +1,4 @@
 .prism.log
-.vscode
 _dev
 
 __pycache__

.stats.yml

@@ -1,4 +1,4 @@
 configured_endpoints: 188
 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/hanzo-industries-inc%2Fhanzo-ai-2d6e1036fb1eea7e95cafc281141ead9ef77796e43711b17edccaab67c5e791a.yml
 openapi_spec_hash: 12501774d0127be4ec1812d613a58e97
-config_hash: 830747463ff4d018b5633ce511e88558
+config_hash: 5b61cc8c6c31c071a08578ad825b421d

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "python.analysis.importFormat": "relative",
+}

mypy.ini

@@ -1,50 +0,0 @@
-[mypy]
-pretty = True
-show_error_codes = True
-
-# Exclude _files.py because mypy isn't smart enough to apply
-# the correct type narrowing and as this is an internal module
-# it's fine to just use Pyright.
-#
-# We also exclude our `tests` as mypy doesn't always infer
-# types correctly and Pyright will still catch any type errors.
-exclude = ^(src/hanzoai/_files\.py|_dev/.*\.py|tests/.*)$
-
-strict_equality = True
-implicit_reexport = True
-check_untyped_defs = True
-no_implicit_optional = True
-
-warn_return_any = True
-warn_unreachable = True
-warn_unused_configs = True
-
-# Turn these options off as it could cause conflicts
-# with the Pyright options.
-warn_unused_ignores = False
-warn_redundant_casts = False
-
-disallow_any_generics = True
-disallow_untyped_defs = True
-disallow_untyped_calls = True
-disallow_subclassing_any = True
-disallow_incomplete_defs = True
-disallow_untyped_decorators = True
-cache_fine_grained = True
-
-# By default, mypy reports an error if you assign a value to the result
-# of a function call that doesn't return anything. We do this in our test
-# cases:
-# ```
-# result = ...
-# assert result is None
-# ```
-# Changing this codegen to make mypy happy would increase complexity
-# and would not be worth it.
-disable_error_code = func-returns-value,overload-cannot-match
-
-# https://github.com/python/mypy/issues/12162
-[mypy.overrides]
-module = "black.files.*"
-ignore_errors = true
-ignore_missing_imports = true

pyproject.toml

@@ -56,7 +56,6 @@ dev-dependencies = [
     "dirty-equals>=0.6.0",
     "importlib-metadata>=6.7.0",
     "rich>=13.7.1",
-    "nest_asyncio==1.6.0",
     "pytest-xdist>=3.6.1",
 ]
 
@@ -148,6 +147,7 @@ exclude = [
     "_dev",
     ".venv",
     ".nox",
+    ".git",
 ]
 
 reportImplicitOverride = true
@@ -156,10 +156,62 @@ reportOverlappingOverload = false
 reportImportCycles = false
 reportPrivateUsage = false
 
+[tool.mypy]
+pretty = true
+show_error_codes = true
+
+# Exclude _files.py because mypy isn't smart enough to apply
+# the correct type narrowing and as this is an internal module
+# it's fine to just use Pyright.
+#
+# We also exclude our `tests` as mypy doesn't always infer
+# types correctly and Pyright will still catch any type errors.
+exclude = ['src/hanzoai/_files.py', '_dev/.*.py', 'tests/.*']
+
+strict_equality = true
+implicit_reexport = true
+check_untyped_defs = true
+no_implicit_optional = true
+
+warn_return_any = true
+warn_unreachable = true
+warn_unused_configs = true
+
+# Turn these options off as it could cause conflicts
+# with the Pyright options.
+warn_unused_ignores = false
+warn_redundant_casts = false
+
+disallow_any_generics = true
+disallow_untyped_defs = true
+disallow_untyped_calls = true
+disallow_subclassing_any = true
+disallow_incomplete_defs = true
+disallow_untyped_decorators = true
+cache_fine_grained = true
+
+# By default, mypy reports an error if you assign a value to the result
+# of a function call that doesn't return anything. We do this in our test
+# cases:
+# ```
+# result = ...
+# assert result is None
+# ```
+# Changing this codegen to make mypy happy would increase complexity
+# and would not be worth it.
+disable_error_code = "func-returns-value,overload-cannot-match"
+
+# https://github.com/python/mypy/issues/12162
+[[tool.mypy.overrides]]
+module = "black.files.*"
+ignore_errors = true
+ignore_missing_imports = true
+
+
 [tool.ruff]
 line-length = 120
 output-format = "grouped"
-target-version = "py37"
+target-version = "py38"
 
 [tool.ruff.format]
 docstring-code-format = true

requirements-dev.lock

@@ -75,7 +75,6 @@ multidict==6.4.4
 mypy==1.14.1
 mypy-extensions==1.0.0
     # via mypy
-nest-asyncio==1.6.0
 nodeenv==1.8.0
     # via pyright
 nox==2023.4.22

scripts/mock

@@ -21,7 +21,7 @@ echo "==> Starting mock server with URL ${URL}"
 
 # Run prism mock on the given spec
 if [ "$1" == "--daemon" ]; then
-  npm exec --package=@stainless-api/prism-cli@5.8.5 -- prism mock "$URL" &> .prism.log &
+  npm exec --package=@stainless-api/prism-cli@5.15.0 -- prism mock "$URL" &> .prism.log &
 
   # Wait for server to come online
   echo -n "Waiting for server"
@@ -37,5 +37,5 @@ if [ "$1" == "--daemon" ]; then
 
   echo
 else
-  npm exec --package=@stainless-api/prism-cli@5.8.5 -- prism mock "$URL"
+  npm exec --package=@stainless-api/prism-cli@5.15.0 -- prism mock "$URL"
 fi

scripts/test

@@ -43,7 +43,7 @@ elif ! prism_is_running ; then
   echo -e "To run the server, pass in the path or url of your OpenAPI"
   echo -e "spec to the prism command:"
   echo
-  echo -e "  \$ ${YELLOW}npm exec --package=@stoplight/prism-cli@~5.3.2 -- prism mock path/to/your.openapi.yml${NC}"
+  echo -e "  \$ ${YELLOW}npm exec --package=@stainless-api/prism-cli@5.15.0 -- prism mock path/to/your.openapi.yml${NC}"
   echo
 
   exit 1

src/hanzoai/_base_client.py

@@ -59,7 +59,7 @@ from ._types import (
     ModelBuilderProtocol,
 )
 from ._utils import is_dict, is_list, asyncify, is_given, lru_cache, is_mapping
-from ._compat import PYDANTIC_V2, model_copy, model_dump
+from ._compat import PYDANTIC_V1, model_copy, model_dump
 from ._models import GenericModel, FinalRequestOptions, validate_type, construct_type
 from ._response import (
     APIResponse,
@@ -232,7 +232,7 @@ class BaseSyncPage(BasePage[_T], Generic[_T]):
         model: Type[_T],
         options: FinalRequestOptions,
     ) -> None:
-        if PYDANTIC_V2 and getattr(self, "__pydantic_private__", None) is None:
+        if (not PYDANTIC_V1) and getattr(self, "__pydantic_private__", None) is None:
             self.__pydantic_private__ = {}
 
         self._model = model
@@ -320,7 +320,7 @@ class BaseAsyncPage(BasePage[_T], Generic[_T]):
         client: AsyncAPIClient,
         options: FinalRequestOptions,
     ) -> None:
-        if PYDANTIC_V2 and getattr(self, "__pydantic_private__", None) is None:
+        if (not PYDANTIC_V1) and getattr(self, "__pydantic_private__", None) is None:
             self.__pydantic_private__ = {}
 
         self._model = model
@@ -532,7 +532,10 @@ class BaseClient(Generic[_HttpxClientT, _DefaultStreamT]):
         is_body_allowed = options.method.lower() != "get"
 
         if is_body_allowed:
-            kwargs["json"] = json_data if is_given(json_data) else None
+            if isinstance(json_data, bytes):
+                kwargs["content"] = json_data
+            else:
+                kwargs["json"] = json_data if is_given(json_data) else None
             kwargs["files"] = files
         else:
             headers.pop("Content-Type", None)

src/hanzoai/_compat.py

@@ -12,14 +12,13 @@ from ._types import IncEx, StrBytesIntFloat
 _T = TypeVar("_T")
 _ModelT = TypeVar("_ModelT", bound=pydantic.BaseModel)
 
-# --------------- Pydantic v2 compatibility ---------------
+# --------------- Pydantic v2, v3 compatibility ---------------
 
 # Pyright incorrectly reports some of our functions as overriding a method when they don't
 # pyright: reportIncompatibleMethodOverride=false
 
-PYDANTIC_V2 = pydantic.VERSION.startswith("2.")
+PYDANTIC_V1 = pydantic.VERSION.startswith("1.")
 
-# v1 re-exports
 if TYPE_CHECKING:
 
     def parse_date(value: date | StrBytesIntFloat) -> date:  # noqa: ARG001
@@ -44,16 +43,8 @@ if TYPE_CHECKING:
         ...
 
 else:
-    if PYDANTIC_V2:
-        from pydantic.v1.typing 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 pydantic.v1.datetime_parse import parse_date as parse_date, parse_datetime as parse_datetime
-    else:
+    # v1 re-exports
+    if PYDANTIC_V1:
         from pydantic.typing import (
             get_args as get_args,
             is_union as is_union,
@@ -62,72 +53,82 @@ else:
             is_literal_type as is_literal_type,
         )
         from pydantic.datetime_parse import parse_date as parse_date, parse_datetime as parse_datetime
+    else:
+        from ._utils import (
+            get_args as get_args,
+            is_union as is_union,
+            get_origin as get_origin,
+            parse_date as parse_date,
+            is_typeddict as is_typeddict,
+            parse_datetime as parse_datetime,
+            is_literal_type as is_literal_type,
+        )
 
 
 # refactored config
 if TYPE_CHECKING:
     from pydantic import ConfigDict as ConfigDict
 else:
-    if PYDANTIC_V2:
-        from pydantic import ConfigDict
-    else:
+    if PYDANTIC_V1:
         # TODO: provide an error message here?
         ConfigDict = None
+    else:
+        from pydantic import ConfigDict as ConfigDict
 
 
 # renamed methods / properties
 def parse_obj(model: type[_ModelT], value: object) -> _ModelT:
-    if PYDANTIC_V2:
-        return model.model_validate(value)
-    else:
+    if PYDANTIC_V1:
         return cast(_ModelT, model.parse_obj(value))  # pyright: ignore[reportDeprecated, reportUnnecessaryCast]
+    else:
+        return model.model_validate(value)
 
 
 def field_is_required(field: FieldInfo) -> bool:
-    if PYDANTIC_V2:
-        return field.is_required()
-    return field.required  # type: ignore
+    if PYDANTIC_V1:
+        return field.required  # type: ignore
+    return field.is_required()
 
 
 def field_get_default(field: FieldInfo) -> Any:
     value = field.get_default()
-    if PYDANTIC_V2:
-        from pydantic_core import PydanticUndefined
-
-        if value == PydanticUndefined:
-            return None
+    if PYDANTIC_V1:
         return value
+    from pydantic_core import PydanticUndefined
+
+    if value == PydanticUndefined:
+        return None
     return value
 
 
 def field_outer_type(field: FieldInfo) -> Any:
-    if PYDANTIC_V2:
-        return field.annotation
-    return field.outer_type_  # type: ignore
+    if PYDANTIC_V1:
+        return field.outer_type_  # type: ignore
+    return field.annotation
 
 
 def get_model_config(model: type[pydantic.BaseModel]) -> Any:
-    if PYDANTIC_V2:
-        return model.model_config
-    return model.__config__  # type: ignore
+    if PYDANTIC_V1:
+        return model.__config__  # type: ignore
+    return model.model_config
 
 
 def get_model_fields(model: type[pydantic.BaseModel]) -> dict[str, FieldInfo]:
-    if PYDANTIC_V2:
-        return model.model_fields
-    return model.__fields__  # type: ignore
+    if PYDANTIC_V1:
+        return model.__fields__  # type: ignore
+    return model.model_fields
 
 
 def model_copy(model: _ModelT, *, deep: bool = False) -> _ModelT:
-    if PYDANTIC_V2:
-        return model.model_copy(deep=deep)
-    return model.copy(deep=deep)  # type: ignore
+    if PYDANTIC_V1:
+        return model.copy(deep=deep)  # type: ignore
+    return model.model_copy(deep=deep)
 
 
 def model_json(model: pydantic.BaseModel, *, indent: int | None = None) -> str:
-    if PYDANTIC_V2:
-        return model.model_dump_json(indent=indent)
-    return model.json(indent=indent)  # type: ignore
+    if PYDANTIC_V1:
+        return model.json(indent=indent)  # type: ignore
+    return model.model_dump_json(indent=indent)
 
 
 def model_dump(
@@ -139,14 +140,14 @@ def model_dump(
     warnings: bool = True,
     mode: Literal["json", "python"] = "python",
 ) -> dict[str, Any]:
-    if PYDANTIC_V2 or hasattr(model, "model_dump"):
+    if (not PYDANTIC_V1) or hasattr(model, "model_dump"):
         return model.model_dump(
             mode=mode,
             exclude=exclude,
             exclude_unset=exclude_unset,
             exclude_defaults=exclude_defaults,
             # warnings are not supported in Pydantic v1
-            warnings=warnings if PYDANTIC_V2 else True,
+            warnings=True if PYDANTIC_V1 else warnings,
         )
     return cast(
         "dict[str, Any]",
@@ -159,9 +160,9 @@ def model_dump(
 
 
 def model_parse(model: type[_ModelT], data: Any) -> _ModelT:
-    if PYDANTIC_V2:
-        return model.model_validate(data)
-    return model.parse_obj(data)  # pyright: ignore[reportDeprecated]
+    if PYDANTIC_V1:
+        return model.parse_obj(data)  # pyright: ignore[reportDeprecated]
+    return model.model_validate(data)
 
 
 # generic models
@@ -170,17 +171,16 @@ if TYPE_CHECKING:
     class GenericModel(pydantic.BaseModel): ...
 
 else:
-    if PYDANTIC_V2:
+    if PYDANTIC_V1:
+        import pydantic.generics
+
+        class GenericModel(pydantic.generics.GenericModel, pydantic.BaseModel): ...
+    else:
         # there no longer needs to be a distinction in v2 but
         # we still have to create our own subclass to avoid
         # inconsistent MRO ordering errors
         class GenericModel(pydantic.BaseModel): ...
 
-    else:
-        import pydantic.generics
-
-        class GenericModel(pydantic.generics.GenericModel, pydantic.BaseModel): ...
-
 
 # cached properties
 if TYPE_CHECKING:

src/hanzoai/_files.py

@@ -69,12 +69,12 @@ def _transform_file(file: FileTypes) -> HttpxFileTypes:
         return file
 
     if is_tuple_t(file):
-        return (file[0], _read_file_content(file[1]), *file[2:])
+        return (file[0], read_file_content(file[1]), *file[2:])
 
     raise TypeError(f"Expected file types input to be a FileContent type or to be a tuple")
 
 
-def _read_file_content(file: FileContent) -> HttpxFileContent:
+def read_file_content(file: FileContent) -> HttpxFileContent:
     if isinstance(file, os.PathLike):
         return pathlib.Path(file).read_bytes()
     return file
@@ -111,12 +111,12 @@ async def _async_transform_file(file: FileTypes) -> HttpxFileTypes:
         return file
 
     if is_tuple_t(file):
-        return (file[0], await _async_read_file_content(file[1]), *file[2:])
+        return (file[0], await async_read_file_content(file[1]), *file[2:])
 
     raise TypeError(f"Expected file types input to be a FileContent type or to be a tuple")
 
 
-async def _async_read_file_content(file: FileContent) -> HttpxFileContent:
+async def async_read_file_content(file: FileContent) -> HttpxFileContent:
     if isinstance(file, os.PathLike):
         return await anyio.Path(file).read_bytes()
 

src/hanzoai/_models.py

@@ -50,7 +50,7 @@ from ._utils import (
     strip_annotated_type,
 )
 from ._compat import (
-    PYDANTIC_V2,
+    PYDANTIC_V1,
     ConfigDict,
     GenericModel as BaseGenericModel,
     get_args,
@@ -81,11 +81,7 @@ class _ConfigProtocol(Protocol):
 
 
 class BaseModel(pydantic.BaseModel):
-    if PYDANTIC_V2:
-        model_config: ClassVar[ConfigDict] = ConfigDict(
-            extra="allow", defer_build=coerce_boolean(os.environ.get("DEFER_PYDANTIC_BUILD", "true"))
-        )
-    else:
+    if PYDANTIC_V1:
 
         @property
         @override
@@ -95,6 +91,10 @@ class BaseModel(pydantic.BaseModel):
 
         class Config(pydantic.BaseConfig):  # pyright: ignore[reportDeprecated]
             extra: Any = pydantic.Extra.allow  # type: ignore
+    else:
+        model_config: ClassVar[ConfigDict] = ConfigDict(
+            extra="allow", defer_build=coerce_boolean(os.environ.get("DEFER_PYDANTIC_BUILD", "true"))
+        )
 
     def to_dict(
         self,
@@ -208,28 +208,32 @@ class BaseModel(pydantic.BaseModel):
             else:
                 fields_values[name] = field_get_default(field)
 
+        extra_field_type = _get_extra_fields_type(__cls)
+
         _extra = {}
         for key, value in values.items():
             if key not in model_fields:
-                if PYDANTIC_V2:
-                    _extra[key] = value
-                else:
+                parsed = construct_type(value=value, type_=extra_field_type) if extra_field_type is not None else value
+
+                if PYDANTIC_V1:
                     _fields_set.add(key)
-                    fields_values[key] = value
+                    fields_values[key] = parsed
+                else:
+                    _extra[key] = parsed
 
         object.__setattr__(m, "__dict__", fields_values)
 
-        if PYDANTIC_V2:
-            # these properties are copied from Pydantic's `model_construct()` method
-            object.__setattr__(m, "__pydantic_private__", None)
-            object.__setattr__(m, "__pydantic_extra__", _extra)
-            object.__setattr__(m, "__pydantic_fields_set__", _fields_set)
-        else:
+        if PYDANTIC_V1:
             # init_private_attributes() does not exist in v2
             m._init_private_attributes()  # type: ignore
 
             # copied from Pydantic v1's `construct()` method
             object.__setattr__(m, "__fields_set__", _fields_set)
+        else:
+            # these properties are copied from Pydantic's `model_construct()` method
+            object.__setattr__(m, "__pydantic_private__", None)
+            object.__setattr__(m, "__pydantic_extra__", _extra)
+            object.__setattr__(m, "__pydantic_fields_set__", _fields_set)
 
         return m
 
@@ -239,7 +243,7 @@ class BaseModel(pydantic.BaseModel):
         # although not in practice
         model_construct = construct
 
-    if not PYDANTIC_V2:
+    if PYDANTIC_V1:
         # we define aliases for some of the new pydantic v2 methods so
         # that we can just document these methods without having to specify
         # a specific pydantic version as some users may not know which
@@ -300,7 +304,7 @@ class BaseModel(pydantic.BaseModel):
                 exclude_none=exclude_none,
             )
 
-            return cast(dict[str, Any], json_safe(dumped)) if mode == "json" else dumped
+            return cast("dict[str, Any]", json_safe(dumped)) if mode == "json" else dumped
 
         @override
         def model_dump_json(
@@ -359,10 +363,10 @@ def _construct_field(value: object, field: FieldInfo, key: str) -> object:
     if value is None:
         return field_get_default(field)
 
-    if PYDANTIC_V2:
-        type_ = field.annotation
-    else:
+    if PYDANTIC_V1:
         type_ = cast(type, field.outer_type_)  # type: ignore
+    else:
+        type_ = field.annotation  # type: ignore
 
     if type_ is None:
         raise RuntimeError(f"Unexpected field type is None for {key}")
@@ -370,6 +374,23 @@ def _construct_field(value: object, field: FieldInfo, key: str) -> object:
     return construct_type(value=value, type_=type_, metadata=getattr(field, "metadata", None))
 
 
+def _get_extra_fields_type(cls: type[pydantic.BaseModel]) -> type | None:
+    if PYDANTIC_V1:
+        # TODO
+        return None
+
+    schema = cls.__pydantic_core_schema__
+    if schema["type"] == "model":
+        fields = schema["schema"]
+        if fields["type"] == "model-fields":
+            extras = fields.get("extras_schema")
+            if extras and "cls" in extras:
+                # mypy can't narrow the type
+                return extras["cls"]  # type: ignore[no-any-return]
+
+    return None
+
+
 def is_basemodel(type_: type) -> bool:
     """Returns whether or not the given type is either a `BaseModel` or a union of `BaseModel`"""
     if is_union(type_):
@@ -439,7 +460,7 @@ def construct_type(*, value: object, type_: object, metadata: Optional[List[Any]
         type_ = type_.__value__  # type: ignore[unreachable]
 
     # unwrap `Annotated[T, ...]` -> `T`
-    if metadata is not None:
+    if metadata is not None and len(metadata) > 0:
         meta: tuple[Any, ...] = tuple(metadata)
     elif is_annotated_type(type_):
         meta = get_args(type_)[1:]
@@ -607,7 +628,19 @@ def _build_discriminated_union_meta(*, union: type, meta_annotations: tuple[Any,
     for variant in get_args(union):
         variant = strip_annotated_type(variant)
         if is_basemodel_type(variant):
-            if PYDANTIC_V2:
+            if PYDANTIC_V1:
+                field_info = cast("dict[str, FieldInfo]", variant.__fields__).get(discriminator_field_name)  # pyright: ignore[reportDeprecated, reportUnnecessaryCast]
+                if not field_info:
+                    continue
+
+                # Note: if one variant defines an alias then they all should
+                discriminator_alias = field_info.alias
+
+                if (annotation := getattr(field_info, "annotation", None)) and is_literal_type(annotation):
+                    for entry in get_args(annotation):
+                        if isinstance(entry, str):
+                            mapping[entry] = variant
+            else:
                 field = _extract_field_schema_pv2(variant, discriminator_field_name)
                 if not field:
                     continue
@@ -621,18 +654,6 @@ def _build_discriminated_union_meta(*, union: type, meta_annotations: tuple[Any,
                     for entry in cast("LiteralSchema", field_schema)["expected"]:
                         if isinstance(entry, str):
                             mapping[entry] = variant
-            else:
-                field_info = cast("dict[str, FieldInfo]", variant.__fields__).get(discriminator_field_name)  # pyright: ignore[reportDeprecated, reportUnnecessaryCast]
-                if not field_info:
-                    continue
-
-                # Note: if one variant defines an alias then they all should
-                discriminator_alias = field_info.alias
-
-                if (annotation := getattr(field_info, "annotation", None)) and is_literal_type(annotation):
-                    for entry in get_args(annotation):
-                        if isinstance(entry, str):
-                            mapping[entry] = variant
 
     if not mapping:
         return None
@@ -693,7 +714,7 @@ else:
         pass
 
 
-if PYDANTIC_V2:
+if not PYDANTIC_V1:
     from pydantic import TypeAdapter as _TypeAdapter
 
     _CachedTypeAdapter = cast("TypeAdapter[object]", lru_cache(maxsize=None)(_TypeAdapter))
@@ -761,12 +782,12 @@ class FinalRequestOptions(pydantic.BaseModel):
     json_data: Union[Body, None] = None
     extra_json: Union[AnyMapping, None] = None
 
-    if PYDANTIC_V2:
-        model_config: ClassVar[ConfigDict] = ConfigDict(arbitrary_types_allowed=True)
-    else:
+    if PYDANTIC_V1:
 
         class Config(pydantic.BaseConfig):  # pyright: ignore[reportDeprecated]
             arbitrary_types_allowed: bool = True
+    else:
+        model_config: ClassVar[ConfigDict] = ConfigDict(arbitrary_types_allowed=True)
 
     def get_max_retries(self, max_retries: int) -> int:
         if isinstance(self.max_retries, NotGiven):
@@ -799,9 +820,9 @@ class FinalRequestOptions(pydantic.BaseModel):
             key: strip_not_given(value)
             for key, value in values.items()
         }
-        if PYDANTIC_V2:
-            return super().model_construct(_fields_set, **kwargs)
-        return cast(FinalRequestOptions, super().construct(_fields_set, **kwargs))  # pyright: ignore[reportDeprecated]
+        if PYDANTIC_V1:
+            return cast(FinalRequestOptions, super().construct(_fields_set, **kwargs))  # pyright: ignore[reportDeprecated]
+        return super().model_construct(_fields_set, **kwargs)
 
     if not TYPE_CHECKING:
         # type checkers incorrectly complain about this assignment

src/hanzoai/_types.py

@@ -13,10 +13,21 @@ from typing import (
     Mapping,
     TypeVar,
     Callable,
+    Iterator,
     Optional,
     Sequence,
 )
-from typing_extensions import Set, Literal, Protocol, TypeAlias, TypedDict, override, runtime_checkable
+from typing_extensions import (
+    Set,
+    Literal,
+    Protocol,
+    TypeAlias,
+    TypedDict,
+    SupportsIndex,
+    overload,
+    override,
+    runtime_checkable,
+)
 
 import httpx
 import pydantic
@@ -217,3 +228,26 @@ class _GenericAlias(Protocol):
 class HttpxSendArgs(TypedDict, total=False):
     auth: httpx.Auth
     follow_redirects: bool
+
+
+_T_co = TypeVar("_T_co", covariant=True)
+
+
+if TYPE_CHECKING:
+    # This works because str.__contains__ does not accept object (either in typeshed or at runtime)
+    # https://github.com/hauntsaninja/useful_types/blob/5e9710f3875107d068e7679fd7fec9cfab0eff3b/useful_types/__init__.py#L285
+    class SequenceNotStr(Protocol[_T_co]):
+        @overload
+        def __getitem__(self, index: SupportsIndex, /) -> _T_co: ...
+        @overload
+        def __getitem__(self, index: slice, /) -> Sequence[_T_co]: ...
+        def __contains__(self, value: object, /) -> bool: ...
+        def __len__(self) -> int: ...
+        def __iter__(self) -> Iterator[_T_co]: ...
+        def index(self, value: Any, start: int = 0, stop: int = ..., /) -> int: ...
+        def count(self, value: Any, /) -> int: ...
+        def __reversed__(self) -> Iterator[_T_co]: ...
+else:
+    # just point this to a normal `Sequence` at runtime to avoid having to special case
+    # deserializing our custom sequence type
+    SequenceNotStr = Sequence

src/hanzoai/_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

src/hanzoai/_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)

src/hanzoai/_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

src/hanzoai/_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.

src/hanzoai/_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

src/hanzoai/_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, ...])

src/hanzoai/resources/budget.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Dict, List, Optional
+from typing import Dict, Optional
 
 import httpx
 
@@ -13,7 +13,7 @@ from ..types import (
     budget_update_params,
     budget_settings_params,
 )
-from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven, SequenceNotStr
 from .._utils import maybe_transform, async_maybe_transform
 from .._compat import cached_property
 from .._resource import SyncAPIResource, AsyncAPIResource
@@ -273,7 +273,7 @@ class BudgetResource(SyncAPIResource):
     def info(
         self,
         *,
-        budgets: List[str],
+        budgets: SequenceNotStr[str],
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
@@ -594,7 +594,7 @@ class AsyncBudgetResource(AsyncAPIResource):
     async def info(
         self,
         *,
-        budgets: List[str],
+        budgets: SequenceNotStr[str],
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,

src/hanzoai/resources/customer.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Dict, List, Optional
+from typing import Dict, Optional
 from typing_extensions import Literal
 
 import httpx
@@ -15,7 +15,7 @@ from ..types import (
     customer_unblock_params,
     customer_retrieve_info_params,
 )
-from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven, SequenceNotStr
 from .._utils import maybe_transform, async_maybe_transform
 from .._compat import cached_property
 from .._resource import SyncAPIResource, AsyncAPIResource
@@ -280,7 +280,7 @@ class CustomerResource(SyncAPIResource):
     def delete(
         self,
         *,
-        user_ids: List[str],
+        user_ids: SequenceNotStr[str],
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
@@ -326,7 +326,7 @@ class CustomerResource(SyncAPIResource):
     def block(
         self,
         *,
-        user_ids: List[str],
+        user_ids: SequenceNotStr[str],
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
@@ -424,7 +424,7 @@ class CustomerResource(SyncAPIResource):
     def unblock(
         self,
         *,
-        user_ids: List[str],
+        user_ids: SequenceNotStr[str],
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
@@ -712,7 +712,7 @@ class AsyncCustomerResource(AsyncAPIResource):
     async def delete(
         self,
         *,
-        user_ids: List[str],
+        user_ids: SequenceNotStr[str],
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
@@ -758,7 +758,7 @@ class AsyncCustomerResource(AsyncAPIResource):
     async def block(
         self,
         *,
-        user_ids: List[str],
+        user_ids: SequenceNotStr[str],
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
@@ -856,7 +856,7 @@ class AsyncCustomerResource(AsyncAPIResource):
     async def unblock(
         self,
         *,
-        user_ids: List[str],
+        user_ids: SequenceNotStr[str],
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,

src/hanzoai/resources/fine_tuning/jobs/jobs.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import List, Optional
+from typing import Optional
 from typing_extensions import Literal
 
 import httpx
@@ -15,7 +15,7 @@ from .cancel import (
     CancelResourceWithStreamingResponse,
     AsyncCancelResourceWithStreamingResponse,
 )
-from ...._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from ...._types import NOT_GIVEN, Body, Query, Headers, NotGiven, SequenceNotStr
 from ...._utils import maybe_transform, async_maybe_transform
 from ...._compat import cached_property
 from ...._resource import SyncAPIResource, AsyncAPIResource
@@ -62,7 +62,7 @@ class JobsResource(SyncAPIResource):
         model: str,
         training_file: str,
         hyperparameters: Optional[job_create_params.Hyperparameters] | NotGiven = NOT_GIVEN,
-        integrations: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        integrations: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         seed: Optional[int] | NotGiven = NOT_GIVEN,
         suffix: Optional[str] | NotGiven = NOT_GIVEN,
         validation_file: Optional[str] | NotGiven = NOT_GIVEN,
@@ -254,7 +254,7 @@ class AsyncJobsResource(AsyncAPIResource):
         model: str,
         training_file: str,
         hyperparameters: Optional[job_create_params.Hyperparameters] | NotGiven = NOT_GIVEN,
-        integrations: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        integrations: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         seed: Optional[int] | NotGiven = NOT_GIVEN,
         suffix: Optional[str] | NotGiven = NOT_GIVEN,
         validation_file: Optional[str] | NotGiven = NOT_GIVEN,

src/hanzoai/resources/key/key.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import List, Union, Iterable, Optional
+from typing import Union, Iterable, Optional
 from datetime import datetime
 
 import httpx
@@ -17,7 +17,7 @@ from ...types import (
     key_retrieve_info_params,
     key_regenerate_by_key_params,
 )
-from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven, SequenceNotStr
 from ..._utils import maybe_transform, strip_not_given, async_maybe_transform
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
@@ -67,8 +67,8 @@ class KeyResource(SyncAPIResource):
         budget_id: Optional[str] | NotGiven = NOT_GIVEN,
         config: Optional[object] | NotGiven = NOT_GIVEN,
         duration: Optional[str] | NotGiven = NOT_GIVEN,
-        enforced_params: Optional[List[str]] | NotGiven = NOT_GIVEN,
-        guardrails: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        enforced_params: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
+        guardrails: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         key_alias: Optional[str] | NotGiven = NOT_GIVEN,
         max_budget: Optional[float] | NotGiven = NOT_GIVEN,
         max_parallel_requests: Optional[int] | NotGiven = NOT_GIVEN,
@@ -80,7 +80,7 @@ class KeyResource(SyncAPIResource):
         permissions: Optional[object] | NotGiven = NOT_GIVEN,
         rpm_limit: Optional[int] | NotGiven = NOT_GIVEN,
         spend: Optional[float] | NotGiven = NOT_GIVEN,
-        tags: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        tags: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         team_id: Optional[str] | NotGiven = NOT_GIVEN,
         temp_budget_expiry: Union[str, datetime, None] | NotGiven = NOT_GIVEN,
         temp_budget_increase: Optional[float] | NotGiven = NOT_GIVEN,
@@ -282,8 +282,8 @@ class KeyResource(SyncAPIResource):
     def delete(
         self,
         *,
-        key_aliases: Optional[List[str]] | NotGiven = NOT_GIVEN,
-        keys: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        key_aliases: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
+        keys: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         llm_changed_by: str | NotGiven = NOT_GIVEN,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
@@ -468,8 +468,8 @@ class KeyResource(SyncAPIResource):
         budget_id: Optional[str] | NotGiven = NOT_GIVEN,
         config: Optional[object] | NotGiven = NOT_GIVEN,
         duration: Optional[str] | NotGiven = NOT_GIVEN,
-        enforced_params: Optional[List[str]] | NotGiven = NOT_GIVEN,
-        guardrails: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        enforced_params: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
+        guardrails: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         key: Optional[str] | NotGiven = NOT_GIVEN,
         key_alias: Optional[str] | NotGiven = NOT_GIVEN,
         max_budget: Optional[float] | NotGiven = NOT_GIVEN,
@@ -484,7 +484,7 @@ class KeyResource(SyncAPIResource):
         send_invite_email: Optional[bool] | NotGiven = NOT_GIVEN,
         soft_budget: Optional[float] | NotGiven = NOT_GIVEN,
         spend: Optional[float] | NotGiven = NOT_GIVEN,
-        tags: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        tags: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         team_id: Optional[str] | NotGiven = NOT_GIVEN,
         tpm_limit: Optional[int] | NotGiven = NOT_GIVEN,
         user_id: Optional[str] | NotGiven = NOT_GIVEN,
@@ -645,8 +645,8 @@ class KeyResource(SyncAPIResource):
         budget_id: Optional[str] | NotGiven = NOT_GIVEN,
         config: Optional[object] | NotGiven = NOT_GIVEN,
         duration: Optional[str] | NotGiven = NOT_GIVEN,
-        enforced_params: Optional[List[str]] | NotGiven = NOT_GIVEN,
-        guardrails: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        enforced_params: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
+        guardrails: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         body_key: Optional[str] | NotGiven = NOT_GIVEN,
         key_alias: Optional[str] | NotGiven = NOT_GIVEN,
         max_budget: Optional[float] | NotGiven = NOT_GIVEN,
@@ -662,7 +662,7 @@ class KeyResource(SyncAPIResource):
         send_invite_email: Optional[bool] | NotGiven = NOT_GIVEN,
         soft_budget: Optional[float] | NotGiven = NOT_GIVEN,
         spend: Optional[float] | NotGiven = NOT_GIVEN,
-        tags: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        tags: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         team_id: Optional[str] | NotGiven = NOT_GIVEN,
         tpm_limit: Optional[int] | NotGiven = NOT_GIVEN,
         user_id: Optional[str] | NotGiven = NOT_GIVEN,
@@ -920,8 +920,8 @@ class AsyncKeyResource(AsyncAPIResource):
         budget_id: Optional[str] | NotGiven = NOT_GIVEN,
         config: Optional[object] | NotGiven = NOT_GIVEN,
         duration: Optional[str] | NotGiven = NOT_GIVEN,
-        enforced_params: Optional[List[str]] | NotGiven = NOT_GIVEN,
-        guardrails: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        enforced_params: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
+        guardrails: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         key_alias: Optional[str] | NotGiven = NOT_GIVEN,
         max_budget: Optional[float] | NotGiven = NOT_GIVEN,
         max_parallel_requests: Optional[int] | NotGiven = NOT_GIVEN,
@@ -933,7 +933,7 @@ class AsyncKeyResource(AsyncAPIResource):
         permissions: Optional[object] | NotGiven = NOT_GIVEN,
         rpm_limit: Optional[int] | NotGiven = NOT_GIVEN,
         spend: Optional[float] | NotGiven = NOT_GIVEN,
-        tags: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        tags: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         team_id: Optional[str] | NotGiven = NOT_GIVEN,
         temp_budget_expiry: Union[str, datetime, None] | NotGiven = NOT_GIVEN,
         temp_budget_increase: Optional[float] | NotGiven = NOT_GIVEN,
@@ -1135,8 +1135,8 @@ class AsyncKeyResource(AsyncAPIResource):
     async def delete(
         self,
         *,
-        key_aliases: Optional[List[str]] | NotGiven = NOT_GIVEN,
-        keys: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        key_aliases: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
+        keys: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         llm_changed_by: str | NotGiven = NOT_GIVEN,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
@@ -1321,8 +1321,8 @@ class AsyncKeyResource(AsyncAPIResource):
         budget_id: Optional[str] | NotGiven = NOT_GIVEN,
         config: Optional[object] | NotGiven = NOT_GIVEN,
         duration: Optional[str] | NotGiven = NOT_GIVEN,
-        enforced_params: Optional[List[str]] | NotGiven = NOT_GIVEN,
-        guardrails: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        enforced_params: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
+        guardrails: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         key: Optional[str] | NotGiven = NOT_GIVEN,
         key_alias: Optional[str] | NotGiven = NOT_GIVEN,
         max_budget: Optional[float] | NotGiven = NOT_GIVEN,
@@ -1337,7 +1337,7 @@ class AsyncKeyResource(AsyncAPIResource):
         send_invite_email: Optional[bool] | NotGiven = NOT_GIVEN,
         soft_budget: Optional[float] | NotGiven = NOT_GIVEN,
         spend: Optional[float] | NotGiven = NOT_GIVEN,
-        tags: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        tags: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         team_id: Optional[str] | NotGiven = NOT_GIVEN,
         tpm_limit: Optional[int] | NotGiven = NOT_GIVEN,
         user_id: Optional[str] | NotGiven = NOT_GIVEN,
@@ -1498,8 +1498,8 @@ class AsyncKeyResource(AsyncAPIResource):
         budget_id: Optional[str] | NotGiven = NOT_GIVEN,
         config: Optional[object] | NotGiven = NOT_GIVEN,
         duration: Optional[str] | NotGiven = NOT_GIVEN,
-        enforced_params: Optional[List[str]] | NotGiven = NOT_GIVEN,
-        guardrails: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        enforced_params: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
+        guardrails: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         body_key: Optional[str] | NotGiven = NOT_GIVEN,
         key_alias: Optional[str] | NotGiven = NOT_GIVEN,
         max_budget: Optional[float] | NotGiven = NOT_GIVEN,
@@ -1515,7 +1515,7 @@ class AsyncKeyResource(AsyncAPIResource):
         send_invite_email: Optional[bool] | NotGiven = NOT_GIVEN,
         soft_budget: Optional[float] | NotGiven = NOT_GIVEN,
         spend: Optional[float] | NotGiven = NOT_GIVEN,
-        tags: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        tags: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         team_id: Optional[str] | NotGiven = NOT_GIVEN,
         tpm_limit: Optional[int] | NotGiven = NOT_GIVEN,
         user_id: Optional[str] | NotGiven = NOT_GIVEN,

src/hanzoai/resources/organization/info.py

@@ -2,11 +2,9 @@
 
 from __future__ import annotations
 
-from typing import List
-
 import httpx
 
-from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven, SequenceNotStr
 from ..._utils import maybe_transform, async_maybe_transform
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
@@ -81,7 +79,7 @@ class InfoResource(SyncAPIResource):
     def deprecated(
         self,
         *,
-        organizations: List[str],
+        organizations: SequenceNotStr[str],
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
@@ -171,7 +169,7 @@ class AsyncInfoResource(AsyncAPIResource):
     async def deprecated(
         self,
         *,
-        organizations: List[str],
+        organizations: SequenceNotStr[str],
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,

src/hanzoai/resources/organization/organization.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import List, Iterable, Optional
+from typing import Iterable, Optional
 from typing_extensions import Literal
 
 import httpx
@@ -23,7 +23,7 @@ from ...types import (
     organization_delete_member_params,
     organization_update_member_params,
 )
-from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven, SequenceNotStr
 from ..._utils import maybe_transform, async_maybe_transform
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
@@ -195,7 +195,7 @@ class OrganizationResource(SyncAPIResource):
         *,
         budget_id: Optional[str] | NotGiven = NOT_GIVEN,
         metadata: Optional[object] | NotGiven = NOT_GIVEN,
-        models: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        models: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         organization_alias: Optional[str] | NotGiven = NOT_GIVEN,
         organization_id: Optional[str] | NotGiven = NOT_GIVEN,
         spend: Optional[float] | NotGiven = NOT_GIVEN,
@@ -265,7 +265,7 @@ class OrganizationResource(SyncAPIResource):
     def delete(
         self,
         *,
-        organization_ids: List[str],
+        organization_ids: SequenceNotStr[str],
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,
@@ -638,7 +638,7 @@ class AsyncOrganizationResource(AsyncAPIResource):
         *,
         budget_id: Optional[str] | NotGiven = NOT_GIVEN,
         metadata: Optional[object] | NotGiven = NOT_GIVEN,
-        models: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        models: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         organization_alias: Optional[str] | NotGiven = NOT_GIVEN,
         organization_id: Optional[str] | NotGiven = NOT_GIVEN,
         spend: Optional[float] | NotGiven = NOT_GIVEN,
@@ -708,7 +708,7 @@ class AsyncOrganizationResource(AsyncAPIResource):
     async def delete(
         self,
         *,
-        organization_ids: List[str],
+        organization_ids: SequenceNotStr[str],
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
         extra_headers: Headers | None = None,

src/hanzoai/resources/team/model.py

@@ -2,11 +2,9 @@
 
 from __future__ import annotations
 
-from typing import List
-
 import httpx
 
-from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven, SequenceNotStr
 from ..._utils import maybe_transform, async_maybe_transform
 from ..._compat import cached_property
 from ..._resource import SyncAPIResource, AsyncAPIResource
@@ -45,7 +43,7 @@ class ModelResource(SyncAPIResource):
     def add(
         self,
         *,
-        models: List[str],
+        models: SequenceNotStr[str],
         team_id: str,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
@@ -100,7 +98,7 @@ class ModelResource(SyncAPIResource):
     def remove(
         self,
         *,
-        models: List[str],
+        models: SequenceNotStr[str],
         team_id: str,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
@@ -176,7 +174,7 @@ class AsyncModelResource(AsyncAPIResource):
     async def add(
         self,
         *,
-        models: List[str],
+        models: SequenceNotStr[str],
         team_id: str,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
@@ -231,7 +229,7 @@ class AsyncModelResource(AsyncAPIResource):
     async def remove(
         self,
         *,
-        models: List[str],
+        models: SequenceNotStr[str],
         team_id: str,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.

src/hanzoai/resources/team/team.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import List, Iterable, Optional
+from typing import Iterable, Optional
 from typing_extensions import Literal
 
 import httpx
@@ -28,7 +28,7 @@ from ...types import (
     team_update_member_params,
     team_list_available_params,
 )
-from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven, SequenceNotStr
 from ..._utils import maybe_transform, strip_not_given, async_maybe_transform
 from .callback import (
     CallbackResource,
@@ -89,7 +89,7 @@ class TeamResource(SyncAPIResource):
         admins: Iterable[object] | NotGiven = NOT_GIVEN,
         blocked: bool | NotGiven = NOT_GIVEN,
         budget_duration: Optional[str] | NotGiven = NOT_GIVEN,
-        guardrails: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        guardrails: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         max_budget: Optional[float] | NotGiven = NOT_GIVEN,
         members: Iterable[object] | NotGiven = NOT_GIVEN,
         members_with_roles: Iterable[MemberParam] | NotGiven = NOT_GIVEN,
@@ -227,7 +227,7 @@ class TeamResource(SyncAPIResource):
         team_id: str,
         blocked: Optional[bool] | NotGiven = NOT_GIVEN,
         budget_duration: Optional[str] | NotGiven = NOT_GIVEN,
-        guardrails: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        guardrails: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         max_budget: Optional[float] | NotGiven = NOT_GIVEN,
         metadata: Optional[object] | NotGiven = NOT_GIVEN,
         model_aliases: Optional[object] | NotGiven = NOT_GIVEN,
@@ -394,7 +394,7 @@ class TeamResource(SyncAPIResource):
     def delete(
         self,
         *,
-        team_ids: List[str],
+        team_ids: SequenceNotStr[str],
         llm_changed_by: str | NotGiven = NOT_GIVEN,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
@@ -847,7 +847,7 @@ class AsyncTeamResource(AsyncAPIResource):
         admins: Iterable[object] | NotGiven = NOT_GIVEN,
         blocked: bool | NotGiven = NOT_GIVEN,
         budget_duration: Optional[str] | NotGiven = NOT_GIVEN,
-        guardrails: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        guardrails: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         max_budget: Optional[float] | NotGiven = NOT_GIVEN,
         members: Iterable[object] | NotGiven = NOT_GIVEN,
         members_with_roles: Iterable[MemberParam] | NotGiven = NOT_GIVEN,
@@ -985,7 +985,7 @@ class AsyncTeamResource(AsyncAPIResource):
         team_id: str,
         blocked: Optional[bool] | NotGiven = NOT_GIVEN,
         budget_duration: Optional[str] | NotGiven = NOT_GIVEN,
-        guardrails: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        guardrails: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         max_budget: Optional[float] | NotGiven = NOT_GIVEN,
         metadata: Optional[object] | NotGiven = NOT_GIVEN,
         model_aliases: Optional[object] | NotGiven = NOT_GIVEN,
@@ -1152,7 +1152,7 @@ class AsyncTeamResource(AsyncAPIResource):
     async def delete(
         self,
         *,
-        team_ids: List[str],
+        team_ids: SequenceNotStr[str],
         llm_changed_by: str | NotGiven = NOT_GIVEN,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.

src/hanzoai/resources/user.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import List, Iterable, Optional
+from typing import Iterable, Optional
 from typing_extensions import Literal
 
 import httpx
@@ -14,7 +14,7 @@ from ..types import (
     user_update_params,
     user_retrieve_info_params,
 )
-from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven, SequenceNotStr
 from .._utils import maybe_transform, strip_not_given, async_maybe_transform
 from .._compat import cached_property
 from .._resource import SyncAPIResource, AsyncAPIResource
@@ -60,7 +60,7 @@ class UserResource(SyncAPIResource):
         budget_duration: Optional[str] | NotGiven = NOT_GIVEN,
         config: Optional[object] | NotGiven = NOT_GIVEN,
         duration: Optional[str] | NotGiven = NOT_GIVEN,
-        guardrails: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        guardrails: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         key_alias: Optional[str] | NotGiven = NOT_GIVEN,
         max_budget: Optional[float] | NotGiven = NOT_GIVEN,
         max_parallel_requests: Optional[int] | NotGiven = NOT_GIVEN,
@@ -231,7 +231,7 @@ class UserResource(SyncAPIResource):
         budget_duration: Optional[str] | NotGiven = NOT_GIVEN,
         config: Optional[object] | NotGiven = NOT_GIVEN,
         duration: Optional[str] | NotGiven = NOT_GIVEN,
-        guardrails: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        guardrails: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         key_alias: Optional[str] | NotGiven = NOT_GIVEN,
         max_budget: Optional[float] | NotGiven = NOT_GIVEN,
         max_parallel_requests: Optional[int] | NotGiven = NOT_GIVEN,
@@ -434,7 +434,7 @@ class UserResource(SyncAPIResource):
     def delete(
         self,
         *,
-        user_ids: List[str],
+        user_ids: SequenceNotStr[str],
         llm_changed_by: str | NotGiven = NOT_GIVEN,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
@@ -557,7 +557,7 @@ class AsyncUserResource(AsyncAPIResource):
         budget_duration: Optional[str] | NotGiven = NOT_GIVEN,
         config: Optional[object] | NotGiven = NOT_GIVEN,
         duration: Optional[str] | NotGiven = NOT_GIVEN,
-        guardrails: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        guardrails: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         key_alias: Optional[str] | NotGiven = NOT_GIVEN,
         max_budget: Optional[float] | NotGiven = NOT_GIVEN,
         max_parallel_requests: Optional[int] | NotGiven = NOT_GIVEN,
@@ -728,7 +728,7 @@ class AsyncUserResource(AsyncAPIResource):
         budget_duration: Optional[str] | NotGiven = NOT_GIVEN,
         config: Optional[object] | NotGiven = NOT_GIVEN,
         duration: Optional[str] | NotGiven = NOT_GIVEN,
-        guardrails: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        guardrails: Optional[SequenceNotStr[str]] | NotGiven = NOT_GIVEN,
         key_alias: Optional[str] | NotGiven = NOT_GIVEN,
         max_budget: Optional[float] | NotGiven = NOT_GIVEN,
         max_parallel_requests: Optional[int] | NotGiven = NOT_GIVEN,
@@ -931,7 +931,7 @@ class AsyncUserResource(AsyncAPIResource):
     async def delete(
         self,
         *,
-        user_ids: List[str],
+        user_ids: SequenceNotStr[str],
         llm_changed_by: str | NotGiven = NOT_GIVEN,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.

src/hanzoai/types/budget_info_params.py

@@ -2,11 +2,12 @@
 
 from __future__ import annotations
 
-from typing import List
 from typing_extensions import Required, TypedDict
 
+from .._types import SequenceNotStr
+
 __all__ = ["BudgetInfoParams"]
 
 
 class BudgetInfoParams(TypedDict, total=False):
-    budgets: Required[List[str]]
+    budgets: Required[SequenceNotStr[str]]

src/hanzoai/types/customer_block_params.py

@@ -2,11 +2,12 @@
 
 from __future__ import annotations
 
-from typing import List
 from typing_extensions import Required, TypedDict
 
+from .._types import SequenceNotStr
+
 __all__ = ["CustomerBlockParams"]
 
 
 class CustomerBlockParams(TypedDict, total=False):
-    user_ids: Required[List[str]]
+    user_ids: Required[SequenceNotStr[str]]

src/hanzoai/types/customer_delete_params.py

@@ -2,11 +2,12 @@
 
 from __future__ import annotations
 
-from typing import List
 from typing_extensions import Required, TypedDict
 
+from .._types import SequenceNotStr
+
 __all__ = ["CustomerDeleteParams"]
 
 
 class CustomerDeleteParams(TypedDict, total=False):
-    user_ids: Required[List[str]]
+    user_ids: Required[SequenceNotStr[str]]

src/hanzoai/types/customer_unblock_params.py

@@ -2,11 +2,12 @@
 
 from __future__ import annotations
 
-from typing import List
 from typing_extensions import Required, TypedDict
 
+from .._types import SequenceNotStr
+
 __all__ = ["CustomerUnblockParams"]
 
 
 class CustomerUnblockParams(TypedDict, total=False):
-    user_ids: Required[List[str]]
+    user_ids: Required[SequenceNotStr[str]]

src/hanzoai/types/fine_tuning/job_create_params.py

@@ -2,9 +2,11 @@
 
 from __future__ import annotations
 
-from typing import List, Union, Optional
+from typing import Union, Optional
 from typing_extensions import Literal, Required, TypedDict
 
+from ..._types import SequenceNotStr
+
 __all__ = ["JobCreateParams", "Hyperparameters"]
 
 
@@ -17,7 +19,7 @@ class JobCreateParams(TypedDict, total=False):
 
     hyperparameters: Optional[Hyperparameters]
 
-    integrations: Optional[List[str]]
+    integrations: Optional[SequenceNotStr[str]]
 
     seed: Optional[int]
 

src/hanzoai/types/key_delete_params.py

@@ -2,18 +2,19 @@
 
 from __future__ import annotations
 
-from typing import List, Optional
+from typing import Optional
 from typing_extensions import Annotated, TypedDict
 
+from .._types import SequenceNotStr
 from .._utils import PropertyInfo
 
 __all__ = ["KeyDeleteParams"]
 
 
 class KeyDeleteParams(TypedDict, total=False):
-    key_aliases: Optional[List[str]]
+    key_aliases: Optional[SequenceNotStr[str]]
 
-    keys: Optional[List[str]]
+    keys: Optional[SequenceNotStr[str]]
 
     llm_changed_by: Annotated[str, PropertyInfo(alias="llm-changed-by")]
     """

src/hanzoai/types/key_generate_params.py

@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
-from typing import List, Iterable, Optional
+from typing import Iterable, Optional
 from typing_extensions import Annotated, TypedDict
 
+from .._types import SequenceNotStr
 from .._utils import PropertyInfo
 
 __all__ = ["KeyGenerateParams"]
@@ -25,9 +26,9 @@ class KeyGenerateParams(TypedDict, total=False):
 
     duration: Optional[str]
 
-    enforced_params: Optional[List[str]]
+    enforced_params: Optional[SequenceNotStr[str]]
 
-    guardrails: Optional[List[str]]
+    guardrails: Optional[SequenceNotStr[str]]
 
     key: Optional[str]
 
@@ -57,7 +58,7 @@ class KeyGenerateParams(TypedDict, total=False):
 
     spend: Optional[float]
 
-    tags: Optional[List[str]]
+    tags: Optional[SequenceNotStr[str]]
 
     team_id: Optional[str]
 

src/hanzoai/types/key_regenerate_by_key_params.py

@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
-from typing import List, Iterable, Optional
+from typing import Iterable, Optional
 from typing_extensions import Annotated, TypedDict
 
+from .._types import SequenceNotStr
 from .._utils import PropertyInfo
 
 __all__ = ["KeyRegenerateByKeyParams"]
@@ -25,9 +26,9 @@ class KeyRegenerateByKeyParams(TypedDict, total=False):
 
     duration: Optional[str]
 
-    enforced_params: Optional[List[str]]
+    enforced_params: Optional[SequenceNotStr[str]]
 
-    guardrails: Optional[List[str]]
+    guardrails: Optional[SequenceNotStr[str]]
 
     body_key: Annotated[Optional[str], PropertyInfo(alias="key")]
 
@@ -59,7 +60,7 @@ class KeyRegenerateByKeyParams(TypedDict, total=False):
 
     spend: Optional[float]
 
-    tags: Optional[List[str]]
+    tags: Optional[SequenceNotStr[str]]
 
     team_id: Optional[str]
 

src/hanzoai/types/key_update_params.py

@@ -2,10 +2,11 @@
 
 from __future__ import annotations
 
-from typing import List, Union, Iterable, Optional
+from typing import Union, Iterable, Optional
 from datetime import datetime
 from typing_extensions import Required, Annotated, TypedDict
 
+from .._types import SequenceNotStr
 from .._utils import PropertyInfo
 
 __all__ = ["KeyUpdateParams"]
@@ -28,9 +29,9 @@ class KeyUpdateParams(TypedDict, total=False):
 
     duration: Optional[str]
 
-    enforced_params: Optional[List[str]]
+    enforced_params: Optional[SequenceNotStr[str]]
 
-    guardrails: Optional[List[str]]
+    guardrails: Optional[SequenceNotStr[str]]
 
     key_alias: Optional[str]
 
@@ -54,7 +55,7 @@ class KeyUpdateParams(TypedDict, total=False):
 
     spend: Optional[float]
 
-    tags: Optional[List[str]]
+    tags: Optional[SequenceNotStr[str]]
 
     team_id: Optional[str]
 

src/hanzoai/types/model/update_full_params.py

@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
-from typing import Dict, List, Union, Optional
+from typing import Dict, Union, Optional
 from typing_extensions import TypeAlias, TypedDict
 
+from ..._types import SequenceNotStr
 from ..model_info_param import ModelInfoParam
 from ..configurable_clientside_params_custom_auth_param import ConfigurableClientsideParamsCustomAuthParam
 
@@ -37,7 +38,7 @@ class LlmParamsTyped(TypedDict, total=False):
 
     budget_duration: Optional[str]
 
-    configurable_clientside_auth_params: Optional[List[LlmParamsConfigurableClientsideAuthParam]]
+    configurable_clientside_auth_params: Optional[SequenceNotStr[LlmParamsConfigurableClientsideAuthParam]]
 
     custom_llm_provider: Optional[str]
 

src/hanzoai/types/model/update_partial_params.py

@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
-from typing import Dict, List, Union, Optional
+from typing import Dict, Union, Optional
 from typing_extensions import TypeAlias, TypedDict
 
+from ..._types import SequenceNotStr
 from ..model_info_param import ModelInfoParam
 from ..configurable_clientside_params_custom_auth_param import ConfigurableClientsideParamsCustomAuthParam
 
@@ -37,7 +38,7 @@ class LlmParamsTyped(TypedDict, total=False):
 
     budget_duration: Optional[str]
 
-    configurable_clientside_auth_params: Optional[List[LlmParamsConfigurableClientsideAuthParam]]
+    configurable_clientside_auth_params: Optional[SequenceNotStr[LlmParamsConfigurableClientsideAuthParam]]
 
     custom_llm_provider: Optional[str]
 

src/hanzoai/types/model_create_params.py

@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
-from typing import Dict, List, Union, Optional
+from typing import Dict, Union, Optional
 from typing_extensions import Required, TypeAlias, TypedDict
 
+from .._types import SequenceNotStr
 from .model_info_param import ModelInfoParam
 from .configurable_clientside_params_custom_auth_param import ConfigurableClientsideParamsCustomAuthParam
 
@@ -40,7 +41,7 @@ class LlmParamsTyped(TypedDict, total=False):
 
     budget_duration: Optional[str]
 
-    configurable_clientside_auth_params: Optional[List[LlmParamsConfigurableClientsideAuthParam]]
+    configurable_clientside_auth_params: Optional[SequenceNotStr[LlmParamsConfigurableClientsideAuthParam]]
 
     custom_llm_provider: Optional[str]
 

src/hanzoai/types/organization/info_deprecated_params.py

@@ -2,11 +2,12 @@
 
 from __future__ import annotations
 
-from typing import List
 from typing_extensions import Required, TypedDict
 
+from ..._types import SequenceNotStr
+
 __all__ = ["InfoDeprecatedParams"]
 
 
 class InfoDeprecatedParams(TypedDict, total=False):
-    organizations: Required[List[str]]
+    organizations: Required[SequenceNotStr[str]]

src/hanzoai/types/organization_delete_params.py

@@ -2,11 +2,12 @@
 
 from __future__ import annotations
 
-from typing import List
 from typing_extensions import Required, TypedDict
 
+from .._types import SequenceNotStr
+
 __all__ = ["OrganizationDeleteParams"]
 
 
 class OrganizationDeleteParams(TypedDict, total=False):
-    organization_ids: Required[List[str]]
+    organization_ids: Required[SequenceNotStr[str]]

src/hanzoai/types/organization_update_params.py

@@ -2,9 +2,11 @@
 
 from __future__ import annotations
 
-from typing import List, Optional
+from typing import Optional
 from typing_extensions import TypedDict
 
+from .._types import SequenceNotStr
+
 __all__ = ["OrganizationUpdateParams"]
 
 
@@ -13,7 +15,7 @@ class OrganizationUpdateParams(TypedDict, total=False):
 
     metadata: Optional[object]
 
-    models: Optional[List[str]]
+    models: Optional[SequenceNotStr[str]]
 
     organization_alias: Optional[str]
 

src/hanzoai/types/team/model_add_params.py

@@ -2,13 +2,14 @@
 
 from __future__ import annotations
 
-from typing import List
 from typing_extensions import Required, TypedDict
 
+from ..._types import SequenceNotStr
+
 __all__ = ["ModelAddParams"]
 
 
 class ModelAddParams(TypedDict, total=False):
-    models: Required[List[str]]
+    models: Required[SequenceNotStr[str]]
 
     team_id: Required[str]

src/hanzoai/types/team/model_remove_params.py

@@ -2,13 +2,14 @@
 
 from __future__ import annotations
 
-from typing import List
 from typing_extensions import Required, TypedDict
 
+from ..._types import SequenceNotStr
+
 __all__ = ["ModelRemoveParams"]
 
 
 class ModelRemoveParams(TypedDict, total=False):
-    models: Required[List[str]]
+    models: Required[SequenceNotStr[str]]
 
     team_id: Required[str]

src/hanzoai/types/team_create_params.py

@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
-from typing import List, Iterable, Optional
+from typing import Iterable, Optional
 from typing_extensions import Annotated, TypedDict
 
+from .._types import SequenceNotStr
 from .._utils import PropertyInfo
 from .member_param import MemberParam
 
@@ -18,7 +19,7 @@ class TeamCreateParams(TypedDict, total=False):
 
     budget_duration: Optional[str]
 
-    guardrails: Optional[List[str]]
+    guardrails: Optional[SequenceNotStr[str]]
 
     max_budget: Optional[float]
 

src/hanzoai/types/team_delete_params.py

@@ -2,16 +2,16 @@
 
 from __future__ import annotations
 
-from typing import List
 from typing_extensions import Required, Annotated, TypedDict
 
+from .._types import SequenceNotStr
 from .._utils import PropertyInfo
 
 __all__ = ["TeamDeleteParams"]
 
 
 class TeamDeleteParams(TypedDict, total=False):
-    team_ids: Required[List[str]]
+    team_ids: Required[SequenceNotStr[str]]
 
     llm_changed_by: Annotated[str, PropertyInfo(alias="llm-changed-by")]
     """

src/hanzoai/types/team_update_params.py

@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
-from typing import List, Iterable, Optional
+from typing import Iterable, Optional
 from typing_extensions import Required, Annotated, TypedDict
 
+from .._types import SequenceNotStr
 from .._utils import PropertyInfo
 
 __all__ = ["TeamUpdateParams"]
@@ -17,7 +18,7 @@ class TeamUpdateParams(TypedDict, total=False):
 
     budget_duration: Optional[str]
 
-    guardrails: Optional[List[str]]
+    guardrails: Optional[SequenceNotStr[str]]
 
     max_budget: Optional[float]
 

src/hanzoai/types/user_create_params.py

@@ -2,9 +2,11 @@
 
 from __future__ import annotations
 
-from typing import List, Iterable, Optional
+from typing import Iterable, Optional
 from typing_extensions import Literal, TypedDict
 
+from .._types import SequenceNotStr
+
 __all__ = ["UserCreateParams"]
 
 
@@ -23,7 +25,7 @@ class UserCreateParams(TypedDict, total=False):
 
     duration: Optional[str]
 
-    guardrails: Optional[List[str]]
+    guardrails: Optional[SequenceNotStr[str]]
 
     key_alias: Optional[str]
 

src/hanzoai/types/user_delete_params.py

@@ -2,16 +2,16 @@
 
 from __future__ import annotations
 
-from typing import List
 from typing_extensions import Required, Annotated, TypedDict
 
+from .._types import SequenceNotStr
 from .._utils import PropertyInfo
 
 __all__ = ["UserDeleteParams"]
 
 
 class UserDeleteParams(TypedDict, total=False):
-    user_ids: Required[List[str]]
+    user_ids: Required[SequenceNotStr[str]]
 
     llm_changed_by: Annotated[str, PropertyInfo(alias="llm-changed-by")]
     """

src/hanzoai/types/user_update_params.py

@@ -2,9 +2,11 @@
 
 from __future__ import annotations
 
-from typing import List, Iterable, Optional
+from typing import Iterable, Optional
 from typing_extensions import Literal, TypedDict
 
+from .._types import SequenceNotStr
+
 __all__ = ["UserUpdateParams"]
 
 
@@ -21,7 +23,7 @@ class UserUpdateParams(TypedDict, total=False):
 
     duration: Optional[str]
 
-    guardrails: Optional[List[str]]
+    guardrails: Optional[SequenceNotStr[str]]
 
     key_alias: Optional[str]
 

tests/api_resources/audio/test_speech.py

@@ -16,13 +16,13 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestSpeech:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create(self, client: Hanzo) -> None:
         speech = client.audio.speech.create()
         assert_matches_type(object, speech, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Hanzo) -> None:
         response = client.audio.speech.with_raw_response.create()
@@ -32,7 +32,7 @@ class TestSpeech:
         speech = response.parse()
         assert_matches_type(object, speech, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Hanzo) -> None:
         with client.audio.speech.with_streaming_response.create() as response:
@@ -50,13 +50,13 @@ class TestAsyncSpeech:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncHanzo) -> None:
         speech = await async_client.audio.speech.create()
         assert_matches_type(object, speech, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
         response = await async_client.audio.speech.with_raw_response.create()
@@ -66,7 +66,7 @@ class TestAsyncSpeech:
         speech = await response.parse()
         assert_matches_type(object, speech, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
         async with async_client.audio.speech.with_streaming_response.create() as response:

tests/api_resources/audio/test_transcriptions.py

@@ -16,7 +16,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestTranscriptions:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create(self, client: Hanzo) -> None:
         transcription = client.audio.transcriptions.create(
@@ -24,7 +24,7 @@ class TestTranscriptions:
         )
         assert_matches_type(object, transcription, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Hanzo) -> None:
         response = client.audio.transcriptions.with_raw_response.create(
@@ -36,7 +36,7 @@ class TestTranscriptions:
         transcription = response.parse()
         assert_matches_type(object, transcription, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Hanzo) -> None:
         with client.audio.transcriptions.with_streaming_response.create(
@@ -56,7 +56,7 @@ class TestAsyncTranscriptions:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncHanzo) -> None:
         transcription = await async_client.audio.transcriptions.create(
@@ -64,7 +64,7 @@ class TestAsyncTranscriptions:
         )
         assert_matches_type(object, transcription, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
         response = await async_client.audio.transcriptions.with_raw_response.create(
@@ -76,7 +76,7 @@ class TestAsyncTranscriptions:
         transcription = await response.parse()
         assert_matches_type(object, transcription, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
         async with async_client.audio.transcriptions.with_streaming_response.create(

tests/api_resources/batches/test_cancel.py

@@ -16,7 +16,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestCancel:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_cancel(self, client: Hanzo) -> None:
         cancel = client.batches.cancel.cancel(
@@ -24,7 +24,7 @@ class TestCancel:
         )
         assert_matches_type(object, cancel, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_cancel_with_all_params(self, client: Hanzo) -> None:
         cancel = client.batches.cancel.cancel(
@@ -33,7 +33,7 @@ class TestCancel:
         )
         assert_matches_type(object, cancel, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_cancel(self, client: Hanzo) -> None:
         response = client.batches.cancel.with_raw_response.cancel(
@@ -45,7 +45,7 @@ class TestCancel:
         cancel = response.parse()
         assert_matches_type(object, cancel, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_cancel(self, client: Hanzo) -> None:
         with client.batches.cancel.with_streaming_response.cancel(
@@ -59,7 +59,7 @@ class TestCancel:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_cancel(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `batch_id` but received ''"):
@@ -73,7 +73,7 @@ class TestAsyncCancel:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_cancel(self, async_client: AsyncHanzo) -> None:
         cancel = await async_client.batches.cancel.cancel(
@@ -81,7 +81,7 @@ class TestAsyncCancel:
         )
         assert_matches_type(object, cancel, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_cancel_with_all_params(self, async_client: AsyncHanzo) -> None:
         cancel = await async_client.batches.cancel.cancel(
@@ -90,7 +90,7 @@ class TestAsyncCancel:
         )
         assert_matches_type(object, cancel, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_cancel(self, async_client: AsyncHanzo) -> None:
         response = await async_client.batches.cancel.with_raw_response.cancel(
@@ -102,7 +102,7 @@ class TestAsyncCancel:
         cancel = await response.parse()
         assert_matches_type(object, cancel, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_cancel(self, async_client: AsyncHanzo) -> None:
         async with async_client.batches.cancel.with_streaming_response.cancel(
@@ -116,7 +116,7 @@ class TestAsyncCancel:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_cancel(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `batch_id` but received ''"):

tests/api_resources/cache/test_redis.py

@@ -16,13 +16,13 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestRedis:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_retrieve_info(self, client: Hanzo) -> None:
         redi = client.cache.redis.retrieve_info()
         assert_matches_type(object, redi, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_retrieve_info(self, client: Hanzo) -> None:
         response = client.cache.redis.with_raw_response.retrieve_info()
@@ -32,7 +32,7 @@ class TestRedis:
         redi = response.parse()
         assert_matches_type(object, redi, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_retrieve_info(self, client: Hanzo) -> None:
         with client.cache.redis.with_streaming_response.retrieve_info() as response:
@@ -50,13 +50,13 @@ class TestAsyncRedis:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_retrieve_info(self, async_client: AsyncHanzo) -> None:
         redi = await async_client.cache.redis.retrieve_info()
         assert_matches_type(object, redi, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_retrieve_info(self, async_client: AsyncHanzo) -> None:
         response = await async_client.cache.redis.with_raw_response.retrieve_info()
@@ -66,7 +66,7 @@ class TestAsyncRedis:
         redi = await response.parse()
         assert_matches_type(object, redi, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_retrieve_info(self, async_client: AsyncHanzo) -> None:
         async with async_client.cache.redis.with_streaming_response.retrieve_info() as response:

tests/api_resources/chat/test_completions.py

@@ -16,13 +16,13 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestCompletions:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create(self, client: Hanzo) -> None:
         completion = client.chat.completions.create()
         assert_matches_type(object, completion, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create_with_all_params(self, client: Hanzo) -> None:
         completion = client.chat.completions.create(
@@ -30,7 +30,7 @@ class TestCompletions:
         )
         assert_matches_type(object, completion, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Hanzo) -> None:
         response = client.chat.completions.with_raw_response.create()
@@ -40,7 +40,7 @@ class TestCompletions:
         completion = response.parse()
         assert_matches_type(object, completion, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Hanzo) -> None:
         with client.chat.completions.with_streaming_response.create() as response:
@@ -58,13 +58,13 @@ class TestAsyncCompletions:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncHanzo) -> None:
         completion = await async_client.chat.completions.create()
         assert_matches_type(object, completion, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create_with_all_params(self, async_client: AsyncHanzo) -> None:
         completion = await async_client.chat.completions.create(
@@ -72,7 +72,7 @@ class TestAsyncCompletions:
         )
         assert_matches_type(object, completion, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
         response = await async_client.chat.completions.with_raw_response.create()
@@ -82,7 +82,7 @@ class TestAsyncCompletions:
         completion = await response.parse()
         assert_matches_type(object, completion, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
         async with async_client.chat.completions.with_streaming_response.create() as response:

tests/api_resources/config/test_pass_through_endpoint.py

@@ -19,7 +19,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestPassThroughEndpoint:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create(self, client: Hanzo) -> None:
         pass_through_endpoint = client.config.pass_through_endpoint.create(
@@ -29,7 +29,7 @@ class TestPassThroughEndpoint:
         )
         assert_matches_type(object, pass_through_endpoint, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Hanzo) -> None:
         response = client.config.pass_through_endpoint.with_raw_response.create(
@@ -43,7 +43,7 @@ class TestPassThroughEndpoint:
         pass_through_endpoint = response.parse()
         assert_matches_type(object, pass_through_endpoint, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Hanzo) -> None:
         with client.config.pass_through_endpoint.with_streaming_response.create(
@@ -59,7 +59,7 @@ class TestPassThroughEndpoint:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_update(self, client: Hanzo) -> None:
         pass_through_endpoint = client.config.pass_through_endpoint.update(
@@ -67,7 +67,7 @@ class TestPassThroughEndpoint:
         )
         assert_matches_type(object, pass_through_endpoint, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_update(self, client: Hanzo) -> None:
         response = client.config.pass_through_endpoint.with_raw_response.update(
@@ -79,7 +79,7 @@ class TestPassThroughEndpoint:
         pass_through_endpoint = response.parse()
         assert_matches_type(object, pass_through_endpoint, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_update(self, client: Hanzo) -> None:
         with client.config.pass_through_endpoint.with_streaming_response.update(
@@ -93,7 +93,7 @@ class TestPassThroughEndpoint:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_update(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint_id` but received ''"):
@@ -101,13 +101,13 @@ class TestPassThroughEndpoint:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_list(self, client: Hanzo) -> None:
         pass_through_endpoint = client.config.pass_through_endpoint.list()
         assert_matches_type(PassThroughEndpointResponse, pass_through_endpoint, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_list_with_all_params(self, client: Hanzo) -> None:
         pass_through_endpoint = client.config.pass_through_endpoint.list(
@@ -115,7 +115,7 @@ class TestPassThroughEndpoint:
         )
         assert_matches_type(PassThroughEndpointResponse, pass_through_endpoint, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_list(self, client: Hanzo) -> None:
         response = client.config.pass_through_endpoint.with_raw_response.list()
@@ -125,7 +125,7 @@ class TestPassThroughEndpoint:
         pass_through_endpoint = response.parse()
         assert_matches_type(PassThroughEndpointResponse, pass_through_endpoint, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_list(self, client: Hanzo) -> None:
         with client.config.pass_through_endpoint.with_streaming_response.list() as response:
@@ -137,7 +137,7 @@ class TestPassThroughEndpoint:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_delete(self, client: Hanzo) -> None:
         pass_through_endpoint = client.config.pass_through_endpoint.delete(
@@ -145,7 +145,7 @@ class TestPassThroughEndpoint:
         )
         assert_matches_type(PassThroughEndpointResponse, pass_through_endpoint, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_delete(self, client: Hanzo) -> None:
         response = client.config.pass_through_endpoint.with_raw_response.delete(
@@ -157,7 +157,7 @@ class TestPassThroughEndpoint:
         pass_through_endpoint = response.parse()
         assert_matches_type(PassThroughEndpointResponse, pass_through_endpoint, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_delete(self, client: Hanzo) -> None:
         with client.config.pass_through_endpoint.with_streaming_response.delete(
@@ -177,7 +177,7 @@ class TestAsyncPassThroughEndpoint:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncHanzo) -> None:
         pass_through_endpoint = await async_client.config.pass_through_endpoint.create(
@@ -187,7 +187,7 @@ class TestAsyncPassThroughEndpoint:
         )
         assert_matches_type(object, pass_through_endpoint, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
         response = await async_client.config.pass_through_endpoint.with_raw_response.create(
@@ -201,7 +201,7 @@ class TestAsyncPassThroughEndpoint:
         pass_through_endpoint = await response.parse()
         assert_matches_type(object, pass_through_endpoint, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
         async with async_client.config.pass_through_endpoint.with_streaming_response.create(
@@ -217,7 +217,7 @@ class TestAsyncPassThroughEndpoint:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_update(self, async_client: AsyncHanzo) -> None:
         pass_through_endpoint = await async_client.config.pass_through_endpoint.update(
@@ -225,7 +225,7 @@ class TestAsyncPassThroughEndpoint:
         )
         assert_matches_type(object, pass_through_endpoint, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
         response = await async_client.config.pass_through_endpoint.with_raw_response.update(
@@ -237,7 +237,7 @@ class TestAsyncPassThroughEndpoint:
         pass_through_endpoint = await response.parse()
         assert_matches_type(object, pass_through_endpoint, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
         async with async_client.config.pass_through_endpoint.with_streaming_response.update(
@@ -251,7 +251,7 @@ class TestAsyncPassThroughEndpoint:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_update(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint_id` but received ''"):
@@ -259,13 +259,13 @@ class TestAsyncPassThroughEndpoint:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_list(self, async_client: AsyncHanzo) -> None:
         pass_through_endpoint = await async_client.config.pass_through_endpoint.list()
         assert_matches_type(PassThroughEndpointResponse, pass_through_endpoint, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_list_with_all_params(self, async_client: AsyncHanzo) -> None:
         pass_through_endpoint = await async_client.config.pass_through_endpoint.list(
@@ -273,7 +273,7 @@ class TestAsyncPassThroughEndpoint:
         )
         assert_matches_type(PassThroughEndpointResponse, pass_through_endpoint, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
         response = await async_client.config.pass_through_endpoint.with_raw_response.list()
@@ -283,7 +283,7 @@ class TestAsyncPassThroughEndpoint:
         pass_through_endpoint = await response.parse()
         assert_matches_type(PassThroughEndpointResponse, pass_through_endpoint, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
         async with async_client.config.pass_through_endpoint.with_streaming_response.list() as response:
@@ -295,7 +295,7 @@ class TestAsyncPassThroughEndpoint:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_delete(self, async_client: AsyncHanzo) -> None:
         pass_through_endpoint = await async_client.config.pass_through_endpoint.delete(
@@ -303,7 +303,7 @@ class TestAsyncPassThroughEndpoint:
         )
         assert_matches_type(PassThroughEndpointResponse, pass_through_endpoint, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
         response = await async_client.config.pass_through_endpoint.with_raw_response.delete(
@@ -315,7 +315,7 @@ class TestAsyncPassThroughEndpoint:
         pass_through_endpoint = await response.parse()
         assert_matches_type(PassThroughEndpointResponse, pass_through_endpoint, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
         async with async_client.config.pass_through_endpoint.with_streaming_response.delete(

tests/api_resources/engines/test_chat.py

@@ -16,7 +16,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestChat:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_complete(self, client: Hanzo) -> None:
         chat = client.engines.chat.complete(
@@ -24,7 +24,7 @@ class TestChat:
         )
         assert_matches_type(object, chat, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_complete(self, client: Hanzo) -> None:
         response = client.engines.chat.with_raw_response.complete(
@@ -36,7 +36,7 @@ class TestChat:
         chat = response.parse()
         assert_matches_type(object, chat, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_complete(self, client: Hanzo) -> None:
         with client.engines.chat.with_streaming_response.complete(
@@ -50,7 +50,7 @@ class TestChat:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_complete(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `model` but received ''"):
@@ -64,7 +64,7 @@ class TestAsyncChat:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_complete(self, async_client: AsyncHanzo) -> None:
         chat = await async_client.engines.chat.complete(
@@ -72,7 +72,7 @@ class TestAsyncChat:
         )
         assert_matches_type(object, chat, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_complete(self, async_client: AsyncHanzo) -> None:
         response = await async_client.engines.chat.with_raw_response.complete(
@@ -84,7 +84,7 @@ class TestAsyncChat:
         chat = await response.parse()
         assert_matches_type(object, chat, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_complete(self, async_client: AsyncHanzo) -> None:
         async with async_client.engines.chat.with_streaming_response.complete(
@@ -98,7 +98,7 @@ class TestAsyncChat:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_complete(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `model` but received ''"):

tests/api_resources/files/test_content.py

@@ -16,7 +16,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestContent:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_retrieve(self, client: Hanzo) -> None:
         content = client.files.content.retrieve(
@@ -25,7 +25,7 @@ class TestContent:
         )
         assert_matches_type(object, content, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_retrieve(self, client: Hanzo) -> None:
         response = client.files.content.with_raw_response.retrieve(
@@ -38,7 +38,7 @@ class TestContent:
         content = response.parse()
         assert_matches_type(object, content, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_retrieve(self, client: Hanzo) -> None:
         with client.files.content.with_streaming_response.retrieve(
@@ -53,7 +53,7 @@ class TestContent:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_retrieve(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `provider` but received ''"):
@@ -74,7 +74,7 @@ class TestAsyncContent:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
         content = await async_client.files.content.retrieve(
@@ -83,7 +83,7 @@ class TestAsyncContent:
         )
         assert_matches_type(object, content, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
         response = await async_client.files.content.with_raw_response.retrieve(
@@ -96,7 +96,7 @@ class TestAsyncContent:
         content = await response.parse()
         assert_matches_type(object, content, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
         async with async_client.files.content.with_streaming_response.retrieve(
@@ -111,7 +111,7 @@ class TestAsyncContent:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `provider` but received ''"):

tests/api_resources/fine_tuning/jobs/test_cancel.py

@@ -16,7 +16,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestCancel:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create(self, client: Hanzo) -> None:
         cancel = client.fine_tuning.jobs.cancel.create(
@@ -24,7 +24,7 @@ class TestCancel:
         )
         assert_matches_type(object, cancel, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Hanzo) -> None:
         response = client.fine_tuning.jobs.cancel.with_raw_response.create(
@@ -36,7 +36,7 @@ class TestCancel:
         cancel = response.parse()
         assert_matches_type(object, cancel, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Hanzo) -> None:
         with client.fine_tuning.jobs.cancel.with_streaming_response.create(
@@ -50,7 +50,7 @@ class TestCancel:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_create(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `fine_tuning_job_id` but received ''"):
@@ -64,7 +64,7 @@ class TestAsyncCancel:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncHanzo) -> None:
         cancel = await async_client.fine_tuning.jobs.cancel.create(
@@ -72,7 +72,7 @@ class TestAsyncCancel:
         )
         assert_matches_type(object, cancel, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
         response = await async_client.fine_tuning.jobs.cancel.with_raw_response.create(
@@ -84,7 +84,7 @@ class TestAsyncCancel:
         cancel = await response.parse()
         assert_matches_type(object, cancel, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
         async with async_client.fine_tuning.jobs.cancel.with_streaming_response.create(
@@ -98,7 +98,7 @@ class TestAsyncCancel:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_create(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `fine_tuning_job_id` but received ''"):

tests/api_resources/fine_tuning/test_jobs.py

@@ -16,7 +16,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestJobs:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create(self, client: Hanzo) -> None:
         job = client.fine_tuning.jobs.create(
@@ -26,7 +26,7 @@ class TestJobs:
         )
         assert_matches_type(object, job, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create_with_all_params(self, client: Hanzo) -> None:
         job = client.fine_tuning.jobs.create(
@@ -45,7 +45,7 @@ class TestJobs:
         )
         assert_matches_type(object, job, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Hanzo) -> None:
         response = client.fine_tuning.jobs.with_raw_response.create(
@@ -59,7 +59,7 @@ class TestJobs:
         job = response.parse()
         assert_matches_type(object, job, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Hanzo) -> None:
         with client.fine_tuning.jobs.with_streaming_response.create(
@@ -75,7 +75,7 @@ class TestJobs:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_retrieve(self, client: Hanzo) -> None:
         job = client.fine_tuning.jobs.retrieve(
@@ -84,7 +84,7 @@ class TestJobs:
         )
         assert_matches_type(object, job, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_retrieve(self, client: Hanzo) -> None:
         response = client.fine_tuning.jobs.with_raw_response.retrieve(
@@ -97,7 +97,7 @@ class TestJobs:
         job = response.parse()
         assert_matches_type(object, job, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_retrieve(self, client: Hanzo) -> None:
         with client.fine_tuning.jobs.with_streaming_response.retrieve(
@@ -112,7 +112,7 @@ class TestJobs:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_retrieve(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `fine_tuning_job_id` but received ''"):
@@ -121,7 +121,7 @@ class TestJobs:
                 custom_llm_provider="openai",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_list(self, client: Hanzo) -> None:
         job = client.fine_tuning.jobs.list(
@@ -129,7 +129,7 @@ class TestJobs:
         )
         assert_matches_type(object, job, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_list_with_all_params(self, client: Hanzo) -> None:
         job = client.fine_tuning.jobs.list(
@@ -139,7 +139,7 @@ class TestJobs:
         )
         assert_matches_type(object, job, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_list(self, client: Hanzo) -> None:
         response = client.fine_tuning.jobs.with_raw_response.list(
@@ -151,7 +151,7 @@ class TestJobs:
         job = response.parse()
         assert_matches_type(object, job, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_list(self, client: Hanzo) -> None:
         with client.fine_tuning.jobs.with_streaming_response.list(
@@ -171,7 +171,7 @@ class TestAsyncJobs:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncHanzo) -> None:
         job = await async_client.fine_tuning.jobs.create(
@@ -181,7 +181,7 @@ class TestAsyncJobs:
         )
         assert_matches_type(object, job, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create_with_all_params(self, async_client: AsyncHanzo) -> None:
         job = await async_client.fine_tuning.jobs.create(
@@ -200,7 +200,7 @@ class TestAsyncJobs:
         )
         assert_matches_type(object, job, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
         response = await async_client.fine_tuning.jobs.with_raw_response.create(
@@ -214,7 +214,7 @@ class TestAsyncJobs:
         job = await response.parse()
         assert_matches_type(object, job, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
         async with async_client.fine_tuning.jobs.with_streaming_response.create(
@@ -230,7 +230,7 @@ class TestAsyncJobs:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
         job = await async_client.fine_tuning.jobs.retrieve(
@@ -239,7 +239,7 @@ class TestAsyncJobs:
         )
         assert_matches_type(object, job, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
         response = await async_client.fine_tuning.jobs.with_raw_response.retrieve(
@@ -252,7 +252,7 @@ class TestAsyncJobs:
         job = await response.parse()
         assert_matches_type(object, job, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
         async with async_client.fine_tuning.jobs.with_streaming_response.retrieve(
@@ -267,7 +267,7 @@ class TestAsyncJobs:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `fine_tuning_job_id` but received ''"):
@@ -276,7 +276,7 @@ class TestAsyncJobs:
                 custom_llm_provider="openai",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_list(self, async_client: AsyncHanzo) -> None:
         job = await async_client.fine_tuning.jobs.list(
@@ -284,7 +284,7 @@ class TestAsyncJobs:
         )
         assert_matches_type(object, job, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_list_with_all_params(self, async_client: AsyncHanzo) -> None:
         job = await async_client.fine_tuning.jobs.list(
@@ -294,7 +294,7 @@ class TestAsyncJobs:
         )
         assert_matches_type(object, job, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
         response = await async_client.fine_tuning.jobs.with_raw_response.list(
@@ -306,7 +306,7 @@ class TestAsyncJobs:
         job = await response.parse()
         assert_matches_type(object, job, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
         async with async_client.fine_tuning.jobs.with_streaming_response.list(

tests/api_resources/global_/test_spend.py

@@ -20,13 +20,13 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestSpend:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_list_tags(self, client: Hanzo) -> None:
         spend = client.global_.spend.list_tags()
         assert_matches_type(SpendListTagsResponse, spend, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_list_tags_with_all_params(self, client: Hanzo) -> None:
         spend = client.global_.spend.list_tags(
@@ -36,7 +36,7 @@ class TestSpend:
         )
         assert_matches_type(SpendListTagsResponse, spend, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_list_tags(self, client: Hanzo) -> None:
         response = client.global_.spend.with_raw_response.list_tags()
@@ -46,7 +46,7 @@ class TestSpend:
         spend = response.parse()
         assert_matches_type(SpendListTagsResponse, spend, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_list_tags(self, client: Hanzo) -> None:
         with client.global_.spend.with_streaming_response.list_tags() as response:
@@ -58,13 +58,13 @@ class TestSpend:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_reset(self, client: Hanzo) -> None:
         spend = client.global_.spend.reset()
         assert_matches_type(object, spend, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_reset(self, client: Hanzo) -> None:
         response = client.global_.spend.with_raw_response.reset()
@@ -74,7 +74,7 @@ class TestSpend:
         spend = response.parse()
         assert_matches_type(object, spend, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_reset(self, client: Hanzo) -> None:
         with client.global_.spend.with_streaming_response.reset() as response:
@@ -86,13 +86,13 @@ class TestSpend:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_retrieve_report(self, client: Hanzo) -> None:
         spend = client.global_.spend.retrieve_report()
         assert_matches_type(SpendRetrieveReportResponse, spend, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_retrieve_report_with_all_params(self, client: Hanzo) -> None:
         spend = client.global_.spend.retrieve_report(
@@ -106,7 +106,7 @@ class TestSpend:
         )
         assert_matches_type(SpendRetrieveReportResponse, spend, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_retrieve_report(self, client: Hanzo) -> None:
         response = client.global_.spend.with_raw_response.retrieve_report()
@@ -116,7 +116,7 @@ class TestSpend:
         spend = response.parse()
         assert_matches_type(SpendRetrieveReportResponse, spend, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_retrieve_report(self, client: Hanzo) -> None:
         with client.global_.spend.with_streaming_response.retrieve_report() as response:
@@ -134,13 +134,13 @@ class TestAsyncSpend:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_list_tags(self, async_client: AsyncHanzo) -> None:
         spend = await async_client.global_.spend.list_tags()
         assert_matches_type(SpendListTagsResponse, spend, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_list_tags_with_all_params(self, async_client: AsyncHanzo) -> None:
         spend = await async_client.global_.spend.list_tags(
@@ -150,7 +150,7 @@ class TestAsyncSpend:
         )
         assert_matches_type(SpendListTagsResponse, spend, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_list_tags(self, async_client: AsyncHanzo) -> None:
         response = await async_client.global_.spend.with_raw_response.list_tags()
@@ -160,7 +160,7 @@ class TestAsyncSpend:
         spend = await response.parse()
         assert_matches_type(SpendListTagsResponse, spend, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_list_tags(self, async_client: AsyncHanzo) -> None:
         async with async_client.global_.spend.with_streaming_response.list_tags() as response:
@@ -172,13 +172,13 @@ class TestAsyncSpend:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_reset(self, async_client: AsyncHanzo) -> None:
         spend = await async_client.global_.spend.reset()
         assert_matches_type(object, spend, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_reset(self, async_client: AsyncHanzo) -> None:
         response = await async_client.global_.spend.with_raw_response.reset()
@@ -188,7 +188,7 @@ class TestAsyncSpend:
         spend = await response.parse()
         assert_matches_type(object, spend, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_reset(self, async_client: AsyncHanzo) -> None:
         async with async_client.global_.spend.with_streaming_response.reset() as response:
@@ -200,13 +200,13 @@ class TestAsyncSpend:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_retrieve_report(self, async_client: AsyncHanzo) -> None:
         spend = await async_client.global_.spend.retrieve_report()
         assert_matches_type(SpendRetrieveReportResponse, spend, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_retrieve_report_with_all_params(self, async_client: AsyncHanzo) -> None:
         spend = await async_client.global_.spend.retrieve_report(
@@ -220,7 +220,7 @@ class TestAsyncSpend:
         )
         assert_matches_type(SpendRetrieveReportResponse, spend, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_retrieve_report(self, async_client: AsyncHanzo) -> None:
         response = await async_client.global_.spend.with_raw_response.retrieve_report()
@@ -230,7 +230,7 @@ class TestAsyncSpend:
         spend = await response.parse()
         assert_matches_type(SpendRetrieveReportResponse, spend, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_retrieve_report(self, async_client: AsyncHanzo) -> None:
         async with async_client.global_.spend.with_streaming_response.retrieve_report() as response:

tests/api_resources/images/test_generations.py

@@ -16,13 +16,13 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestGenerations:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create(self, client: Hanzo) -> None:
         generation = client.images.generations.create()
         assert_matches_type(object, generation, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Hanzo) -> None:
         response = client.images.generations.with_raw_response.create()
@@ -32,7 +32,7 @@ class TestGenerations:
         generation = response.parse()
         assert_matches_type(object, generation, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Hanzo) -> None:
         with client.images.generations.with_streaming_response.create() as response:
@@ -50,13 +50,13 @@ class TestAsyncGenerations:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncHanzo) -> None:
         generation = await async_client.images.generations.create()
         assert_matches_type(object, generation, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
         response = await async_client.images.generations.with_raw_response.create()
@@ -66,7 +66,7 @@ class TestAsyncGenerations:
         generation = await response.parse()
         assert_matches_type(object, generation, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
         async with async_client.images.generations.with_streaming_response.create() as response:

tests/api_resources/model/test_info.py

@@ -16,13 +16,13 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestInfo:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_list(self, client: Hanzo) -> None:
         info = client.model.info.list()
         assert_matches_type(object, info, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_list_with_all_params(self, client: Hanzo) -> None:
         info = client.model.info.list(
@@ -30,7 +30,7 @@ class TestInfo:
         )
         assert_matches_type(object, info, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_list(self, client: Hanzo) -> None:
         response = client.model.info.with_raw_response.list()
@@ -40,7 +40,7 @@ class TestInfo:
         info = response.parse()
         assert_matches_type(object, info, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_list(self, client: Hanzo) -> None:
         with client.model.info.with_streaming_response.list() as response:
@@ -58,13 +58,13 @@ class TestAsyncInfo:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_list(self, async_client: AsyncHanzo) -> None:
         info = await async_client.model.info.list()
         assert_matches_type(object, info, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_list_with_all_params(self, async_client: AsyncHanzo) -> None:
         info = await async_client.model.info.list(
@@ -72,7 +72,7 @@ class TestAsyncInfo:
         )
         assert_matches_type(object, info, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
         response = await async_client.model.info.with_raw_response.list()
@@ -82,7 +82,7 @@ class TestAsyncInfo:
         info = await response.parse()
         assert_matches_type(object, info, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
         async with async_client.model.info.with_streaming_response.list() as response:

tests/api_resources/model/test_update.py

@@ -17,13 +17,13 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestUpdate:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_full(self, client: Hanzo) -> None:
         update = client.model.update.full()
         assert_matches_type(object, update, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_full_with_all_params(self, client: Hanzo) -> None:
         update = client.model.update.full(
@@ -76,7 +76,7 @@ class TestUpdate:
         )
         assert_matches_type(object, update, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_full(self, client: Hanzo) -> None:
         response = client.model.update.with_raw_response.full()
@@ -86,7 +86,7 @@ class TestUpdate:
         update = response.parse()
         assert_matches_type(object, update, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_full(self, client: Hanzo) -> None:
         with client.model.update.with_streaming_response.full() as response:
@@ -98,7 +98,7 @@ class TestUpdate:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_partial(self, client: Hanzo) -> None:
         update = client.model.update.partial(
@@ -106,7 +106,7 @@ class TestUpdate:
         )
         assert_matches_type(object, update, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_partial_with_all_params(self, client: Hanzo) -> None:
         update = client.model.update.partial(
@@ -160,7 +160,7 @@ class TestUpdate:
         )
         assert_matches_type(object, update, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_partial(self, client: Hanzo) -> None:
         response = client.model.update.with_raw_response.partial(
@@ -172,7 +172,7 @@ class TestUpdate:
         update = response.parse()
         assert_matches_type(object, update, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_partial(self, client: Hanzo) -> None:
         with client.model.update.with_streaming_response.partial(
@@ -186,7 +186,7 @@ class TestUpdate:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_partial(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `model_id` but received ''"):
@@ -200,13 +200,13 @@ class TestAsyncUpdate:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_full(self, async_client: AsyncHanzo) -> None:
         update = await async_client.model.update.full()
         assert_matches_type(object, update, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_full_with_all_params(self, async_client: AsyncHanzo) -> None:
         update = await async_client.model.update.full(
@@ -259,7 +259,7 @@ class TestAsyncUpdate:
         )
         assert_matches_type(object, update, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_full(self, async_client: AsyncHanzo) -> None:
         response = await async_client.model.update.with_raw_response.full()
@@ -269,7 +269,7 @@ class TestAsyncUpdate:
         update = await response.parse()
         assert_matches_type(object, update, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_full(self, async_client: AsyncHanzo) -> None:
         async with async_client.model.update.with_streaming_response.full() as response:
@@ -281,7 +281,7 @@ class TestAsyncUpdate:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_partial(self, async_client: AsyncHanzo) -> None:
         update = await async_client.model.update.partial(
@@ -289,7 +289,7 @@ class TestAsyncUpdate:
         )
         assert_matches_type(object, update, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_partial_with_all_params(self, async_client: AsyncHanzo) -> None:
         update = await async_client.model.update.partial(
@@ -343,7 +343,7 @@ class TestAsyncUpdate:
         )
         assert_matches_type(object, update, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_partial(self, async_client: AsyncHanzo) -> None:
         response = await async_client.model.update.with_raw_response.partial(
@@ -355,7 +355,7 @@ class TestAsyncUpdate:
         update = await response.parse()
         assert_matches_type(object, update, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_partial(self, async_client: AsyncHanzo) -> None:
         async with async_client.model.update.with_streaming_response.partial(
@@ -369,7 +369,7 @@ class TestAsyncUpdate:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_partial(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `model_id` but received ''"):

tests/api_resources/openai/deployments/test_chat.py

@@ -16,7 +16,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestChat:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_complete(self, client: Hanzo) -> None:
         chat = client.openai.deployments.chat.complete(
@@ -24,7 +24,7 @@ class TestChat:
         )
         assert_matches_type(object, chat, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_complete(self, client: Hanzo) -> None:
         response = client.openai.deployments.chat.with_raw_response.complete(
@@ -36,7 +36,7 @@ class TestChat:
         chat = response.parse()
         assert_matches_type(object, chat, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_complete(self, client: Hanzo) -> None:
         with client.openai.deployments.chat.with_streaming_response.complete(
@@ -50,7 +50,7 @@ class TestChat:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_complete(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `model` but received ''"):
@@ -64,7 +64,7 @@ class TestAsyncChat:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_complete(self, async_client: AsyncHanzo) -> None:
         chat = await async_client.openai.deployments.chat.complete(
@@ -72,7 +72,7 @@ class TestAsyncChat:
         )
         assert_matches_type(object, chat, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_complete(self, async_client: AsyncHanzo) -> None:
         response = await async_client.openai.deployments.chat.with_raw_response.complete(
@@ -84,7 +84,7 @@ class TestAsyncChat:
         chat = await response.parse()
         assert_matches_type(object, chat, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_complete(self, async_client: AsyncHanzo) -> None:
         async with async_client.openai.deployments.chat.with_streaming_response.complete(
@@ -98,7 +98,7 @@ class TestAsyncChat:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_complete(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `model` but received ''"):

tests/api_resources/openai/test_deployments.py

@@ -16,7 +16,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestDeployments:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_complete(self, client: Hanzo) -> None:
         deployment = client.openai.deployments.complete(
@@ -24,7 +24,7 @@ class TestDeployments:
         )
         assert_matches_type(object, deployment, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_complete(self, client: Hanzo) -> None:
         response = client.openai.deployments.with_raw_response.complete(
@@ -36,7 +36,7 @@ class TestDeployments:
         deployment = response.parse()
         assert_matches_type(object, deployment, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_complete(self, client: Hanzo) -> None:
         with client.openai.deployments.with_streaming_response.complete(
@@ -50,7 +50,7 @@ class TestDeployments:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_complete(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `model` but received ''"):
@@ -58,7 +58,7 @@ class TestDeployments:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_embed(self, client: Hanzo) -> None:
         deployment = client.openai.deployments.embed(
@@ -66,7 +66,7 @@ class TestDeployments:
         )
         assert_matches_type(object, deployment, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_embed(self, client: Hanzo) -> None:
         response = client.openai.deployments.with_raw_response.embed(
@@ -78,7 +78,7 @@ class TestDeployments:
         deployment = response.parse()
         assert_matches_type(object, deployment, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_embed(self, client: Hanzo) -> None:
         with client.openai.deployments.with_streaming_response.embed(
@@ -92,7 +92,7 @@ class TestDeployments:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_embed(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `model` but received ''"):
@@ -106,7 +106,7 @@ class TestAsyncDeployments:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_complete(self, async_client: AsyncHanzo) -> None:
         deployment = await async_client.openai.deployments.complete(
@@ -114,7 +114,7 @@ class TestAsyncDeployments:
         )
         assert_matches_type(object, deployment, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_complete(self, async_client: AsyncHanzo) -> None:
         response = await async_client.openai.deployments.with_raw_response.complete(
@@ -126,7 +126,7 @@ class TestAsyncDeployments:
         deployment = await response.parse()
         assert_matches_type(object, deployment, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_complete(self, async_client: AsyncHanzo) -> None:
         async with async_client.openai.deployments.with_streaming_response.complete(
@@ -140,7 +140,7 @@ class TestAsyncDeployments:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_complete(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `model` but received ''"):
@@ -148,7 +148,7 @@ class TestAsyncDeployments:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_embed(self, async_client: AsyncHanzo) -> None:
         deployment = await async_client.openai.deployments.embed(
@@ -156,7 +156,7 @@ class TestAsyncDeployments:
         )
         assert_matches_type(object, deployment, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_embed(self, async_client: AsyncHanzo) -> None:
         response = await async_client.openai.deployments.with_raw_response.embed(
@@ -168,7 +168,7 @@ class TestAsyncDeployments:
         deployment = await response.parse()
         assert_matches_type(object, deployment, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_embed(self, async_client: AsyncHanzo) -> None:
         async with async_client.openai.deployments.with_streaming_response.embed(
@@ -182,7 +182,7 @@ class TestAsyncDeployments:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_embed(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `model` but received ''"):

tests/api_resources/organization/test_info.py

@@ -17,7 +17,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestInfo:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_retrieve(self, client: Hanzo) -> None:
         info = client.organization.info.retrieve(
@@ -25,7 +25,7 @@ class TestInfo:
         )
         assert_matches_type(InfoRetrieveResponse, info, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_retrieve(self, client: Hanzo) -> None:
         response = client.organization.info.with_raw_response.retrieve(
@@ -37,7 +37,7 @@ class TestInfo:
         info = response.parse()
         assert_matches_type(InfoRetrieveResponse, info, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_retrieve(self, client: Hanzo) -> None:
         with client.organization.info.with_streaming_response.retrieve(
@@ -51,7 +51,7 @@ class TestInfo:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_deprecated(self, client: Hanzo) -> None:
         info = client.organization.info.deprecated(
@@ -59,7 +59,7 @@ class TestInfo:
         )
         assert_matches_type(object, info, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_deprecated(self, client: Hanzo) -> None:
         response = client.organization.info.with_raw_response.deprecated(
@@ -71,7 +71,7 @@ class TestInfo:
         info = response.parse()
         assert_matches_type(object, info, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_deprecated(self, client: Hanzo) -> None:
         with client.organization.info.with_streaming_response.deprecated(
@@ -91,7 +91,7 @@ class TestAsyncInfo:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
         info = await async_client.organization.info.retrieve(
@@ -99,7 +99,7 @@ class TestAsyncInfo:
         )
         assert_matches_type(InfoRetrieveResponse, info, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
         response = await async_client.organization.info.with_raw_response.retrieve(
@@ -111,7 +111,7 @@ class TestAsyncInfo:
         info = await response.parse()
         assert_matches_type(InfoRetrieveResponse, info, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
         async with async_client.organization.info.with_streaming_response.retrieve(
@@ -125,7 +125,7 @@ class TestAsyncInfo:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_deprecated(self, async_client: AsyncHanzo) -> None:
         info = await async_client.organization.info.deprecated(
@@ -133,7 +133,7 @@ class TestAsyncInfo:
         )
         assert_matches_type(object, info, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_deprecated(self, async_client: AsyncHanzo) -> None:
         response = await async_client.organization.info.with_raw_response.deprecated(
@@ -145,7 +145,7 @@ class TestAsyncInfo:
         info = await response.parse()
         assert_matches_type(object, info, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_deprecated(self, async_client: AsyncHanzo) -> None:
         async with async_client.organization.info.with_streaming_response.deprecated(

tests/api_resources/responses/test_input_items.py

@@ -16,7 +16,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestInputItems:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_list(self, client: Hanzo) -> None:
         input_item = client.responses.input_items.list(
@@ -24,7 +24,7 @@ class TestInputItems:
         )
         assert_matches_type(object, input_item, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_list(self, client: Hanzo) -> None:
         response = client.responses.input_items.with_raw_response.list(
@@ -36,7 +36,7 @@ class TestInputItems:
         input_item = response.parse()
         assert_matches_type(object, input_item, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_list(self, client: Hanzo) -> None:
         with client.responses.input_items.with_streaming_response.list(
@@ -50,7 +50,7 @@ class TestInputItems:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_list(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `response_id` but received ''"):
@@ -64,7 +64,7 @@ class TestAsyncInputItems:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_list(self, async_client: AsyncHanzo) -> None:
         input_item = await async_client.responses.input_items.list(
@@ -72,7 +72,7 @@ class TestAsyncInputItems:
         )
         assert_matches_type(object, input_item, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
         response = await async_client.responses.input_items.with_raw_response.list(
@@ -84,7 +84,7 @@ class TestAsyncInputItems:
         input_item = await response.parse()
         assert_matches_type(object, input_item, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
         async with async_client.responses.input_items.with_streaming_response.list(
@@ -98,7 +98,7 @@ class TestAsyncInputItems:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_list(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `response_id` but received ''"):

tests/api_resources/team/test_callback.py

@@ -16,7 +16,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestCallback:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_retrieve(self, client: Hanzo) -> None:
         callback = client.team.callback.retrieve(
@@ -24,7 +24,7 @@ class TestCallback:
         )
         assert_matches_type(object, callback, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_retrieve(self, client: Hanzo) -> None:
         response = client.team.callback.with_raw_response.retrieve(
@@ -36,7 +36,7 @@ class TestCallback:
         callback = response.parse()
         assert_matches_type(object, callback, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_retrieve(self, client: Hanzo) -> None:
         with client.team.callback.with_streaming_response.retrieve(
@@ -50,7 +50,7 @@ class TestCallback:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_retrieve(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `team_id` but received ''"):
@@ -58,7 +58,7 @@ class TestCallback:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_add(self, client: Hanzo) -> None:
         callback = client.team.callback.add(
@@ -68,7 +68,7 @@ class TestCallback:
         )
         assert_matches_type(object, callback, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_add_with_all_params(self, client: Hanzo) -> None:
         callback = client.team.callback.add(
@@ -80,7 +80,7 @@ class TestCallback:
         )
         assert_matches_type(object, callback, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_add(self, client: Hanzo) -> None:
         response = client.team.callback.with_raw_response.add(
@@ -94,7 +94,7 @@ class TestCallback:
         callback = response.parse()
         assert_matches_type(object, callback, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_add(self, client: Hanzo) -> None:
         with client.team.callback.with_streaming_response.add(
@@ -110,7 +110,7 @@ class TestCallback:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_add(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `team_id` but received ''"):
@@ -126,7 +126,7 @@ class TestAsyncCallback:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
         callback = await async_client.team.callback.retrieve(
@@ -134,7 +134,7 @@ class TestAsyncCallback:
         )
         assert_matches_type(object, callback, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
         response = await async_client.team.callback.with_raw_response.retrieve(
@@ -146,7 +146,7 @@ class TestAsyncCallback:
         callback = await response.parse()
         assert_matches_type(object, callback, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
         async with async_client.team.callback.with_streaming_response.retrieve(
@@ -160,7 +160,7 @@ class TestAsyncCallback:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `team_id` but received ''"):
@@ -168,7 +168,7 @@ class TestAsyncCallback:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_add(self, async_client: AsyncHanzo) -> None:
         callback = await async_client.team.callback.add(
@@ -178,7 +178,7 @@ class TestAsyncCallback:
         )
         assert_matches_type(object, callback, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_add_with_all_params(self, async_client: AsyncHanzo) -> None:
         callback = await async_client.team.callback.add(
@@ -190,7 +190,7 @@ class TestAsyncCallback:
         )
         assert_matches_type(object, callback, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_add(self, async_client: AsyncHanzo) -> None:
         response = await async_client.team.callback.with_raw_response.add(
@@ -204,7 +204,7 @@ class TestAsyncCallback:
         callback = await response.parse()
         assert_matches_type(object, callback, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_add(self, async_client: AsyncHanzo) -> None:
         async with async_client.team.callback.with_streaming_response.add(
@@ -220,7 +220,7 @@ class TestAsyncCallback:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_add(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `team_id` but received ''"):

tests/api_resources/team/test_model.py

@@ -16,7 +16,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestModel:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_add(self, client: Hanzo) -> None:
         model = client.team.model.add(
@@ -25,7 +25,7 @@ class TestModel:
         )
         assert_matches_type(object, model, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_add(self, client: Hanzo) -> None:
         response = client.team.model.with_raw_response.add(
@@ -38,7 +38,7 @@ class TestModel:
         model = response.parse()
         assert_matches_type(object, model, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_add(self, client: Hanzo) -> None:
         with client.team.model.with_streaming_response.add(
@@ -53,7 +53,7 @@ class TestModel:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_remove(self, client: Hanzo) -> None:
         model = client.team.model.remove(
@@ -62,7 +62,7 @@ class TestModel:
         )
         assert_matches_type(object, model, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_remove(self, client: Hanzo) -> None:
         response = client.team.model.with_raw_response.remove(
@@ -75,7 +75,7 @@ class TestModel:
         model = response.parse()
         assert_matches_type(object, model, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_remove(self, client: Hanzo) -> None:
         with client.team.model.with_streaming_response.remove(
@@ -96,7 +96,7 @@ class TestAsyncModel:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_add(self, async_client: AsyncHanzo) -> None:
         model = await async_client.team.model.add(
@@ -105,7 +105,7 @@ class TestAsyncModel:
         )
         assert_matches_type(object, model, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_add(self, async_client: AsyncHanzo) -> None:
         response = await async_client.team.model.with_raw_response.add(
@@ -118,7 +118,7 @@ class TestAsyncModel:
         model = await response.parse()
         assert_matches_type(object, model, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_add(self, async_client: AsyncHanzo) -> None:
         async with async_client.team.model.with_streaming_response.add(
@@ -133,7 +133,7 @@ class TestAsyncModel:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_remove(self, async_client: AsyncHanzo) -> None:
         model = await async_client.team.model.remove(
@@ -142,7 +142,7 @@ class TestAsyncModel:
         )
         assert_matches_type(object, model, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_remove(self, async_client: AsyncHanzo) -> None:
         response = await async_client.team.model.with_raw_response.remove(
@@ -155,7 +155,7 @@ class TestAsyncModel:
         model = await response.parse()
         assert_matches_type(object, model, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_remove(self, async_client: AsyncHanzo) -> None:
         async with async_client.team.model.with_streaming_response.remove(

tests/api_resources/test_active.py

@@ -16,13 +16,13 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestActive:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_list_callbacks(self, client: Hanzo) -> None:
         active = client.active.list_callbacks()
         assert_matches_type(object, active, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_list_callbacks(self, client: Hanzo) -> None:
         response = client.active.with_raw_response.list_callbacks()
@@ -32,7 +32,7 @@ class TestActive:
         active = response.parse()
         assert_matches_type(object, active, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_list_callbacks(self, client: Hanzo) -> None:
         with client.active.with_streaming_response.list_callbacks() as response:
@@ -50,13 +50,13 @@ class TestAsyncActive:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_list_callbacks(self, async_client: AsyncHanzo) -> None:
         active = await async_client.active.list_callbacks()
         assert_matches_type(object, active, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_list_callbacks(self, async_client: AsyncHanzo) -> None:
         response = await async_client.active.with_raw_response.list_callbacks()
@@ -66,7 +66,7 @@ class TestAsyncActive:
         active = await response.parse()
         assert_matches_type(object, active, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_list_callbacks(self, async_client: AsyncHanzo) -> None:
         async with async_client.active.with_streaming_response.list_callbacks() as response:

tests/api_resources/test_add.py

@@ -16,7 +16,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestAdd:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_add_allowed_ip(self, client: Hanzo) -> None:
         add = client.add.add_allowed_ip(
@@ -24,7 +24,7 @@ class TestAdd:
         )
         assert_matches_type(object, add, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_add_allowed_ip(self, client: Hanzo) -> None:
         response = client.add.with_raw_response.add_allowed_ip(
@@ -36,7 +36,7 @@ class TestAdd:
         add = response.parse()
         assert_matches_type(object, add, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_add_allowed_ip(self, client: Hanzo) -> None:
         with client.add.with_streaming_response.add_allowed_ip(
@@ -56,7 +56,7 @@ class TestAsyncAdd:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_add_allowed_ip(self, async_client: AsyncHanzo) -> None:
         add = await async_client.add.add_allowed_ip(
@@ -64,7 +64,7 @@ class TestAsyncAdd:
         )
         assert_matches_type(object, add, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_add_allowed_ip(self, async_client: AsyncHanzo) -> None:
         response = await async_client.add.with_raw_response.add_allowed_ip(
@@ -76,7 +76,7 @@ class TestAsyncAdd:
         add = await response.parse()
         assert_matches_type(object, add, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_add_allowed_ip(self, async_client: AsyncHanzo) -> None:
         async with async_client.add.with_streaming_response.add_allowed_ip(

tests/api_resources/test_anthropic.py

@@ -16,7 +16,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestAnthropic:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create(self, client: Hanzo) -> None:
         anthropic = client.anthropic.create(
@@ -24,7 +24,7 @@ class TestAnthropic:
         )
         assert_matches_type(object, anthropic, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Hanzo) -> None:
         response = client.anthropic.with_raw_response.create(
@@ -36,7 +36,7 @@ class TestAnthropic:
         anthropic = response.parse()
         assert_matches_type(object, anthropic, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Hanzo) -> None:
         with client.anthropic.with_streaming_response.create(
@@ -50,7 +50,7 @@ class TestAnthropic:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_create(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -58,7 +58,7 @@ class TestAnthropic:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_retrieve(self, client: Hanzo) -> None:
         anthropic = client.anthropic.retrieve(
@@ -66,7 +66,7 @@ class TestAnthropic:
         )
         assert_matches_type(object, anthropic, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_retrieve(self, client: Hanzo) -> None:
         response = client.anthropic.with_raw_response.retrieve(
@@ -78,7 +78,7 @@ class TestAnthropic:
         anthropic = response.parse()
         assert_matches_type(object, anthropic, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_retrieve(self, client: Hanzo) -> None:
         with client.anthropic.with_streaming_response.retrieve(
@@ -92,7 +92,7 @@ class TestAnthropic:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_retrieve(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -100,7 +100,7 @@ class TestAnthropic:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_update(self, client: Hanzo) -> None:
         anthropic = client.anthropic.update(
@@ -108,7 +108,7 @@ class TestAnthropic:
         )
         assert_matches_type(object, anthropic, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_update(self, client: Hanzo) -> None:
         response = client.anthropic.with_raw_response.update(
@@ -120,7 +120,7 @@ class TestAnthropic:
         anthropic = response.parse()
         assert_matches_type(object, anthropic, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_update(self, client: Hanzo) -> None:
         with client.anthropic.with_streaming_response.update(
@@ -134,7 +134,7 @@ class TestAnthropic:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_update(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -142,7 +142,7 @@ class TestAnthropic:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_delete(self, client: Hanzo) -> None:
         anthropic = client.anthropic.delete(
@@ -150,7 +150,7 @@ class TestAnthropic:
         )
         assert_matches_type(object, anthropic, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_delete(self, client: Hanzo) -> None:
         response = client.anthropic.with_raw_response.delete(
@@ -162,7 +162,7 @@ class TestAnthropic:
         anthropic = response.parse()
         assert_matches_type(object, anthropic, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_delete(self, client: Hanzo) -> None:
         with client.anthropic.with_streaming_response.delete(
@@ -176,7 +176,7 @@ class TestAnthropic:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_delete(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -184,7 +184,7 @@ class TestAnthropic:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_modify(self, client: Hanzo) -> None:
         anthropic = client.anthropic.modify(
@@ -192,7 +192,7 @@ class TestAnthropic:
         )
         assert_matches_type(object, anthropic, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_modify(self, client: Hanzo) -> None:
         response = client.anthropic.with_raw_response.modify(
@@ -204,7 +204,7 @@ class TestAnthropic:
         anthropic = response.parse()
         assert_matches_type(object, anthropic, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_modify(self, client: Hanzo) -> None:
         with client.anthropic.with_streaming_response.modify(
@@ -218,7 +218,7 @@ class TestAnthropic:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_modify(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -232,7 +232,7 @@ class TestAsyncAnthropic:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncHanzo) -> None:
         anthropic = await async_client.anthropic.create(
@@ -240,7 +240,7 @@ class TestAsyncAnthropic:
         )
         assert_matches_type(object, anthropic, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
         response = await async_client.anthropic.with_raw_response.create(
@@ -252,7 +252,7 @@ class TestAsyncAnthropic:
         anthropic = await response.parse()
         assert_matches_type(object, anthropic, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
         async with async_client.anthropic.with_streaming_response.create(
@@ -266,7 +266,7 @@ class TestAsyncAnthropic:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_create(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -274,7 +274,7 @@ class TestAsyncAnthropic:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
         anthropic = await async_client.anthropic.retrieve(
@@ -282,7 +282,7 @@ class TestAsyncAnthropic:
         )
         assert_matches_type(object, anthropic, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
         response = await async_client.anthropic.with_raw_response.retrieve(
@@ -294,7 +294,7 @@ class TestAsyncAnthropic:
         anthropic = await response.parse()
         assert_matches_type(object, anthropic, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
         async with async_client.anthropic.with_streaming_response.retrieve(
@@ -308,7 +308,7 @@ class TestAsyncAnthropic:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -316,7 +316,7 @@ class TestAsyncAnthropic:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_update(self, async_client: AsyncHanzo) -> None:
         anthropic = await async_client.anthropic.update(
@@ -324,7 +324,7 @@ class TestAsyncAnthropic:
         )
         assert_matches_type(object, anthropic, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
         response = await async_client.anthropic.with_raw_response.update(
@@ -336,7 +336,7 @@ class TestAsyncAnthropic:
         anthropic = await response.parse()
         assert_matches_type(object, anthropic, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
         async with async_client.anthropic.with_streaming_response.update(
@@ -350,7 +350,7 @@ class TestAsyncAnthropic:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_update(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -358,7 +358,7 @@ class TestAsyncAnthropic:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_delete(self, async_client: AsyncHanzo) -> None:
         anthropic = await async_client.anthropic.delete(
@@ -366,7 +366,7 @@ class TestAsyncAnthropic:
         )
         assert_matches_type(object, anthropic, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
         response = await async_client.anthropic.with_raw_response.delete(
@@ -378,7 +378,7 @@ class TestAsyncAnthropic:
         anthropic = await response.parse()
         assert_matches_type(object, anthropic, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
         async with async_client.anthropic.with_streaming_response.delete(
@@ -392,7 +392,7 @@ class TestAsyncAnthropic:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_delete(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -400,7 +400,7 @@ class TestAsyncAnthropic:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_modify(self, async_client: AsyncHanzo) -> None:
         anthropic = await async_client.anthropic.modify(
@@ -408,7 +408,7 @@ class TestAsyncAnthropic:
         )
         assert_matches_type(object, anthropic, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_modify(self, async_client: AsyncHanzo) -> None:
         response = await async_client.anthropic.with_raw_response.modify(
@@ -420,7 +420,7 @@ class TestAsyncAnthropic:
         anthropic = await response.parse()
         assert_matches_type(object, anthropic, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_modify(self, async_client: AsyncHanzo) -> None:
         async with async_client.anthropic.with_streaming_response.modify(
@@ -434,7 +434,7 @@ class TestAsyncAnthropic:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_modify(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):

tests/api_resources/test_assemblyai.py

@@ -16,7 +16,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestAssemblyai:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create(self, client: Hanzo) -> None:
         assemblyai = client.assemblyai.create(
@@ -24,7 +24,7 @@ class TestAssemblyai:
         )
         assert_matches_type(object, assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Hanzo) -> None:
         response = client.assemblyai.with_raw_response.create(
@@ -36,7 +36,7 @@ class TestAssemblyai:
         assemblyai = response.parse()
         assert_matches_type(object, assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Hanzo) -> None:
         with client.assemblyai.with_streaming_response.create(
@@ -50,7 +50,7 @@ class TestAssemblyai:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_create(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -58,7 +58,7 @@ class TestAssemblyai:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_retrieve(self, client: Hanzo) -> None:
         assemblyai = client.assemblyai.retrieve(
@@ -66,7 +66,7 @@ class TestAssemblyai:
         )
         assert_matches_type(object, assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_retrieve(self, client: Hanzo) -> None:
         response = client.assemblyai.with_raw_response.retrieve(
@@ -78,7 +78,7 @@ class TestAssemblyai:
         assemblyai = response.parse()
         assert_matches_type(object, assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_retrieve(self, client: Hanzo) -> None:
         with client.assemblyai.with_streaming_response.retrieve(
@@ -92,7 +92,7 @@ class TestAssemblyai:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_retrieve(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -100,7 +100,7 @@ class TestAssemblyai:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_update(self, client: Hanzo) -> None:
         assemblyai = client.assemblyai.update(
@@ -108,7 +108,7 @@ class TestAssemblyai:
         )
         assert_matches_type(object, assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_update(self, client: Hanzo) -> None:
         response = client.assemblyai.with_raw_response.update(
@@ -120,7 +120,7 @@ class TestAssemblyai:
         assemblyai = response.parse()
         assert_matches_type(object, assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_update(self, client: Hanzo) -> None:
         with client.assemblyai.with_streaming_response.update(
@@ -134,7 +134,7 @@ class TestAssemblyai:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_update(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -142,7 +142,7 @@ class TestAssemblyai:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_delete(self, client: Hanzo) -> None:
         assemblyai = client.assemblyai.delete(
@@ -150,7 +150,7 @@ class TestAssemblyai:
         )
         assert_matches_type(object, assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_delete(self, client: Hanzo) -> None:
         response = client.assemblyai.with_raw_response.delete(
@@ -162,7 +162,7 @@ class TestAssemblyai:
         assemblyai = response.parse()
         assert_matches_type(object, assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_delete(self, client: Hanzo) -> None:
         with client.assemblyai.with_streaming_response.delete(
@@ -176,7 +176,7 @@ class TestAssemblyai:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_delete(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -184,7 +184,7 @@ class TestAssemblyai:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_patch(self, client: Hanzo) -> None:
         assemblyai = client.assemblyai.patch(
@@ -192,7 +192,7 @@ class TestAssemblyai:
         )
         assert_matches_type(object, assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_patch(self, client: Hanzo) -> None:
         response = client.assemblyai.with_raw_response.patch(
@@ -204,7 +204,7 @@ class TestAssemblyai:
         assemblyai = response.parse()
         assert_matches_type(object, assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_patch(self, client: Hanzo) -> None:
         with client.assemblyai.with_streaming_response.patch(
@@ -218,7 +218,7 @@ class TestAssemblyai:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_patch(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -232,7 +232,7 @@ class TestAsyncAssemblyai:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncHanzo) -> None:
         assemblyai = await async_client.assemblyai.create(
@@ -240,7 +240,7 @@ class TestAsyncAssemblyai:
         )
         assert_matches_type(object, assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
         response = await async_client.assemblyai.with_raw_response.create(
@@ -252,7 +252,7 @@ class TestAsyncAssemblyai:
         assemblyai = await response.parse()
         assert_matches_type(object, assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
         async with async_client.assemblyai.with_streaming_response.create(
@@ -266,7 +266,7 @@ class TestAsyncAssemblyai:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_create(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -274,7 +274,7 @@ class TestAsyncAssemblyai:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
         assemblyai = await async_client.assemblyai.retrieve(
@@ -282,7 +282,7 @@ class TestAsyncAssemblyai:
         )
         assert_matches_type(object, assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
         response = await async_client.assemblyai.with_raw_response.retrieve(
@@ -294,7 +294,7 @@ class TestAsyncAssemblyai:
         assemblyai = await response.parse()
         assert_matches_type(object, assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
         async with async_client.assemblyai.with_streaming_response.retrieve(
@@ -308,7 +308,7 @@ class TestAsyncAssemblyai:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -316,7 +316,7 @@ class TestAsyncAssemblyai:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_update(self, async_client: AsyncHanzo) -> None:
         assemblyai = await async_client.assemblyai.update(
@@ -324,7 +324,7 @@ class TestAsyncAssemblyai:
         )
         assert_matches_type(object, assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
         response = await async_client.assemblyai.with_raw_response.update(
@@ -336,7 +336,7 @@ class TestAsyncAssemblyai:
         assemblyai = await response.parse()
         assert_matches_type(object, assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
         async with async_client.assemblyai.with_streaming_response.update(
@@ -350,7 +350,7 @@ class TestAsyncAssemblyai:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_update(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -358,7 +358,7 @@ class TestAsyncAssemblyai:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_delete(self, async_client: AsyncHanzo) -> None:
         assemblyai = await async_client.assemblyai.delete(
@@ -366,7 +366,7 @@ class TestAsyncAssemblyai:
         )
         assert_matches_type(object, assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
         response = await async_client.assemblyai.with_raw_response.delete(
@@ -378,7 +378,7 @@ class TestAsyncAssemblyai:
         assemblyai = await response.parse()
         assert_matches_type(object, assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
         async with async_client.assemblyai.with_streaming_response.delete(
@@ -392,7 +392,7 @@ class TestAsyncAssemblyai:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_delete(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -400,7 +400,7 @@ class TestAsyncAssemblyai:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_patch(self, async_client: AsyncHanzo) -> None:
         assemblyai = await async_client.assemblyai.patch(
@@ -408,7 +408,7 @@ class TestAsyncAssemblyai:
         )
         assert_matches_type(object, assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_patch(self, async_client: AsyncHanzo) -> None:
         response = await async_client.assemblyai.with_raw_response.patch(
@@ -420,7 +420,7 @@ class TestAsyncAssemblyai:
         assemblyai = await response.parse()
         assert_matches_type(object, assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_patch(self, async_client: AsyncHanzo) -> None:
         async with async_client.assemblyai.with_streaming_response.patch(
@@ -434,7 +434,7 @@ class TestAsyncAssemblyai:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_patch(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):

tests/api_resources/test_assistants.py

@@ -16,13 +16,13 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestAssistants:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create(self, client: Hanzo) -> None:
         assistant = client.assistants.create()
         assert_matches_type(object, assistant, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Hanzo) -> None:
         response = client.assistants.with_raw_response.create()
@@ -32,7 +32,7 @@ class TestAssistants:
         assistant = response.parse()
         assert_matches_type(object, assistant, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Hanzo) -> None:
         with client.assistants.with_streaming_response.create() as response:
@@ -44,13 +44,13 @@ class TestAssistants:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_list(self, client: Hanzo) -> None:
         assistant = client.assistants.list()
         assert_matches_type(object, assistant, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_list(self, client: Hanzo) -> None:
         response = client.assistants.with_raw_response.list()
@@ -60,7 +60,7 @@ class TestAssistants:
         assistant = response.parse()
         assert_matches_type(object, assistant, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_list(self, client: Hanzo) -> None:
         with client.assistants.with_streaming_response.list() as response:
@@ -72,7 +72,7 @@ class TestAssistants:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_delete(self, client: Hanzo) -> None:
         assistant = client.assistants.delete(
@@ -80,7 +80,7 @@ class TestAssistants:
         )
         assert_matches_type(object, assistant, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_delete(self, client: Hanzo) -> None:
         response = client.assistants.with_raw_response.delete(
@@ -92,7 +92,7 @@ class TestAssistants:
         assistant = response.parse()
         assert_matches_type(object, assistant, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_delete(self, client: Hanzo) -> None:
         with client.assistants.with_streaming_response.delete(
@@ -106,7 +106,7 @@ class TestAssistants:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_delete(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `assistant_id` but received ''"):
@@ -120,13 +120,13 @@ class TestAsyncAssistants:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncHanzo) -> None:
         assistant = await async_client.assistants.create()
         assert_matches_type(object, assistant, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
         response = await async_client.assistants.with_raw_response.create()
@@ -136,7 +136,7 @@ class TestAsyncAssistants:
         assistant = await response.parse()
         assert_matches_type(object, assistant, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
         async with async_client.assistants.with_streaming_response.create() as response:
@@ -148,13 +148,13 @@ class TestAsyncAssistants:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_list(self, async_client: AsyncHanzo) -> None:
         assistant = await async_client.assistants.list()
         assert_matches_type(object, assistant, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
         response = await async_client.assistants.with_raw_response.list()
@@ -164,7 +164,7 @@ class TestAsyncAssistants:
         assistant = await response.parse()
         assert_matches_type(object, assistant, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
         async with async_client.assistants.with_streaming_response.list() as response:
@@ -176,7 +176,7 @@ class TestAsyncAssistants:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_delete(self, async_client: AsyncHanzo) -> None:
         assistant = await async_client.assistants.delete(
@@ -184,7 +184,7 @@ class TestAsyncAssistants:
         )
         assert_matches_type(object, assistant, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
         response = await async_client.assistants.with_raw_response.delete(
@@ -196,7 +196,7 @@ class TestAsyncAssistants:
         assistant = await response.parse()
         assert_matches_type(object, assistant, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
         async with async_client.assistants.with_streaming_response.delete(
@@ -210,7 +210,7 @@ class TestAsyncAssistants:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_delete(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `assistant_id` but received ''"):

tests/api_resources/test_azure.py

@@ -16,7 +16,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestAzure:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create(self, client: Hanzo) -> None:
         azure = client.azure.create(
@@ -24,7 +24,7 @@ class TestAzure:
         )
         assert_matches_type(object, azure, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Hanzo) -> None:
         response = client.azure.with_raw_response.create(
@@ -36,7 +36,7 @@ class TestAzure:
         azure = response.parse()
         assert_matches_type(object, azure, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Hanzo) -> None:
         with client.azure.with_streaming_response.create(
@@ -50,7 +50,7 @@ class TestAzure:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_create(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -58,7 +58,7 @@ class TestAzure:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_update(self, client: Hanzo) -> None:
         azure = client.azure.update(
@@ -66,7 +66,7 @@ class TestAzure:
         )
         assert_matches_type(object, azure, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_update(self, client: Hanzo) -> None:
         response = client.azure.with_raw_response.update(
@@ -78,7 +78,7 @@ class TestAzure:
         azure = response.parse()
         assert_matches_type(object, azure, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_update(self, client: Hanzo) -> None:
         with client.azure.with_streaming_response.update(
@@ -92,7 +92,7 @@ class TestAzure:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_update(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -100,7 +100,7 @@ class TestAzure:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_delete(self, client: Hanzo) -> None:
         azure = client.azure.delete(
@@ -108,7 +108,7 @@ class TestAzure:
         )
         assert_matches_type(object, azure, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_delete(self, client: Hanzo) -> None:
         response = client.azure.with_raw_response.delete(
@@ -120,7 +120,7 @@ class TestAzure:
         azure = response.parse()
         assert_matches_type(object, azure, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_delete(self, client: Hanzo) -> None:
         with client.azure.with_streaming_response.delete(
@@ -134,7 +134,7 @@ class TestAzure:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_delete(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -142,7 +142,7 @@ class TestAzure:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_call(self, client: Hanzo) -> None:
         azure = client.azure.call(
@@ -150,7 +150,7 @@ class TestAzure:
         )
         assert_matches_type(object, azure, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_call(self, client: Hanzo) -> None:
         response = client.azure.with_raw_response.call(
@@ -162,7 +162,7 @@ class TestAzure:
         azure = response.parse()
         assert_matches_type(object, azure, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_call(self, client: Hanzo) -> None:
         with client.azure.with_streaming_response.call(
@@ -176,7 +176,7 @@ class TestAzure:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_call(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -184,7 +184,7 @@ class TestAzure:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_patch(self, client: Hanzo) -> None:
         azure = client.azure.patch(
@@ -192,7 +192,7 @@ class TestAzure:
         )
         assert_matches_type(object, azure, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_patch(self, client: Hanzo) -> None:
         response = client.azure.with_raw_response.patch(
@@ -204,7 +204,7 @@ class TestAzure:
         azure = response.parse()
         assert_matches_type(object, azure, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_patch(self, client: Hanzo) -> None:
         with client.azure.with_streaming_response.patch(
@@ -218,7 +218,7 @@ class TestAzure:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_patch(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -232,7 +232,7 @@ class TestAsyncAzure:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncHanzo) -> None:
         azure = await async_client.azure.create(
@@ -240,7 +240,7 @@ class TestAsyncAzure:
         )
         assert_matches_type(object, azure, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
         response = await async_client.azure.with_raw_response.create(
@@ -252,7 +252,7 @@ class TestAsyncAzure:
         azure = await response.parse()
         assert_matches_type(object, azure, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
         async with async_client.azure.with_streaming_response.create(
@@ -266,7 +266,7 @@ class TestAsyncAzure:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_create(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -274,7 +274,7 @@ class TestAsyncAzure:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_update(self, async_client: AsyncHanzo) -> None:
         azure = await async_client.azure.update(
@@ -282,7 +282,7 @@ class TestAsyncAzure:
         )
         assert_matches_type(object, azure, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
         response = await async_client.azure.with_raw_response.update(
@@ -294,7 +294,7 @@ class TestAsyncAzure:
         azure = await response.parse()
         assert_matches_type(object, azure, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
         async with async_client.azure.with_streaming_response.update(
@@ -308,7 +308,7 @@ class TestAsyncAzure:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_update(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -316,7 +316,7 @@ class TestAsyncAzure:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_delete(self, async_client: AsyncHanzo) -> None:
         azure = await async_client.azure.delete(
@@ -324,7 +324,7 @@ class TestAsyncAzure:
         )
         assert_matches_type(object, azure, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
         response = await async_client.azure.with_raw_response.delete(
@@ -336,7 +336,7 @@ class TestAsyncAzure:
         azure = await response.parse()
         assert_matches_type(object, azure, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
         async with async_client.azure.with_streaming_response.delete(
@@ -350,7 +350,7 @@ class TestAsyncAzure:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_delete(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -358,7 +358,7 @@ class TestAsyncAzure:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_call(self, async_client: AsyncHanzo) -> None:
         azure = await async_client.azure.call(
@@ -366,7 +366,7 @@ class TestAsyncAzure:
         )
         assert_matches_type(object, azure, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_call(self, async_client: AsyncHanzo) -> None:
         response = await async_client.azure.with_raw_response.call(
@@ -378,7 +378,7 @@ class TestAsyncAzure:
         azure = await response.parse()
         assert_matches_type(object, azure, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_call(self, async_client: AsyncHanzo) -> None:
         async with async_client.azure.with_streaming_response.call(
@@ -392,7 +392,7 @@ class TestAsyncAzure:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_call(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -400,7 +400,7 @@ class TestAsyncAzure:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_patch(self, async_client: AsyncHanzo) -> None:
         azure = await async_client.azure.patch(
@@ -408,7 +408,7 @@ class TestAsyncAzure:
         )
         assert_matches_type(object, azure, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_patch(self, async_client: AsyncHanzo) -> None:
         response = await async_client.azure.with_raw_response.patch(
@@ -420,7 +420,7 @@ class TestAsyncAzure:
         azure = await response.parse()
         assert_matches_type(object, azure, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_patch(self, async_client: AsyncHanzo) -> None:
         async with async_client.azure.with_streaming_response.patch(
@@ -434,7 +434,7 @@ class TestAsyncAzure:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_patch(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):

tests/api_resources/test_batches.py

@@ -16,13 +16,13 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestBatches:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create(self, client: Hanzo) -> None:
         batch = client.batches.create()
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create_with_all_params(self, client: Hanzo) -> None:
         batch = client.batches.create(
@@ -30,7 +30,7 @@ class TestBatches:
         )
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Hanzo) -> None:
         response = client.batches.with_raw_response.create()
@@ -40,7 +40,7 @@ class TestBatches:
         batch = response.parse()
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Hanzo) -> None:
         with client.batches.with_streaming_response.create() as response:
@@ -52,7 +52,7 @@ class TestBatches:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_retrieve(self, client: Hanzo) -> None:
         batch = client.batches.retrieve(
@@ -60,7 +60,7 @@ class TestBatches:
         )
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_retrieve_with_all_params(self, client: Hanzo) -> None:
         batch = client.batches.retrieve(
@@ -69,7 +69,7 @@ class TestBatches:
         )
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_retrieve(self, client: Hanzo) -> None:
         response = client.batches.with_raw_response.retrieve(
@@ -81,7 +81,7 @@ class TestBatches:
         batch = response.parse()
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_retrieve(self, client: Hanzo) -> None:
         with client.batches.with_streaming_response.retrieve(
@@ -95,7 +95,7 @@ class TestBatches:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_retrieve(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `batch_id` but received ''"):
@@ -103,13 +103,13 @@ class TestBatches:
                 batch_id="",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_list(self, client: Hanzo) -> None:
         batch = client.batches.list()
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_list_with_all_params(self, client: Hanzo) -> None:
         batch = client.batches.list(
@@ -119,7 +119,7 @@ class TestBatches:
         )
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_list(self, client: Hanzo) -> None:
         response = client.batches.with_raw_response.list()
@@ -129,7 +129,7 @@ class TestBatches:
         batch = response.parse()
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_list(self, client: Hanzo) -> None:
         with client.batches.with_streaming_response.list() as response:
@@ -141,7 +141,7 @@ class TestBatches:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_cancel_with_provider(self, client: Hanzo) -> None:
         batch = client.batches.cancel_with_provider(
@@ -150,7 +150,7 @@ class TestBatches:
         )
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_cancel_with_provider(self, client: Hanzo) -> None:
         response = client.batches.with_raw_response.cancel_with_provider(
@@ -163,7 +163,7 @@ class TestBatches:
         batch = response.parse()
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_cancel_with_provider(self, client: Hanzo) -> None:
         with client.batches.with_streaming_response.cancel_with_provider(
@@ -178,7 +178,7 @@ class TestBatches:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_cancel_with_provider(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `provider` but received ''"):
@@ -193,7 +193,7 @@ class TestBatches:
                 provider="provider",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create_with_provider(self, client: Hanzo) -> None:
         batch = client.batches.create_with_provider(
@@ -201,7 +201,7 @@ class TestBatches:
         )
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_create_with_provider(self, client: Hanzo) -> None:
         response = client.batches.with_raw_response.create_with_provider(
@@ -213,7 +213,7 @@ class TestBatches:
         batch = response.parse()
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_create_with_provider(self, client: Hanzo) -> None:
         with client.batches.with_streaming_response.create_with_provider(
@@ -227,7 +227,7 @@ class TestBatches:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_create_with_provider(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `provider` but received ''"):
@@ -235,7 +235,7 @@ class TestBatches:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_list_with_provider(self, client: Hanzo) -> None:
         batch = client.batches.list_with_provider(
@@ -243,7 +243,7 @@ class TestBatches:
         )
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_list_with_provider_with_all_params(self, client: Hanzo) -> None:
         batch = client.batches.list_with_provider(
@@ -253,7 +253,7 @@ class TestBatches:
         )
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_list_with_provider(self, client: Hanzo) -> None:
         response = client.batches.with_raw_response.list_with_provider(
@@ -265,7 +265,7 @@ class TestBatches:
         batch = response.parse()
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_list_with_provider(self, client: Hanzo) -> None:
         with client.batches.with_streaming_response.list_with_provider(
@@ -279,7 +279,7 @@ class TestBatches:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_list_with_provider(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `provider` but received ''"):
@@ -287,7 +287,7 @@ class TestBatches:
                 provider="",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_retrieve_with_provider(self, client: Hanzo) -> None:
         batch = client.batches.retrieve_with_provider(
@@ -296,7 +296,7 @@ class TestBatches:
         )
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_retrieve_with_provider(self, client: Hanzo) -> None:
         response = client.batches.with_raw_response.retrieve_with_provider(
@@ -309,7 +309,7 @@ class TestBatches:
         batch = response.parse()
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_retrieve_with_provider(self, client: Hanzo) -> None:
         with client.batches.with_streaming_response.retrieve_with_provider(
@@ -324,7 +324,7 @@ class TestBatches:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_retrieve_with_provider(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `provider` but received ''"):
@@ -345,13 +345,13 @@ class TestAsyncBatches:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncHanzo) -> None:
         batch = await async_client.batches.create()
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create_with_all_params(self, async_client: AsyncHanzo) -> None:
         batch = await async_client.batches.create(
@@ -359,7 +359,7 @@ class TestAsyncBatches:
         )
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
         response = await async_client.batches.with_raw_response.create()
@@ -369,7 +369,7 @@ class TestAsyncBatches:
         batch = await response.parse()
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
         async with async_client.batches.with_streaming_response.create() as response:
@@ -381,7 +381,7 @@ class TestAsyncBatches:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
         batch = await async_client.batches.retrieve(
@@ -389,7 +389,7 @@ class TestAsyncBatches:
         )
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_retrieve_with_all_params(self, async_client: AsyncHanzo) -> None:
         batch = await async_client.batches.retrieve(
@@ -398,7 +398,7 @@ class TestAsyncBatches:
         )
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
         response = await async_client.batches.with_raw_response.retrieve(
@@ -410,7 +410,7 @@ class TestAsyncBatches:
         batch = await response.parse()
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
         async with async_client.batches.with_streaming_response.retrieve(
@@ -424,7 +424,7 @@ class TestAsyncBatches:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `batch_id` but received ''"):
@@ -432,13 +432,13 @@ class TestAsyncBatches:
                 batch_id="",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_list(self, async_client: AsyncHanzo) -> None:
         batch = await async_client.batches.list()
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_list_with_all_params(self, async_client: AsyncHanzo) -> None:
         batch = await async_client.batches.list(
@@ -448,7 +448,7 @@ class TestAsyncBatches:
         )
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
         response = await async_client.batches.with_raw_response.list()
@@ -458,7 +458,7 @@ class TestAsyncBatches:
         batch = await response.parse()
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
         async with async_client.batches.with_streaming_response.list() as response:
@@ -470,7 +470,7 @@ class TestAsyncBatches:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_cancel_with_provider(self, async_client: AsyncHanzo) -> None:
         batch = await async_client.batches.cancel_with_provider(
@@ -479,7 +479,7 @@ class TestAsyncBatches:
         )
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_cancel_with_provider(self, async_client: AsyncHanzo) -> None:
         response = await async_client.batches.with_raw_response.cancel_with_provider(
@@ -492,7 +492,7 @@ class TestAsyncBatches:
         batch = await response.parse()
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_cancel_with_provider(self, async_client: AsyncHanzo) -> None:
         async with async_client.batches.with_streaming_response.cancel_with_provider(
@@ -507,7 +507,7 @@ class TestAsyncBatches:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_cancel_with_provider(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `provider` but received ''"):
@@ -522,7 +522,7 @@ class TestAsyncBatches:
                 provider="provider",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create_with_provider(self, async_client: AsyncHanzo) -> None:
         batch = await async_client.batches.create_with_provider(
@@ -530,7 +530,7 @@ class TestAsyncBatches:
         )
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_create_with_provider(self, async_client: AsyncHanzo) -> None:
         response = await async_client.batches.with_raw_response.create_with_provider(
@@ -542,7 +542,7 @@ class TestAsyncBatches:
         batch = await response.parse()
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_create_with_provider(self, async_client: AsyncHanzo) -> None:
         async with async_client.batches.with_streaming_response.create_with_provider(
@@ -556,7 +556,7 @@ class TestAsyncBatches:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_create_with_provider(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `provider` but received ''"):
@@ -564,7 +564,7 @@ class TestAsyncBatches:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_list_with_provider(self, async_client: AsyncHanzo) -> None:
         batch = await async_client.batches.list_with_provider(
@@ -572,7 +572,7 @@ class TestAsyncBatches:
         )
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_list_with_provider_with_all_params(self, async_client: AsyncHanzo) -> None:
         batch = await async_client.batches.list_with_provider(
@@ -582,7 +582,7 @@ class TestAsyncBatches:
         )
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_list_with_provider(self, async_client: AsyncHanzo) -> None:
         response = await async_client.batches.with_raw_response.list_with_provider(
@@ -594,7 +594,7 @@ class TestAsyncBatches:
         batch = await response.parse()
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_list_with_provider(self, async_client: AsyncHanzo) -> None:
         async with async_client.batches.with_streaming_response.list_with_provider(
@@ -608,7 +608,7 @@ class TestAsyncBatches:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_list_with_provider(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `provider` but received ''"):
@@ -616,7 +616,7 @@ class TestAsyncBatches:
                 provider="",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_retrieve_with_provider(self, async_client: AsyncHanzo) -> None:
         batch = await async_client.batches.retrieve_with_provider(
@@ -625,7 +625,7 @@ class TestAsyncBatches:
         )
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_retrieve_with_provider(self, async_client: AsyncHanzo) -> None:
         response = await async_client.batches.with_raw_response.retrieve_with_provider(
@@ -638,7 +638,7 @@ class TestAsyncBatches:
         batch = await response.parse()
         assert_matches_type(object, batch, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_retrieve_with_provider(self, async_client: AsyncHanzo) -> None:
         async with async_client.batches.with_streaming_response.retrieve_with_provider(
@@ -653,7 +653,7 @@ class TestAsyncBatches:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_retrieve_with_provider(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `provider` but received ''"):

tests/api_resources/test_bedrock.py

@@ -16,7 +16,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestBedrock:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create(self, client: Hanzo) -> None:
         bedrock = client.bedrock.create(
@@ -24,7 +24,7 @@ class TestBedrock:
         )
         assert_matches_type(object, bedrock, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Hanzo) -> None:
         response = client.bedrock.with_raw_response.create(
@@ -36,7 +36,7 @@ class TestBedrock:
         bedrock = response.parse()
         assert_matches_type(object, bedrock, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Hanzo) -> None:
         with client.bedrock.with_streaming_response.create(
@@ -50,7 +50,7 @@ class TestBedrock:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_create(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -58,7 +58,7 @@ class TestBedrock:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_retrieve(self, client: Hanzo) -> None:
         bedrock = client.bedrock.retrieve(
@@ -66,7 +66,7 @@ class TestBedrock:
         )
         assert_matches_type(object, bedrock, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_retrieve(self, client: Hanzo) -> None:
         response = client.bedrock.with_raw_response.retrieve(
@@ -78,7 +78,7 @@ class TestBedrock:
         bedrock = response.parse()
         assert_matches_type(object, bedrock, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_retrieve(self, client: Hanzo) -> None:
         with client.bedrock.with_streaming_response.retrieve(
@@ -92,7 +92,7 @@ class TestBedrock:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_retrieve(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -100,7 +100,7 @@ class TestBedrock:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_update(self, client: Hanzo) -> None:
         bedrock = client.bedrock.update(
@@ -108,7 +108,7 @@ class TestBedrock:
         )
         assert_matches_type(object, bedrock, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_update(self, client: Hanzo) -> None:
         response = client.bedrock.with_raw_response.update(
@@ -120,7 +120,7 @@ class TestBedrock:
         bedrock = response.parse()
         assert_matches_type(object, bedrock, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_update(self, client: Hanzo) -> None:
         with client.bedrock.with_streaming_response.update(
@@ -134,7 +134,7 @@ class TestBedrock:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_update(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -142,7 +142,7 @@ class TestBedrock:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_delete(self, client: Hanzo) -> None:
         bedrock = client.bedrock.delete(
@@ -150,7 +150,7 @@ class TestBedrock:
         )
         assert_matches_type(object, bedrock, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_delete(self, client: Hanzo) -> None:
         response = client.bedrock.with_raw_response.delete(
@@ -162,7 +162,7 @@ class TestBedrock:
         bedrock = response.parse()
         assert_matches_type(object, bedrock, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_delete(self, client: Hanzo) -> None:
         with client.bedrock.with_streaming_response.delete(
@@ -176,7 +176,7 @@ class TestBedrock:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_delete(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -184,7 +184,7 @@ class TestBedrock:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_patch(self, client: Hanzo) -> None:
         bedrock = client.bedrock.patch(
@@ -192,7 +192,7 @@ class TestBedrock:
         )
         assert_matches_type(object, bedrock, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_patch(self, client: Hanzo) -> None:
         response = client.bedrock.with_raw_response.patch(
@@ -204,7 +204,7 @@ class TestBedrock:
         bedrock = response.parse()
         assert_matches_type(object, bedrock, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_patch(self, client: Hanzo) -> None:
         with client.bedrock.with_streaming_response.patch(
@@ -218,7 +218,7 @@ class TestBedrock:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_patch(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -232,7 +232,7 @@ class TestAsyncBedrock:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncHanzo) -> None:
         bedrock = await async_client.bedrock.create(
@@ -240,7 +240,7 @@ class TestAsyncBedrock:
         )
         assert_matches_type(object, bedrock, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
         response = await async_client.bedrock.with_raw_response.create(
@@ -252,7 +252,7 @@ class TestAsyncBedrock:
         bedrock = await response.parse()
         assert_matches_type(object, bedrock, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
         async with async_client.bedrock.with_streaming_response.create(
@@ -266,7 +266,7 @@ class TestAsyncBedrock:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_create(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -274,7 +274,7 @@ class TestAsyncBedrock:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
         bedrock = await async_client.bedrock.retrieve(
@@ -282,7 +282,7 @@ class TestAsyncBedrock:
         )
         assert_matches_type(object, bedrock, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
         response = await async_client.bedrock.with_raw_response.retrieve(
@@ -294,7 +294,7 @@ class TestAsyncBedrock:
         bedrock = await response.parse()
         assert_matches_type(object, bedrock, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
         async with async_client.bedrock.with_streaming_response.retrieve(
@@ -308,7 +308,7 @@ class TestAsyncBedrock:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -316,7 +316,7 @@ class TestAsyncBedrock:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_update(self, async_client: AsyncHanzo) -> None:
         bedrock = await async_client.bedrock.update(
@@ -324,7 +324,7 @@ class TestAsyncBedrock:
         )
         assert_matches_type(object, bedrock, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
         response = await async_client.bedrock.with_raw_response.update(
@@ -336,7 +336,7 @@ class TestAsyncBedrock:
         bedrock = await response.parse()
         assert_matches_type(object, bedrock, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
         async with async_client.bedrock.with_streaming_response.update(
@@ -350,7 +350,7 @@ class TestAsyncBedrock:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_update(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -358,7 +358,7 @@ class TestAsyncBedrock:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_delete(self, async_client: AsyncHanzo) -> None:
         bedrock = await async_client.bedrock.delete(
@@ -366,7 +366,7 @@ class TestAsyncBedrock:
         )
         assert_matches_type(object, bedrock, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
         response = await async_client.bedrock.with_raw_response.delete(
@@ -378,7 +378,7 @@ class TestAsyncBedrock:
         bedrock = await response.parse()
         assert_matches_type(object, bedrock, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
         async with async_client.bedrock.with_streaming_response.delete(
@@ -392,7 +392,7 @@ class TestAsyncBedrock:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_delete(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -400,7 +400,7 @@ class TestAsyncBedrock:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_patch(self, async_client: AsyncHanzo) -> None:
         bedrock = await async_client.bedrock.patch(
@@ -408,7 +408,7 @@ class TestAsyncBedrock:
         )
         assert_matches_type(object, bedrock, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_patch(self, async_client: AsyncHanzo) -> None:
         response = await async_client.bedrock.with_raw_response.patch(
@@ -420,7 +420,7 @@ class TestAsyncBedrock:
         bedrock = await response.parse()
         assert_matches_type(object, bedrock, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_patch(self, async_client: AsyncHanzo) -> None:
         async with async_client.bedrock.with_streaming_response.patch(
@@ -434,7 +434,7 @@ class TestAsyncBedrock:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_patch(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):

tests/api_resources/test_budget.py

@@ -16,13 +16,13 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestBudget:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create(self, client: Hanzo) -> None:
         budget = client.budget.create()
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create_with_all_params(self, client: Hanzo) -> None:
         budget = client.budget.create(
@@ -44,7 +44,7 @@ class TestBudget:
         )
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Hanzo) -> None:
         response = client.budget.with_raw_response.create()
@@ -54,7 +54,7 @@ class TestBudget:
         budget = response.parse()
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Hanzo) -> None:
         with client.budget.with_streaming_response.create() as response:
@@ -66,13 +66,13 @@ class TestBudget:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_update(self, client: Hanzo) -> None:
         budget = client.budget.update()
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_update_with_all_params(self, client: Hanzo) -> None:
         budget = client.budget.update(
@@ -94,7 +94,7 @@ class TestBudget:
         )
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_update(self, client: Hanzo) -> None:
         response = client.budget.with_raw_response.update()
@@ -104,7 +104,7 @@ class TestBudget:
         budget = response.parse()
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_update(self, client: Hanzo) -> None:
         with client.budget.with_streaming_response.update() as response:
@@ -116,13 +116,13 @@ class TestBudget:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_list(self, client: Hanzo) -> None:
         budget = client.budget.list()
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_list(self, client: Hanzo) -> None:
         response = client.budget.with_raw_response.list()
@@ -132,7 +132,7 @@ class TestBudget:
         budget = response.parse()
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_list(self, client: Hanzo) -> None:
         with client.budget.with_streaming_response.list() as response:
@@ -144,7 +144,7 @@ class TestBudget:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_delete(self, client: Hanzo) -> None:
         budget = client.budget.delete(
@@ -152,7 +152,7 @@ class TestBudget:
         )
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_delete(self, client: Hanzo) -> None:
         response = client.budget.with_raw_response.delete(
@@ -164,7 +164,7 @@ class TestBudget:
         budget = response.parse()
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_delete(self, client: Hanzo) -> None:
         with client.budget.with_streaming_response.delete(
@@ -178,7 +178,7 @@ class TestBudget:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_info(self, client: Hanzo) -> None:
         budget = client.budget.info(
@@ -186,7 +186,7 @@ class TestBudget:
         )
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_info(self, client: Hanzo) -> None:
         response = client.budget.with_raw_response.info(
@@ -198,7 +198,7 @@ class TestBudget:
         budget = response.parse()
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_info(self, client: Hanzo) -> None:
         with client.budget.with_streaming_response.info(
@@ -212,7 +212,7 @@ class TestBudget:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_settings(self, client: Hanzo) -> None:
         budget = client.budget.settings(
@@ -220,7 +220,7 @@ class TestBudget:
         )
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_settings(self, client: Hanzo) -> None:
         response = client.budget.with_raw_response.settings(
@@ -232,7 +232,7 @@ class TestBudget:
         budget = response.parse()
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_settings(self, client: Hanzo) -> None:
         with client.budget.with_streaming_response.settings(
@@ -252,13 +252,13 @@ class TestAsyncBudget:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncHanzo) -> None:
         budget = await async_client.budget.create()
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create_with_all_params(self, async_client: AsyncHanzo) -> None:
         budget = await async_client.budget.create(
@@ -280,7 +280,7 @@ class TestAsyncBudget:
         )
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
         response = await async_client.budget.with_raw_response.create()
@@ -290,7 +290,7 @@ class TestAsyncBudget:
         budget = await response.parse()
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
         async with async_client.budget.with_streaming_response.create() as response:
@@ -302,13 +302,13 @@ class TestAsyncBudget:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_update(self, async_client: AsyncHanzo) -> None:
         budget = await async_client.budget.update()
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_update_with_all_params(self, async_client: AsyncHanzo) -> None:
         budget = await async_client.budget.update(
@@ -330,7 +330,7 @@ class TestAsyncBudget:
         )
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
         response = await async_client.budget.with_raw_response.update()
@@ -340,7 +340,7 @@ class TestAsyncBudget:
         budget = await response.parse()
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
         async with async_client.budget.with_streaming_response.update() as response:
@@ -352,13 +352,13 @@ class TestAsyncBudget:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_list(self, async_client: AsyncHanzo) -> None:
         budget = await async_client.budget.list()
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
         response = await async_client.budget.with_raw_response.list()
@@ -368,7 +368,7 @@ class TestAsyncBudget:
         budget = await response.parse()
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
         async with async_client.budget.with_streaming_response.list() as response:
@@ -380,7 +380,7 @@ class TestAsyncBudget:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_delete(self, async_client: AsyncHanzo) -> None:
         budget = await async_client.budget.delete(
@@ -388,7 +388,7 @@ class TestAsyncBudget:
         )
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
         response = await async_client.budget.with_raw_response.delete(
@@ -400,7 +400,7 @@ class TestAsyncBudget:
         budget = await response.parse()
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
         async with async_client.budget.with_streaming_response.delete(
@@ -414,7 +414,7 @@ class TestAsyncBudget:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_info(self, async_client: AsyncHanzo) -> None:
         budget = await async_client.budget.info(
@@ -422,7 +422,7 @@ class TestAsyncBudget:
         )
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_info(self, async_client: AsyncHanzo) -> None:
         response = await async_client.budget.with_raw_response.info(
@@ -434,7 +434,7 @@ class TestAsyncBudget:
         budget = await response.parse()
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_info(self, async_client: AsyncHanzo) -> None:
         async with async_client.budget.with_streaming_response.info(
@@ -448,7 +448,7 @@ class TestAsyncBudget:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_settings(self, async_client: AsyncHanzo) -> None:
         budget = await async_client.budget.settings(
@@ -456,7 +456,7 @@ class TestAsyncBudget:
         )
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_settings(self, async_client: AsyncHanzo) -> None:
         response = await async_client.budget.with_raw_response.settings(
@@ -468,7 +468,7 @@ class TestAsyncBudget:
         budget = await response.parse()
         assert_matches_type(object, budget, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_settings(self, async_client: AsyncHanzo) -> None:
         async with async_client.budget.with_streaming_response.settings(

tests/api_resources/test_cache.py

@@ -17,13 +17,13 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestCache:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_delete(self, client: Hanzo) -> None:
         cache = client.cache.delete()
         assert_matches_type(object, cache, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_delete(self, client: Hanzo) -> None:
         response = client.cache.with_raw_response.delete()
@@ -33,7 +33,7 @@ class TestCache:
         cache = response.parse()
         assert_matches_type(object, cache, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_delete(self, client: Hanzo) -> None:
         with client.cache.with_streaming_response.delete() as response:
@@ -45,13 +45,13 @@ class TestCache:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_flush_all(self, client: Hanzo) -> None:
         cache = client.cache.flush_all()
         assert_matches_type(object, cache, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_flush_all(self, client: Hanzo) -> None:
         response = client.cache.with_raw_response.flush_all()
@@ -61,7 +61,7 @@ class TestCache:
         cache = response.parse()
         assert_matches_type(object, cache, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_flush_all(self, client: Hanzo) -> None:
         with client.cache.with_streaming_response.flush_all() as response:
@@ -73,13 +73,13 @@ class TestCache:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_ping(self, client: Hanzo) -> None:
         cache = client.cache.ping()
         assert_matches_type(CachePingResponse, cache, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_ping(self, client: Hanzo) -> None:
         response = client.cache.with_raw_response.ping()
@@ -89,7 +89,7 @@ class TestCache:
         cache = response.parse()
         assert_matches_type(CachePingResponse, cache, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_ping(self, client: Hanzo) -> None:
         with client.cache.with_streaming_response.ping() as response:
@@ -107,13 +107,13 @@ class TestAsyncCache:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_delete(self, async_client: AsyncHanzo) -> None:
         cache = await async_client.cache.delete()
         assert_matches_type(object, cache, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
         response = await async_client.cache.with_raw_response.delete()
@@ -123,7 +123,7 @@ class TestAsyncCache:
         cache = await response.parse()
         assert_matches_type(object, cache, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
         async with async_client.cache.with_streaming_response.delete() as response:
@@ -135,13 +135,13 @@ class TestAsyncCache:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_flush_all(self, async_client: AsyncHanzo) -> None:
         cache = await async_client.cache.flush_all()
         assert_matches_type(object, cache, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_flush_all(self, async_client: AsyncHanzo) -> None:
         response = await async_client.cache.with_raw_response.flush_all()
@@ -151,7 +151,7 @@ class TestAsyncCache:
         cache = await response.parse()
         assert_matches_type(object, cache, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_flush_all(self, async_client: AsyncHanzo) -> None:
         async with async_client.cache.with_streaming_response.flush_all() as response:
@@ -163,13 +163,13 @@ class TestAsyncCache:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_ping(self, async_client: AsyncHanzo) -> None:
         cache = await async_client.cache.ping()
         assert_matches_type(CachePingResponse, cache, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_ping(self, async_client: AsyncHanzo) -> None:
         response = await async_client.cache.with_raw_response.ping()
@@ -179,7 +179,7 @@ class TestAsyncCache:
         cache = await response.parse()
         assert_matches_type(CachePingResponse, cache, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_ping(self, async_client: AsyncHanzo) -> None:
         async with async_client.cache.with_streaming_response.ping() as response:

tests/api_resources/test_client.py

@@ -16,13 +16,13 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestClient:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_get_home(self, client: Hanzo) -> None:
         client_ = client.get_home()
         assert_matches_type(object, client_, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_get_home(self, client: Hanzo) -> None:
         response = client.with_raw_response.get_home()
@@ -32,7 +32,7 @@ class TestClient:
         client_ = response.parse()
         assert_matches_type(object, client_, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_get_home(self, client: Hanzo) -> None:
         with client.with_streaming_response.get_home() as response:
@@ -50,13 +50,13 @@ class TestAsyncClient:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_get_home(self, async_client: AsyncHanzo) -> None:
         client = await async_client.get_home()
         assert_matches_type(object, client, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_get_home(self, async_client: AsyncHanzo) -> None:
         response = await async_client.with_raw_response.get_home()
@@ -66,7 +66,7 @@ class TestAsyncClient:
         client = await response.parse()
         assert_matches_type(object, client, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_get_home(self, async_client: AsyncHanzo) -> None:
         async with async_client.with_streaming_response.get_home() as response:

tests/api_resources/test_cohere.py

@@ -16,7 +16,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestCohere:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create(self, client: Hanzo) -> None:
         cohere = client.cohere.create(
@@ -24,7 +24,7 @@ class TestCohere:
         )
         assert_matches_type(object, cohere, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Hanzo) -> None:
         response = client.cohere.with_raw_response.create(
@@ -36,7 +36,7 @@ class TestCohere:
         cohere = response.parse()
         assert_matches_type(object, cohere, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Hanzo) -> None:
         with client.cohere.with_streaming_response.create(
@@ -50,7 +50,7 @@ class TestCohere:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_create(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -58,7 +58,7 @@ class TestCohere:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_retrieve(self, client: Hanzo) -> None:
         cohere = client.cohere.retrieve(
@@ -66,7 +66,7 @@ class TestCohere:
         )
         assert_matches_type(object, cohere, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_retrieve(self, client: Hanzo) -> None:
         response = client.cohere.with_raw_response.retrieve(
@@ -78,7 +78,7 @@ class TestCohere:
         cohere = response.parse()
         assert_matches_type(object, cohere, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_retrieve(self, client: Hanzo) -> None:
         with client.cohere.with_streaming_response.retrieve(
@@ -92,7 +92,7 @@ class TestCohere:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_retrieve(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -100,7 +100,7 @@ class TestCohere:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_update(self, client: Hanzo) -> None:
         cohere = client.cohere.update(
@@ -108,7 +108,7 @@ class TestCohere:
         )
         assert_matches_type(object, cohere, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_update(self, client: Hanzo) -> None:
         response = client.cohere.with_raw_response.update(
@@ -120,7 +120,7 @@ class TestCohere:
         cohere = response.parse()
         assert_matches_type(object, cohere, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_update(self, client: Hanzo) -> None:
         with client.cohere.with_streaming_response.update(
@@ -134,7 +134,7 @@ class TestCohere:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_update(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -142,7 +142,7 @@ class TestCohere:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_delete(self, client: Hanzo) -> None:
         cohere = client.cohere.delete(
@@ -150,7 +150,7 @@ class TestCohere:
         )
         assert_matches_type(object, cohere, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_delete(self, client: Hanzo) -> None:
         response = client.cohere.with_raw_response.delete(
@@ -162,7 +162,7 @@ class TestCohere:
         cohere = response.parse()
         assert_matches_type(object, cohere, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_delete(self, client: Hanzo) -> None:
         with client.cohere.with_streaming_response.delete(
@@ -176,7 +176,7 @@ class TestCohere:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_delete(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -184,7 +184,7 @@ class TestCohere:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_modify(self, client: Hanzo) -> None:
         cohere = client.cohere.modify(
@@ -192,7 +192,7 @@ class TestCohere:
         )
         assert_matches_type(object, cohere, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_modify(self, client: Hanzo) -> None:
         response = client.cohere.with_raw_response.modify(
@@ -204,7 +204,7 @@ class TestCohere:
         cohere = response.parse()
         assert_matches_type(object, cohere, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_modify(self, client: Hanzo) -> None:
         with client.cohere.with_streaming_response.modify(
@@ -218,7 +218,7 @@ class TestCohere:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_modify(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -232,7 +232,7 @@ class TestAsyncCohere:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncHanzo) -> None:
         cohere = await async_client.cohere.create(
@@ -240,7 +240,7 @@ class TestAsyncCohere:
         )
         assert_matches_type(object, cohere, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
         response = await async_client.cohere.with_raw_response.create(
@@ -252,7 +252,7 @@ class TestAsyncCohere:
         cohere = await response.parse()
         assert_matches_type(object, cohere, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
         async with async_client.cohere.with_streaming_response.create(
@@ -266,7 +266,7 @@ class TestAsyncCohere:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_create(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -274,7 +274,7 @@ class TestAsyncCohere:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
         cohere = await async_client.cohere.retrieve(
@@ -282,7 +282,7 @@ class TestAsyncCohere:
         )
         assert_matches_type(object, cohere, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
         response = await async_client.cohere.with_raw_response.retrieve(
@@ -294,7 +294,7 @@ class TestAsyncCohere:
         cohere = await response.parse()
         assert_matches_type(object, cohere, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
         async with async_client.cohere.with_streaming_response.retrieve(
@@ -308,7 +308,7 @@ class TestAsyncCohere:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -316,7 +316,7 @@ class TestAsyncCohere:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_update(self, async_client: AsyncHanzo) -> None:
         cohere = await async_client.cohere.update(
@@ -324,7 +324,7 @@ class TestAsyncCohere:
         )
         assert_matches_type(object, cohere, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
         response = await async_client.cohere.with_raw_response.update(
@@ -336,7 +336,7 @@ class TestAsyncCohere:
         cohere = await response.parse()
         assert_matches_type(object, cohere, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
         async with async_client.cohere.with_streaming_response.update(
@@ -350,7 +350,7 @@ class TestAsyncCohere:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_update(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -358,7 +358,7 @@ class TestAsyncCohere:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_delete(self, async_client: AsyncHanzo) -> None:
         cohere = await async_client.cohere.delete(
@@ -366,7 +366,7 @@ class TestAsyncCohere:
         )
         assert_matches_type(object, cohere, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
         response = await async_client.cohere.with_raw_response.delete(
@@ -378,7 +378,7 @@ class TestAsyncCohere:
         cohere = await response.parse()
         assert_matches_type(object, cohere, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
         async with async_client.cohere.with_streaming_response.delete(
@@ -392,7 +392,7 @@ class TestAsyncCohere:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_delete(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -400,7 +400,7 @@ class TestAsyncCohere:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_modify(self, async_client: AsyncHanzo) -> None:
         cohere = await async_client.cohere.modify(
@@ -408,7 +408,7 @@ class TestAsyncCohere:
         )
         assert_matches_type(object, cohere, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_modify(self, async_client: AsyncHanzo) -> None:
         response = await async_client.cohere.with_raw_response.modify(
@@ -420,7 +420,7 @@ class TestAsyncCohere:
         cohere = await response.parse()
         assert_matches_type(object, cohere, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_modify(self, async_client: AsyncHanzo) -> None:
         async with async_client.cohere.with_streaming_response.modify(
@@ -434,7 +434,7 @@ class TestAsyncCohere:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_modify(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):

tests/api_resources/test_completions.py

@@ -16,13 +16,13 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestCompletions:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create(self, client: Hanzo) -> None:
         completion = client.completions.create()
         assert_matches_type(object, completion, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create_with_all_params(self, client: Hanzo) -> None:
         completion = client.completions.create(
@@ -30,7 +30,7 @@ class TestCompletions:
         )
         assert_matches_type(object, completion, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Hanzo) -> None:
         response = client.completions.with_raw_response.create()
@@ -40,7 +40,7 @@ class TestCompletions:
         completion = response.parse()
         assert_matches_type(object, completion, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Hanzo) -> None:
         with client.completions.with_streaming_response.create() as response:
@@ -58,13 +58,13 @@ class TestAsyncCompletions:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncHanzo) -> None:
         completion = await async_client.completions.create()
         assert_matches_type(object, completion, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create_with_all_params(self, async_client: AsyncHanzo) -> None:
         completion = await async_client.completions.create(
@@ -72,7 +72,7 @@ class TestAsyncCompletions:
         )
         assert_matches_type(object, completion, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
         response = await async_client.completions.with_raw_response.create()
@@ -82,7 +82,7 @@ class TestAsyncCompletions:
         completion = await response.parse()
         assert_matches_type(object, completion, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
         async with async_client.completions.with_streaming_response.create() as response:

tests/api_resources/test_credentials.py

@@ -16,7 +16,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestCredentials:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create(self, client: Hanzo) -> None:
         credential = client.credentials.create(
@@ -25,7 +25,7 @@ class TestCredentials:
         )
         assert_matches_type(object, credential, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create_with_all_params(self, client: Hanzo) -> None:
         credential = client.credentials.create(
@@ -36,7 +36,7 @@ class TestCredentials:
         )
         assert_matches_type(object, credential, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Hanzo) -> None:
         response = client.credentials.with_raw_response.create(
@@ -49,7 +49,7 @@ class TestCredentials:
         credential = response.parse()
         assert_matches_type(object, credential, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Hanzo) -> None:
         with client.credentials.with_streaming_response.create(
@@ -64,13 +64,13 @@ class TestCredentials:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_list(self, client: Hanzo) -> None:
         credential = client.credentials.list()
         assert_matches_type(object, credential, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_list(self, client: Hanzo) -> None:
         response = client.credentials.with_raw_response.list()
@@ -80,7 +80,7 @@ class TestCredentials:
         credential = response.parse()
         assert_matches_type(object, credential, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_list(self, client: Hanzo) -> None:
         with client.credentials.with_streaming_response.list() as response:
@@ -92,7 +92,7 @@ class TestCredentials:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_delete(self, client: Hanzo) -> None:
         credential = client.credentials.delete(
@@ -100,7 +100,7 @@ class TestCredentials:
         )
         assert_matches_type(object, credential, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_delete(self, client: Hanzo) -> None:
         response = client.credentials.with_raw_response.delete(
@@ -112,7 +112,7 @@ class TestCredentials:
         credential = response.parse()
         assert_matches_type(object, credential, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_delete(self, client: Hanzo) -> None:
         with client.credentials.with_streaming_response.delete(
@@ -126,7 +126,7 @@ class TestCredentials:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_delete(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `credential_name` but received ''"):
@@ -140,7 +140,7 @@ class TestAsyncCredentials:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncHanzo) -> None:
         credential = await async_client.credentials.create(
@@ -149,7 +149,7 @@ class TestAsyncCredentials:
         )
         assert_matches_type(object, credential, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create_with_all_params(self, async_client: AsyncHanzo) -> None:
         credential = await async_client.credentials.create(
@@ -160,7 +160,7 @@ class TestAsyncCredentials:
         )
         assert_matches_type(object, credential, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
         response = await async_client.credentials.with_raw_response.create(
@@ -173,7 +173,7 @@ class TestAsyncCredentials:
         credential = await response.parse()
         assert_matches_type(object, credential, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
         async with async_client.credentials.with_streaming_response.create(
@@ -188,13 +188,13 @@ class TestAsyncCredentials:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_list(self, async_client: AsyncHanzo) -> None:
         credential = await async_client.credentials.list()
         assert_matches_type(object, credential, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
         response = await async_client.credentials.with_raw_response.list()
@@ -204,7 +204,7 @@ class TestAsyncCredentials:
         credential = await response.parse()
         assert_matches_type(object, credential, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
         async with async_client.credentials.with_streaming_response.list() as response:
@@ -216,7 +216,7 @@ class TestAsyncCredentials:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_delete(self, async_client: AsyncHanzo) -> None:
         credential = await async_client.credentials.delete(
@@ -224,7 +224,7 @@ class TestAsyncCredentials:
         )
         assert_matches_type(object, credential, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
         response = await async_client.credentials.with_raw_response.delete(
@@ -236,7 +236,7 @@ class TestAsyncCredentials:
         credential = await response.parse()
         assert_matches_type(object, credential, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
         async with async_client.credentials.with_streaming_response.delete(
@@ -250,7 +250,7 @@ class TestAsyncCredentials:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_delete(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `credential_name` but received ''"):

tests/api_resources/test_customer.py

@@ -20,7 +20,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestCustomer:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create(self, client: Hanzo) -> None:
         customer = client.customer.create(
@@ -28,7 +28,7 @@ class TestCustomer:
         )
         assert_matches_type(object, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create_with_all_params(self, client: Hanzo) -> None:
         customer = client.customer.create(
@@ -55,7 +55,7 @@ class TestCustomer:
         )
         assert_matches_type(object, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Hanzo) -> None:
         response = client.customer.with_raw_response.create(
@@ -67,7 +67,7 @@ class TestCustomer:
         customer = response.parse()
         assert_matches_type(object, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Hanzo) -> None:
         with client.customer.with_streaming_response.create(
@@ -81,7 +81,7 @@ class TestCustomer:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_update(self, client: Hanzo) -> None:
         customer = client.customer.update(
@@ -89,7 +89,7 @@ class TestCustomer:
         )
         assert_matches_type(object, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_update_with_all_params(self, client: Hanzo) -> None:
         customer = client.customer.update(
@@ -103,7 +103,7 @@ class TestCustomer:
         )
         assert_matches_type(object, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_update(self, client: Hanzo) -> None:
         response = client.customer.with_raw_response.update(
@@ -115,7 +115,7 @@ class TestCustomer:
         customer = response.parse()
         assert_matches_type(object, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_update(self, client: Hanzo) -> None:
         with client.customer.with_streaming_response.update(
@@ -129,13 +129,13 @@ class TestCustomer:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_list(self, client: Hanzo) -> None:
         customer = client.customer.list()
         assert_matches_type(CustomerListResponse, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_list(self, client: Hanzo) -> None:
         response = client.customer.with_raw_response.list()
@@ -145,7 +145,7 @@ class TestCustomer:
         customer = response.parse()
         assert_matches_type(CustomerListResponse, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_list(self, client: Hanzo) -> None:
         with client.customer.with_streaming_response.list() as response:
@@ -157,7 +157,7 @@ class TestCustomer:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_delete(self, client: Hanzo) -> None:
         customer = client.customer.delete(
@@ -165,7 +165,7 @@ class TestCustomer:
         )
         assert_matches_type(object, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_delete(self, client: Hanzo) -> None:
         response = client.customer.with_raw_response.delete(
@@ -177,7 +177,7 @@ class TestCustomer:
         customer = response.parse()
         assert_matches_type(object, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_delete(self, client: Hanzo) -> None:
         with client.customer.with_streaming_response.delete(
@@ -191,7 +191,7 @@ class TestCustomer:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_block(self, client: Hanzo) -> None:
         customer = client.customer.block(
@@ -199,7 +199,7 @@ class TestCustomer:
         )
         assert_matches_type(object, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_block(self, client: Hanzo) -> None:
         response = client.customer.with_raw_response.block(
@@ -211,7 +211,7 @@ class TestCustomer:
         customer = response.parse()
         assert_matches_type(object, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_block(self, client: Hanzo) -> None:
         with client.customer.with_streaming_response.block(
@@ -225,7 +225,7 @@ class TestCustomer:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_retrieve_info(self, client: Hanzo) -> None:
         customer = client.customer.retrieve_info(
@@ -233,7 +233,7 @@ class TestCustomer:
         )
         assert_matches_type(CustomerRetrieveInfoResponse, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_retrieve_info(self, client: Hanzo) -> None:
         response = client.customer.with_raw_response.retrieve_info(
@@ -245,7 +245,7 @@ class TestCustomer:
         customer = response.parse()
         assert_matches_type(CustomerRetrieveInfoResponse, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_retrieve_info(self, client: Hanzo) -> None:
         with client.customer.with_streaming_response.retrieve_info(
@@ -259,7 +259,7 @@ class TestCustomer:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_unblock(self, client: Hanzo) -> None:
         customer = client.customer.unblock(
@@ -267,7 +267,7 @@ class TestCustomer:
         )
         assert_matches_type(object, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_unblock(self, client: Hanzo) -> None:
         response = client.customer.with_raw_response.unblock(
@@ -279,7 +279,7 @@ class TestCustomer:
         customer = response.parse()
         assert_matches_type(object, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_unblock(self, client: Hanzo) -> None:
         with client.customer.with_streaming_response.unblock(
@@ -299,7 +299,7 @@ class TestAsyncCustomer:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncHanzo) -> None:
         customer = await async_client.customer.create(
@@ -307,7 +307,7 @@ class TestAsyncCustomer:
         )
         assert_matches_type(object, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create_with_all_params(self, async_client: AsyncHanzo) -> None:
         customer = await async_client.customer.create(
@@ -334,7 +334,7 @@ class TestAsyncCustomer:
         )
         assert_matches_type(object, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
         response = await async_client.customer.with_raw_response.create(
@@ -346,7 +346,7 @@ class TestAsyncCustomer:
         customer = await response.parse()
         assert_matches_type(object, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
         async with async_client.customer.with_streaming_response.create(
@@ -360,7 +360,7 @@ class TestAsyncCustomer:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_update(self, async_client: AsyncHanzo) -> None:
         customer = await async_client.customer.update(
@@ -368,7 +368,7 @@ class TestAsyncCustomer:
         )
         assert_matches_type(object, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_update_with_all_params(self, async_client: AsyncHanzo) -> None:
         customer = await async_client.customer.update(
@@ -382,7 +382,7 @@ class TestAsyncCustomer:
         )
         assert_matches_type(object, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
         response = await async_client.customer.with_raw_response.update(
@@ -394,7 +394,7 @@ class TestAsyncCustomer:
         customer = await response.parse()
         assert_matches_type(object, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
         async with async_client.customer.with_streaming_response.update(
@@ -408,13 +408,13 @@ class TestAsyncCustomer:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_list(self, async_client: AsyncHanzo) -> None:
         customer = await async_client.customer.list()
         assert_matches_type(CustomerListResponse, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
         response = await async_client.customer.with_raw_response.list()
@@ -424,7 +424,7 @@ class TestAsyncCustomer:
         customer = await response.parse()
         assert_matches_type(CustomerListResponse, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
         async with async_client.customer.with_streaming_response.list() as response:
@@ -436,7 +436,7 @@ class TestAsyncCustomer:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_delete(self, async_client: AsyncHanzo) -> None:
         customer = await async_client.customer.delete(
@@ -444,7 +444,7 @@ class TestAsyncCustomer:
         )
         assert_matches_type(object, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
         response = await async_client.customer.with_raw_response.delete(
@@ -456,7 +456,7 @@ class TestAsyncCustomer:
         customer = await response.parse()
         assert_matches_type(object, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
         async with async_client.customer.with_streaming_response.delete(
@@ -470,7 +470,7 @@ class TestAsyncCustomer:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_block(self, async_client: AsyncHanzo) -> None:
         customer = await async_client.customer.block(
@@ -478,7 +478,7 @@ class TestAsyncCustomer:
         )
         assert_matches_type(object, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_block(self, async_client: AsyncHanzo) -> None:
         response = await async_client.customer.with_raw_response.block(
@@ -490,7 +490,7 @@ class TestAsyncCustomer:
         customer = await response.parse()
         assert_matches_type(object, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_block(self, async_client: AsyncHanzo) -> None:
         async with async_client.customer.with_streaming_response.block(
@@ -504,7 +504,7 @@ class TestAsyncCustomer:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_retrieve_info(self, async_client: AsyncHanzo) -> None:
         customer = await async_client.customer.retrieve_info(
@@ -512,7 +512,7 @@ class TestAsyncCustomer:
         )
         assert_matches_type(CustomerRetrieveInfoResponse, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_retrieve_info(self, async_client: AsyncHanzo) -> None:
         response = await async_client.customer.with_raw_response.retrieve_info(
@@ -524,7 +524,7 @@ class TestAsyncCustomer:
         customer = await response.parse()
         assert_matches_type(CustomerRetrieveInfoResponse, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_retrieve_info(self, async_client: AsyncHanzo) -> None:
         async with async_client.customer.with_streaming_response.retrieve_info(
@@ -538,7 +538,7 @@ class TestAsyncCustomer:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_unblock(self, async_client: AsyncHanzo) -> None:
         customer = await async_client.customer.unblock(
@@ -546,7 +546,7 @@ class TestAsyncCustomer:
         )
         assert_matches_type(object, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_unblock(self, async_client: AsyncHanzo) -> None:
         response = await async_client.customer.with_raw_response.unblock(
@@ -558,7 +558,7 @@ class TestAsyncCustomer:
         customer = await response.parse()
         assert_matches_type(object, customer, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_unblock(self, async_client: AsyncHanzo) -> None:
         async with async_client.customer.with_streaming_response.unblock(

tests/api_resources/test_delete.py

@@ -16,7 +16,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestDelete:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create_allowed_ip(self, client: Hanzo) -> None:
         delete = client.delete.create_allowed_ip(
@@ -24,7 +24,7 @@ class TestDelete:
         )
         assert_matches_type(object, delete, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_create_allowed_ip(self, client: Hanzo) -> None:
         response = client.delete.with_raw_response.create_allowed_ip(
@@ -36,7 +36,7 @@ class TestDelete:
         delete = response.parse()
         assert_matches_type(object, delete, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_create_allowed_ip(self, client: Hanzo) -> None:
         with client.delete.with_streaming_response.create_allowed_ip(
@@ -56,7 +56,7 @@ class TestAsyncDelete:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create_allowed_ip(self, async_client: AsyncHanzo) -> None:
         delete = await async_client.delete.create_allowed_ip(
@@ -64,7 +64,7 @@ class TestAsyncDelete:
         )
         assert_matches_type(object, delete, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_create_allowed_ip(self, async_client: AsyncHanzo) -> None:
         response = await async_client.delete.with_raw_response.create_allowed_ip(
@@ -76,7 +76,7 @@ class TestAsyncDelete:
         delete = await response.parse()
         assert_matches_type(object, delete, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_create_allowed_ip(self, async_client: AsyncHanzo) -> None:
         async with async_client.delete.with_streaming_response.create_allowed_ip(

tests/api_resources/test_embeddings.py

@@ -16,13 +16,13 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestEmbeddings:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create(self, client: Hanzo) -> None:
         embedding = client.embeddings.create()
         assert_matches_type(object, embedding, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create_with_all_params(self, client: Hanzo) -> None:
         embedding = client.embeddings.create(
@@ -30,7 +30,7 @@ class TestEmbeddings:
         )
         assert_matches_type(object, embedding, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Hanzo) -> None:
         response = client.embeddings.with_raw_response.create()
@@ -40,7 +40,7 @@ class TestEmbeddings:
         embedding = response.parse()
         assert_matches_type(object, embedding, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Hanzo) -> None:
         with client.embeddings.with_streaming_response.create() as response:
@@ -58,13 +58,13 @@ class TestAsyncEmbeddings:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncHanzo) -> None:
         embedding = await async_client.embeddings.create()
         assert_matches_type(object, embedding, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create_with_all_params(self, async_client: AsyncHanzo) -> None:
         embedding = await async_client.embeddings.create(
@@ -72,7 +72,7 @@ class TestAsyncEmbeddings:
         )
         assert_matches_type(object, embedding, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
         response = await async_client.embeddings.with_raw_response.create()
@@ -82,7 +82,7 @@ class TestAsyncEmbeddings:
         embedding = await response.parse()
         assert_matches_type(object, embedding, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
         async with async_client.embeddings.with_streaming_response.create() as response:

tests/api_resources/test_engines.py

@@ -16,7 +16,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestEngines:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_complete(self, client: Hanzo) -> None:
         engine = client.engines.complete(
@@ -24,7 +24,7 @@ class TestEngines:
         )
         assert_matches_type(object, engine, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_complete(self, client: Hanzo) -> None:
         response = client.engines.with_raw_response.complete(
@@ -36,7 +36,7 @@ class TestEngines:
         engine = response.parse()
         assert_matches_type(object, engine, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_complete(self, client: Hanzo) -> None:
         with client.engines.with_streaming_response.complete(
@@ -50,7 +50,7 @@ class TestEngines:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_complete(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `model` but received ''"):
@@ -58,7 +58,7 @@ class TestEngines:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_embed(self, client: Hanzo) -> None:
         engine = client.engines.embed(
@@ -66,7 +66,7 @@ class TestEngines:
         )
         assert_matches_type(object, engine, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_embed(self, client: Hanzo) -> None:
         response = client.engines.with_raw_response.embed(
@@ -78,7 +78,7 @@ class TestEngines:
         engine = response.parse()
         assert_matches_type(object, engine, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_embed(self, client: Hanzo) -> None:
         with client.engines.with_streaming_response.embed(
@@ -92,7 +92,7 @@ class TestEngines:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_embed(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `model` but received ''"):
@@ -106,7 +106,7 @@ class TestAsyncEngines:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_complete(self, async_client: AsyncHanzo) -> None:
         engine = await async_client.engines.complete(
@@ -114,7 +114,7 @@ class TestAsyncEngines:
         )
         assert_matches_type(object, engine, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_complete(self, async_client: AsyncHanzo) -> None:
         response = await async_client.engines.with_raw_response.complete(
@@ -126,7 +126,7 @@ class TestAsyncEngines:
         engine = await response.parse()
         assert_matches_type(object, engine, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_complete(self, async_client: AsyncHanzo) -> None:
         async with async_client.engines.with_streaming_response.complete(
@@ -140,7 +140,7 @@ class TestAsyncEngines:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_complete(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `model` but received ''"):
@@ -148,7 +148,7 @@ class TestAsyncEngines:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_embed(self, async_client: AsyncHanzo) -> None:
         engine = await async_client.engines.embed(
@@ -156,7 +156,7 @@ class TestAsyncEngines:
         )
         assert_matches_type(object, engine, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_embed(self, async_client: AsyncHanzo) -> None:
         response = await async_client.engines.with_raw_response.embed(
@@ -168,7 +168,7 @@ class TestAsyncEngines:
         engine = await response.parse()
         assert_matches_type(object, engine, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_embed(self, async_client: AsyncHanzo) -> None:
         async with async_client.engines.with_streaming_response.embed(
@@ -182,7 +182,7 @@ class TestAsyncEngines:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_embed(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `model` but received ''"):

tests/api_resources/test_eu_assemblyai.py

@@ -16,7 +16,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestEuAssemblyai:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create(self, client: Hanzo) -> None:
         eu_assemblyai = client.eu_assemblyai.create(
@@ -24,7 +24,7 @@ class TestEuAssemblyai:
         )
         assert_matches_type(object, eu_assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Hanzo) -> None:
         response = client.eu_assemblyai.with_raw_response.create(
@@ -36,7 +36,7 @@ class TestEuAssemblyai:
         eu_assemblyai = response.parse()
         assert_matches_type(object, eu_assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Hanzo) -> None:
         with client.eu_assemblyai.with_streaming_response.create(
@@ -50,7 +50,7 @@ class TestEuAssemblyai:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_create(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -58,7 +58,7 @@ class TestEuAssemblyai:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_retrieve(self, client: Hanzo) -> None:
         eu_assemblyai = client.eu_assemblyai.retrieve(
@@ -66,7 +66,7 @@ class TestEuAssemblyai:
         )
         assert_matches_type(object, eu_assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_retrieve(self, client: Hanzo) -> None:
         response = client.eu_assemblyai.with_raw_response.retrieve(
@@ -78,7 +78,7 @@ class TestEuAssemblyai:
         eu_assemblyai = response.parse()
         assert_matches_type(object, eu_assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_retrieve(self, client: Hanzo) -> None:
         with client.eu_assemblyai.with_streaming_response.retrieve(
@@ -92,7 +92,7 @@ class TestEuAssemblyai:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_retrieve(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -100,7 +100,7 @@ class TestEuAssemblyai:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_update(self, client: Hanzo) -> None:
         eu_assemblyai = client.eu_assemblyai.update(
@@ -108,7 +108,7 @@ class TestEuAssemblyai:
         )
         assert_matches_type(object, eu_assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_update(self, client: Hanzo) -> None:
         response = client.eu_assemblyai.with_raw_response.update(
@@ -120,7 +120,7 @@ class TestEuAssemblyai:
         eu_assemblyai = response.parse()
         assert_matches_type(object, eu_assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_update(self, client: Hanzo) -> None:
         with client.eu_assemblyai.with_streaming_response.update(
@@ -134,7 +134,7 @@ class TestEuAssemblyai:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_update(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -142,7 +142,7 @@ class TestEuAssemblyai:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_delete(self, client: Hanzo) -> None:
         eu_assemblyai = client.eu_assemblyai.delete(
@@ -150,7 +150,7 @@ class TestEuAssemblyai:
         )
         assert_matches_type(object, eu_assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_delete(self, client: Hanzo) -> None:
         response = client.eu_assemblyai.with_raw_response.delete(
@@ -162,7 +162,7 @@ class TestEuAssemblyai:
         eu_assemblyai = response.parse()
         assert_matches_type(object, eu_assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_delete(self, client: Hanzo) -> None:
         with client.eu_assemblyai.with_streaming_response.delete(
@@ -176,7 +176,7 @@ class TestEuAssemblyai:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_delete(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -184,7 +184,7 @@ class TestEuAssemblyai:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_patch(self, client: Hanzo) -> None:
         eu_assemblyai = client.eu_assemblyai.patch(
@@ -192,7 +192,7 @@ class TestEuAssemblyai:
         )
         assert_matches_type(object, eu_assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_patch(self, client: Hanzo) -> None:
         response = client.eu_assemblyai.with_raw_response.patch(
@@ -204,7 +204,7 @@ class TestEuAssemblyai:
         eu_assemblyai = response.parse()
         assert_matches_type(object, eu_assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_patch(self, client: Hanzo) -> None:
         with client.eu_assemblyai.with_streaming_response.patch(
@@ -218,7 +218,7 @@ class TestEuAssemblyai:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_patch(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -232,7 +232,7 @@ class TestAsyncEuAssemblyai:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncHanzo) -> None:
         eu_assemblyai = await async_client.eu_assemblyai.create(
@@ -240,7 +240,7 @@ class TestAsyncEuAssemblyai:
         )
         assert_matches_type(object, eu_assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
         response = await async_client.eu_assemblyai.with_raw_response.create(
@@ -252,7 +252,7 @@ class TestAsyncEuAssemblyai:
         eu_assemblyai = await response.parse()
         assert_matches_type(object, eu_assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
         async with async_client.eu_assemblyai.with_streaming_response.create(
@@ -266,7 +266,7 @@ class TestAsyncEuAssemblyai:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_create(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -274,7 +274,7 @@ class TestAsyncEuAssemblyai:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
         eu_assemblyai = await async_client.eu_assemblyai.retrieve(
@@ -282,7 +282,7 @@ class TestAsyncEuAssemblyai:
         )
         assert_matches_type(object, eu_assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
         response = await async_client.eu_assemblyai.with_raw_response.retrieve(
@@ -294,7 +294,7 @@ class TestAsyncEuAssemblyai:
         eu_assemblyai = await response.parse()
         assert_matches_type(object, eu_assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
         async with async_client.eu_assemblyai.with_streaming_response.retrieve(
@@ -308,7 +308,7 @@ class TestAsyncEuAssemblyai:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -316,7 +316,7 @@ class TestAsyncEuAssemblyai:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_update(self, async_client: AsyncHanzo) -> None:
         eu_assemblyai = await async_client.eu_assemblyai.update(
@@ -324,7 +324,7 @@ class TestAsyncEuAssemblyai:
         )
         assert_matches_type(object, eu_assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
         response = await async_client.eu_assemblyai.with_raw_response.update(
@@ -336,7 +336,7 @@ class TestAsyncEuAssemblyai:
         eu_assemblyai = await response.parse()
         assert_matches_type(object, eu_assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
         async with async_client.eu_assemblyai.with_streaming_response.update(
@@ -350,7 +350,7 @@ class TestAsyncEuAssemblyai:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_update(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -358,7 +358,7 @@ class TestAsyncEuAssemblyai:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_delete(self, async_client: AsyncHanzo) -> None:
         eu_assemblyai = await async_client.eu_assemblyai.delete(
@@ -366,7 +366,7 @@ class TestAsyncEuAssemblyai:
         )
         assert_matches_type(object, eu_assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
         response = await async_client.eu_assemblyai.with_raw_response.delete(
@@ -378,7 +378,7 @@ class TestAsyncEuAssemblyai:
         eu_assemblyai = await response.parse()
         assert_matches_type(object, eu_assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
         async with async_client.eu_assemblyai.with_streaming_response.delete(
@@ -392,7 +392,7 @@ class TestAsyncEuAssemblyai:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_delete(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -400,7 +400,7 @@ class TestAsyncEuAssemblyai:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_patch(self, async_client: AsyncHanzo) -> None:
         eu_assemblyai = await async_client.eu_assemblyai.patch(
@@ -408,7 +408,7 @@ class TestAsyncEuAssemblyai:
         )
         assert_matches_type(object, eu_assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_patch(self, async_client: AsyncHanzo) -> None:
         response = await async_client.eu_assemblyai.with_raw_response.patch(
@@ -420,7 +420,7 @@ class TestAsyncEuAssemblyai:
         eu_assemblyai = await response.parse()
         assert_matches_type(object, eu_assemblyai, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_patch(self, async_client: AsyncHanzo) -> None:
         async with async_client.eu_assemblyai.with_streaming_response.patch(
@@ -434,7 +434,7 @@ class TestAsyncEuAssemblyai:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_patch(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):

tests/api_resources/test_files.py

@@ -16,7 +16,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestFiles:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create(self, client: Hanzo) -> None:
         file = client.files.create(
@@ -26,7 +26,7 @@ class TestFiles:
         )
         assert_matches_type(object, file, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create_with_all_params(self, client: Hanzo) -> None:
         file = client.files.create(
@@ -37,7 +37,7 @@ class TestFiles:
         )
         assert_matches_type(object, file, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Hanzo) -> None:
         response = client.files.with_raw_response.create(
@@ -51,7 +51,7 @@ class TestFiles:
         file = response.parse()
         assert_matches_type(object, file, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Hanzo) -> None:
         with client.files.with_streaming_response.create(
@@ -67,7 +67,7 @@ class TestFiles:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_create(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `provider` but received ''"):
@@ -77,7 +77,7 @@ class TestFiles:
                 purpose="purpose",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_retrieve(self, client: Hanzo) -> None:
         file = client.files.retrieve(
@@ -86,7 +86,7 @@ class TestFiles:
         )
         assert_matches_type(object, file, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_retrieve(self, client: Hanzo) -> None:
         response = client.files.with_raw_response.retrieve(
@@ -99,7 +99,7 @@ class TestFiles:
         file = response.parse()
         assert_matches_type(object, file, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_retrieve(self, client: Hanzo) -> None:
         with client.files.with_streaming_response.retrieve(
@@ -114,7 +114,7 @@ class TestFiles:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_retrieve(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `provider` but received ''"):
@@ -129,7 +129,7 @@ class TestFiles:
                 provider="provider",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_list(self, client: Hanzo) -> None:
         file = client.files.list(
@@ -137,7 +137,7 @@ class TestFiles:
         )
         assert_matches_type(object, file, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_list_with_all_params(self, client: Hanzo) -> None:
         file = client.files.list(
@@ -146,7 +146,7 @@ class TestFiles:
         )
         assert_matches_type(object, file, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_list(self, client: Hanzo) -> None:
         response = client.files.with_raw_response.list(
@@ -158,7 +158,7 @@ class TestFiles:
         file = response.parse()
         assert_matches_type(object, file, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_list(self, client: Hanzo) -> None:
         with client.files.with_streaming_response.list(
@@ -172,7 +172,7 @@ class TestFiles:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_list(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `provider` but received ''"):
@@ -180,7 +180,7 @@ class TestFiles:
                 provider="",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_delete(self, client: Hanzo) -> None:
         file = client.files.delete(
@@ -189,7 +189,7 @@ class TestFiles:
         )
         assert_matches_type(object, file, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_delete(self, client: Hanzo) -> None:
         response = client.files.with_raw_response.delete(
@@ -202,7 +202,7 @@ class TestFiles:
         file = response.parse()
         assert_matches_type(object, file, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_delete(self, client: Hanzo) -> None:
         with client.files.with_streaming_response.delete(
@@ -217,7 +217,7 @@ class TestFiles:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_delete(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `provider` but received ''"):
@@ -238,7 +238,7 @@ class TestAsyncFiles:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncHanzo) -> None:
         file = await async_client.files.create(
@@ -248,7 +248,7 @@ class TestAsyncFiles:
         )
         assert_matches_type(object, file, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create_with_all_params(self, async_client: AsyncHanzo) -> None:
         file = await async_client.files.create(
@@ -259,7 +259,7 @@ class TestAsyncFiles:
         )
         assert_matches_type(object, file, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
         response = await async_client.files.with_raw_response.create(
@@ -273,7 +273,7 @@ class TestAsyncFiles:
         file = await response.parse()
         assert_matches_type(object, file, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
         async with async_client.files.with_streaming_response.create(
@@ -289,7 +289,7 @@ class TestAsyncFiles:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_create(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `provider` but received ''"):
@@ -299,7 +299,7 @@ class TestAsyncFiles:
                 purpose="purpose",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
         file = await async_client.files.retrieve(
@@ -308,7 +308,7 @@ class TestAsyncFiles:
         )
         assert_matches_type(object, file, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
         response = await async_client.files.with_raw_response.retrieve(
@@ -321,7 +321,7 @@ class TestAsyncFiles:
         file = await response.parse()
         assert_matches_type(object, file, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
         async with async_client.files.with_streaming_response.retrieve(
@@ -336,7 +336,7 @@ class TestAsyncFiles:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `provider` but received ''"):
@@ -351,7 +351,7 @@ class TestAsyncFiles:
                 provider="provider",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_list(self, async_client: AsyncHanzo) -> None:
         file = await async_client.files.list(
@@ -359,7 +359,7 @@ class TestAsyncFiles:
         )
         assert_matches_type(object, file, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_list_with_all_params(self, async_client: AsyncHanzo) -> None:
         file = await async_client.files.list(
@@ -368,7 +368,7 @@ class TestAsyncFiles:
         )
         assert_matches_type(object, file, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
         response = await async_client.files.with_raw_response.list(
@@ -380,7 +380,7 @@ class TestAsyncFiles:
         file = await response.parse()
         assert_matches_type(object, file, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
         async with async_client.files.with_streaming_response.list(
@@ -394,7 +394,7 @@ class TestAsyncFiles:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_list(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `provider` but received ''"):
@@ -402,7 +402,7 @@ class TestAsyncFiles:
                 provider="",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_delete(self, async_client: AsyncHanzo) -> None:
         file = await async_client.files.delete(
@@ -411,7 +411,7 @@ class TestAsyncFiles:
         )
         assert_matches_type(object, file, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
         response = await async_client.files.with_raw_response.delete(
@@ -424,7 +424,7 @@ class TestAsyncFiles:
         file = await response.parse()
         assert_matches_type(object, file, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
         async with async_client.files.with_streaming_response.delete(
@@ -439,7 +439,7 @@ class TestAsyncFiles:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_delete(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `provider` but received ''"):

tests/api_resources/test_gemini.py

@@ -16,7 +16,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestGemini:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create(self, client: Hanzo) -> None:
         gemini = client.gemini.create(
@@ -24,7 +24,7 @@ class TestGemini:
         )
         assert_matches_type(object, gemini, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Hanzo) -> None:
         response = client.gemini.with_raw_response.create(
@@ -36,7 +36,7 @@ class TestGemini:
         gemini = response.parse()
         assert_matches_type(object, gemini, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Hanzo) -> None:
         with client.gemini.with_streaming_response.create(
@@ -50,7 +50,7 @@ class TestGemini:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_create(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -58,7 +58,7 @@ class TestGemini:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_retrieve(self, client: Hanzo) -> None:
         gemini = client.gemini.retrieve(
@@ -66,7 +66,7 @@ class TestGemini:
         )
         assert_matches_type(object, gemini, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_retrieve(self, client: Hanzo) -> None:
         response = client.gemini.with_raw_response.retrieve(
@@ -78,7 +78,7 @@ class TestGemini:
         gemini = response.parse()
         assert_matches_type(object, gemini, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_retrieve(self, client: Hanzo) -> None:
         with client.gemini.with_streaming_response.retrieve(
@@ -92,7 +92,7 @@ class TestGemini:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_retrieve(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -100,7 +100,7 @@ class TestGemini:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_update(self, client: Hanzo) -> None:
         gemini = client.gemini.update(
@@ -108,7 +108,7 @@ class TestGemini:
         )
         assert_matches_type(object, gemini, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_update(self, client: Hanzo) -> None:
         response = client.gemini.with_raw_response.update(
@@ -120,7 +120,7 @@ class TestGemini:
         gemini = response.parse()
         assert_matches_type(object, gemini, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_update(self, client: Hanzo) -> None:
         with client.gemini.with_streaming_response.update(
@@ -134,7 +134,7 @@ class TestGemini:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_update(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -142,7 +142,7 @@ class TestGemini:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_delete(self, client: Hanzo) -> None:
         gemini = client.gemini.delete(
@@ -150,7 +150,7 @@ class TestGemini:
         )
         assert_matches_type(object, gemini, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_delete(self, client: Hanzo) -> None:
         response = client.gemini.with_raw_response.delete(
@@ -162,7 +162,7 @@ class TestGemini:
         gemini = response.parse()
         assert_matches_type(object, gemini, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_delete(self, client: Hanzo) -> None:
         with client.gemini.with_streaming_response.delete(
@@ -176,7 +176,7 @@ class TestGemini:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_delete(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -184,7 +184,7 @@ class TestGemini:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_patch(self, client: Hanzo) -> None:
         gemini = client.gemini.patch(
@@ -192,7 +192,7 @@ class TestGemini:
         )
         assert_matches_type(object, gemini, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_patch(self, client: Hanzo) -> None:
         response = client.gemini.with_raw_response.patch(
@@ -204,7 +204,7 @@ class TestGemini:
         gemini = response.parse()
         assert_matches_type(object, gemini, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_patch(self, client: Hanzo) -> None:
         with client.gemini.with_streaming_response.patch(
@@ -218,7 +218,7 @@ class TestGemini:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_patch(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -232,7 +232,7 @@ class TestAsyncGemini:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncHanzo) -> None:
         gemini = await async_client.gemini.create(
@@ -240,7 +240,7 @@ class TestAsyncGemini:
         )
         assert_matches_type(object, gemini, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
         response = await async_client.gemini.with_raw_response.create(
@@ -252,7 +252,7 @@ class TestAsyncGemini:
         gemini = await response.parse()
         assert_matches_type(object, gemini, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
         async with async_client.gemini.with_streaming_response.create(
@@ -266,7 +266,7 @@ class TestAsyncGemini:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_create(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -274,7 +274,7 @@ class TestAsyncGemini:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
         gemini = await async_client.gemini.retrieve(
@@ -282,7 +282,7 @@ class TestAsyncGemini:
         )
         assert_matches_type(object, gemini, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
         response = await async_client.gemini.with_raw_response.retrieve(
@@ -294,7 +294,7 @@ class TestAsyncGemini:
         gemini = await response.parse()
         assert_matches_type(object, gemini, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
         async with async_client.gemini.with_streaming_response.retrieve(
@@ -308,7 +308,7 @@ class TestAsyncGemini:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -316,7 +316,7 @@ class TestAsyncGemini:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_update(self, async_client: AsyncHanzo) -> None:
         gemini = await async_client.gemini.update(
@@ -324,7 +324,7 @@ class TestAsyncGemini:
         )
         assert_matches_type(object, gemini, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
         response = await async_client.gemini.with_raw_response.update(
@@ -336,7 +336,7 @@ class TestAsyncGemini:
         gemini = await response.parse()
         assert_matches_type(object, gemini, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
         async with async_client.gemini.with_streaming_response.update(
@@ -350,7 +350,7 @@ class TestAsyncGemini:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_update(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -358,7 +358,7 @@ class TestAsyncGemini:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_delete(self, async_client: AsyncHanzo) -> None:
         gemini = await async_client.gemini.delete(
@@ -366,7 +366,7 @@ class TestAsyncGemini:
         )
         assert_matches_type(object, gemini, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
         response = await async_client.gemini.with_raw_response.delete(
@@ -378,7 +378,7 @@ class TestAsyncGemini:
         gemini = await response.parse()
         assert_matches_type(object, gemini, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
         async with async_client.gemini.with_streaming_response.delete(
@@ -392,7 +392,7 @@ class TestAsyncGemini:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_delete(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -400,7 +400,7 @@ class TestAsyncGemini:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_patch(self, async_client: AsyncHanzo) -> None:
         gemini = await async_client.gemini.patch(
@@ -408,7 +408,7 @@ class TestAsyncGemini:
         )
         assert_matches_type(object, gemini, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_patch(self, async_client: AsyncHanzo) -> None:
         response = await async_client.gemini.with_raw_response.patch(
@@ -420,7 +420,7 @@ class TestAsyncGemini:
         gemini = await response.parse()
         assert_matches_type(object, gemini, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_patch(self, async_client: AsyncHanzo) -> None:
         async with async_client.gemini.with_streaming_response.patch(
@@ -434,7 +434,7 @@ class TestAsyncGemini:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_patch(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):

tests/api_resources/test_guardrails.py

@@ -17,13 +17,13 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestGuardrails:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_list(self, client: Hanzo) -> None:
         guardrail = client.guardrails.list()
         assert_matches_type(GuardrailListResponse, guardrail, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_list(self, client: Hanzo) -> None:
         response = client.guardrails.with_raw_response.list()
@@ -33,7 +33,7 @@ class TestGuardrails:
         guardrail = response.parse()
         assert_matches_type(GuardrailListResponse, guardrail, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_list(self, client: Hanzo) -> None:
         with client.guardrails.with_streaming_response.list() as response:
@@ -51,13 +51,13 @@ class TestAsyncGuardrails:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_list(self, async_client: AsyncHanzo) -> None:
         guardrail = await async_client.guardrails.list()
         assert_matches_type(GuardrailListResponse, guardrail, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
         response = await async_client.guardrails.with_raw_response.list()
@@ -67,7 +67,7 @@ class TestAsyncGuardrails:
         guardrail = await response.parse()
         assert_matches_type(GuardrailListResponse, guardrail, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
         async with async_client.guardrails.with_streaming_response.list() as response:

tests/api_resources/test_health.py

@@ -16,13 +16,13 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestHealth:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_check_all(self, client: Hanzo) -> None:
         health = client.health.check_all()
         assert_matches_type(object, health, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_check_all_with_all_params(self, client: Hanzo) -> None:
         health = client.health.check_all(
@@ -30,7 +30,7 @@ class TestHealth:
         )
         assert_matches_type(object, health, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_check_all(self, client: Hanzo) -> None:
         response = client.health.with_raw_response.check_all()
@@ -40,7 +40,7 @@ class TestHealth:
         health = response.parse()
         assert_matches_type(object, health, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_check_all(self, client: Hanzo) -> None:
         with client.health.with_streaming_response.check_all() as response:
@@ -52,13 +52,13 @@ class TestHealth:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_check_liveliness(self, client: Hanzo) -> None:
         health = client.health.check_liveliness()
         assert_matches_type(object, health, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_check_liveliness(self, client: Hanzo) -> None:
         response = client.health.with_raw_response.check_liveliness()
@@ -68,7 +68,7 @@ class TestHealth:
         health = response.parse()
         assert_matches_type(object, health, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_check_liveliness(self, client: Hanzo) -> None:
         with client.health.with_streaming_response.check_liveliness() as response:
@@ -80,13 +80,13 @@ class TestHealth:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_check_liveness(self, client: Hanzo) -> None:
         health = client.health.check_liveness()
         assert_matches_type(object, health, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_check_liveness(self, client: Hanzo) -> None:
         response = client.health.with_raw_response.check_liveness()
@@ -96,7 +96,7 @@ class TestHealth:
         health = response.parse()
         assert_matches_type(object, health, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_check_liveness(self, client: Hanzo) -> None:
         with client.health.with_streaming_response.check_liveness() as response:
@@ -108,13 +108,13 @@ class TestHealth:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_check_readiness(self, client: Hanzo) -> None:
         health = client.health.check_readiness()
         assert_matches_type(object, health, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_check_readiness(self, client: Hanzo) -> None:
         response = client.health.with_raw_response.check_readiness()
@@ -124,7 +124,7 @@ class TestHealth:
         health = response.parse()
         assert_matches_type(object, health, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_check_readiness(self, client: Hanzo) -> None:
         with client.health.with_streaming_response.check_readiness() as response:
@@ -136,7 +136,7 @@ class TestHealth:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_check_services(self, client: Hanzo) -> None:
         health = client.health.check_services(
@@ -144,7 +144,7 @@ class TestHealth:
         )
         assert_matches_type(object, health, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_check_services(self, client: Hanzo) -> None:
         response = client.health.with_raw_response.check_services(
@@ -156,7 +156,7 @@ class TestHealth:
         health = response.parse()
         assert_matches_type(object, health, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_check_services(self, client: Hanzo) -> None:
         with client.health.with_streaming_response.check_services(
@@ -176,13 +176,13 @@ class TestAsyncHealth:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_check_all(self, async_client: AsyncHanzo) -> None:
         health = await async_client.health.check_all()
         assert_matches_type(object, health, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_check_all_with_all_params(self, async_client: AsyncHanzo) -> None:
         health = await async_client.health.check_all(
@@ -190,7 +190,7 @@ class TestAsyncHealth:
         )
         assert_matches_type(object, health, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_check_all(self, async_client: AsyncHanzo) -> None:
         response = await async_client.health.with_raw_response.check_all()
@@ -200,7 +200,7 @@ class TestAsyncHealth:
         health = await response.parse()
         assert_matches_type(object, health, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_check_all(self, async_client: AsyncHanzo) -> None:
         async with async_client.health.with_streaming_response.check_all() as response:
@@ -212,13 +212,13 @@ class TestAsyncHealth:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_check_liveliness(self, async_client: AsyncHanzo) -> None:
         health = await async_client.health.check_liveliness()
         assert_matches_type(object, health, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_check_liveliness(self, async_client: AsyncHanzo) -> None:
         response = await async_client.health.with_raw_response.check_liveliness()
@@ -228,7 +228,7 @@ class TestAsyncHealth:
         health = await response.parse()
         assert_matches_type(object, health, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_check_liveliness(self, async_client: AsyncHanzo) -> None:
         async with async_client.health.with_streaming_response.check_liveliness() as response:
@@ -240,13 +240,13 @@ class TestAsyncHealth:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_check_liveness(self, async_client: AsyncHanzo) -> None:
         health = await async_client.health.check_liveness()
         assert_matches_type(object, health, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_check_liveness(self, async_client: AsyncHanzo) -> None:
         response = await async_client.health.with_raw_response.check_liveness()
@@ -256,7 +256,7 @@ class TestAsyncHealth:
         health = await response.parse()
         assert_matches_type(object, health, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_check_liveness(self, async_client: AsyncHanzo) -> None:
         async with async_client.health.with_streaming_response.check_liveness() as response:
@@ -268,13 +268,13 @@ class TestAsyncHealth:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_check_readiness(self, async_client: AsyncHanzo) -> None:
         health = await async_client.health.check_readiness()
         assert_matches_type(object, health, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_check_readiness(self, async_client: AsyncHanzo) -> None:
         response = await async_client.health.with_raw_response.check_readiness()
@@ -284,7 +284,7 @@ class TestAsyncHealth:
         health = await response.parse()
         assert_matches_type(object, health, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_check_readiness(self, async_client: AsyncHanzo) -> None:
         async with async_client.health.with_streaming_response.check_readiness() as response:
@@ -296,7 +296,7 @@ class TestAsyncHealth:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_check_services(self, async_client: AsyncHanzo) -> None:
         health = await async_client.health.check_services(
@@ -304,7 +304,7 @@ class TestAsyncHealth:
         )
         assert_matches_type(object, health, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_check_services(self, async_client: AsyncHanzo) -> None:
         response = await async_client.health.with_raw_response.check_services(
@@ -316,7 +316,7 @@ class TestAsyncHealth:
         health = await response.parse()
         assert_matches_type(object, health, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_check_services(self, async_client: AsyncHanzo) -> None:
         async with async_client.health.with_streaming_response.check_services(

tests/api_resources/test_key.py

@@ -23,7 +23,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestKey:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_update(self, client: Hanzo) -> None:
         key = client.key.update(
@@ -31,7 +31,7 @@ class TestKey:
         )
         assert_matches_type(object, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_update_with_all_params(self, client: Hanzo) -> None:
         key = client.key.update(
@@ -66,7 +66,7 @@ class TestKey:
         )
         assert_matches_type(object, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_update(self, client: Hanzo) -> None:
         response = client.key.with_raw_response.update(
@@ -78,7 +78,7 @@ class TestKey:
         key = response.parse()
         assert_matches_type(object, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_update(self, client: Hanzo) -> None:
         with client.key.with_streaming_response.update(
@@ -92,13 +92,13 @@ class TestKey:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_list(self, client: Hanzo) -> None:
         key = client.key.list()
         assert_matches_type(KeyListResponse, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_list_with_all_params(self, client: Hanzo) -> None:
         key = client.key.list(
@@ -113,7 +113,7 @@ class TestKey:
         )
         assert_matches_type(KeyListResponse, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_list(self, client: Hanzo) -> None:
         response = client.key.with_raw_response.list()
@@ -123,7 +123,7 @@ class TestKey:
         key = response.parse()
         assert_matches_type(KeyListResponse, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_list(self, client: Hanzo) -> None:
         with client.key.with_streaming_response.list() as response:
@@ -135,13 +135,13 @@ class TestKey:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_delete(self, client: Hanzo) -> None:
         key = client.key.delete()
         assert_matches_type(object, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_delete_with_all_params(self, client: Hanzo) -> None:
         key = client.key.delete(
@@ -151,7 +151,7 @@ class TestKey:
         )
         assert_matches_type(object, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_delete(self, client: Hanzo) -> None:
         response = client.key.with_raw_response.delete()
@@ -161,7 +161,7 @@ class TestKey:
         key = response.parse()
         assert_matches_type(object, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_delete(self, client: Hanzo) -> None:
         with client.key.with_streaming_response.delete() as response:
@@ -173,7 +173,7 @@ class TestKey:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_block(self, client: Hanzo) -> None:
         key = client.key.block(
@@ -181,7 +181,7 @@ class TestKey:
         )
         assert_matches_type(Optional[KeyBlockResponse], key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_block_with_all_params(self, client: Hanzo) -> None:
         key = client.key.block(
@@ -190,7 +190,7 @@ class TestKey:
         )
         assert_matches_type(Optional[KeyBlockResponse], key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_block(self, client: Hanzo) -> None:
         response = client.key.with_raw_response.block(
@@ -202,7 +202,7 @@ class TestKey:
         key = response.parse()
         assert_matches_type(Optional[KeyBlockResponse], key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_block(self, client: Hanzo) -> None:
         with client.key.with_streaming_response.block(
@@ -216,13 +216,13 @@ class TestKey:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_check_health(self, client: Hanzo) -> None:
         key = client.key.check_health()
         assert_matches_type(KeyCheckHealthResponse, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_check_health(self, client: Hanzo) -> None:
         response = client.key.with_raw_response.check_health()
@@ -232,7 +232,7 @@ class TestKey:
         key = response.parse()
         assert_matches_type(KeyCheckHealthResponse, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_check_health(self, client: Hanzo) -> None:
         with client.key.with_streaming_response.check_health() as response:
@@ -244,13 +244,13 @@ class TestKey:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_generate(self, client: Hanzo) -> None:
         key = client.key.generate()
         assert_matches_type(GenerateKeyResponse, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_generate_with_all_params(self, client: Hanzo) -> None:
         key = client.key.generate(
@@ -285,7 +285,7 @@ class TestKey:
         )
         assert_matches_type(GenerateKeyResponse, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_generate(self, client: Hanzo) -> None:
         response = client.key.with_raw_response.generate()
@@ -295,7 +295,7 @@ class TestKey:
         key = response.parse()
         assert_matches_type(GenerateKeyResponse, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_generate(self, client: Hanzo) -> None:
         with client.key.with_streaming_response.generate() as response:
@@ -307,7 +307,7 @@ class TestKey:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_regenerate_by_key(self, client: Hanzo) -> None:
         key = client.key.regenerate_by_key(
@@ -315,7 +315,7 @@ class TestKey:
         )
         assert_matches_type(Optional[GenerateKeyResponse], key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_regenerate_by_key_with_all_params(self, client: Hanzo) -> None:
         key = client.key.regenerate_by_key(
@@ -352,7 +352,7 @@ class TestKey:
         )
         assert_matches_type(Optional[GenerateKeyResponse], key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_regenerate_by_key(self, client: Hanzo) -> None:
         response = client.key.with_raw_response.regenerate_by_key(
@@ -364,7 +364,7 @@ class TestKey:
         key = response.parse()
         assert_matches_type(Optional[GenerateKeyResponse], key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_regenerate_by_key(self, client: Hanzo) -> None:
         with client.key.with_streaming_response.regenerate_by_key(
@@ -378,7 +378,7 @@ class TestKey:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_regenerate_by_key(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `path_key` but received ''"):
@@ -386,13 +386,13 @@ class TestKey:
                 path_key="",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_retrieve_info(self, client: Hanzo) -> None:
         key = client.key.retrieve_info()
         assert_matches_type(object, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_retrieve_info_with_all_params(self, client: Hanzo) -> None:
         key = client.key.retrieve_info(
@@ -400,7 +400,7 @@ class TestKey:
         )
         assert_matches_type(object, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_retrieve_info(self, client: Hanzo) -> None:
         response = client.key.with_raw_response.retrieve_info()
@@ -410,7 +410,7 @@ class TestKey:
         key = response.parse()
         assert_matches_type(object, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_retrieve_info(self, client: Hanzo) -> None:
         with client.key.with_streaming_response.retrieve_info() as response:
@@ -422,7 +422,7 @@ class TestKey:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_unblock(self, client: Hanzo) -> None:
         key = client.key.unblock(
@@ -430,7 +430,7 @@ class TestKey:
         )
         assert_matches_type(object, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_unblock_with_all_params(self, client: Hanzo) -> None:
         key = client.key.unblock(
@@ -439,7 +439,7 @@ class TestKey:
         )
         assert_matches_type(object, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_unblock(self, client: Hanzo) -> None:
         response = client.key.with_raw_response.unblock(
@@ -451,7 +451,7 @@ class TestKey:
         key = response.parse()
         assert_matches_type(object, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_unblock(self, client: Hanzo) -> None:
         with client.key.with_streaming_response.unblock(
@@ -471,7 +471,7 @@ class TestAsyncKey:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_update(self, async_client: AsyncHanzo) -> None:
         key = await async_client.key.update(
@@ -479,7 +479,7 @@ class TestAsyncKey:
         )
         assert_matches_type(object, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_update_with_all_params(self, async_client: AsyncHanzo) -> None:
         key = await async_client.key.update(
@@ -514,7 +514,7 @@ class TestAsyncKey:
         )
         assert_matches_type(object, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
         response = await async_client.key.with_raw_response.update(
@@ -526,7 +526,7 @@ class TestAsyncKey:
         key = await response.parse()
         assert_matches_type(object, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
         async with async_client.key.with_streaming_response.update(
@@ -540,13 +540,13 @@ class TestAsyncKey:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_list(self, async_client: AsyncHanzo) -> None:
         key = await async_client.key.list()
         assert_matches_type(KeyListResponse, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_list_with_all_params(self, async_client: AsyncHanzo) -> None:
         key = await async_client.key.list(
@@ -561,7 +561,7 @@ class TestAsyncKey:
         )
         assert_matches_type(KeyListResponse, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
         response = await async_client.key.with_raw_response.list()
@@ -571,7 +571,7 @@ class TestAsyncKey:
         key = await response.parse()
         assert_matches_type(KeyListResponse, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
         async with async_client.key.with_streaming_response.list() as response:
@@ -583,13 +583,13 @@ class TestAsyncKey:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_delete(self, async_client: AsyncHanzo) -> None:
         key = await async_client.key.delete()
         assert_matches_type(object, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_delete_with_all_params(self, async_client: AsyncHanzo) -> None:
         key = await async_client.key.delete(
@@ -599,7 +599,7 @@ class TestAsyncKey:
         )
         assert_matches_type(object, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
         response = await async_client.key.with_raw_response.delete()
@@ -609,7 +609,7 @@ class TestAsyncKey:
         key = await response.parse()
         assert_matches_type(object, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
         async with async_client.key.with_streaming_response.delete() as response:
@@ -621,7 +621,7 @@ class TestAsyncKey:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_block(self, async_client: AsyncHanzo) -> None:
         key = await async_client.key.block(
@@ -629,7 +629,7 @@ class TestAsyncKey:
         )
         assert_matches_type(Optional[KeyBlockResponse], key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_block_with_all_params(self, async_client: AsyncHanzo) -> None:
         key = await async_client.key.block(
@@ -638,7 +638,7 @@ class TestAsyncKey:
         )
         assert_matches_type(Optional[KeyBlockResponse], key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_block(self, async_client: AsyncHanzo) -> None:
         response = await async_client.key.with_raw_response.block(
@@ -650,7 +650,7 @@ class TestAsyncKey:
         key = await response.parse()
         assert_matches_type(Optional[KeyBlockResponse], key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_block(self, async_client: AsyncHanzo) -> None:
         async with async_client.key.with_streaming_response.block(
@@ -664,13 +664,13 @@ class TestAsyncKey:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_check_health(self, async_client: AsyncHanzo) -> None:
         key = await async_client.key.check_health()
         assert_matches_type(KeyCheckHealthResponse, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_check_health(self, async_client: AsyncHanzo) -> None:
         response = await async_client.key.with_raw_response.check_health()
@@ -680,7 +680,7 @@ class TestAsyncKey:
         key = await response.parse()
         assert_matches_type(KeyCheckHealthResponse, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_check_health(self, async_client: AsyncHanzo) -> None:
         async with async_client.key.with_streaming_response.check_health() as response:
@@ -692,13 +692,13 @@ class TestAsyncKey:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_generate(self, async_client: AsyncHanzo) -> None:
         key = await async_client.key.generate()
         assert_matches_type(GenerateKeyResponse, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_generate_with_all_params(self, async_client: AsyncHanzo) -> None:
         key = await async_client.key.generate(
@@ -733,7 +733,7 @@ class TestAsyncKey:
         )
         assert_matches_type(GenerateKeyResponse, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_generate(self, async_client: AsyncHanzo) -> None:
         response = await async_client.key.with_raw_response.generate()
@@ -743,7 +743,7 @@ class TestAsyncKey:
         key = await response.parse()
         assert_matches_type(GenerateKeyResponse, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_generate(self, async_client: AsyncHanzo) -> None:
         async with async_client.key.with_streaming_response.generate() as response:
@@ -755,7 +755,7 @@ class TestAsyncKey:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_regenerate_by_key(self, async_client: AsyncHanzo) -> None:
         key = await async_client.key.regenerate_by_key(
@@ -763,7 +763,7 @@ class TestAsyncKey:
         )
         assert_matches_type(Optional[GenerateKeyResponse], key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_regenerate_by_key_with_all_params(self, async_client: AsyncHanzo) -> None:
         key = await async_client.key.regenerate_by_key(
@@ -800,7 +800,7 @@ class TestAsyncKey:
         )
         assert_matches_type(Optional[GenerateKeyResponse], key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_regenerate_by_key(self, async_client: AsyncHanzo) -> None:
         response = await async_client.key.with_raw_response.regenerate_by_key(
@@ -812,7 +812,7 @@ class TestAsyncKey:
         key = await response.parse()
         assert_matches_type(Optional[GenerateKeyResponse], key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_regenerate_by_key(self, async_client: AsyncHanzo) -> None:
         async with async_client.key.with_streaming_response.regenerate_by_key(
@@ -826,7 +826,7 @@ class TestAsyncKey:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_regenerate_by_key(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `path_key` but received ''"):
@@ -834,13 +834,13 @@ class TestAsyncKey:
                 path_key="",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_retrieve_info(self, async_client: AsyncHanzo) -> None:
         key = await async_client.key.retrieve_info()
         assert_matches_type(object, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_retrieve_info_with_all_params(self, async_client: AsyncHanzo) -> None:
         key = await async_client.key.retrieve_info(
@@ -848,7 +848,7 @@ class TestAsyncKey:
         )
         assert_matches_type(object, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_retrieve_info(self, async_client: AsyncHanzo) -> None:
         response = await async_client.key.with_raw_response.retrieve_info()
@@ -858,7 +858,7 @@ class TestAsyncKey:
         key = await response.parse()
         assert_matches_type(object, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_retrieve_info(self, async_client: AsyncHanzo) -> None:
         async with async_client.key.with_streaming_response.retrieve_info() as response:
@@ -870,7 +870,7 @@ class TestAsyncKey:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_unblock(self, async_client: AsyncHanzo) -> None:
         key = await async_client.key.unblock(
@@ -878,7 +878,7 @@ class TestAsyncKey:
         )
         assert_matches_type(object, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_unblock_with_all_params(self, async_client: AsyncHanzo) -> None:
         key = await async_client.key.unblock(
@@ -887,7 +887,7 @@ class TestAsyncKey:
         )
         assert_matches_type(object, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_unblock(self, async_client: AsyncHanzo) -> None:
         response = await async_client.key.with_raw_response.unblock(
@@ -899,7 +899,7 @@ class TestAsyncKey:
         key = await response.parse()
         assert_matches_type(object, key, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_unblock(self, async_client: AsyncHanzo) -> None:
         async with async_client.key.with_streaming_response.unblock(

tests/api_resources/test_langfuse.py

@@ -16,7 +16,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestLangfuse:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create(self, client: Hanzo) -> None:
         langfuse = client.langfuse.create(
@@ -24,7 +24,7 @@ class TestLangfuse:
         )
         assert_matches_type(object, langfuse, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Hanzo) -> None:
         response = client.langfuse.with_raw_response.create(
@@ -36,7 +36,7 @@ class TestLangfuse:
         langfuse = response.parse()
         assert_matches_type(object, langfuse, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Hanzo) -> None:
         with client.langfuse.with_streaming_response.create(
@@ -50,7 +50,7 @@ class TestLangfuse:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_create(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -58,7 +58,7 @@ class TestLangfuse:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_retrieve(self, client: Hanzo) -> None:
         langfuse = client.langfuse.retrieve(
@@ -66,7 +66,7 @@ class TestLangfuse:
         )
         assert_matches_type(object, langfuse, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_retrieve(self, client: Hanzo) -> None:
         response = client.langfuse.with_raw_response.retrieve(
@@ -78,7 +78,7 @@ class TestLangfuse:
         langfuse = response.parse()
         assert_matches_type(object, langfuse, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_retrieve(self, client: Hanzo) -> None:
         with client.langfuse.with_streaming_response.retrieve(
@@ -92,7 +92,7 @@ class TestLangfuse:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_retrieve(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -100,7 +100,7 @@ class TestLangfuse:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_update(self, client: Hanzo) -> None:
         langfuse = client.langfuse.update(
@@ -108,7 +108,7 @@ class TestLangfuse:
         )
         assert_matches_type(object, langfuse, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_update(self, client: Hanzo) -> None:
         response = client.langfuse.with_raw_response.update(
@@ -120,7 +120,7 @@ class TestLangfuse:
         langfuse = response.parse()
         assert_matches_type(object, langfuse, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_update(self, client: Hanzo) -> None:
         with client.langfuse.with_streaming_response.update(
@@ -134,7 +134,7 @@ class TestLangfuse:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_update(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -142,7 +142,7 @@ class TestLangfuse:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_delete(self, client: Hanzo) -> None:
         langfuse = client.langfuse.delete(
@@ -150,7 +150,7 @@ class TestLangfuse:
         )
         assert_matches_type(object, langfuse, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_delete(self, client: Hanzo) -> None:
         response = client.langfuse.with_raw_response.delete(
@@ -162,7 +162,7 @@ class TestLangfuse:
         langfuse = response.parse()
         assert_matches_type(object, langfuse, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_delete(self, client: Hanzo) -> None:
         with client.langfuse.with_streaming_response.delete(
@@ -176,7 +176,7 @@ class TestLangfuse:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_delete(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -184,7 +184,7 @@ class TestLangfuse:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_patch(self, client: Hanzo) -> None:
         langfuse = client.langfuse.patch(
@@ -192,7 +192,7 @@ class TestLangfuse:
         )
         assert_matches_type(object, langfuse, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_patch(self, client: Hanzo) -> None:
         response = client.langfuse.with_raw_response.patch(
@@ -204,7 +204,7 @@ class TestLangfuse:
         langfuse = response.parse()
         assert_matches_type(object, langfuse, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_patch(self, client: Hanzo) -> None:
         with client.langfuse.with_streaming_response.patch(
@@ -218,7 +218,7 @@ class TestLangfuse:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_path_params_patch(self, client: Hanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -232,7 +232,7 @@ class TestAsyncLangfuse:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncHanzo) -> None:
         langfuse = await async_client.langfuse.create(
@@ -240,7 +240,7 @@ class TestAsyncLangfuse:
         )
         assert_matches_type(object, langfuse, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
         response = await async_client.langfuse.with_raw_response.create(
@@ -252,7 +252,7 @@ class TestAsyncLangfuse:
         langfuse = await response.parse()
         assert_matches_type(object, langfuse, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
         async with async_client.langfuse.with_streaming_response.create(
@@ -266,7 +266,7 @@ class TestAsyncLangfuse:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_create(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -274,7 +274,7 @@ class TestAsyncLangfuse:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_retrieve(self, async_client: AsyncHanzo) -> None:
         langfuse = await async_client.langfuse.retrieve(
@@ -282,7 +282,7 @@ class TestAsyncLangfuse:
         )
         assert_matches_type(object, langfuse, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_retrieve(self, async_client: AsyncHanzo) -> None:
         response = await async_client.langfuse.with_raw_response.retrieve(
@@ -294,7 +294,7 @@ class TestAsyncLangfuse:
         langfuse = await response.parse()
         assert_matches_type(object, langfuse, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_retrieve(self, async_client: AsyncHanzo) -> None:
         async with async_client.langfuse.with_streaming_response.retrieve(
@@ -308,7 +308,7 @@ class TestAsyncLangfuse:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_retrieve(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -316,7 +316,7 @@ class TestAsyncLangfuse:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_update(self, async_client: AsyncHanzo) -> None:
         langfuse = await async_client.langfuse.update(
@@ -324,7 +324,7 @@ class TestAsyncLangfuse:
         )
         assert_matches_type(object, langfuse, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_update(self, async_client: AsyncHanzo) -> None:
         response = await async_client.langfuse.with_raw_response.update(
@@ -336,7 +336,7 @@ class TestAsyncLangfuse:
         langfuse = await response.parse()
         assert_matches_type(object, langfuse, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_update(self, async_client: AsyncHanzo) -> None:
         async with async_client.langfuse.with_streaming_response.update(
@@ -350,7 +350,7 @@ class TestAsyncLangfuse:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_update(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -358,7 +358,7 @@ class TestAsyncLangfuse:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_delete(self, async_client: AsyncHanzo) -> None:
         langfuse = await async_client.langfuse.delete(
@@ -366,7 +366,7 @@ class TestAsyncLangfuse:
         )
         assert_matches_type(object, langfuse, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
         response = await async_client.langfuse.with_raw_response.delete(
@@ -378,7 +378,7 @@ class TestAsyncLangfuse:
         langfuse = await response.parse()
         assert_matches_type(object, langfuse, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
         async with async_client.langfuse.with_streaming_response.delete(
@@ -392,7 +392,7 @@ class TestAsyncLangfuse:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_delete(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):
@@ -400,7 +400,7 @@ class TestAsyncLangfuse:
                 "",
             )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_patch(self, async_client: AsyncHanzo) -> None:
         langfuse = await async_client.langfuse.patch(
@@ -408,7 +408,7 @@ class TestAsyncLangfuse:
         )
         assert_matches_type(object, langfuse, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_patch(self, async_client: AsyncHanzo) -> None:
         response = await async_client.langfuse.with_raw_response.patch(
@@ -420,7 +420,7 @@ class TestAsyncLangfuse:
         langfuse = await response.parse()
         assert_matches_type(object, langfuse, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_patch(self, async_client: AsyncHanzo) -> None:
         async with async_client.langfuse.with_streaming_response.patch(
@@ -434,7 +434,7 @@ class TestAsyncLangfuse:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_path_params_patch(self, async_client: AsyncHanzo) -> None:
         with pytest.raises(ValueError, match=r"Expected a non-empty value for `endpoint` but received ''"):

tests/api_resources/test_model.py

@@ -17,7 +17,7 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestModel:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create(self, client: Hanzo) -> None:
         model = client.model.create(
@@ -27,7 +27,7 @@ class TestModel:
         )
         assert_matches_type(object, model, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_create_with_all_params(self, client: Hanzo) -> None:
         model = client.model.create(
@@ -80,7 +80,7 @@ class TestModel:
         )
         assert_matches_type(object, model, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_create(self, client: Hanzo) -> None:
         response = client.model.with_raw_response.create(
@@ -94,7 +94,7 @@ class TestModel:
         model = response.parse()
         assert_matches_type(object, model, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_create(self, client: Hanzo) -> None:
         with client.model.with_streaming_response.create(
@@ -110,7 +110,7 @@ class TestModel:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_delete(self, client: Hanzo) -> None:
         model = client.model.delete(
@@ -118,7 +118,7 @@ class TestModel:
         )
         assert_matches_type(object, model, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_delete(self, client: Hanzo) -> None:
         response = client.model.with_raw_response.delete(
@@ -130,7 +130,7 @@ class TestModel:
         model = response.parse()
         assert_matches_type(object, model, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_delete(self, client: Hanzo) -> None:
         with client.model.with_streaming_response.delete(
@@ -150,7 +150,7 @@ class TestAsyncModel:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create(self, async_client: AsyncHanzo) -> None:
         model = await async_client.model.create(
@@ -160,7 +160,7 @@ class TestAsyncModel:
         )
         assert_matches_type(object, model, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_create_with_all_params(self, async_client: AsyncHanzo) -> None:
         model = await async_client.model.create(
@@ -213,7 +213,7 @@ class TestAsyncModel:
         )
         assert_matches_type(object, model, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_create(self, async_client: AsyncHanzo) -> None:
         response = await async_client.model.with_raw_response.create(
@@ -227,7 +227,7 @@ class TestAsyncModel:
         model = await response.parse()
         assert_matches_type(object, model, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_create(self, async_client: AsyncHanzo) -> None:
         async with async_client.model.with_streaming_response.create(
@@ -243,7 +243,7 @@ class TestAsyncModel:
 
         assert cast(Any, response.is_closed) is True
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_delete(self, async_client: AsyncHanzo) -> None:
         model = await async_client.model.delete(
@@ -251,7 +251,7 @@ class TestAsyncModel:
         )
         assert_matches_type(object, model, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncHanzo) -> None:
         response = await async_client.model.with_raw_response.delete(
@@ -263,7 +263,7 @@ class TestAsyncModel:
         model = await response.parse()
         assert_matches_type(object, model, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncHanzo) -> None:
         async with async_client.model.with_streaming_response.delete(

tests/api_resources/test_model_group.py

@@ -16,13 +16,13 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestModelGroup:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_retrieve_info(self, client: Hanzo) -> None:
         model_group = client.model_group.retrieve_info()
         assert_matches_type(object, model_group, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_retrieve_info_with_all_params(self, client: Hanzo) -> None:
         model_group = client.model_group.retrieve_info(
@@ -30,7 +30,7 @@ class TestModelGroup:
         )
         assert_matches_type(object, model_group, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_retrieve_info(self, client: Hanzo) -> None:
         response = client.model_group.with_raw_response.retrieve_info()
@@ -40,7 +40,7 @@ class TestModelGroup:
         model_group = response.parse()
         assert_matches_type(object, model_group, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_retrieve_info(self, client: Hanzo) -> None:
         with client.model_group.with_streaming_response.retrieve_info() as response:
@@ -58,13 +58,13 @@ class TestAsyncModelGroup:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_retrieve_info(self, async_client: AsyncHanzo) -> None:
         model_group = await async_client.model_group.retrieve_info()
         assert_matches_type(object, model_group, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_retrieve_info_with_all_params(self, async_client: AsyncHanzo) -> None:
         model_group = await async_client.model_group.retrieve_info(
@@ -72,7 +72,7 @@ class TestAsyncModelGroup:
         )
         assert_matches_type(object, model_group, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_retrieve_info(self, async_client: AsyncHanzo) -> None:
         response = await async_client.model_group.with_raw_response.retrieve_info()
@@ -82,7 +82,7 @@ class TestAsyncModelGroup:
         model_group = await response.parse()
         assert_matches_type(object, model_group, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_retrieve_info(self, async_client: AsyncHanzo) -> None:
         async with async_client.model_group.with_streaming_response.retrieve_info() as response:

tests/api_resources/test_models.py

@@ -16,13 +16,13 @@ base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010")
 class TestModels:
     parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_list(self, client: Hanzo) -> None:
         model = client.models.list()
         assert_matches_type(object, model, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_method_list_with_all_params(self, client: Hanzo) -> None:
         model = client.models.list(
@@ -31,7 +31,7 @@ class TestModels:
         )
         assert_matches_type(object, model, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_list(self, client: Hanzo) -> None:
         response = client.models.with_raw_response.list()
@@ -41,7 +41,7 @@ class TestModels:
         model = response.parse()
         assert_matches_type(object, model, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_streaming_response_list(self, client: Hanzo) -> None:
         with client.models.with_streaming_response.list() as response:
@@ -59,13 +59,13 @@ class TestAsyncModels:
         "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"]
     )
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_list(self, async_client: AsyncHanzo) -> None:
         model = await async_client.models.list()
         assert_matches_type(object, model, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_method_list_with_all_params(self, async_client: AsyncHanzo) -> None:
         model = await async_client.models.list(
@@ -74,7 +74,7 @@ class TestAsyncModels:
         )
         assert_matches_type(object, model, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_list(self, async_client: AsyncHanzo) -> None:
         response = await async_client.models.with_raw_response.list()
@@ -84,7 +84,7 @@ class TestAsyncModels:
         model = await response.parse()
         assert_matches_type(object, model, path=["response"])
 
-    @pytest.mark.skip()
+    @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_streaming_response_list(self, async_client: AsyncHanzo) -> None:
         async with async_client.models.with_streaming_response.list() as response: