schemathesis 4.0.0a10__py3-none-any.whl → 4.0.0a11__py3-none-any.whl

schemathesis/schemas.py

@@ -14,16 +14,15 @@ from typing import (
     NoReturn,
     TypeVar,
 )
-from urllib.parse import quote, unquote, urljoin, urlparse, urlsplit, urlunsplit
+from urllib.parse import quote, unquote, urljoin, urlsplit, urlunsplit
 
 from schemathesis import transport
+from schemathesis.config import ProjectConfig
 from schemathesis.core import NOT_SET, NotSet
 from schemathesis.core.errors import IncorrectUsage, InvalidSchema
-from schemathesis.core.output import OutputConfig
-from schemathesis.core.rate_limit import build_limiter
 from schemathesis.core.result import Ok, Result
 from schemathesis.core.transport import Response
-from schemathesis.generation import GenerationConfig, GenerationMode
+from schemathesis.generation import GenerationMode
 from schemathesis.generation.case import Case
 from schemathesis.generation.hypothesis import strategies
 from schemathesis.generation.hypothesis.given import GivenInput, given_proxy
@@ -42,7 +41,6 @@ from .hooks import GLOBAL_HOOK_DISPATCHER, HookContext, HookDispatcher, HookScop
 
 if TYPE_CHECKING:
     from hypothesis.strategies import SearchStrategy
-    from pyrate_limiter import Limiter
     from typing_extensions import Self
 
     from schemathesis.core import Specification
@@ -102,16 +100,13 @@ class ApiOperationsCount:
 @dataclass(eq=False)
 class BaseSchema(Mapping):
     raw_schema: dict[str, Any]
+    config: ProjectConfig
     location: str | None = None
-    base_url: str | None = None
     filter_set: FilterSet = field(default_factory=FilterSet)
     app: Any = None
     hooks: HookDispatcher = field(default_factory=lambda: HookDispatcher(scope=HookScope.SCHEMA))
     auth: AuthStorage = field(default_factory=AuthStorage)
     test_function: Callable | None = None
-    generation_config: GenerationConfig = field(default_factory=GenerationConfig)
-    output_config: OutputConfig = field(default_factory=OutputConfig)
-    rate_limiter: Limiter | None = None
 
     def __post_init__(self) -> None:
         self.hook = to_filterable_hook(self.hooks)  # type: ignore[method-assign]
@@ -227,8 +222,8 @@ class BaseSchema(Mapping):
         """Base path for the schema."""
         # if `base_url` is specified, then it should include base path
         # Example: http://127.0.0.1:8080/api
-        if self.base_url:
-            path = urlsplit(self.base_url).path
+        if self.config.base_url:
+            path = urlsplit(self.config.base_url).path
         else:
             path = self._get_base_path()
         if not path.endswith("/"):
@@ -244,7 +239,7 @@ class BaseSchema(Mapping):
         return urlunsplit(parts)
 
     def get_base_url(self) -> str:
-        base_url = self.base_url
+        base_url = self.config.base_url
         if base_url is not None:
             return base_url.rstrip("/")
         return self._build_base_url()
@@ -259,9 +254,7 @@ class BaseSchema(Mapping):
     def _measure_statistic(self) -> ApiStatistic:
         raise NotImplementedError
 
-    def get_all_operations(
-        self, generation_config: GenerationConfig | None = None
-    ) -> Generator[Result[APIOperation, InvalidSchema], None, None]:
+    def get_all_operations(self) -> Generator[Result[APIOperation, InvalidSchema], None, None]:
         raise NotImplementedError
 
     def get_strategies_from_examples(self, operation: APIOperation, **kwargs: Any) -> list[SearchStrategy[Case]]:
@@ -317,15 +310,12 @@ class BaseSchema(Mapping):
 
         return self.__class__(
             self.raw_schema,
+            config=self.config,
             location=self.location,
-            base_url=self.base_url,
             app=self.app,
             hooks=self.hooks,
             auth=self.auth,
             test_function=_test_function,
-            generation_config=self.generation_config,
-            output_config=self.output_config,
-            rate_limiter=self.rate_limiter,
             filter_set=_filter_set,
         )
 
@@ -379,7 +369,6 @@ class BaseSchema(Mapping):
         hooks: HookDispatcher | None = None,
         auth_storage: AuthStorage | None = None,
         generation_mode: GenerationMode = GenerationMode.default(),
-        generation_config: GenerationConfig | None = None,
         **kwargs: Any,
     ) -> SearchStrategy:
         raise NotImplementedError
@@ -408,7 +397,6 @@ class BaseSchema(Mapping):
         hooks: HookDispatcher | None = None,
         auth_storage: AuthStorage | None = None,
         generation_mode: GenerationMode = GenerationMode.default(),
-        generation_config: GenerationConfig | None = None,
         **kwargs: Any,
     ) -> SearchStrategy:
         """Build a strategy for generating test cases for all defined API operations."""
@@ -417,7 +405,6 @@ class BaseSchema(Mapping):
                 hooks=hooks,
                 auth_storage=auth_storage,
                 generation_mode=generation_mode,
-                generation_config=generation_config,
                 **kwargs,
             )
             for operation in self.get_all_operations()
@@ -428,48 +415,16 @@ class BaseSchema(Mapping):
     def configure(
         self,
         *,
-        base_url: str | None | NotSet = NOT_SET,
         location: str | None | NotSet = NOT_SET,
-        rate_limit: str | None | NotSet = NOT_SET,
-        generation: GenerationConfig | NotSet = NOT_SET,
-        output: OutputConfig | NotSet = NOT_SET,
         app: Any | NotSet = NOT_SET,
     ) -> Self:
-        if not isinstance(base_url, NotSet):
-            if base_url is not None:
-                validate_base_url(base_url)
-            self.base_url = base_url
         if not isinstance(location, NotSet):
             self.location = location
-        if not isinstance(rate_limit, NotSet):
-            if isinstance(rate_limit, str):
-                self.rate_limiter = build_limiter(rate_limit)
-            else:
-                self.rate_limiter = None
-        if not isinstance(generation, NotSet):
-            self.generation_config = generation
-        if not isinstance(output, NotSet):
-            self.output_config = output
         if not isinstance(app, NotSet):
             self.app = app
         return self
 
 
-INVALID_BASE_URL_MESSAGE = (
-    "The provided base URL is invalid. This URL serves as a prefix for all API endpoints you want to test. "
-    "Make sure it is a properly formatted URL."
-)
-
-
-def validate_base_url(value: str) -> None:
-    try:
-        netloc = urlparse(value).netloc
-    except ValueError as exc:
-        raise ValueError(INVALID_BASE_URL_MESSAGE) from exc
-    if value and not netloc:
-        raise ValueError(INVALID_BASE_URL_MESSAGE)
-
-
 @dataclass
 class APIOperationMap(Mapping):
     _schema: BaseSchema
@@ -489,7 +444,6 @@ class APIOperationMap(Mapping):
         hooks: HookDispatcher | None = None,
         auth_storage: AuthStorage | None = None,
         generation_mode: GenerationMode = GenerationMode.default(),
-        generation_config: GenerationConfig | None = None,
         **kwargs: Any,
     ) -> SearchStrategy:
         """Build a strategy for generating test cases for all API operations defined in this subset."""
@@ -498,7 +452,6 @@ class APIOperationMap(Mapping):
                 hooks=hooks,
                 auth_storage=auth_storage,
                 generation_mode=generation_mode,
-                generation_config=generation_config,
                 **kwargs,
             )
             for operation in self._data.values()
@@ -638,6 +591,9 @@ class APIOperation(Generic[P]):
         if self.label is None:
             self.label = f"{self.method.upper()} {self.path}"  # type: ignore
 
