schemathesis 3.21.2__py3-none-any.whl → 3.22.1__py3-none-any.whl

schemathesis/specs/openapi/loaders.py

@@ -3,19 +3,24 @@ import io
 import json
 import pathlib
 import re
-from typing import IO, Any, Callable, Dict, List, Optional, Tuple, Union, cast, TYPE_CHECKING
+from typing import IO, Any, Callable, cast, TYPE_CHECKING
 from urllib.parse import urljoin
 
 from ... import experimental, fixups
 from ...code_samples import CodeSampleStyle
-from ...generation import DEFAULT_DATA_GENERATION_METHODS, DataGenerationMethodInput, DataGenerationMethod
+from ...generation import (
+    DEFAULT_DATA_GENERATION_METHODS,
+    DataGenerationMethodInput,
+    DataGenerationMethod,
+    GenerationConfig,
+)
 from ...constants import WAIT_FOR_SCHEMA_INTERVAL
 from ...exceptions import SchemaError, SchemaErrorType
 from ...hooks import HookContext, dispatch
 from ...loaders import load_schema_from_url, load_yaml
 from ...throttling import build_limiter
 from ...types import Filter, NotSet, PathLike
-from ...transports.content_types import is_json_media_type
+from ...transports.content_types import is_json_media_type, is_yaml_media_type
 from ...transports.headers import setup_default_headers
 from ...internal.validation import require_relative_url
 from ...constants import NOT_SET
@@ -37,27 +42,44 @@ def _is_json_response(response: GenericResponse) -> bool:
     return False
 
 
-def _is_json_path(path: PathLike) -> bool:
+def _has_suffix(path: PathLike, suffix: str) -> bool:
     if isinstance(path, str):
-        return path.endswith(".json")
-    return path.suffix == ".json"
+        return path.endswith(suffix)
+    return path.suffix == suffix
+
+
+def _is_json_path(path: PathLike) -> bool:
+    return _has_suffix(path, ".json")
+
+
+def _is_yaml_response(response: GenericResponse) -> bool:
+    """Guess if the response contains YAML."""
+    content_type = response.headers.get("Content-Type")
+    if content_type is not None:
+        return is_yaml_media_type(content_type)
+    return False
+
+
+def _is_yaml_path(path: PathLike) -> bool:
+    return _has_suffix(path, ".yaml") or _has_suffix(path, ".yml")
 
 
 def from_path(
     path: PathLike,
     *,
     app: Any = None,
-    base_url: Optional[str] = None,
-    method: Optional[Filter] = None,
-    endpoint: Optional[Filter] = None,
-    tag: Optional[Filter] = None,
-    operation_id: Optional[Filter] = None,
+    base_url: str | None = None,
+    method: Filter | None = None,
+    endpoint: Filter | None = None,
+    tag: Filter | None = None,
+    operation_id: Filter | None = None,
     skip_deprecated_operations: bool = False,
     validate_schema: bool = False,
-    force_schema_version: Optional[str] = None,
+    force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
+    generation_config: GenerationConfig | None = None,
     code_sample_style: str = CodeSampleStyle.default().name,
-    rate_limit: Optional[str] = None,
+    rate_limit: str | None = None,
     encoding: str = "utf8",
     sanitize_output: bool = True,
 ) -> BaseOpenAPISchema:
@@ -79,11 +101,13 @@ def from_path(
             validate_schema=validate_schema,
             force_schema_version=force_schema_version,
             data_generation_methods=data_generation_methods,
+            generation_config=generation_config,
             code_sample_style=code_sample_style,
             location=pathlib.Path(path).absolute().as_uri(),
             rate_limit=rate_limit,
             sanitize_output=sanitize_output,
             __expects_json=_is_json_path(path),
+            __expects_yaml=_is_yaml_path(path),
         )
 
 
