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

schemathesis/internal/jsonschema.py

@@ -1,15 +1,16 @@
+from __future__ import annotations
 from typing import overload, Dict, Union, Any, List, Callable
 
 JsonValue = Union[Dict[str, Any], List, str, float, int]
 
 
 @overload
-def traverse_schema(schema: Dict[str, Any], callback: Callable, *args: Any, **kwargs: Any) -> Dict[str, Any]:
+def traverse_schema(schema: dict[str, Any], callback: Callable, *args: Any, **kwargs: Any) -> dict[str, Any]:
     pass
 
 
 @overload
-def traverse_schema(schema: List, callback: Callable, *args: Any, **kwargs: Any) -> List:
+def traverse_schema(schema: list, callback: Callable, *args: Any, **kwargs: Any) -> list:
     pass
 
 
@@ -23,7 +24,7 @@ def traverse_schema(schema: float, callback: Callable, *args: Any, **kwargs: Any
     pass
 
 
-def traverse_schema(schema: JsonValue, callback: Callable[..., Dict[str, Any]], *args: Any, **kwargs: Any) -> JsonValue:
+def traverse_schema(schema: JsonValue, callback: Callable[..., dict[str, Any]], *args: Any, **kwargs: Any) -> JsonValue:
     """Apply callback recursively to the given schema."""
     if isinstance(schema, dict):
         schema = callback(schema, *args, **kwargs)

schemathesis/internal/transformation.py

@@ -1,7 +1,8 @@
-from typing import Dict, Any
+from __future__ import annotations
+from typing import Any
 
 
-def merge_recursively(a: Dict[str, Any], b: Dict[str, Any]) -> Dict[str, Any]:
+def merge_recursively(a: dict[str, Any], b: dict[str, Any]) -> dict[str, Any]:
     """Merge two dictionaries recursively."""
     for key in b:
         if key in a:

schemathesis/lazy.py

@@ -1,6 +1,7 @@
+from __future__ import annotations
 from dataclasses import dataclass, field
 from inspect import signature
-from typing import Any, Callable, Dict, Generator, Optional, Type, Union
+from typing import Any, Callable, Generator
 
 import pytest
 from _pytest.fixtures import FixtureRequest
@@ -15,7 +16,7 @@ from ._compat import MultipleFailures, get_interesting_origin
 from .auths import AuthStorage
 from .code_samples import CodeSampleStyle
 from .constants import FLAKY_FAILURE_MESSAGE, NOT_SET
-from .generation import DataGenerationMethodInput
+from .generation import DataGenerationMethodInput, GenerationConfig
 from .exceptions import CheckFailed, OperationSchemaError, SkipTest, get_grouped_exception
 from .hooks import HookDispatcher, HookScope
 from .internal.result import Ok
@@ -37,34 +38,36 @@ from .utils import (
 @dataclass
 class LazySchema:
     fixture_name: str
-    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
     app: Any = NOT_SET
     hooks: HookDispatcher = field(default_factory=lambda: HookDispatcher(scope=HookScope.SCHEMA))
     auth: AuthStorage = field(default_factory=AuthStorage)
     validate_schema: bool = True
     skip_deprecated_operations: 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: CodeSampleStyle = CodeSampleStyle.default()
-    rate_limiter: Optional[Limiter] = None
+    rate_limiter: Limiter | None = None
     sanitize_output: bool = True
 
-    def hook(self, hook: Union[str, Callable]) -> Callable:
+    def hook(self, hook: str | Callable) -> Callable:
         return self.hooks.register(hook)
 
     def parametrize(
         self,
-        method: Optional[Filter] = NOT_SET,
-        endpoint: Optional[Filter] = NOT_SET,
-        tag: Optional[Filter] = NOT_SET,
-        operation_id: Optional[Filter] = NOT_SET,
-        validate_schema: Union[bool, NotSet] = NOT_SET,
-        skip_deprecated_operations: Union[bool, NotSet] = NOT_SET,
-        data_generation_methods: Union[DataGenerationMethodInput, NotSet] = NOT_SET,
-        code_sample_style: Union[str, NotSet] = NOT_SET,
+        method: Filter | None = NOT_SET,
+        endpoint: Filter | None = NOT_SET,
+        tag: Filter | None = NOT_SET,
+        operation_id: Filter | None = NOT_SET,
+        validate_schema: bool | NotSet = NOT_SET,
+        skip_deprecated_operations: bool | NotSet = NOT_SET,
+        data_generation_methods: DataGenerationMethodInput | NotSet = NOT_SET,
+        generation_config: GenerationConfig | NotSet = NOT_SET,
+        code_sample_style: str | NotSet = NOT_SET,
     ) -> Callable:
         if method is NOT_SET:
             method = self.method
@@ -76,6 +79,8 @@ class LazySchema:
             operation_id = self.operation_id
         if data_generation_methods is NOT_SET:
             data_generation_methods = self.data_generation_methods
+        if generation_config is NOT_SET:
+            generation_config = self.generation_config
         if isinstance(code_sample_style, str):
             _code_sample_style = CodeSampleStyle.from_str(code_sample_style)
         else:
@@ -114,6 +119,7 @@ class LazySchema:
                     validate_schema=validate_schema,
                     skip_deprecated_operations=skip_deprecated_operations,
                     data_generation_methods=data_generation_methods,
+                    generation_config=generation_config,
                     code_sample_style=_code_sample_style,
                     app=self.app,
                     rate_limiter=self.rate_limiter,
@@ -183,7 +189,7 @@ def _get_partial_node_name(node_id: str, **kwargs: Any) -> str:
 
 def run_subtest(
     operation: APIOperation,
-    fixtures: Dict[str, Any],
+    fixtures: dict[str, Any],
     sub_test: Callable,
     subtests: SubTests,
 ) -> None:
@@ -208,7 +214,7 @@ def run_subtest(
             exceptions.append(exception)
             raise
 
-    def get_exception_class() -> Type[CheckFailed]:
+    def get_exception_class() -> type[CheckFailed]:
         return get_grouped_exception("Lazy", *failed_checks.values())
 
     sub_test.hypothesis.inner_test = collecting_wrapper  # type: ignore
@@ -264,20 +270,21 @@ def get_schema(
     *,
     request: FixtureRequest,
     name: str,
-    base_url: Union[Optional[str], NotSet] = None,
-    method: Optional[Filter] = None,
-    endpoint: Optional[Filter] = None,
-    tag: Optional[Filter] = None,
-    operation_id: Optional[Filter] = None,
+    base_url: str | None | NotSet = None,
+    method: Filter | None = None,
+    endpoint: Filter | None = None,
+    tag: Filter | None = None,
+    operation_id: Filter | None = None,
     app: Any = None,
     test_function: GenericTest,
     hooks: HookDispatcher,
-    auth: Union[AuthStorage, NotSet],
-    validate_schema: Union[bool, NotSet] = NOT_SET,
-    skip_deprecated_operations: Union[bool, NotSet] = NOT_SET,
-    data_generation_methods: Union[DataGenerationMethodInput, NotSet] = NOT_SET,
+    auth: AuthStorage | NotSet,
+    validate_schema: bool | NotSet = NOT_SET,
+    skip_deprecated_operations: bool | NotSet = NOT_SET,
+    data_generation_methods: DataGenerationMethodInput | NotSet = NOT_SET,
+    generation_config: GenerationConfig | NotSet = NOT_SET,
     code_sample_style: CodeSampleStyle,
-    rate_limiter: Optional[Limiter],
+    rate_limiter: Limiter | None,
     sanitize_output: bool,
 ) -> BaseSchema:
     """Loads a schema from the fixture."""
@@ -297,13 +304,14 @@ def get_schema(
         validate_schema=validate_schema,
         skip_deprecated_operations=skip_deprecated_operations,
         data_generation_methods=data_generation_methods,
+        generation_config=generation_config,
         code_sample_style=code_sample_style,
         rate_limiter=rate_limiter,
         sanitize_output=sanitize_output,
     )
 
 
-def get_fixtures(func: Callable, request: FixtureRequest, given_kwargs: Dict[str, Any]) -> Dict[str, Any]:
+def get_fixtures(func: Callable, request: FixtureRequest, given_kwargs: dict[str, Any]) -> dict[str, Any]:
     """Load fixtures, needed for the test function."""
     sig = signature(func)
     return {

schemathesis/loaders.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 import re
 import sys
 from functools import lru_cache
-from typing import Callable, TypeVar, cast, TYPE_CHECKING, TextIO, Any, Dict, Type, BinaryIO
+from typing import Callable, TypeVar, TYPE_CHECKING, TextIO, Any, BinaryIO
 
 from .exceptions import SchemaError, SchemaErrorType, extract_requests_exception_details
 
@@ -19,7 +19,7 @@ def load_schema_from_url(loader: Callable[[], R]) -> R:
     try:
         response = loader()
     except requests.RequestException as exc:
-        request = cast(requests.PreparedRequest, exc.request)
+        url = exc.request.url if exc.request is not None else None
         if isinstance(exc, requests.exceptions.SSLError):
             type_ = SchemaErrorType.CONNECTION_SSL
         elif isinstance(exc, requests.exceptions.ConnectionError):
@@ -27,12 +27,12 @@ def load_schema_from_url(loader: Callable[[], R]) -> R:
         else:
             type_ = SchemaErrorType.NETWORK_OTHER
         message, extras = extract_requests_exception_details(exc)
-        raise SchemaError(message=message, type=type_, url=request.url, response=exc.response, extras=extras) from exc
+        raise SchemaError(message=message, type=type_, url=url, response=exc.response, extras=extras) from exc
     _raise_for_status(response)
     return response
 
 
-def _raise_for_status(response: "GenericResponse") -> None:
+def _raise_for_status(response: GenericResponse) -> None:
     from .transports.responses import get_reason
 
     status_code = response.status_code
@@ -63,8 +63,8 @@ def load_app(path: str) -> Any:
     return getattr(module, name)
 
 
-@lru_cache()
-def get_yaml_loader() -> Type[yaml.SafeLoader]:
+@lru_cache
+def get_yaml_loader() -> type[yaml.SafeLoader]:
     """Create a YAML loader, that doesn't parse specific tokens into Python objects."""
     import yaml
 
@@ -73,7 +73,7 @@ def get_yaml_loader() -> Type[yaml.SafeLoader]:
     except ImportError:
         from yaml import SafeLoader  # type: ignore
 
-    cls: Type[yaml.SafeLoader] = type("YAMLLoader", (SafeLoader,), {})
+    cls: type[yaml.SafeLoader] = type("YAMLLoader", (SafeLoader,), {})
     cls.yaml_implicit_resolvers = {
         key: [(tag, regexp) for tag, regexp in mapping if tag != "tag:yaml.org,2002:timestamp"]
         for key, mapping in cls.yaml_implicit_resolvers.copy().items()
@@ -95,7 +95,7 @@ def get_yaml_loader() -> Type[yaml.SafeLoader]:
         list("-+0123456789."),
     )
 
-    def construct_mapping(self: SafeLoader, node: yaml.Node, deep: bool = False) -> Dict[str, Any]:
+    def construct_mapping(self: SafeLoader, node: yaml.Node, deep: bool = False) -> dict[str, Any]:
         if isinstance(node, yaml.MappingNode):
             self.flatten_mapping(node)  # type: ignore
         mapping = {}