+    def __deepcopy__(self, memo: dict) -> APIOperation[P]:
+        return self
+
     @property
     def full_path(self) -> str:
         return self.schema.get_full_path(self.path)
@@ -688,13 +644,10 @@ class APIOperation(Generic[P]):
         hooks: HookDispatcher | None = None,
         auth_storage: AuthStorage | None = None,
         generation_mode: GenerationMode = GenerationMode.default(),
-        generation_config: GenerationConfig | None = None,
         **kwargs: Any,
     ) -> SearchStrategy[Case]:
         """Turn this API operation into a Hypothesis strategy."""
-        strategy = self.schema.get_case_strategy(
-            self, hooks, auth_storage, generation_mode, generation_config=generation_config, **kwargs
-        )
+        strategy = self.schema.get_case_strategy(self, hooks, auth_storage, generation_mode, **kwargs)
 
         def _apply_hooks(dispatcher: HookDispatcher, _strategy: SearchStrategy[Case]) -> SearchStrategy[Case]:
             context = HookContext(self)
@@ -722,7 +675,6 @@ class APIOperation(Generic[P]):
 
     def get_strategies_from_examples(self, **kwargs: Any) -> list[SearchStrategy[Case]]:
         """Get examples from the API operation."""
-        kwargs.setdefault("generation_config", self.schema.generation_config)
         return self.schema.get_strategies_from_examples(self, **kwargs)
 
     def get_parameter_serializer(self, location: str) -> Callable | None:

schemathesis/specs/graphql/schemas.py

@@ -28,7 +28,7 @@ from schemathesis import auths
 from schemathesis.core import NOT_SET, NotSet, Specification
 from schemathesis.core.errors import InvalidSchema, OperationNotFound
 from schemathesis.core.result import Ok, Result