@@ -91,19 +115,20 @@ def from_uri(
     uri: str,
     *,
     app: Any = None,
-    base_url: Optional[str] = None,
-    port: Optional[int] = None,
-    method: Optional[Filter] = None,
-    endpoint: Optional[Filter] = None,
-    tag: Optional[Filter] = None,
-    operation_id: Optional[Filter] = None,
+    base_url: str | None = None,
+    port: int | None = None,
+    method: Filter | None = None,
+    endpoint: Filter | None = None,
+    tag: Filter | None = None,
+    operation_id: Filter | None = None,
     skip_deprecated_operations: bool = False,
     validate_schema: bool = False,
-    force_schema_version: Optional[str] = None,
+    force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
+    generation_config: GenerationConfig | None = None,
     code_sample_style: str = CodeSampleStyle.default().name,
-    wait_for_schema: Optional[float] = None,
-    rate_limit: Optional[str] = None,
+    wait_for_schema: float | None = None,
+    rate_limit: str | None = None,
     sanitize_output: bool = True,
     **kwargs: Any,
 ) -> BaseOpenAPISchema:
@@ -149,44 +174,57 @@ def from_uri(
         validate_schema=validate_schema,
         force_schema_version=force_schema_version,
         data_generation_methods=data_generation_methods,
+        generation_config=generation_config,
         code_sample_style=code_sample_style,
         location=uri,
         rate_limit=rate_limit,
         sanitize_output=sanitize_output,
         __expects_json=_is_json_response(response),
+        __expects_yaml=_is_yaml_response(response),
     )
 
 
 SCHEMA_LOADING_ERROR = "Received unsupported content while expecting a JSON or YAML payload for Open API"
+SCHEMA_SYNTAX_ERROR = "API schema does not appear syntactically valid"
 
 
-def _load_yaml(data: str) -> Dict[str, Any]:
+def _load_yaml(data: str, include_details_on_error: bool = False) -> dict[str, Any]:
     import yaml
 
     try:
         return load_yaml(data)
     except yaml.YAMLError as exc:
-        raise SchemaError(SchemaErrorType.UNEXPECTED_CONTENT_TYPE, SCHEMA_LOADING_ERROR) from exc
+        if include_details_on_error:
+            type_ = SchemaErrorType.SYNTAX_ERROR
+            message = SCHEMA_SYNTAX_ERROR
+            extras = [entry for entry in str(exc).splitlines() if entry]
+        else:
+            type_ = SchemaErrorType.UNEXPECTED_CONTENT_TYPE
+            message = SCHEMA_LOADING_ERROR
+            extras = []
+        raise SchemaError(type_, message, extras=extras) from exc
 
 
 def from_file(
-    file: Union[IO[str], str],
+    file: IO[str] | str,
     *,
     app: Any = None,
-    base_url: Optional[str] = None,
-    method: Optional[Filter] = None,
-    endpoint: Optional[Filter] = None,
-    tag: Optional[Filter] = None,
-    operation_id: Optional[Filter] = None,
+    base_url: str | None = None,
+    method: Filter | None = None,
+    endpoint: Filter | None = None,
+    tag: Filter | None = None,
+    operation_id: Filter | None = None,
     skip_deprecated_operations: bool = False,
     validate_schema: bool = False,
-    force_schema_version: Optional[str] = None,
+    force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
+    generation_config: GenerationConfig | None = None,
     code_sample_style: str = CodeSampleStyle.default().name,
-    location: Optional[str] = None,
-    rate_limit: Optional[str] = None,
+    location: str | None = None,
+    rate_limit: str | None = None,
     sanitize_output: bool = True,
     __expects_json: bool = False,
+    __expects_yaml: bool = False,
     **kwargs: Any,  # needed in the runner to have compatible API across all loaders
 ) -> BaseOpenAPISchema:
     """Load Open API schema from a file descriptor, string or bytes.
@@ -200,13 +238,20 @@ def from_file(
     if __expects_json:
         try:
             raw = json.loads(data)
-        except json.JSONDecodeError:
+        except json.JSONDecodeError as exc:
             # Fallback to a slower YAML loader. This way we'll still load schemas from responses with
             # invalid `Content-Type` headers or YAML files that have the `.json` extension.
             # This is a rare case, and it will be slower but trying JSON first improves a more common use case
-            raw = _load_yaml(data)
+            try:
+                raw = _load_yaml(data)
+            except SchemaError:
+                raise SchemaError(
+                    SchemaErrorType.SYNTAX_ERROR,
+                    SCHEMA_SYNTAX_ERROR,
+                    extras=[entry for entry in str(exc).splitlines() if entry],
+                ) from exc
     else:
-        raw = _load_yaml(data)
+        raw = _load_yaml(data, include_details_on_error=__expects_yaml)
     return from_dict(
         raw,
         app=app,
@@ -219,6 +264,7 @@ def from_file(
         validate_schema=validate_schema,
         force_schema_version=force_schema_version,
         data_generation_methods=data_generation_methods,
+        generation_config=generation_config,
         code_sample_style=code_sample_style,
         location=location,
         rate_limit=rate_limit,
@@ -234,21 +280,22 @@ def _is_fast_api(app: Any) -> bool:
 
 
 def from_dict(
-    raw_schema: Dict[str, Any],
+    raw_schema: dict[str, Any],
     *,
     app: Any = None,
-    base_url: Optional[str] = None,
-    method: Optional[Filter] = None,
-    endpoint: Optional[Filter] = None,
-    tag: Optional[Filter] = None,
-    operation_id: Optional[Filter] = None,
+    base_url: str | None = None,
+    method: Filter | None = None,
+    endpoint: Filter | None = None,
+    tag: Filter | None = None,
+    operation_id: Filter | None = None,
     skip_deprecated_operations: bool = False,
     validate_schema: bool = False,
-    force_schema_version: Optional[str] = None,
+    force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
+    generation_config: GenerationConfig | None = None,
     code_sample_style: str = CodeSampleStyle.default().name,
-    location: Optional[str] = None,
-    rate_limit: Optional[str] = None,
+    location: str | None = None,
+    rate_limit: str | None = None,
     sanitize_output: bool = True,
 ) -> BaseOpenAPISchema:
     """Load Open API schema from a Python dictionary.
@@ -266,7 +313,7 @@ def from_dict(
     elif _is_fast_api(app):
         fixups.fast_api.adjust_schema(raw_schema)
     dispatch("before_load_schema", hook_context, raw_schema)
-    rate_limiter: Optional[Limiter] = None
+    rate_limiter: Limiter | None = None
     if rate_limit is not None:
         rate_limiter = build_limiter(rate_limit)
 
@@ -356,7 +403,7 @@ NON_STRING_OBJECT_KEY_MESSAGE = (
 )
 
 
-def _format_status_codes(status_codes: List[Tuple[int, List[Union[str, int]]]]) -> str:
+def _format_status_codes(status_codes: list[tuple[int, list[str | int]]]) -> str:
     buffer = io.StringIO()
     for status_code, path in status_codes:
         buffer.write(f" - {status_code} at schema['paths']")
@@ -367,7 +414,7 @@ def _format_status_codes(status_codes: List[Tuple[int, List[Union[str, int]]]])
 
 
 def _maybe_validate_schema(
-    instance: Dict[str, Any], validator: jsonschema.validators.Draft4Validator, validate_schema: bool
+    instance: dict[str, Any], validator: jsonschema.validators.Draft4Validator, validate_schema: bool
 ) -> None:
     from jsonschema import ValidationError
 
@@ -397,16 +444,17 @@ def from_pytest_fixture(
     fixture_name: str,
     *,
     app: Any = NOT_SET,
-    base_url: Union[Optional[str], NotSet] = NOT_SET,
-    method: Optional[Filter] = NOT_SET,
-    endpoint: Optional[Filter] = NOT_SET,
-    tag: Optional[Filter] = NOT_SET,
-    operation_id: Optional[Filter] = NOT_SET,
+    base_url: str | None | NotSet = NOT_SET,
+    method: Filter | None = NOT_SET,
+    endpoint: Filter | None = NOT_SET,
+    tag: Filter | None = NOT_SET,
+    operation_id: Filter | None = NOT_SET,
     skip_deprecated_operations: bool = False,
     validate_schema: bool = False,
-    data_generation_methods: Union[DataGenerationMethodInput, NotSet] = NOT_SET,
+    data_generation_methods: DataGenerationMethodInput | NotSet = NOT_SET,
+    generation_config: GenerationConfig | NotSet = NOT_SET,
     code_sample_style: str = CodeSampleStyle.default().name,
-    rate_limit: Optional[str] = None,
+    rate_limit: str | None = None,
     sanitize_output: bool = True,
 ) -> LazySchema:
     """Load schema from a ``pytest`` fixture.
@@ -421,13 +469,13 @@ def from_pytest_fixture(
     from ...lazy import LazySchema
 
     _code_sample_style = CodeSampleStyle.from_str(code_sample_style)
-    _data_generation_methods: Union[DataGenerationMethodInput, NotSet]
+    _data_generation_methods: DataGenerationMethodInput | NotSet
     if data_generation_methods is not NOT_SET:
         data_generation_methods = cast(DataGenerationMethodInput, data_generation_methods)
         _data_generation_methods = DataGenerationMethod.ensure_list(data_generation_methods)
     else:
         _data_generation_methods = data_generation_methods
-    rate_limiter: Optional[Limiter] = None
+    rate_limiter: Limiter | None = None
     if rate_limit is not None:
         rate_limiter = build_limiter(rate_limit)
     return LazySchema(
@@ -441,6 +489,7 @@ def from_pytest_fixture(
         skip_deprecated_operations=skip_deprecated_operations,
         validate_schema=validate_schema,
         data_generation_methods=_data_generation_methods,
+        generation_config=generation_config,
         code_sample_style=_code_sample_style,
         rate_limiter=rate_limiter,
         sanitize_output=sanitize_output,
@@ -451,17 +500,18 @@ def from_wsgi(
     schema_path: str,
     app: Any,
     *,
-    base_url: Optional[str] = None,
-    method: Optional[Filter] = None,
-    endpoint: Optional[Filter] = None,
-    tag: Optional[Filter] = None,
-    operation_id: Optional[Filter] = None,
+    base_url: str | None = None,
+    method: Filter | None = None,
+    endpoint: Filter | None = None,
+    tag: Filter | None = None,
+    operation_id: Filter | None = None,
     skip_deprecated_operations: bool = False,
     validate_schema: bool = False,
-    force_schema_version: Optional[str] = None,
+    force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
+    generation_config: GenerationConfig | None = None,
     code_sample_style: str = CodeSampleStyle.default().name,
-    rate_limit: Optional[str] = None,
+    rate_limit: str | None = None,
     sanitize_output: bool = True,
     **kwargs: Any,
 ) -> BaseOpenAPISchema:
@@ -489,6 +539,7 @@ def from_wsgi(
         validate_schema=validate_schema,
         force_schema_version=force_schema_version,
         data_generation_methods=data_generation_methods,
+        generation_config=generation_config,
         code_sample_style=code_sample_style,
         location=schema_path,
         rate_limit=rate_limit,
@@ -511,17 +562,18 @@ def from_aiohttp(
     schema_path: str,
     app: Any,
     *,
-    base_url: Optional[str] = None,
-    method: Optional[Filter] = None,
-    endpoint: Optional[Filter] = None,
-    tag: Optional[Filter] = None,
-    operation_id: Optional[Filter] = None,
+    base_url: str | None = None,
+    method: Filter | None = None,
+    endpoint: Filter | None = None,
+    tag: Filter | None = None,
+    operation_id: Filter | None = None,
     skip_deprecated_operations: bool = False,
     validate_schema: bool = False,
-    force_schema_version: Optional[str] = None,
+    force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
+    generation_config: GenerationConfig | None = None,
     code_sample_style: str = CodeSampleStyle.default().name,
-    rate_limit: Optional[str] = None,
+    rate_limit: str | None = None,
     sanitize_output: bool = True,
     **kwargs: Any,
 ) -> BaseOpenAPISchema:
@@ -546,6 +598,7 @@ def from_aiohttp(
         validate_schema=validate_schema,
         force_schema_version=force_schema_version,
         data_generation_methods=data_generation_methods,
+        generation_config=generation_config,
         code_sample_style=code_sample_style,
         rate_limit=rate_limit,
         sanitize_output=sanitize_output,
@@ -557,17 +610,18 @@ def from_asgi(
     schema_path: str,
     app: Any,
     *,
-    base_url: Optional[str] = None,
-    method: Optional[Filter] = None,
-    endpoint: Optional[Filter] = None,
-    tag: Optional[Filter] = None,
-    operation_id: Optional[Filter] = None,
+    base_url: str | None = None,
+    method: Filter | None = None,
+    endpoint: Filter | None = None,
+    tag: Filter | None = None,
+    operation_id: Filter | None = None,
     skip_deprecated_operations: bool = False,
     validate_schema: bool = False,
-    force_schema_version: Optional[str] = None,
+    force_schema_version: str | None = None,
     data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
+    generation_config: GenerationConfig | None = None,
     code_sample_style: str = CodeSampleStyle.default().name,
-    rate_limit: Optional[str] = None,
+    rate_limit: str | None = None,
     sanitize_output: bool = True,
     **kwargs: Any,
 ) -> BaseOpenAPISchema:
@@ -594,6 +648,7 @@ def from_asgi(
         validate_schema=validate_schema,
         force_schema_version=force_schema_version,
         data_generation_methods=data_generation_methods,
+        generation_config=generation_config,
         code_sample_style=code_sample_style,
         location=schema_path,
         rate_limit=rate_limit,

schemathesis/specs/openapi/negative/__init__.py

@@ -1,6 +1,7 @@
+from __future__ import annotations
 from dataclasses import dataclass
 from functools import lru_cache
-from typing import Any, Dict, Optional, Tuple
+from typing import Any
 from urllib.parse import urlencode
 
 import jsonschema
@@ -10,6 +11,7 @@ from hypothesis_jsonschema import from_schema
 from ..constants import ALL_KEYWORDS
 from .mutations import MutationContext
 from .types import Draw, Schema
+from ....generation import GenerationConfig
 
 
 @dataclass
@@ -27,15 +29,15 @@ class CacheKey:
         return hash((self.operation_name, self.location))
 
 
-@lru_cache()
+@lru_cache
 def get_validator(cache_key: CacheKey) -> jsonschema.Draft4Validator:
     """Get JSON Schema validator for the given schema."""
     # Each operation / location combo has only a single schema, therefore could be cached
     return jsonschema.Draft4Validator(cache_key.schema)
 
 
-@lru_cache()
-def split_schema(cache_key: CacheKey) -> Tuple[Schema, Schema]:
+@lru_cache
+def split_schema(cache_key: CacheKey) -> tuple[Schema, Schema]:
     """Split the schema in two parts.
 
     The first one contains only validation JSON Schema keywords, the second one everything else.
@@ -53,9 +55,10 @@ def negative_schema(
     schema: Schema,
     operation_name: str,
     location: str,
-    media_type: Optional[str],
+    media_type: str | None,
+    generation_config: GenerationConfig,
     *,
-    custom_formats: Dict[str, st.SearchStrategy[str]],
+    custom_formats: dict[str, st.SearchStrategy[str]],
 ) -> st.SearchStrategy:
     """A strategy for instances that DO NOT match the input schema.
 
@@ -69,20 +72,22 @@ def negative_schema(
 
     if location == "query":
 
-        def filter_values(value: Dict[str, Any]) -> bool:
+        def filter_values(value: dict[str, Any]) -> bool:
             return is_non_empty_query(value) and not validator.is_valid(value)
 
     else:
 
-        def filter_values(value: Dict[str, Any]) -> bool:
+        def filter_values(value: dict[str, Any]) -> bool:
             return not validator.is_valid(value)
 
     return mutated(keywords, non_keywords, location, media_type).flatmap(
-        lambda s: from_schema(s, custom_formats=custom_formats).filter(filter_values)
+        lambda s: from_schema(
+            s, custom_formats=custom_formats, allow_x00=generation_config.allow_x00, codec=generation_config.codec
+        ).filter(filter_values)
     )
 
 
-def is_non_empty_query(query: Dict[str, Any]) -> bool:
+def is_non_empty_query(query: dict[str, Any]) -> bool:
     # Whether this query parameters will be encoded to a non-empty query string
     result = []
     for key, values in query.items():
@@ -100,7 +105,7 @@ def is_non_empty_query(query: Dict[str, Any]) -> bool:
 
 
 @st.composite  # type: ignore
-def mutated(draw: Draw, keywords: Schema, non_keywords: Schema, location: str, media_type: Optional[str]) -> Any:
+def mutated(draw: Draw, keywords: Schema, non_keywords: Schema, location: str, media_type: str | None) -> Any:
     return MutationContext(
         keywords=keywords, non_keywords=non_keywords, location=location, media_type=media_type
     ).mutate(draw)

schemathesis/specs/openapi/negative/mutations.py

@@ -1,8 +1,9 @@
 """Schema mutations."""
+from __future__ import annotations
 import enum
 from dataclasses import dataclass
 from functools import wraps
-from typing import Any, Callable, List, Optional, Sequence, Set, Tuple, TypeVar
+from typing import Any, Callable, Sequence, TypeVar
 
 from hypothesis import reject
 from hypothesis import strategies as st
@@ -28,10 +29,10 @@ class MutationResult(enum.Enum):
     SUCCESS = 1
     FAILURE = 2
 
-    def __ior__(self, other: Any) -> "MutationResult":
+    def __ior__(self, other: Any) -> MutationResult:
         return self | other
 
-    def __or__(self, other: Any) -> "MutationResult":
+    def __or__(self, other: Any) -> MutationResult:
         # Syntactic sugar to simplify handling of multiple results
         if self == MutationResult.SUCCESS:
             return self
@@ -68,7 +69,7 @@ class MutationContext:
     # Schema location within API operation (header, query, etc)
     location: str
     # Payload media type, if available
-    media_type: Optional[str]
+    media_type: str | None
 
     @property
     def is_header_location(self) -> bool:
@@ -81,7 +82,7 @@ class MutationContext:
     def mutate(self, draw: Draw) -> Schema:
         # On the top level, Schemathesis creates "object" schemas for all parameter "in" values except "body", which is
         # taken as-is. Therefore, we can only apply mutations that won't change the Open API semantics of the schema.
-        mutations: List[Mutation]
+        mutations: list[Mutation]
         if self.location in ("header", "cookie", "query"):
             # These objects follow this pattern:
             # {
@@ -225,7 +226,7 @@ def change_type(context: MutationContext, draw: Draw, schema: Schema) -> Mutatio
     return MutationResult.SUCCESS
 
 
-def _get_type_candidates(context: MutationContext, schema: Schema) -> Set[str]:
+def _get_type_candidates(context: MutationContext, schema: Schema) -> set[str]:
     types = set(get_type(schema))
     if context.is_path_location:
         candidates = {"string", "integer", "number", "boolean", "null"} - types
@@ -334,7 +335,7 @@ def _change_items_object(context: MutationContext, draw: Draw, schema: Schema, i
     return MutationResult.SUCCESS
 
 
-def _change_items_array(context: MutationContext, draw: Draw, schema: Schema, items: List) -> MutationResult:
+def _change_items_array(context: MutationContext, draw: Draw, schema: Schema, items: list) -> MutationResult:
     latest_success_index = None
     for idx, item in enumerate(items):
         result = MutationResult.FAILURE
@@ -397,12 +398,12 @@ def negate_constraints(context: MutationContext, draw: Draw, schema: Schema) ->
 DEPENDENCIES = {"exclusiveMaximum": "maximum", "exclusiveMinimum": "minimum"}
 
 
-def get_mutations(draw: Draw, schema: Schema) -> Tuple[Mutation, ...]:
+def get_mutations(draw: Draw, schema: Schema) -> tuple[Mutation, ...]:
     """Get mutations possible for a schema."""
     types = get_type(schema)
     # On the top-level of Open API schemas, types are always strings, but inside "schema" objects, they are the same as
     # in JSON Schema, where it could be either a string or an array of strings.
-    options: List[Mutation] = [negate_constraints, change_type]
+    options: list[Mutation] = [negate_constraints, change_type]
     if "object" in types:
         options.extend([change_properties, remove_required_property])
     elif "array" in types:
@@ -414,7 +415,7 @@ def ident(x: T) -> T:
     return x
 
 
-def ordered(items: Sequence[T], unique_by: Callable[[T], Any] = ident) -> st.SearchStrategy[List[T]]:
+def ordered(items: Sequence[T], unique_by: Callable[[T], Any] = ident) -> st.SearchStrategy[list[T]]:
     """Returns a strategy that generates randomly ordered lists of T.
 
     NOTE. Items should be unique.