schemathesis 3.36.0__py3-none-any.whl → 3.36.2__py3-none-any.whl

schemathesis/_hypothesis.py

@@ -245,6 +245,11 @@ def _iter_coverage_cases(
     if operation.body:
         for body in operation.body:
             schema = body.as_json_schema(operation)
+            # Definition could be a list for Open API 2.0
+            definition = body.definition if isinstance(body.definition, dict) else {}
+            examples = [example["value"] for example in definition.get("examples", {}).values() if "value" in example]
+            if examples:
+                schema.setdefault("examples", []).extend(examples)
             gen = coverage.cover_schema_iter(ctx, schema)
             value = next(gen, NOT_SET)
             if isinstance(value, NotSet):

schemathesis/auths.py

@@ -450,6 +450,7 @@ class AuthStorage(Generic[Auth]):
             data: Auth | None = _provider_get(provider, case, context)
             if data is not None:
                 provider.set(case, data, context)
+                case._has_explicit_auth = True
                 break
 
 

schemathesis/generation/coverage.py

@@ -4,7 +4,8 @@ import json
 from contextlib import contextmanager, suppress
 from dataclasses import dataclass, field
 from functools import lru_cache
-from typing import Any, Generator, TypeVar, cast
+from itertools import combinations
+from typing import Any, Generator, Iterator, TypeVar, cast
 
 import jsonschema
 from hypothesis import strategies as st
@@ -14,7 +15,7 @@ from hypothesis_jsonschema._canonicalise import canonicalish
 
 from schemathesis.constants import NOT_SET
 
-from ._hypothesis import combine_strategies, get_single_example
+from ._hypothesis import get_single_example
 from ._methods import DataGenerationMethod
 
 BUFFER_SIZE = 8 * 1024
@@ -156,12 +157,17 @@ def _ignore_unfixable(
             raise
 
 
-def cover_schema_iter(ctx: CoverageContext, schema: dict | bool) -> Generator[GeneratedValue, None, None]:
+def cover_schema_iter(
+    ctx: CoverageContext, schema: dict | bool, seen: set[Any | tuple[type, str]] | None = None
+) -> Generator[GeneratedValue, None, None]:
+    if seen is None:
+        seen = set()
     if isinstance(schema, bool):
         types = ["null", "boolean", "string", "number", "array", "object"]
         schema = {}
     else:
         types = schema.get("type", [])
+    push_examples_to_properties(schema)
     if not isinstance(types, list):
         types = [types]  # type: ignore[unreachable]
     if not types:
@@ -172,13 +178,16 @@ def cover_schema_iter(ctx: CoverageContext, schema: dict | bool) -> Generator[Ge
             yield from _cover_positive_for_type(ctx, schema, ty)
     if DataGenerationMethod.negative in ctx.data_generation_methods:
         template = None
-        seen: set[Any | tuple[type, str]] = set()
         for key, value in schema.items():
             with _ignore_unfixable():
                 if key == "enum":
                     yield from _negative_enum(ctx, value)
                 elif key == "const":
-                    yield from _negative_enum(ctx, [value])
+                    for value_ in _negative_enum(ctx, [value]):
+                        k = _to_hashable_key(value_.value)
+                        if k not in seen:
+                            yield value_
+                            seen.add(k)
                 elif key == "type":
                     yield from _negative_type(ctx, seen, value)
                 elif key == "properties":
@@ -190,27 +199,37 @@ def cover_schema_iter(ctx: CoverageContext, schema: dict | bool) -> Generator[Ge
                     yield from _negative_format(ctx, schema, value)
                 elif key == "maximum":
                     next = value + 1
-                    yield NegativeValue(next)
-                    seen.add(next)
+                    if next not in seen:
+                        yield NegativeValue(next)
+                        seen.add(next)
                 elif key == "minimum":
                     next = value - 1
-                    yield NegativeValue(next)
-                    seen.add(next)
+                    if next not in seen:
+                        yield NegativeValue(next)
+                        seen.add(next)
                 elif key == "exclusiveMaximum" or key == "exclusiveMinimum" and value not in seen:
                     yield NegativeValue(value)
                     seen.add(value)
                 elif key == "multipleOf":
-                    yield from _negative_multiple_of(ctx, schema, value)
+                    for value_ in _negative_multiple_of(ctx, schema, value):
+                        k = _to_hashable_key(value_.value)
+                        if k not in seen:
+                            yield value_
+                            seen.add(k)
                 elif key == "minLength" and 0 < value < BUFFER_SIZE:
                     with suppress(InvalidArgument):
-                        yield NegativeValue(
-                            ctx.generate_from_schema({**schema, "minLength": value - 1, "maxLength": value - 1})
-                        )
+                        value = ctx.generate_from_schema({**schema, "minLength": value - 1, "maxLength": value - 1})
+                        k = _to_hashable_key(value)
+                        if k not in seen:
+                            yield NegativeValue(value)
+                            seen.add(k)
                 elif key == "maxLength" and value < BUFFER_SIZE:
                     with suppress(InvalidArgument):
-                        yield NegativeValue(
-                            ctx.generate_from_schema({**schema, "minLength": value + 1, "maxLength": value + 1})
-                        )
+                        value = ctx.generate_from_schema({**schema, "minLength": value + 1, "maxLength": value + 1})
+                        k = _to_hashable_key(value)
+                        if k not in seen:
+                            yield NegativeValue(value)
+                            seen.add(k)
                 elif key == "uniqueItems" and value:
                     yield from _negative_unique_items(ctx, schema)
                 elif key == "required":
@@ -222,16 +241,16 @@ def cover_schema_iter(ctx: CoverageContext, schema: dict | bool) -> Generator[Ge
                 elif key == "allOf":
                     nctx = ctx.with_negative()
                     if len(value) == 1:
-                        yield from cover_schema_iter(nctx, value[0])
+                        yield from cover_schema_iter(nctx, value[0], seen)
                     else:
                         with _ignore_unfixable():
                             canonical = canonicalish(schema)
-                            yield from cover_schema_iter(nctx, canonical)
+                            yield from cover_schema_iter(nctx, canonical, seen)
                 elif key == "anyOf" or key == "oneOf":
                     nctx = ctx.with_negative()
                     # NOTE: Other sub-schemas are not filtered out
                     for sub_schema in value:
-                        yield from cover_schema_iter(nctx, sub_schema)
+                        yield from cover_schema_iter(nctx, sub_schema, seen)
 
 
 def _get_properties(schema: dict | bool) -> dict | bool:
@@ -264,6 +283,8 @@ def _positive_string(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
     """Generate positive string values."""
     # Boundary and near boundary values
     min_length = schema.get("minLength")
+    if min_length == 0:
+        min_length = None
     max_length = schema.get("maxLength")
     example = schema.get("example")
     examples = schema.get("examples")
@@ -283,6 +304,12 @@ def _positive_string(ctx: CoverageContext, schema: dict) -> Generator[GeneratedV
     elif not min_length and not max_length:
         # Default positive value
         yield PositiveValue(ctx.generate_from_schema(schema))
+    elif "pattern" in schema:
+        # Without merging `maxLength` & `minLength` into a regex it is problematic
+        # to generate a valid value as the unredlying machinery will resort to filtering
+        # and it is unlikely that it will generate a string of that length
+        yield PositiveValue(ctx.generate_from_schema(schema))
+        return
 
     seen = set()
 
@@ -476,6 +503,10 @@ def _positive_object(ctx: CoverageContext, schema: dict, template: dict) -> Gene
         combo = {k: v for k, v in template.items() if k in required or k == name}
         if combo != template:
             yield PositiveValue(combo)
+    # Generate one combination for each size from 2 to N-1
+    for selection in select_combinations(optional):
+        combo = {k: v for k, v in template.items() if k in required or k in selection}
+        yield PositiveValue(combo)
     # Generate only required properties
     if set(properties) != required:
         only_required = {k: v for k, v in template.items() if k in required}
@@ -491,6 +522,11 @@ def _positive_object(ctx: CoverageContext, schema: dict, template: dict) -> Gene
         seen.clear()
 
 
+def select_combinations(optional: list[str]) -> Iterator[tuple[str, ...]]:
+    for size in range(2, len(optional)):
+        yield next(combinations(optional, size))
+
+
 def _negative_enum(ctx: CoverageContext, value: list) -> Generator[GeneratedValue, None, None]:
     strategy = JSON_STRATEGY.filter(lambda x: x not in value)
     # The exact negative value is not important here
@@ -565,7 +601,24 @@ def _negative_type(ctx: CoverageContext, seen: set, ty: str | list[str]) -> Gene
         del strategies["integer"]
     if "integer" in types:
         strategies["number"] = FLOAT_STRATEGY.filter(lambda x: x != int(x))
-    negative_strategy = combine_strategies(tuple(strategies.values())).filter(lambda x: _to_hashable_key(x) not in seen)
-    value = ctx.generate_from(negative_strategy, cached=True)
-    yield NegativeValue(value)
-    seen.add(_to_hashable_key(value))
+    for strat in strategies.values():
+        value = ctx.generate_from(strat, cached=True)
+        hashed = _to_hashable_key(value)
+        if hashed in seen:
+            continue
+        yield NegativeValue(value)
+        seen.add(hashed)
+
+
+def push_examples_to_properties(schema: dict[str, Any]) -> None:
+    """Push examples from the top-level 'examples' field to the corresponding properties."""
+    if "examples" in schema and "properties" in schema:
+        properties = schema["properties"]
+        for example in schema["examples"]:
+            if isinstance(example, dict):
+                for prop, value in example.items():
+                    if prop in properties:
+                        if "examples" not in properties[prop]:
+                            properties[prop]["examples"] = []
+                        if value not in schema["properties"][prop]["examples"]:
+                            properties[prop]["examples"].append(value)

schemathesis/internal/checks.py

@@ -6,9 +6,11 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Callable, Optional
 
 if TYPE_CHECKING:
+    from requests.structures import CaseInsensitiveDict
+
     from ..models import Case
     from ..transports.responses import GenericResponse
-    from requests.structures import CaseInsensitiveDict
+    from ..types import RawAuth
 
 
 CheckFunction = Callable[["CheckContext", "GenericResponse", "Case"], Optional[bool]]
@@ -21,6 +23,7 @@ class CheckContext:
     Provides access to broader test execution data beyond individual test cases.
     """
 
+    auth: RawAuth | None = None
     headers: CaseInsensitiveDict | None = None
 
 

schemathesis/models.py

@@ -136,8 +136,7 @@ def prepare_request_data(kwargs: dict[str, Any]) -> PreparedRequestData:
     )
 
 
-@dataclass
-class TestPhase(Enum):
+class TestPhase(str, Enum):
     __test__ = False
 
     EXPLICIT = "explicit"
@@ -184,6 +183,7 @@ class Case:
     # The way the case was generated (None for manually crafted ones)
     data_generation_method: DataGenerationMethod | None = None
     _auth: requests.auth.AuthBase | None = None
+    _has_explicit_auth: bool = False
 
     def __repr__(self) -> str:
         parts = [f"{self.__class__.__name__}("]
@@ -562,6 +562,8 @@ class Case:
             body=fast_deepcopy(self.body),
             generation_time=self.generation_time,
             id=self.id,
+            _auth=self._auth,
+            _has_explicit_auth=self._has_explicit_auth,
         )
 
 

schemathesis/runner/impl/context.py

@@ -11,7 +11,7 @@ if TYPE_CHECKING:
 
     from ...exceptions import OperationSchemaError
     from ...models import Case
-    from ...types import NotSet
+    from ...types import NotSet, RawAuth
 
 
 @dataclass
@@ -19,15 +19,19 @@ class RunnerContext:
     """Holds context shared for a test run."""
 
     data: TestResultSet
+    auth: RawAuth | None
     seed: int | None
     stop_event: threading.Event
     unique_data: bool
     outcome_cache: dict[int, BaseException | None]
 
-    __slots__ = ("data", "seed", "stop_event", "unique_data", "outcome_cache")
+    __slots__ = ("data", "auth", "seed", "stop_event", "unique_data", "outcome_cache")
 
-    def __init__(self, *, seed: int | None, stop_event: threading.Event, unique_data: bool) -> None:
+    def __init__(
+        self, *, seed: int | None, auth: RawAuth | None, stop_event: threading.Event, unique_data: bool
+    ) -> None:
         self.data = TestResultSet(seed=seed)
+        self.auth = auth
         self.seed = seed
         self.stop_event = stop_event
         self.outcome_cache = {}

schemathesis/runner/impl/core.py

@@ -131,7 +131,7 @@ class BaseRunner:
         # If auth is explicitly provided, then the global provider is ignored
         if self.auth is not None:
             unregister_auth()
-        ctx = RunnerContext(seed=self.seed, stop_event=stop_event, unique_data=self.unique_data)
+        ctx = RunnerContext(auth=self.auth, seed=self.seed, stop_event=stop_event, unique_data=self.unique_data)
         start_time = time.monotonic()
         initialized = None
         __probes = None
@@ -955,6 +955,7 @@ def network_test(
             headers["User-Agent"] = USER_AGENT
         if not dry_run:
             args = (
+                ctx,
                 checks,
                 targets,
                 result,
@@ -973,6 +974,7 @@ def network_test(
 
 def _network_test(
     case: Case,
+    ctx: RunnerContext,
     checks: Iterable[CheckFunction],
     targets: Iterable[Target],
     result: TestResult,
@@ -1015,11 +1017,11 @@ def _network_test(
     run_targets(targets, context)
     status = Status.success
 
-    ctx = CheckContext(headers=CaseInsensitiveDict(headers) if headers else None)
+    check_ctx = CheckContext(auth=ctx.auth, headers=CaseInsensitiveDict(headers) if headers else None)
     try:
         run_checks(
             case=case,
-            ctx=ctx,
+            ctx=check_ctx,
             checks=checks,
             check_results=check_results,
             result=result,
@@ -1069,6 +1071,7 @@ def wsgi_test(
         headers = prepare_wsgi_headers(headers, auth, auth_type)
         if not dry_run:
             args = (
+                ctx,
                 checks,
                 targets,
                 result,
@@ -1085,6 +1088,7 @@ def wsgi_test(
 
 def _wsgi_test(
     case: Case,
+    ctx: RunnerContext,
     checks: Iterable[CheckFunction],
     targets: Iterable[Target],
     result: TestResult,
@@ -1105,11 +1109,11 @@ def _wsgi_test(
     result.logs.extend(recorded.records)
     status = Status.success
     check_results: list[Check] = []
-    ctx = CheckContext(headers=CaseInsensitiveDict(headers) if headers else None)
+    check_ctx = CheckContext(auth=ctx.auth, headers=CaseInsensitiveDict(headers) if headers else None)
     try:
         run_checks(
             case=case,
-            ctx=ctx,
+            ctx=check_ctx,
             checks=checks,
             check_results=check_results,
             result=result,
@@ -1151,6 +1155,7 @@ def asgi_test(
 
         if not dry_run:
             args = (
+                ctx,
                 checks,
                 targets,
                 result,
@@ -1167,6 +1172,7 @@ def asgi_test(
 
 def _asgi_test(
     case: Case,
+    ctx: RunnerContext,
     checks: Iterable[CheckFunction],
     targets: Iterable[Target],
     result: TestResult,
@@ -1183,11 +1189,11 @@ def _asgi_test(
     run_targets(targets, context)
     status = Status.success
     check_results: list[Check] = []
-    ctx = CheckContext(headers=CaseInsensitiveDict(headers) if headers else None)
+    check_ctx = CheckContext(auth=ctx.auth, headers=CaseInsensitiveDict(headers) if headers else None)
     try:
         run_checks(
             case=case,
-            ctx=ctx,
+            ctx=check_ctx,
             checks=checks,
             check_results=check_results,
             result=result,

schemathesis/specs/openapi/_hypothesis.py

@@ -527,7 +527,12 @@ def is_valid_path(parameters: dict[str, Any]) -> bool:
     disallowed_values = (SLASH, "")
 
     return not any(
-        (value in disallowed_values or is_illegal_surrogate(value) or isinstance(value, str) and SLASH in value)
+        (
+            value in disallowed_values
+            or is_illegal_surrogate(value)
+            or isinstance(value, str)
+            and (SLASH in value or "}" in value or "{" in value)
+        )
         for value in parameters.values()
     )
 

schemathesis/specs/openapi/checks.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
 import enum
+from dataclasses import dataclass
 from http.cookies import SimpleCookie
 from typing import TYPE_CHECKING, Any, Dict, Generator, NoReturn, cast
 from urllib.parse import parse_qs, urlparse
@@ -348,7 +348,7 @@ def ignored_auth(ctx: CheckContext, response: GenericResponse, case: Case) -> bo
     security_parameters = _get_security_parameters(case.operation)
     # Authentication is required for this API operation and response is successful
     if security_parameters and 200 <= response.status_code < 300:
-        auth = _contains_auth(ctx, response.request, security_parameters)
+        auth = _contains_auth(ctx, case, response.request, security_parameters)
         if auth == AuthKind.EXPLICIT:
             # Auth is explicitly set, it is expected to be valid
             # Check if invalid auth will give an error
@@ -412,11 +412,14 @@ def _get_security_parameters(operation: APIOperation) -> list[SecurityParameter]
 
 
 def _contains_auth(
-    ctx: CheckContext, request: PreparedRequest, security_parameters: list[SecurityParameter]
+    ctx: CheckContext, case: Case, request: PreparedRequest, security_parameters: list[SecurityParameter]
 ) -> AuthKind | None:
     """Whether a request has authentication declared in the schema."""
     from requests.cookies import RequestsCookieJar
 
+    # If auth comes from explicit `auth` option or a custom auth, it is always explicit
+    if ctx.auth is not None or case._has_explicit_auth:
+        return AuthKind.EXPLICIT
     parsed = urlparse(request.url)
     query = parse_qs(parsed.query)  # type: ignore
     # Load the `Cookie` header separately, because it is possible that `request._cookies` and the header are out of sync

schemathesis/specs/openapi/converter.py

@@ -5,6 +5,7 @@ from typing import Any, Callable
 
 from ...internal.copy import fast_deepcopy
 from ...internal.jsonschema import traverse_schema
+from .patterns import update_quantifier
 
 
 def to_json_schema(
@@ -24,6 +25,15 @@ def to_json_schema(
     if schema_type == "file":
         schema["type"] = "string"
         schema["format"] = "binary"
+    pattern = schema.get("pattern")
+    min_length = schema.get("minLength")
+    max_length = schema.get("maxLength")
+    if pattern and (min_length or max_length):
+        new_pattern = update_quantifier(pattern, min_length, max_length)
+        if new_pattern != pattern:
+            schema.pop("minLength", None)
+            schema.pop("maxLength", None)
+            schema["pattern"] = new_pattern
     if schema_type == "object":
         if is_response_schema:
             # Write-only properties should not occur in responses

schemathesis/specs/openapi/patterns.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import re
+from functools import lru_cache
+
+try:  # pragma: no cover
+    import re._constants as sre
+    import re._parser as sre_parse
+except ImportError:
+    import sre_constants as sre
+    import sre_parse
+
+ANCHOR = sre.AT
+REPEATS: tuple
+if hasattr(sre, "POSSESSIVE_REPEAT"):
+    REPEATS = (sre.MIN_REPEAT, sre.MAX_REPEAT, sre.POSSESSIVE_REPEAT)
+else:
+    REPEATS = (sre.MIN_REPEAT, sre.MAX_REPEAT)
+LITERAL = sre.LITERAL
+IN = sre.IN
+MAXREPEAT = sre_parse.MAXREPEAT
+
+
+@lru_cache()
+def update_quantifier(pattern: str, min_length: int | None, max_length: int | None) -> str:
+    """Update the quantifier of a regular expression based on given min and max lengths."""
+    if not pattern or (min_length in (None, 0) and max_length is None):
+        return pattern
+
+    try:
+        parsed = sre_parse.parse(pattern)
+        return _handle_parsed_pattern(parsed, pattern, min_length, max_length)
+    except re.error:
+        # Invalid pattern
+        return pattern
+
+
+def _handle_parsed_pattern(parsed: list, pattern: str, min_length: int | None, max_length: int | None) -> str:
+    """Handle the parsed pattern and update quantifiers based on different cases."""
+    if len(parsed) == 1:
+        op, value = parsed[0]
+        return _update_quantifier(op, value, pattern, min_length, max_length)
+    elif len(parsed) == 2:
+        if parsed[0][0] == ANCHOR:
+            # Starts with an anchor
+            op, value = parsed[1]
+            leading_anchor = pattern[0]
+            return leading_anchor + _update_quantifier(op, value, pattern[1:], min_length, max_length)
+        if parsed[1][0] == ANCHOR:
+            # Ends with an anchor
+            op, value = parsed[0]
+            trailing_anchor = pattern[-1]
+            return _update_quantifier(op, value, pattern[:-1], min_length, max_length) + trailing_anchor
+    elif len(parsed) == 3 and parsed[0][0] == ANCHOR and parsed[2][0] == ANCHOR:
+        op, value = parsed[1]
+        leading_anchor = pattern[0]
+        trailing_anchor = pattern[-1]
+        return leading_anchor + _update_quantifier(op, value, pattern[1:-1], min_length, max_length) + trailing_anchor
+    return pattern
+
+
+def _update_quantifier(op: int, value: tuple, pattern: str, min_length: int | None, max_length: int | None) -> str:
+    """Update the quantifier based on the operation type and given constraints."""
+    if op in REPEATS:
+        return _handle_repeat_quantifier(value, pattern, min_length, max_length)
+    if op in (LITERAL, IN) and max_length != 0:
+        return _handle_literal_or_in_quantifier(pattern, min_length, max_length)
+    return pattern
+
+
+def _handle_repeat_quantifier(
+    value: tuple[int, int, tuple], pattern: str, min_length: int | None, max_length: int | None
+) -> str:
+    """Handle repeat quantifiers (e.g., '+', '*', '?')."""
+    min_repeat, max_repeat, _ = value
+    min_length, max_length = _build_size(min_repeat, max_repeat, min_length, max_length)
+    if min_length > max_length:
+        return pattern
+    return f"({_strip_quantifier(pattern)})" + _build_quantifier(min_length, max_length)
+
+
+def _handle_literal_or_in_quantifier(pattern: str, min_length: int | None, max_length: int | None) -> str:
+    """Handle literal or character class quantifiers."""
+    min_length = 1 if min_length is None else max(min_length, 1)
+    return f"({pattern})" + _build_quantifier(min_length, max_length)
+
+
+def _build_quantifier(minimum: int | None, maximum: int | None) -> str:
+    """Construct a quantifier string based on min and max values."""
+    if maximum == MAXREPEAT or maximum is None:
+        return f"{{{minimum or 0},}}"
+    if minimum == maximum:
+        return f"{{{minimum}}}"
+    return f"{{{minimum or 0},{maximum}}}"
+
+
+def _build_size(min_repeat: int, max_repeat: int, min_length: int | None, max_length: int | None) -> tuple[int, int]:
+    """Merge the current repetition constraints with the provided min and max lengths."""
+    if min_length is not None:
+        min_repeat = max(min_repeat, min_length)
+    if max_length is not None:
+        if max_repeat == MAXREPEAT:
+            max_repeat = max_length
+        else:
+            max_repeat = min(max_repeat, max_length)
+    return min_repeat, max_repeat
+
+
+def _strip_quantifier(pattern: str) -> str:
+    """Remove quantifier from the pattern."""
+    # Lazy & posessive quantifiers
+    if pattern.endswith(("*?", "+?", "??", "*+", "?+", "++")):
+        return pattern[:-2]
+    if pattern.endswith(("?", "*", "+")):
+        pattern = pattern[:-1]
+    if pattern.endswith("}"):
+        # Find the start of the exact quantifier and drop everything since that index
+        idx = pattern.rfind("{")
+        pattern = pattern[:idx]
+    return pattern

{schemathesis-3.36.0.dist-info → schemathesis-3.36.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: schemathesis
-Version: 3.36.0
+Version: 3.36.2
 Summary: Property-based testing framework for Open API and GraphQL based apps
 Project-URL: Documentation, https://schemathesis.readthedocs.io/en/stable/
 Project-URL: Changelog, https://schemathesis.readthedocs.io/en/stable/changelog.html
@@ -237,6 +237,7 @@ Schemathesis is used by a number of projects and companies, including direct usa
 - [Pixie](https://github.com/pixie-io/pixie)
 - [Qdrant](https://github.com/qdrant/qdrant)
 - Spotify ([Backstage](https://github.com/backstage/backstage))
+- [Weechat](https://github.com/weechat/weechat)
 - WordPress ([OpenVerse](https://github.com/WordPress/openverse))
 
 ## Testimonials

{schemathesis-3.36.0.dist-info → schemathesis-3.36.2.dist-info}/RECORD

@@ -1,12 +1,12 @@
 schemathesis/__init__.py,sha256=UW2Bq8hDDkcBeAAA7PzpBFXkOOxkmHox-mfQwzHDjL0,1914
 schemathesis/_compat.py,sha256=y4RZd59i2NCnZ91VQhnKeMn_8t3SgvLOk2Xm8nymUHY,1837
 schemathesis/_dependency_versions.py,sha256=pjEkkGAfOQJYNb-9UOo84V8nj_lKHr_TGDVdFwY2UU0,816
-schemathesis/_hypothesis.py,sha256=NTl1OXL9Us5rkvEroqtxlFcYz3_JVjcNbhPbEHi5B7E,14291
+schemathesis/_hypothesis.py,sha256=Sj7pGspDGeevcPgLkCF1pV7T5HleF84nZd7FbDUs_vE,14646
 schemathesis/_lazy_import.py,sha256=aMhWYgbU2JOltyWBb32vnWBb6kykOghucEzI_F70yVE,470
 schemathesis/_override.py,sha256=TAjYB3eJQmlw9K_xiR9ptt9Wj7if4U7UFlUhGjpBAoM,1625
 schemathesis/_rate_limiter.py,sha256=q_XWst5hzuAyXQRiZc4s_bx7-JlPYZM_yKDmeavt3oo,242
 schemathesis/_xml.py,sha256=lwRaKEMQvl6SUySnhGgooNsdmXPnDh11YSPpbsW8dR8,6923
-schemathesis/auths.py,sha256=mYFOL2YDZl-6Lyh-dv3pMd5dRs4r_kO7UuGUHt6dC88,16790
+schemathesis/auths.py,sha256=De97IS_iOlC36-jRhkZ2DUndjUpXYgsd8R-nA-iHn88,16837
 schemathesis/checks.py,sha256=YPUI1N5giGBy1072vd77e6HWelGAKrJUmJLEG4oqfF8,2630
 schemathesis/code_samples.py,sha256=rsdTo6ksyUs3ZMhqx0mmmkPSKUCFa--snIOYsXgZd80,4120
 schemathesis/constants.py,sha256=l1YQ7PXhEj9dyf9CTESVUpPOaFCH7iz-Fe8o4v6Th_s,2673
@@ -17,7 +17,7 @@ schemathesis/graphql.py,sha256=XiuKcfoOB92iLFC8zpz2msLkM0_V0TLdxPNBqrrGZ8w,216
 schemathesis/hooks.py,sha256=qXyVRfJdhsLk1GuJX47VAqkX0VPm6X6fK-cXhEnFLT4,14765
 schemathesis/lazy.py,sha256=uE8ef_7U_9ovs0-7UA7ssIiiDipJurJFHuxaUFOUETo,18956
 schemathesis/loaders.py,sha256=MoEhcdOEBJxNRn5X-ZNhWB9jZDHQQNpkNfEdQjf_NDw,4590
-schemathesis/models.py,sha256=ix-g8Z6a_V_U2DUc4iC7EmFQv-t4es4Lpt1RLlIz-ng,46294
+schemathesis/models.py,sha256=YNZ9EXVw0WreTy_3hw2aZ9OPS-0W7xePlh5h0dLmgvs,46411
 schemathesis/parameters.py,sha256=PndmqQRlEYsCt1kWjSShPsFf6vj7X_7FRdz_-A95eNg,2258
 schemathesis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 schemathesis/sanitization.py,sha256=Lycn1VVfula9B6XpzkxTHja7CZ7RHqbUh9kBic0Yi4M,9056
@@ -60,9 +60,9 @@ schemathesis/fixups/utf8_bom.py,sha256=lWT9RNmJG8i-l5AXIpaCT3qCPUwRgzXPW3eoOjmZE
 schemathesis/generation/__init__.py,sha256=29Zys_tD6kfngaC4zHeC6TOBZQcmo7CWm7KDSYsHStQ,1581
 schemathesis/generation/_hypothesis.py,sha256=QDBzpcM9eXPgLGGdCPdGlxCtfMXD4YBN9_6Oz73lofI,1406
 schemathesis/generation/_methods.py,sha256=jCK09f4sedDfePrS-6BIiE-CcEE8fJ4ZHxq1BHoTltQ,1101
-schemathesis/generation/coverage.py,sha256=NnXpjkrJ8zjYgNCpGnvvqWx_YxLff-4kc_ET3Essfeg,22407
+schemathesis/generation/coverage.py,sha256=F_ABsBsQ7k4dR_sGI2ZNTUNRCjxpAPh5V80MYXx8F20,24758
 schemathesis/internal/__init__.py,sha256=93HcdG3LF0BbQKbCteOsFMa1w6nXl8yTmx87QLNJOik,161
-schemathesis/internal/checks.py,sha256=z3kHi4zbn4RmG168KIvOYxwUE8jQ1xAnFXTaD1xarb4,1603
+schemathesis/internal/checks.py,sha256=m6lY6x2Pkz6AjU8Hs-UMSDJZEOq8EcgZOCp6BQA7p_g,1668
 schemathesis/internal/copy.py,sha256=DcL56z-d69kKR_5u8mlHvjSL1UTyUKNMAwexrwHFY1s,1031
 schemathesis/internal/datetime.py,sha256=zPLBL0XXLNfP-KYel3H2m8pnsxjsA_4d-zTOhJg2EPQ,136
 schemathesis/internal/deprecation.py,sha256=Ty5VBFBlufkITpP0WWTPIPbnB7biDi0kQgXVYWZp820,1273
@@ -77,8 +77,8 @@ schemathesis/runner/events.py,sha256=cRKKSDvHvKLBIyFBz-J0JtAKshbGGKco9eaMyLCgzsY
 schemathesis/runner/probes.py,sha256=no5AfO3kse25qvHevjeUfB0Q3C860V2AYzschUW3QMQ,5688
 schemathesis/runner/serialization.py,sha256=Rn8wUpxe8saWUBfSI60jK7-qPR-D2pY1ad1hD8qTHhE,20418
 schemathesis/runner/impl/__init__.py,sha256=1E2iME8uthYPBh9MjwVBCTFV-P3fi7AdphCCoBBspjs,199
-schemathesis/runner/impl/context.py,sha256=gEYE58DTRT38Jl__dSmqZhV_YI4mbR_JarnwXv0LeF0,2402
-schemathesis/runner/impl/core.py,sha256=ehNxUReBeSF62OpUzoeh_gBw-fb1ZExWebpHA6Oorh8,46965
+schemathesis/runner/impl/context.py,sha256=KT3Dl1HIUM29Jpp_DwfoSx_NbWFH_7s6gw-p2Sr-N24,2505
+schemathesis/runner/impl/core.py,sha256=bAPwfhLJrXLlPN6BDNGyQoO9v35YlmeuxAmyFTNQg5Y,47197
 schemathesis/runner/impl/solo.py,sha256=y5QSxgK8nBCEjZVD5BpFvYUXmB6tEjk6TwxAo__NejA,2911
 schemathesis/runner/impl/threadpool.py,sha256=yNR5LYE8f3N_4t42OwSgy0_qdGgBPM7d11F9c9oEAAs,15075
 schemathesis/service/__init__.py,sha256=cDVTCFD1G-vvhxZkJUwiToTAEQ-0ByIoqwXvJBCf_V8,472
@@ -104,10 +104,10 @@ schemathesis/specs/graphql/schemas.py,sha256=b7QwglKbcYQCMjuYmqDsVoFu2o4xaA_kduU
 schemathesis/specs/graphql/validation.py,sha256=uINIOt-2E7ZuQV2CxKzwez-7L9tDtqzMSpnVoRWvxy0,1635
 schemathesis/specs/openapi/__init__.py,sha256=HDcx3bqpa6qWPpyMrxAbM3uTo0Lqpg-BUNZhDJSJKnw,279
 schemathesis/specs/openapi/_cache.py,sha256=PAiAu4X_a2PQgD2lG5H3iisXdyg4SaHpU46bRZvfNkM,4320
-schemathesis/specs/openapi/_hypothesis.py,sha256=XgKq36ONJIWM-8ASnDpzOgcCcVz-uUQw74bOxcUC3n8,24201
-schemathesis/specs/openapi/checks.py,sha256=nriqejh-Y5ECCRYvfVenAgRik4xpejlCh22VpRo0RA4,22093
+schemathesis/specs/openapi/_hypothesis.py,sha256=ZbLo8hDf4WVmRKmKF6rhK47xetkVJmE59Ghu_p7kLCw,24293
+schemathesis/specs/openapi/checks.py,sha256=-4qOzkova0e4QSqdgsoUiOv2bg57HZmzbpAiAeotc3Q,22288
 schemathesis/specs/openapi/constants.py,sha256=JqM_FHOenqS_MuUE9sxVQ8Hnw0DNM8cnKDwCwPLhID4,783
-schemathesis/specs/openapi/converter.py,sha256=TaYgc5BBHPdkN-n0lqpbeVgLu3eL3L8Wu3y_Vo3TJaQ,2800
+schemathesis/specs/openapi/converter.py,sha256=NkrzBNjtmVwQTeE73NOtwB_puvQTjxxqqrc7gD_yscc,3241
 schemathesis/specs/openapi/definitions.py,sha256=nEsCKn_LgqYjZ9nNWp-8KUIrB4S94pT3GsV5A8UIzDw,94043
 schemathesis/specs/openapi/examples.py,sha256=FwhPWca7bpdHpUp_LRoK09DVgusojO3aXXhXYrK373I,20354
 schemathesis/specs/openapi/formats.py,sha256=JmmkQWNAj5XreXb7Edgj4LADAf4m86YulR_Ec8evpJ4,1220
@@ -115,6 +115,7 @@ schemathesis/specs/openapi/links.py,sha256=a8JmWM9aZhrR5CfyIh6t2SkfonMLfYKOScXY2
 schemathesis/specs/openapi/loaders.py,sha256=5B1cgYEBj3h2psPQxzrQ5Xq5owLVGw-u9HsCQIx7yFE,25705
 schemathesis/specs/openapi/media_types.py,sha256=dNTxpRQbY3SubdVjh4Cjb38R6Bc9MF9BsRQwPD87x0g,1017
 schemathesis/specs/openapi/parameters.py,sha256=CqJdS4d14l25_yEbqkLCnfIdDTlodRhJpxD8EXdaFwM,14059
+schemathesis/specs/openapi/patterns.py,sha256=IK2BkXI1xByEz5if6jvydFE07nq5rDa4k_-2xX7ifG8,4715
 schemathesis/specs/openapi/references.py,sha256=euxM02kQGMHh4Ss1jWjOY_gyw_HazafKITIsvOEiAvI,9831
 schemathesis/specs/openapi/schemas.py,sha256=t3Gz2q-d9b8Oy-hDhz0rNfjYT3Nx-uOeLOmjO9hpRM0,53741
 schemathesis/specs/openapi/security.py,sha256=Z-6pk2Ga1PTUtBe298KunjVHsNh5A-teegeso7zcPIE,7138
@@ -150,8 +151,8 @@ schemathesis/transports/auth.py,sha256=urSTO9zgFO1qU69xvnKHPFQV0SlJL3d7_Ojl0tLnZ
 schemathesis/transports/content_types.py,sha256=MiKOm-Hy5i75hrROPdpiBZPOTDzOwlCdnthJD12AJzI,2187
 schemathesis/transports/headers.py,sha256=hr_AIDOfUxsJxpHfemIZ_uNG3_vzS_ZeMEKmZjbYiBE,990
 schemathesis/transports/responses.py,sha256=OFD4ZLqwEFpo7F9vaP_SVgjhxAqatxIj38FS4XVq8Qs,1680
-schemathesis-3.36.0.dist-info/METADATA,sha256=HfnlCBEOL6RdgwQymCXcWVvoEfF26bVX_kdRspp4A6Y,12856
-schemathesis-3.36.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-schemathesis-3.36.0.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
-schemathesis-3.36.0.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
-schemathesis-3.36.0.dist-info/RECORD,,
+schemathesis-3.36.2.dist-info/METADATA,sha256=eoWwbh8dfwwyl3EyHoJsV_MUm4zvKYGTMMehbfOJyyQ,12904
+schemathesis-3.36.2.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+schemathesis-3.36.2.dist-info/entry_points.txt,sha256=VHyLcOG7co0nOeuk8WjgpRETk5P1E2iCLrn26Zkn5uk,158
+schemathesis-3.36.2.dist-info/licenses/LICENSE,sha256=PsPYgrDhZ7g9uwihJXNG-XVb55wj2uYhkl2DD8oAzY0,1103
+schemathesis-3.36.2.dist-info/RECORD,,