-from schemathesis.generation import GenerationConfig, GenerationMode
+from schemathesis.generation import GenerationMode
 from schemathesis.generation.case import Case
 from schemathesis.generation.meta import (
     CaseMetadata,
@@ -139,8 +139,8 @@ class GraphQLSchema(BaseSchema):
 
     @property
     def base_path(self) -> str:
-        if self.base_url:
-            return urlsplit(self.base_url).path
+        if self.config.base_url:
+            return urlsplit(self.config.base_url).path
         return self._get_base_path()
 
     def _get_base_path(self) -> str:
@@ -171,9 +171,7 @@ class GraphQLSchema(BaseSchema):
                                 statistic.operations.selected += 1
         return statistic
 
-    def get_all_operations(
-        self, generation_config: GenerationConfig | None = None
-    ) -> Generator[Result[APIOperation, InvalidSchema], None, None]:
+    def get_all_operations(self) -> Generator[Result[APIOperation, InvalidSchema], None, None]:
         schema = self.client_schema
         for root_type, operation_type in (
             (RootType.QUERY, schema.query_type),
@@ -226,7 +224,6 @@ class GraphQLSchema(BaseSchema):
         hooks: HookDispatcher | None = None,
         auth_storage: AuthStorage | None = None,
         generation_mode: GenerationMode = GenerationMode.default(),
-        generation_config: GenerationConfig | None = None,
         **kwargs: Any,
     ) -> SearchStrategy:
         return graphql_cases(
@@ -234,7 +231,6 @@ class GraphQLSchema(BaseSchema):
             hooks=hooks,
             auth_storage=auth_storage,
             generation_mode=generation_mode,
-            generation_config=generation_config or self.generation_config,
             **kwargs,
         )
 
@@ -326,14 +322,13 @@ def graphql_cases(
     hooks: HookDispatcher | None = None,
     auth_storage: auths.AuthStorage | None = None,
     generation_mode: GenerationMode = GenerationMode.default(),
-    generation_config: GenerationConfig,
     path_parameters: NotSet | dict[str, Any] = NOT_SET,
     headers: NotSet | dict[str, Any] = NOT_SET,
     cookies: NotSet | dict[str, Any] = NOT_SET,
     query: NotSet | dict[str, Any] = NOT_SET,
     body: Any = NOT_SET,
     media_type: str | None = None,
-    phase: TestPhase = TestPhase.GENERATE,
+    phase: TestPhase = TestPhase.FUZZING,
 ) -> Any:
     start = time.monotonic()
     definition = cast(GraphQLOperationDefinition, operation.definition)
@@ -343,14 +338,15 @@ def graphql_cases(
     }[definition.root_type]
     hook_context = HookContext(operation)
     custom_scalars = {**get_extra_scalar_strategies(), **CUSTOM_SCALARS}
+    generation = operation.schema.config.generation_for(operation=operation, phase="fuzzing")
     strategy = strategy_factory(
         operation.schema.client_schema,  # type: ignore[attr-defined]
         fields=[definition.field_name],
         custom_scalars=custom_scalars,
         print_ast=_noop,  # type: ignore
-        allow_x00=generation_config.allow_x00,
-        allow_null=generation_config.graphql_allow_null,
-        codec=generation_config.codec,
+        allow_x00=generation.allow_x00,
+        allow_null=generation.graphql_allow_null,
+        codec=generation.codec,
     )
     strategy = apply_to_all_dispatchers(operation, hook_context, hooks, strategy, "body").map(graphql.print_ast)
     body = draw(strategy)
@@ -361,8 +357,8 @@ def graphql_cases(
     query_ = _generate_parameter("query", query, draw, operation, hook_context, hooks)
 
     _phase_data = {
-        TestPhase.EXPLICIT: ExplicitPhaseData(),
-        TestPhase.GENERATE: GeneratePhaseData(),
+        TestPhase.EXAMPLES: ExplicitPhaseData(),
+        TestPhase.FUZZING: GeneratePhaseData(),
     }[phase]
     phase_data = cast(Union[ExplicitPhaseData, GeneratePhaseData], _phase_data)
     instance = operation.Case(

schemathesis/specs/openapi/_hypothesis.py

@@ -11,6 +11,7 @@ from hypothesis import event, note, reject
 from hypothesis import strategies as st
 from hypothesis_jsonschema import from_schema
 
+from schemathesis.config import GenerationConfig
 from schemathesis.core import NOT_SET, NotSet, media_types
 from schemathesis.core.control import SkipTest
 from schemathesis.core.errors import SERIALIZERS_SUGGESTION_MESSAGE, SerializationNotPossible
@@ -30,7 +31,7 @@ from schemathesis.openapi.generation.filters import is_valid_header, is_valid_pa
 from schemathesis.schemas import APIOperation
 
 from ... import auths
-from ...generation import GenerationConfig, GenerationMode
+from ...generation import GenerationMode
 from ...hooks import HookContext, HookDispatcher, apply_to_all_dispatchers
 from .constants import LOCATION_TO_CONTAINER
 from .formats import HEADER_FORMAT, STRING_FORMATS, get_default_format_strategies, header_values
@@ -52,14 +53,14 @@ def openapi_cases(
     hooks: HookDispatcher | None = None,
     auth_storage: auths.AuthStorage | None = None,
     generation_mode: GenerationMode = GenerationMode.default(),
-    generation_config: GenerationConfig,
     path_parameters: NotSet | dict[str, Any] = NOT_SET,
     headers: NotSet | dict[str, Any] = NOT_SET,
     cookies: NotSet | dict[str, Any] = NOT_SET,
     query: NotSet | dict[str, Any] = NOT_SET,
     body: Any = NOT_SET,
     media_type: str | None = None,
-    phase: TestPhase = TestPhase.GENERATE,
+    phase: TestPhase = TestPhase.FUZZING,
+    __is_stateful_phase: bool = False,
 ) -> Any:
     """A strategy that creates `Case` instances.
 
@@ -76,6 +77,9 @@ def openapi_cases(
     start = time.monotonic()
     strategy_factory = GENERATOR_MODE_TO_STRATEGY_FACTORY[generation_mode]
 
+    phase_name = "stateful" if __is_stateful_phase else phase.value
+    generation_config = operation.schema.config.generation_for(operation=operation, phase=phase_name)
+
     context = HookContext(operation)
 
     path_parameters_ = generate_parameter(
@@ -147,8 +151,8 @@ def openapi_cases(
             reject()
 
     _phase_data = {
-        TestPhase.EXPLICIT: ExplicitPhaseData(),
-        TestPhase.GENERATE: GeneratePhaseData(),
+        TestPhase.EXAMPLES: ExplicitPhaseData(),
+        TestPhase.FUZZING: GeneratePhaseData(),
     }[phase]
     phase_data = cast(Union[ExplicitPhaseData, GeneratePhaseData], _phase_data)
 
@@ -407,10 +411,10 @@ def _build_custom_formats(
     custom_formats: dict[str, st.SearchStrategy] | None, generation_config: GenerationConfig
 ) -> dict[str, st.SearchStrategy]:
     custom_formats = {**get_default_format_strategies(), **STRING_FORMATS, **(custom_formats or {})}
-    if generation_config.headers.strategy is not None:
-        custom_formats[HEADER_FORMAT] = generation_config.headers.strategy
+    if generation_config.exclude_header_characters is not None:
+        custom_formats[HEADER_FORMAT] = header_values(exclude_characters=generation_config.exclude_header_characters)
     elif not generation_config.allow_x00:
-        custom_formats[HEADER_FORMAT] = header_values(blacklist_characters="\n\r\x00")
+        custom_formats[HEADER_FORMAT] = header_values(exclude_characters="\n\r\x00")
     return custom_formats
 
 

schemathesis/specs/openapi/checks.py

@@ -22,9 +22,6 @@ from schemathesis.openapi.checks import (
     MalformedMediaType,
     MissingContentType,
     MissingHeaders,
-    MissingRequiredHeaderConfig,
-    NegativeDataRejectionConfig,
-    PositiveDataAcceptanceConfig,
     RejectedPositiveData,
     UndefinedContentType,
     UndefinedStatusCode,
@@ -185,7 +182,7 @@ def response_headers_conformance(ctx: CheckContext, response: Response, case: Ca
                             title="Response header does not conform to the schema",
                             operation=case.operation.label,
                             exc=exc,
-                            output_config=case.operation.schema.output_config,
+                            config=case.operation.schema.config.output,
                         )
                     )
     return _maybe_raise_one_or_more(errors)  # type: ignore[func-returns-value]
@@ -233,8 +230,8 @@ def negative_data_rejection(ctx: CheckContext, response: Response, case: Case) -
     ):
         return True
 
-    config = ctx.config.get(negative_data_rejection, NegativeDataRejectionConfig())
-    allowed_statuses = expand_status_codes(config.allowed_statuses or [])
+    config = ctx.config.negative_data_rejection
+    allowed_statuses = expand_status_codes(config.expected_statuses or [])
 
     if (
         case.meta.generation.mode.is_negative
@@ -243,9 +240,9 @@ def negative_data_rejection(ctx: CheckContext, response: Response, case: Case) -
     ):
         raise AcceptedNegativeData(
             operation=case.operation.label,
-            message=f"Allowed statuses: {', '.join(config.allowed_statuses)}",
+            message=f"Allowed statuses: {', '.join(config.expected_statuses)}",
             status_code=response.status_code,
-            allowed_statuses=config.allowed_statuses,
+            expected_statuses=config.expected_statuses,
         )
     return None
 
@@ -261,21 +258,21 @@ def positive_data_acceptance(ctx: CheckContext, response: Response, case: Case)
     ):
         return True
 
-    config = ctx.config.get(positive_data_acceptance, PositiveDataAcceptanceConfig())
-    allowed_statuses = expand_status_codes(config.allowed_statuses or [])
+    config = ctx.config.positive_data_acceptance
+    allowed_statuses = expand_status_codes(config.expected_statuses or [])
 
     if case.meta.generation.mode.is_positive and response.status_code not in allowed_statuses:
         raise RejectedPositiveData(
             operation=case.operation.label,
-            message=f"Allowed statuses: {', '.join(config.allowed_statuses)}",
+            message=f"Allowed statuses: {', '.join(config.expected_statuses)}",
             status_code=response.status_code,
-            allowed_statuses=config.allowed_statuses,
+            allowed_statuses=config.expected_statuses,
         )
     return None
 
 
+@schemathesis.check
 def missing_required_header(ctx: CheckContext, response: Response, case: Case) -> bool | None:
-    # NOTE: This check is intentionally not registered with `@schemathesis.check` because it is experimental
     meta = case.meta
     if meta is None or not isinstance(meta.phase.data, CoveragePhaseData) or is_unexpected_http_status_case(case):
         return None
@@ -287,16 +284,17 @@ def missing_required_header(ctx: CheckContext, response: Response, case: Case) -
         and data.description.startswith("Missing ")
     ):
         if data.parameter.lower() == "authorization":
-            allowed_statuses = {401}
+            expected_statuses = {401}
         else:
-            config = ctx.config.get(missing_required_header, MissingRequiredHeaderConfig())
-            allowed_statuses = expand_status_codes(config.allowed_statuses or [])
-        if response.status_code not in allowed_statuses:
-            allowed = f"Allowed statuses: {', '.join(map(str, allowed_statuses))}"
+            config = ctx.config.missing_required_header
+            expected_statuses = expand_status_codes(config.expected_statuses or [])
+        if response.status_code not in expected_statuses:
+            allowed = f"Allowed statuses: {', '.join(map(str, expected_statuses))}"
             raise AssertionError(f"Unexpected response status for a missing header: {response.status_code}\n{allowed}")
     return None
 
 
+@schemathesis.check
 def unsupported_method(ctx: CheckContext, response: Response, case: Case) -> bool | None:
     meta = case.meta
     if meta is None or not isinstance(meta.phase.data, CoveragePhaseData) or response.request.method == "OPTIONS":

schemathesis/specs/openapi/examples.py

@@ -9,9 +9,9 @@ from typing import TYPE_CHECKING, Any, Generator, Iterator, Union, cast
 import requests
 from hypothesis_jsonschema import from_schema
 
+from schemathesis.config import GenerationConfig
 from schemathesis.core.transforms import deepclone
 from schemathesis.core.transport import DEFAULT_RESPONSE_TIMEOUT
-from schemathesis.generation import GenerationConfig
 from schemathesis.generation.case import Case
 from schemathesis.generation.hypothesis import examples
 from schemathesis.generation.meta import TestPhase
@@ -68,7 +68,7 @@ def get_strategies_from_examples(
     # Add examples from parameter's schemas
     examples.extend(extract_from_schemas(operation))
     return [
-        openapi_cases(operation=operation, **{**parameters, **kwargs, "phase": TestPhase.EXPLICIT}).map(
+        openapi_cases(operation=operation, **{**parameters, **kwargs, "phase": TestPhase.EXAMPLES}).map(
             serialize_components
         )
         for parameters in produce_combinations(examples)
@@ -274,12 +274,13 @@ def extract_from_schema(
                     continue
                 variants[name] = values
         if variants:
+            config = operation.schema.config.generation_for(operation=operation, phase="examples")
             for name, subschema in to_generate.items():
                 if name in variants:
                     # Generated by one of `anyOf` or similar sub-schemas
                     continue
                 subschema = operation.schema.prepare_schema(subschema)
-                generated = _generate_single_example(subschema, operation.schema.generation_config)
+                generated = _generate_single_example(subschema, config)
                 variants[name] = [generated]
             # Calculate the maximum number of examples any property has
             total_combos = max(len(examples) for examples in variants.values())

schemathesis/specs/openapi/formats.py

@@ -38,11 +38,11 @@ def unregister_string_format(name: str) -> None:
         raise ValueError(f"Unknown Open API format: {name}") from exc
 
 
-def header_values(blacklist_characters: str = "\n\r") -> st.SearchStrategy[str]:
+def header_values(exclude_characters: str = "\n\r") -> st.SearchStrategy[str]:
     from hypothesis import strategies as st
 
     return st.text(
-        alphabet=st.characters(min_codepoint=0, max_codepoint=255, blacklist_characters=blacklist_characters)
+        alphabet=st.characters(min_codepoint=0, max_codepoint=255, exclude_characters=exclude_characters)
         # Header values with leading non-visible chars can't be sent with `requests`
     ).map(str.lstrip)
 

schemathesis/specs/openapi/negative/__init__.py

@@ -9,12 +9,12 @@ import jsonschema
 from hypothesis import strategies as st
 from hypothesis_jsonschema import from_schema
 
+from schemathesis.config import GenerationConfig
+
 from ..constants import ALL_KEYWORDS
 from .mutations import MutationContext
 
 if TYPE_CHECKING:
-    from schemathesis.generation import GenerationConfig
-
     from .types import Draw, Schema
 
 

schemathesis/specs/openapi/patterns.py

@@ -19,6 +19,7 @@ if hasattr(sre, "POSSESSIVE_REPEAT"):
 else:
     REPEATS = (sre.MIN_REPEAT, sre.MAX_REPEAT)
 LITERAL = sre.LITERAL
+NOT_LITERAL = sre.NOT_LITERAL
 IN = sre.IN
 MAXREPEAT = sre_parse.MAXREPEAT
 
@@ -114,8 +115,20 @@ def _handle_anchored_pattern(parsed: list, pattern: str, min_length: int | None,
 
     pattern_parts = parsed[1:-1]
 
+    # Calculate total fixed length and per-repetition lengths
+    fixed_length = 0
+    quantifier_bounds = []
+    repetition_lengths = []
+
+    for op, value in pattern_parts:
+        if op in (LITERAL, NOT_LITERAL):
+            fixed_length += 1
+        elif op in REPEATS:
+            min_repeat, max_repeat, subpattern = value
+            quantifier_bounds.append((min_repeat, max_repeat))
+            repetition_lengths.append(_calculate_min_repetition_length(subpattern))
+
     # Adjust length constraints by subtracting fixed literals length
-    fixed_length = sum(1 for op, _ in pattern_parts if op == LITERAL)
     if min_length is not None:
         min_length -= fixed_length
         if min_length < 0:
@@ -125,13 +138,10 @@ def _handle_anchored_pattern(parsed: list, pattern: str, min_length: int | None,
         if max_length < 0:
             return pattern
 
-    # Extract only min/max bounds from quantified parts
-    quantifier_bounds = [value[:2] for op, value in pattern_parts if op in REPEATS]
-
     if not quantifier_bounds:
         return pattern
 
-    length_distribution = _distribute_length_constraints(quantifier_bounds, min_length, max_length)
+    length_distribution = _distribute_length_constraints(quantifier_bounds, repetition_lengths, min_length, max_length)
     if not length_distribution:
         return pattern
 
@@ -212,7 +222,7 @@ def _find_quantified_end(pattern: str, start: int) -> int:
 
 
 def _distribute_length_constraints(
-    bounds: list[tuple[int, int]], min_length: int | None, max_length: int | None
+    bounds: list[tuple[int, int]], repetition_lengths: list[int], min_length: int | None, max_length: int | None
 ) -> list[tuple[int, int]] | None:
     """Distribute length constraints among quantified pattern parts."""
     # Handle exact length case with dynamic programming
@@ -228,18 +238,22 @@ def _distribute_length_constraints(
             if pos == len(bounds):
                 return [()] if remaining == 0 else None
 
-            max_len: int
-            min_len, max_len = bounds[pos]
-            if max_len == MAXREPEAT:
-                max_len = remaining + 1
-            else:
-                max_len += 1
+            max_repeat: int
+            min_repeat, max_repeat = bounds[pos]
+            repeat_length = repetition_lengths[pos]
+
+            if max_repeat == MAXREPEAT:
+                max_repeat = remaining // repeat_length + 1 if repeat_length > 0 else remaining + 1
 
             # Try each possible length for current quantifier
-            for length in range(min_len, max_len):
-                rest = find_valid_combination(pos + 1, remaining - length)
+            for repeat_count in range(min_repeat, max_repeat + 1):
+                used_length = repeat_count * repeat_length
+                if used_length > remaining:
+                    break
+
+                rest = find_valid_combination(pos + 1, remaining - used_length)
                 if rest is not None:
-                    dp[(pos, remaining)] = [(length,) + r for r in rest]
+                    dp[(pos, remaining)] = [(repeat_count,) + r for r in rest]
                     return dp[(pos, remaining)]
 
             dp[(pos, remaining)] = None
@@ -280,6 +294,22 @@ def _distribute_length_constraints(
     return result
 
 
+def _calculate_min_repetition_length(subpattern: list) -> int:
+    """Calculate minimum length contribution per repetition of a quantified group."""
+    total = 0
+    for op, value in subpattern:
+        if op in [LITERAL, NOT_LITERAL, IN, sre.ANY]:
+            total += 1
+        elif op == sre.SUBPATTERN:
+            _, _, _, inner_pattern = value
+            total += _calculate_min_repetition_length(inner_pattern)
+        elif op in REPEATS:
+            min_repeat, _, inner_pattern = value
+            inner_min = _calculate_min_repetition_length(inner_pattern)
+            total += min_repeat * inner_min
+    return total
+
+
 def _get_anchor_length(node_type: int) -> int:
     """Determine the length of the anchor based on its type."""
     if node_type in {sre.AT_BEGINNING_STRING, sre.AT_END_STRING, sre.AT_BOUNDARY, sre.AT_NON_BOUNDARY}:
@@ -293,7 +323,7 @@ def _update_quantifier(
     """Update the quantifier based on the operation type and given constraints."""
     if op in REPEATS and value is not None:
         return _handle_repeat_quantifier(value, pattern, min_length, max_length)
-    if op in (LITERAL, IN) and max_length != 0:
+    if op in (LITERAL, NOT_LITERAL, IN) and max_length != 0:
         return _handle_literal_or_in_quantifier(pattern, min_length, max_length)
     if op == sre.ANY and value is None:
         # Equivalent to `.` which is in turn is the same as `.{1}`

schemathesis/specs/openapi/references.py

@@ -5,10 +5,9 @@ from functools import lru_cache
 from typing import Any, Callable, Dict, Union, overload
 from urllib.request import urlopen
 
-import jsonschema
 import requests
 
-from schemathesis.core.compat import RefResolutionError
+from schemathesis.core.compat import RefResolutionError, RefResolver
 from schemathesis.core.deserialization import deserialize_yaml
 from schemathesis.core.transforms import deepclone
 from schemathesis.core.transport import DEFAULT_RESPONSE_TIMEOUT
@@ -48,7 +47,7 @@ def load_remote_uri(uri: str) -> Any:
 JSONType = Union[None, bool, float, str, list, Dict[str, Any]]
 
 
-class InliningResolver(jsonschema.RefResolver):
+class InliningResolver(RefResolver):
     """Inlines resolved schemas."""
 
     def __init__(self, *args: Any, **kwargs: Any) -> None: