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

schemathesis/specs/openapi/examples.py

@@ -1,6 +1,7 @@
+from __future__ import annotations
 from contextlib import suppress
 from functools import lru_cache
-from typing import Any, Dict, Generator, List
+from typing import Any, Generator
 
 import requests
 from hypothesis.strategies import SearchStrategy
@@ -11,7 +12,7 @@ from ._hypothesis import PARAMETERS, get_case_strategy
 from .constants import LOCATION_TO_CONTAINER
 
 
-def get_object_example_from_properties(object_schema: Dict[str, Any]) -> Dict[str, Any]:
+def get_object_example_from_properties(object_schema: dict[str, Any]) -> dict[str, Any]:
     return {
         prop_name: prop["example"]
         for prop_name, prop in object_schema.get("properties", {}).items()
@@ -19,7 +20,7 @@ def get_object_example_from_properties(object_schema: Dict[str, Any]) -> Dict[st
     }
 
 
-@lru_cache()
+@lru_cache
 def load_external_example(url: str) -> bytes:
     """Load examples the `externalValue` keyword."""
     response = requests.get(url, timeout=DEFAULT_RESPONSE_TIMEOUT / 1000)
@@ -27,7 +28,7 @@ def load_external_example(url: str) -> bytes:
     return response.content
 
 
-def get_examples(examples: Dict[str, Any]) -> Generator[Any, None, None]:
+def get_examples(examples: dict[str, Any]) -> Generator[Any, None, None]:
     for example in examples.values():
         # IDEA: report when it is not a dictionary
         if isinstance(example, dict):
@@ -39,7 +40,7 @@ def get_examples(examples: Dict[str, Any]) -> Generator[Any, None, None]:
                     yield load_external_example(example["externalValue"])
 
 
-def get_parameter_examples(operation_definition: Dict[str, Any], examples_field: str) -> List[Dict[str, Any]]:
+def get_parameter_examples(operation_definition: dict[str, Any], examples_field: str) -> list[dict[str, Any]]:
     """Gets parameter examples from OAS3 `examples` keyword or `x-examples` for Swagger 2."""
     return [
         {
@@ -52,8 +53,8 @@ def get_parameter_examples(operation_definition: Dict[str, Any], examples_field:
     ]
 
 
-def get_parameter_example_from_properties(operation_definition: Dict[str, Any]) -> Dict[str, Any]:
-    static_parameters: Dict[str, Any] = {}
+def get_parameter_example_from_properties(operation_definition: dict[str, Any]) -> dict[str, Any]:
+    static_parameters: dict[str, Any] = {}
     for parameter in operation_definition.get("parameters", []):
         parameter_schema = parameter["schema"] if "schema" in parameter else parameter
         example = get_object_example_from_properties(parameter_schema)
@@ -69,7 +70,7 @@ def get_parameter_example_from_properties(operation_definition: Dict[str, Any])
     return static_parameters
 
 
-def get_request_body_examples(operation_definition: Dict[str, Any], examples_field: str) -> Dict[str, Any]:
+def get_request_body_examples(operation_definition: dict[str, Any], examples_field: str) -> dict[str, Any]:
     """Gets request body examples from OAS3 `examples` keyword or `x-examples` for Swagger 2."""
     # NOTE. `requestBody` is OAS3-specific. How should it work with OAS2?
     request_bodies_items = operation_definition.get("requestBody", {}).get("content", {}).items()
@@ -84,8 +85,8 @@ def get_request_body_examples(operation_definition: Dict[str, Any], examples_fie
     }
 
 
-def get_request_body_example_from_properties(operation_definition: Dict[str, Any]) -> Dict[str, Any]:
-    static_parameters: Dict[str, Any] = {}
+def get_request_body_example_from_properties(operation_definition: dict[str, Any]) -> dict[str, Any]:
+    static_parameters: dict[str, Any] = {}
     request_bodies_items = operation_definition.get("requestBody", {}).get("content", {}).items()
     if request_bodies_items:
         _, request_body_schema = next(iter(request_bodies_items))
@@ -96,7 +97,7 @@ def get_request_body_example_from_properties(operation_definition: Dict[str, Any
     return static_parameters
 
 
-def get_static_parameters_from_example(operation: APIOperation) -> Dict[str, Any]:
+def get_static_parameters_from_example(operation: APIOperation) -> dict[str, Any]:
     static_parameters = {}
     for name in PARAMETERS:
         parameters = getattr(operation, name)
@@ -106,7 +107,7 @@ def get_static_parameters_from_example(operation: APIOperation) -> Dict[str, Any
     return static_parameters
 
 
-def get_static_parameters_from_examples(operation: APIOperation, examples_field: str) -> List[Dict[str, Any]]:
+def get_static_parameters_from_examples(operation: APIOperation, examples_field: str) -> list[dict[str, Any]]:
     """Get static parameters from OpenAPI examples keyword."""
     operation_definition = operation.definition.resolved
     return merge_examples(
@@ -115,7 +116,7 @@ def get_static_parameters_from_examples(operation: APIOperation, examples_field:
     )
 
 
-def get_static_parameters_from_properties(operation: APIOperation) -> Dict[str, Any]:
+def get_static_parameters_from_properties(operation: APIOperation) -> dict[str, Any]:
     operation_definition = operation.definition.resolved
     return {
         **get_parameter_example_from_properties(operation_definition),
@@ -125,7 +126,7 @@ def get_static_parameters_from_properties(operation: APIOperation) -> Dict[str,
 
 def get_strategies_from_examples(
     operation: APIOperation, examples_field: str = "examples"
-) -> List[SearchStrategy[Case]]:
+) -> list[SearchStrategy[Case]]:
     maps = {}
     for location, container in LOCATION_TO_CONTAINER.items():
         serializer = operation.get_parameter_serializer(location)
@@ -155,12 +156,12 @@ def get_strategies_from_examples(
 
 
 def merge_examples(
-    parameter_examples: List[Dict[str, Any]], request_body_examples: Dict[str, Any]
-) -> List[Dict[str, Any]]:
+    parameter_examples: list[dict[str, Any]], request_body_examples: dict[str, Any]
+) -> list[dict[str, Any]]:
     """Create list of static parameter objects from the parameter and request body examples."""
     static_parameter_list = []
     for idx in range(num_examples(parameter_examples, request_body_examples)):
-        static_parameters: Dict[str, Any] = {}
+        static_parameters: dict[str, Any] = {}
         for parameter in parameter_examples:
             container = static_parameters.setdefault(parameter["type"], {})
             container[parameter["name"]] = parameter["examples"][min(idx, len(parameter["examples"]) - 1)]
@@ -172,18 +173,18 @@ def merge_examples(
     return static_parameter_list
 
 
-def static_parameters_union(sp_1: Dict[str, Any], sp_2: Dict[str, Any]) -> List[Dict[str, Any]]:
+def static_parameters_union(sp_1: dict[str, Any], sp_2: dict[str, Any]) -> list[dict[str, Any]]:
     """Fill missing parameters in each static parameter dict with parameters provided in the other dict."""
     full_static_parameters = (_static_parameters_union(sp_1, sp_2), _static_parameters_union(sp_2, sp_1))
     return [static_parameter for static_parameter in full_static_parameters if static_parameter]
 
 
-def _static_parameters_union(base_obj: Dict[str, Any], fill_obj: Dict[str, Any]) -> Dict[str, Any]:
+def _static_parameters_union(base_obj: dict[str, Any], fill_obj: dict[str, Any]) -> dict[str, Any]:
     """Fill base_obj with parameter examples in fill_obj that were not in base_obj."""
     if not base_obj:
         return {}
 
-    full_static_parameters: Dict[str, Any] = {**base_obj}
+    full_static_parameters: dict[str, Any] = {**base_obj}
 
     for parameter_type, examples in fill_obj.items():
         if parameter_type not in full_static_parameters:
@@ -197,7 +198,7 @@ def _static_parameters_union(base_obj: Dict[str, Any], fill_obj: Dict[str, Any])
     return full_static_parameters
 
 
-def num_examples(parameter_examples: List[Dict[str, Any]], request_body_examples: Dict[str, Any]) -> int:
+def num_examples(parameter_examples: list[dict[str, Any]], request_body_examples: dict[str, Any]) -> int:
     max_parameter_examples = (
         max(len(parameter["examples"]) for parameter in parameter_examples) if parameter_examples else 0
     )

schemathesis/specs/openapi/expressions/nodes.py

@@ -1,7 +1,8 @@
 """Expression nodes description and evaluation logic."""
+from __future__ import annotations
 from dataclasses import dataclass
 from enum import Enum, unique
-from typing import Any, Dict, Optional, Union
+from typing import Any
 
 from requests.structures import CaseInsensitiveDict
 
@@ -74,7 +75,7 @@ class NonBodyRequest(Node):
     parameter: str
 
     def evaluate(self, context: ExpressionContext) -> str:
-        container: Union[Dict, CaseInsensitiveDict] = {
+        container: dict | CaseInsensitiveDict = {
             "query": context.case.query,
             "path": context.case.path_parameters,
             "header": context.case.headers,
@@ -88,7 +89,7 @@ class NonBodyRequest(Node):
 class BodyRequest(Node):
     """A node for `$request` expressions where location is `body`."""
 
-    pointer: Optional[str] = None
+    pointer: str | None = None
 
     def evaluate(self, context: ExpressionContext) -> Any:
         document = context.case.body
@@ -111,7 +112,7 @@ class HeaderResponse(Node):
 class BodyResponse(Node):
     """A node for `$response.body` expressions."""
 
-    pointer: Optional[str] = None
+    pointer: str | None = None
 
     def evaluate(self, context: ExpressionContext) -> Any:
         from ....transports.responses import WSGIResponse

schemathesis/specs/openapi/expressions/parser.py

@@ -1,19 +1,20 @@
+from __future__ import annotations
 from functools import lru_cache
-from typing import Generator, List, Union
+from typing import Generator
 
 from . import lexer, nodes
 from .errors import RuntimeExpressionError, UnknownToken
 
 
-@lru_cache()
-def parse(expr: str) -> List[nodes.Node]:
+@lru_cache
+def parse(expr: str) -> list[nodes.Node]:
     """Parse lexical tokens into concrete expression nodes."""
     return list(_parse(expr))
 
 
 def _parse(expr: str) -> Generator[nodes.Node, None, None]:
     tokens = lexer.tokenize(expr)
-    brackets_stack: List[str] = []
+    brackets_stack: list[str] = []
     for token in tokens:
         if token.is_string or token.is_dot:
             yield nodes.String(token.value)
@@ -46,7 +47,7 @@ def _parse_variable(tokens: lexer.TokenGenerator, token: lexer.Token, expr: str)
         raise UnknownToken(token.value)
 
 
-def _parse_request(tokens: lexer.TokenGenerator, expr: str) -> Union[nodes.BodyRequest, nodes.NonBodyRequest]:
+def _parse_request(tokens: lexer.TokenGenerator, expr: str) -> nodes.BodyRequest | nodes.NonBodyRequest:
     skip_dot(tokens, "$request")
     location = next(tokens)
     if location.value in ("query", "path", "header"):
@@ -63,7 +64,7 @@ def _parse_request(tokens: lexer.TokenGenerator, expr: str) -> Union[nodes.BodyR
     raise RuntimeExpressionError(f"Invalid expression: {expr}")
 
 
-def _parse_response(tokens: lexer.TokenGenerator, expr: str) -> Union[nodes.HeaderResponse, nodes.BodyResponse]:
+def _parse_response(tokens: lexer.TokenGenerator, expr: str) -> nodes.HeaderResponse | nodes.BodyResponse:
     skip_dot(tokens, "$response")
     location = next(tokens)
     if location.value == "header":

schemathesis/specs/openapi/filters.py

@@ -1,23 +1,23 @@
+from __future__ import annotations
 import re
-from typing import List, Optional, Union, Set, Tuple
 
 from ...types import Filter
 
 
-def should_skip_method(method: str, pattern: Optional[Filter]) -> bool:
+def should_skip_method(method: str, pattern: Filter | None) -> bool:
     if pattern is None:
         return False
     patterns = _ensure_tuple(pattern)
     return method.upper() not in map(str.upper, patterns)
 
 
-def should_skip_endpoint(endpoint: str, pattern: Optional[Filter]) -> bool:
+def should_skip_endpoint(endpoint: str, pattern: Filter | None) -> bool:
     if pattern is None:
         return False
     return not _match_any_pattern(endpoint, pattern)
 
 
-def should_skip_by_tag(tags: Optional[List[str]], pattern: Optional[Filter]) -> bool:
+def should_skip_by_tag(tags: list[str] | None, pattern: Filter | None) -> bool:
     if pattern is None:
         return False
     if not tags:
@@ -26,7 +26,7 @@ def should_skip_by_tag(tags: Optional[List[str]], pattern: Optional[Filter]) ->
     return not any(re.search(item, tag) for item in patterns for tag in tags)
 
 
-def should_skip_by_operation_id(operation_id: Optional[str], pattern: Optional[Filter]) -> bool:
+def should_skip_by_operation_id(operation_id: str | None, pattern: Filter | None) -> bool:
     if pattern is None:
         return False
     if not operation_id:
@@ -43,7 +43,7 @@ def _match_any_pattern(target: str, pattern: Filter) -> bool:
     return any(re.search(item, target) for item in patterns)
 
 
-def _ensure_tuple(item: Filter) -> Union[List, Set, Tuple]:
+def _ensure_tuple(item: Filter) -> list | set | tuple:
     if not isinstance(item, (list, set, tuple)):
         return (item,)
     return item

schemathesis/specs/openapi/formats.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Dict
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from hypothesis import strategies as st
 
 
-STRING_FORMATS: Dict[str, st.SearchStrategy] = {}
+STRING_FORMATS: dict[str, st.SearchStrategy] = {}
 
 
 def register_string_format(name: str, strategy: st.SearchStrategy) -> None:

schemathesis/specs/openapi/links.py

@@ -5,7 +5,7 @@ Based on https://swagger.io/docs/specification/links/
 from __future__ import annotations
 from dataclasses import dataclass, field
 from difflib import get_close_matches
-from typing import Any, Dict, Generator, List, NoReturn, Optional, Sequence, Tuple, Union, TYPE_CHECKING
+from typing import Any, Generator, NoReturn, Sequence, Union, TYPE_CHECKING
 
 from ...models import APIOperation, Case
 from ...parameters import ParameterSet
@@ -27,7 +27,7 @@ if TYPE_CHECKING:
 @dataclass(repr=False)
 class Link(StatefulTest):
     operation: APIOperation
-    parameters: Dict[str, Any]
+    parameters: dict[str, Any]
     request_body: Any = NOT_SET
 
     def __post_init__(self) -> None:
@@ -38,9 +38,7 @@ class Link(StatefulTest):
             )
 
     @classmethod
-    def from_definition(
-        cls, name: str, definition: Dict[str, Dict[str, Any]], source_operation: APIOperation
-    ) -> "Link":
+    def from_definition(cls, name: str, definition: dict[str, dict[str, Any]], source_operation: APIOperation) -> Link:
         # Links can be behind a reference
         _, definition = source_operation.schema.resolver.resolve_in_scope(  # type: ignore
             definition, source_operation.definition.scope
@@ -73,7 +71,7 @@ class Link(StatefulTest):
             body=expressions.evaluate(self.request_body, context),
         )
 
-    def make_operation(self, collected: List[ParsedData]) -> APIOperation:
+    def make_operation(self, collected: list[ParsedData]) -> APIOperation:
         """Create a modified version of the original API operation with additional data merged in."""
         # We split the gathered data among all locations & store the original parameter
         containers = {
@@ -91,7 +89,7 @@ class Link(StatefulTest):
             if "body" in containers["body"] and item.body is not NOT_SET:
                 containers["body"]["body"]["options"].append(item.body)
         # These are the final `path_parameters`, `query`, and other API operation components
-        components: Dict[str, ParameterSet] = {
+        components: dict[str, ParameterSet] = {
             container_name: getattr(self.operation, container_name).__class__()
             for location, container_name in LOCATION_TO_CONTAINER.items()
         }
@@ -123,9 +121,9 @@ class Link(StatefulTest):
                     components[LOCATION_TO_CONTAINER[location]].add(parameter)
         return self.operation.clone(**components)
 
-    def _get_container_by_parameter_name(self, full_name: str, templates: Dict[str, Dict[str, Dict[str, Any]]]) -> List:
+    def _get_container_by_parameter_name(self, full_name: str, templates: dict[str, dict[str, dict[str, Any]]]) -> list:
         """Detect in what request part the parameters is defined."""
-        location: Optional[str]
+        location: str | None
         try:
             # The parameter name is prefixed with its location. Example: `path.id`
             location, name = full_name.split(".")
@@ -174,10 +172,10 @@ class OpenAPILink(Direction):
 
     name: str
     status_code: str
-    definition: Dict[str, Any]
+    definition: dict[str, Any]
     operation: APIOperation
-    parameters: List[Tuple[Optional[str], str, str]] = field(init=False)
-    body: Union[Dict[str, Any], NotSet] = field(init=False)
+    parameters: list[tuple[str | None, str, str]] = field(init=False)
+    body: dict[str, Any] | NotSet = field(init=False)
 
     def __post_init__(self) -> None:
         self.parameters = [
@@ -218,7 +216,7 @@ class OpenAPILink(Direction):
         return self.operation.schema.get_operation_by_reference(self.definition["operationRef"])  # type: ignore
 
 
-def get_container(case: Case, location: Optional[str], name: str) -> Optional[Dict[str, Any]]:
+def get_container(case: Case, location: str | None, name: str) -> dict[str, Any] | None:
     """Get a container that suppose to store the given parameter."""
     if location:
         container_name = LOCATION_TO_CONTAINER[location]
@@ -232,7 +230,7 @@ def get_container(case: Case, location: Optional[str], name: str) -> Optional[Di
     return getattr(case, container_name)
 
 
-def normalize_parameter(parameter: str, expression: str) -> Tuple[Optional[str], str, str]:
+def normalize_parameter(parameter: str, expression: str) -> tuple[str | None, str, str]:
     """Normalize runtime expressions.
 
     Runtime expressions may have parameter names prefixed with their location - `path.id`.
@@ -247,7 +245,7 @@ def normalize_parameter(parameter: str, expression: str) -> Tuple[Optional[str],
         return None, parameter, expression
 
 
-def get_all_links(operation: APIOperation) -> Generator[Tuple[str, OpenAPILink], None, None]:
+def get_all_links(operation: APIOperation) -> Generator[tuple[str, OpenAPILink], None, None]:
     for status_code, definition in operation.definition.resolved["responses"].items():
         for name, link_definition in definition.get(operation.schema.links_field, {}).items():  # type: ignore
             yield status_code, OpenAPILink(name, status_code, link_definition, operation)
@@ -256,7 +254,7 @@ def get_all_links(operation: APIOperation) -> Generator[Tuple[str, OpenAPILink],
 StatusCode = Union[str, int]
 
 
-def _get_response_by_status_code(responses: Dict[StatusCode, Dict[str, Any]], status_code: Union[str, int]) -> Dict:
+def _get_response_by_status_code(responses: dict[StatusCode, dict[str, Any]], status_code: str | int) -> dict:
     if isinstance(status_code, int):
         # Invalid schemas may contain status codes as integers
         if status_code in responses:
@@ -275,17 +273,17 @@ def _get_response_by_status_code(responses: Dict[StatusCode, Dict[str, Any]], st
 
 
 def add_link(
-    responses: Dict[StatusCode, Dict[str, Any]],
+    responses: dict[StatusCode, dict[str, Any]],
     links_field: str,
-    parameters: Optional[Dict[str, str]],
+    parameters: dict[str, str] | None,
     request_body: Any,
     status_code: StatusCode,
-    target: Union[str, APIOperation],
-    name: Optional[str] = None,
+    target: str | APIOperation,
+    name: str | None = None,
 ) -> None:
     response = _get_response_by_status_code(responses, status_code)
     links_definition = response.setdefault(links_field, {})
-    new_link: Dict[str, Union[str, Dict[str, str]]] = {}
+    new_link: dict[str, str | dict[str, str]] = {}
     if parameters is not None:
         new_link["parameters"] = parameters
     if request_body is not None: