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

schemathesis/config/_checks.py

@@ -0,0 +1,268 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, ClassVar, Sequence
+
+from schemathesis.config._diff_base import DiffBase
+from schemathesis.config._error import ConfigError
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+NOT_A_SERVER_ERROR_EXPECTED_STATUSES = ["2xx", "3xx", "4xx"]
+NEGATIVE_DATA_REJECTION_EXPECTED_STATUSES = ["400", "401", "403", "404", "406", "422", "428", "5xx"]
+POSITIVE_DATA_ACCEPTANCE_EXPECTED_STATUSES = ["2xx", "401", "403", "404", "5xx"]
+MISSING_REQUIRED_HEADER_EXPECTED_STATUSES = ["406"]
+
+
+def validate_status_codes(value: Sequence[str] | None) -> Sequence[str] | None:
+    if not value:
+        return value
+
+    invalid = []
+
+    for code in value:
+        if len(code) != 3:
+            invalid.append(code)
+            continue
+
+        if code[0] not in {"1", "2", "3", "4", "5"}:
+            invalid.append(code)
+            continue
+
+        upper_code = code.upper()
+
+        if "X" in upper_code:
+            if (
+                upper_code[1:] == "XX"
+                or (upper_code[1] == "X" and upper_code[2].isdigit())
+                or (upper_code[1].isdigit() and upper_code[2] == "X")
+            ):
+                continue
+            else:
+                invalid.append(code)
+                continue
+
+        if not code.isnumeric():
+            invalid.append(code)
+
+    if invalid:
+        raise ConfigError(
+            f"Invalid status code(s): {', '.join(invalid)}. "
+            "Use valid 3-digit codes between 100 and 599, "
+            "or wildcards (e.g., 2XX, 2X0, 20X), where X is a wildcard digit."
+        )
+    return value
+
+
+@dataclass(repr=False)
+class SimpleCheckConfig(DiffBase):
+    enabled: bool
+
+    __slots__ = ("enabled",)
+
+    def __init__(self, *, enabled: bool = True) -> None:
+        self.enabled = enabled
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> SimpleCheckConfig:
+        return cls(enabled=data.get("enabled", True))
+
+
+@dataclass(repr=False)
+class MaxResponseTimeConfig(DiffBase):
+    enabled: bool
+    limit: float | None
+
+    __slots__ = ("enabled", "limit")
+
+    def __init__(self, *, limit: float | None = None) -> None:
+        self.enabled = limit is not None
+        self.limit = limit
+
+
+@dataclass(repr=False)
+class CheckConfig(DiffBase):
+    enabled: bool
+    expected_statuses: list[str]
+    _DEFAULT_EXPECTED_STATUSES: ClassVar[list[str]]
+
+    __slots__ = ("enabled", "expected_statuses")
+
+    def __init__(self, *, enabled: bool = True, expected_statuses: Sequence[str | int] | None = None) -> None:
+        self.enabled = enabled
+        if expected_statuses is not None:
+            statuses = [str(status) for status in expected_statuses]
+            validate_status_codes(statuses)
+            self.expected_statuses = statuses
+        else:
+            self.expected_statuses = self._DEFAULT_EXPECTED_STATUSES
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Self:
+        enabled = data.get("enabled", True)
+        return cls(
+            enabled=enabled,
+            expected_statuses=data.get("expected-statuses", cls._DEFAULT_EXPECTED_STATUSES),
+        )
+
+
+class NotAServerErrorConfig(CheckConfig):
+    _DEFAULT_EXPECTED_STATUSES = NOT_A_SERVER_ERROR_EXPECTED_STATUSES
+
+
+class PositiveDataAcceptanceConfig(CheckConfig):
+    _DEFAULT_EXPECTED_STATUSES = POSITIVE_DATA_ACCEPTANCE_EXPECTED_STATUSES
+
+
+class NegativeDataRejectionConfig(CheckConfig):
+    _DEFAULT_EXPECTED_STATUSES = NEGATIVE_DATA_REJECTION_EXPECTED_STATUSES
+
+
+class MissingRequiredHeaderConfig(CheckConfig):
+    _DEFAULT_EXPECTED_STATUSES = MISSING_REQUIRED_HEADER_EXPECTED_STATUSES
+
+
+@dataclass(repr=False)
+class ChecksConfig(DiffBase):
+    not_a_server_error: NotAServerErrorConfig
+    status_code_conformance: SimpleCheckConfig
+    content_type_conformance: SimpleCheckConfig
+    response_schema_conformance: SimpleCheckConfig
+    response_headers_conformance: SimpleCheckConfig
+    positive_data_acceptance: PositiveDataAcceptanceConfig
+    negative_data_rejection: NegativeDataRejectionConfig
+    use_after_free: SimpleCheckConfig
+    ensure_resource_availability: SimpleCheckConfig
+    missing_required_header: MissingRequiredHeaderConfig
+    ignored_auth: SimpleCheckConfig
+    unsupported_method: SimpleCheckConfig
+    max_response_time: MaxResponseTimeConfig
+    _unknown: dict[str, SimpleCheckConfig]
+
+    __slots__ = (
+        "not_a_server_error",
+        "status_code_conformance",
+        "content_type_conformance",
+        "response_schema_conformance",
+        "response_headers_conformance",
+        "positive_data_acceptance",
+        "negative_data_rejection",
+        "use_after_free",
+        "ensure_resource_availability",
+        "missing_required_header",
+        "ignored_auth",
+        "unsupported_method",
+        "max_response_time",
+        "_unknown",
+    )
+
+    def __init__(
+        self,
+        *,
+        not_a_server_error: NotAServerErrorConfig | None = None,
+        status_code_conformance: SimpleCheckConfig | None = None,
+        content_type_conformance: SimpleCheckConfig | None = None,
+        response_schema_conformance: SimpleCheckConfig | None = None,
+        response_headers_conformance: SimpleCheckConfig | None = None,
+        positive_data_acceptance: PositiveDataAcceptanceConfig | None = None,
+        negative_data_rejection: NegativeDataRejectionConfig | None = None,
+        use_after_free: SimpleCheckConfig | None = None,
+        ensure_resource_availability: SimpleCheckConfig | None = None,
+        missing_required_header: MissingRequiredHeaderConfig | None = None,
+        ignored_auth: SimpleCheckConfig | None = None,
+        unsupported_method: SimpleCheckConfig | None = None,
+        max_response_time: MaxResponseTimeConfig | None = None,
+    ) -> None:
+        self.not_a_server_error = not_a_server_error or NotAServerErrorConfig()
+        self.status_code_conformance = status_code_conformance or SimpleCheckConfig()
+        self.content_type_conformance = content_type_conformance or SimpleCheckConfig()
+        self.response_schema_conformance = response_schema_conformance or SimpleCheckConfig()
+        self.response_headers_conformance = response_headers_conformance or SimpleCheckConfig()
+        self.positive_data_acceptance = positive_data_acceptance or PositiveDataAcceptanceConfig()
+        self.negative_data_rejection = negative_data_rejection or NegativeDataRejectionConfig()
+        self.use_after_free = use_after_free or SimpleCheckConfig()
+        self.ensure_resource_availability = ensure_resource_availability or SimpleCheckConfig()
+        self.missing_required_header = missing_required_header or MissingRequiredHeaderConfig()
+        self.ignored_auth = ignored_auth or SimpleCheckConfig()
+        self.unsupported_method = unsupported_method or SimpleCheckConfig()
+        self.max_response_time = max_response_time or MaxResponseTimeConfig()
+        self._unknown = {}
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> ChecksConfig:
+        # Use the outer "enabled" value as default for all checks.
+        default_enabled = data.get("enabled", None)
+
+        def merge(sub: dict[str, Any]) -> dict[str, Any]:
+            # Merge the default enabled flag with the sub-dict; the sub-dict takes precedence.
+            if default_enabled is not None:
+                return {"enabled": default_enabled, **sub}
+            return sub
+
+        return cls(
+            not_a_server_error=NotAServerErrorConfig.from_dict(
+                merge(data.get("not_a_server_error", {})),
+            ),
+            status_code_conformance=SimpleCheckConfig.from_dict(merge(data.get("status_code_conformance", {}))),
+            content_type_conformance=SimpleCheckConfig.from_dict(merge(data.get("content_type_conformance", {}))),
+            response_schema_conformance=SimpleCheckConfig.from_dict(merge(data.get("response_schema_conformance", {}))),
+            response_headers_conformance=SimpleCheckConfig.from_dict(
+                merge(data.get("response_headers_conformance", {}))
+            ),
+            positive_data_acceptance=PositiveDataAcceptanceConfig.from_dict(
+                merge(data.get("positive_data_acceptance", {})),
+            ),
+            negative_data_rejection=NegativeDataRejectionConfig.from_dict(
+                merge(data.get("negative_data_rejection", {})),
+            ),
+            use_after_free=SimpleCheckConfig.from_dict(merge(data.get("use_after_free", {}))),
+            ensure_resource_availability=SimpleCheckConfig.from_dict(
+                merge(data.get("ensure_resource_availability", {}))
+            ),
+            missing_required_header=MissingRequiredHeaderConfig.from_dict(
+                merge(data.get("missing_required_header", {})),
+            ),
+            ignored_auth=SimpleCheckConfig.from_dict(merge(data.get("ignored_auth", {}))),
+            unsupported_method=SimpleCheckConfig.from_dict(merge(data.get("unsupported_method", {}))),
+            max_response_time=MaxResponseTimeConfig(limit=data.get("max_response_time")),
+        )
+
+    def get_by_name(self, *, name: str) -> CheckConfig | SimpleCheckConfig | MaxResponseTimeConfig:
+        try:
+            return getattr(self, name)
+        except AttributeError:
+            return self._unknown.setdefault(name, SimpleCheckConfig())
+
+    def update(
+        self,
+        *,
+        included_check_names: list[str] | None = None,
+        excluded_check_names: list[str] | None = None,
+        max_response_time: float | None = None,
+    ) -> None:
+        known_names = {name for name in self.__slots__ if not name.startswith("_")}
+        for name in known_names:
+            # Check in explicitly excluded or not in explicitly included
+            if name in (excluded_check_names or []) or (
+                included_check_names is not None
+                and "all" not in included_check_names
+                and name not in included_check_names
+            ):
+                config = self.get_by_name(name=name)
+                config.enabled = False
+            elif included_check_names is not None and name in included_check_names:
+                config = self.get_by_name(name=name)
+                config.enabled = True
+
+        if max_response_time is not None:
+            self.max_response_time.enabled = True
+            self.max_response_time.limit = max_response_time
+
+        for name in included_check_names or []:
+            if name not in known_names and name != "all":
+                self._unknown[name] = SimpleCheckConfig(enabled=True)
+
+        for name in excluded_check_names or []:
+            if name not in known_names and name != "all":
+                self._unknown[name] = SimpleCheckConfig(enabled=False)

schemathesis/config/_diff_base.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, fields, is_dataclass
+from typing import TypeVar
+
+T = TypeVar("T", bound="DiffBase")
+
+
+@dataclass
+class DiffBase:
+    def __repr__(self) -> str:
+        """Show only the fields that differ from the default."""
+        assert is_dataclass(self)
+        default = self.__class__()
+        diffs = []
+        for field in fields(self):
+            name = field.name
+            if name.startswith("_") and name not in ("_seed", "_filter_set"):
+                continue
+            current_value = getattr(self, name)
+            default_value = getattr(default, name)
+            if name == "_seed":
+                name = "seed"
+            if name == "_filter_set":
+                name = "filter_set"
+            if name == "rate_limit" and current_value is not None:
+                assert hasattr(self, "_rate_limit")
+                current_value = self._rate_limit
+            if self._has_diff(current_value, default_value):
+                diffs.append(f"{name}={self._diff_repr(current_value, default_value)}")
+        return f"{self.__class__.__name__}({', '.join(diffs)})"
+
+    def _has_diff(self, value: object, default: object) -> bool:
+        if is_dataclass(value):
+            return repr(value) != repr(default)
+        if isinstance(value, list) and isinstance(default, list):
+            if len(value) != len(default):
+                return True
+            return any(self._has_diff(v, d) for v, d in zip(value, default))
+        if isinstance(value, dict) and isinstance(default, dict):
+            if set(value.keys()) != set(default.keys()):
+                return True
+            return any(self._has_diff(value[k], default[k]) for k in value)
+        return value != default
+
+    def _diff_repr(self, value: object, default: object) -> str:
+        if is_dataclass(value):
+            # If the nested object is a dataclass, recursively show its diff.
+            return repr(value)
+        if isinstance(value, list) and isinstance(default, list):
+            diff_items = []
+            # Compare items pairwise.
+            for v, d in zip(value, default):
+                if self._has_diff(v, d):
+                    diff_items.append(self._diff_repr(v, d))
+            # Include any extra items in value.
+            if len(value) > len(default):
+                diff_items.extend(_repr(item) for item in value[len(default) :])
+            return f"[{', '.join(_repr(item) for item in value)}]"
+        if isinstance(value, dict) and isinstance(default, dict):
+            diff_items = []
+            for k, v in value.items():
+                d = default.get(k)
+                if self._has_diff(v, d):
+                    diff_items.append(f"{k!r}: {self._diff_repr(v, d)}")
+            return f"{{{', '.join(diff_items)}}}"
+        return repr(value)
+
+    @classmethod
+    def from_hierarchy(cls, configs: list[T]) -> T:
+        # This config will accumulate "merged" config options
+        output = cls()
+        for option in cls.__slots__:  # type: ignore
+            if option.startswith("_"):
+                continue
+            default = getattr(output, option)
+            if is_dataclass(default):
+                # Sub-configs require merging of nested config options
+                sub_configs = [getattr(config, option) for config in configs]
+                merged = type(default).from_hierarchy(sub_configs)  # type: ignore[union-attr]
+                setattr(output, option, merged)
+            else:
+                # Primitive config options can be compared directly and do not
+                # require merging of nested options
+                for config in configs:
+                    current = getattr(config, option)
+                    if current != default:
+                        setattr(output, option, current)
+                        # As we go from the highest priority to the lowest one,
+                        # we can just stop on the first non-default value
+                        break
+        return output  # type: ignore
+
+
+def _repr(item: object) -> str:
+    if callable(item) and hasattr(item, "__name__"):
+        return f"<function {item.__name__}>"
+
+    return repr(item)

schemathesis/config/_env.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import os
+from string import Template
+from typing import Any
+
+from schemathesis.config._error import ConfigError
+
+
+def resolve(value: Any) -> Any:
+    """Resolve environment variables using string templates."""
+    if value is None:
+        return None
+    if not isinstance(value, str):
+        return value
+    try:
+        return Template(value).substitute(os.environ)
+    except ValueError:
+        raise ConfigError(f"Invalid placeholder in string: `{value}`") from None
+    except KeyError:
+        raise ConfigError(f"Missing environment variable: `{value}`") from None

schemathesis/config/_error.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import difflib
+from typing import TYPE_CHECKING
+
+from schemathesis.core.errors import SchemathesisError
+
+if TYPE_CHECKING:
+    from jsonschema import ValidationError
+
+
+class ConfigError(SchemathesisError):
+    """Invalid configuration."""
+
+    @classmethod
+    def from_validation_error(cls, error: ValidationError) -> ConfigError:
+        message = error.message
+        if error.validator == "enum":
+            message = _format_enum_error(error)
+        elif error.validator == "minimum":
+            message = _format_minimum_error(error)
+        elif error.validator == "required":
+            message = _format_required_error(error)
+        elif error.validator == "type":
+            message = _format_type_error(error)
+        elif error.validator == "additionalProperties":
+            message = _format_additional_properties_error(error)
+        elif error.validator == "anyOf":
+            message = _format_anyof_error(error)
+        return cls(message)
+
+
+def _format_minimum_error(error: ValidationError) -> str:
+    assert isinstance(error.validator_value, (int, float))
+    section = path_to_section_name(list(error.path)[:-1] if error.path else [])
+    assert error.path
+
+    prop_name = error.path[-1]
+    min_value = error.validator_value
+    actual_value = error.instance
+
+    return (
+        f"Error in {section} section:\n  Value too low:\n\n"
+        f"  - '{prop_name}' → Must be at least {min_value}, but got {actual_value}."
+    )
+
+
+def _format_required_error(error: ValidationError) -> str:
+    assert isinstance(error.validator_value, list)
+    missing_keys = sorted(set(error.validator_value) - set(error.instance))
+
+    section = path_to_section_name(list(error.path))
+
+    details = "\n".join(f"  - '{key}'" for key in missing_keys)
+    return f"Error in {section} section:\n  Missing required properties:\n\n{details}\n\n"
+
+
+def _format_enum_error(error: ValidationError) -> str:
+    assert isinstance(error.validator_value, list)
+    valid_values = sorted(error.validator_value)
+
+    path = list(error.path)
+
+    if path and isinstance(path[-1], int):
+        idx = path[-1]
+        prop_name = path[-2]
+        section_path = path[:-2]
+        description = f"Item #{idx} in the '{prop_name}' array"
+    else:
+        prop_name = path[-1] if path else "value"
+        section_path = path[:-1]
+        description = f"'{prop_name}'"
+
+    suggestion = ""
+    if isinstance(error.instance, str) and all(isinstance(v, str) for v in valid_values):
+        match = _find_closest_match(error.instance, valid_values)
+        if match:
+            suggestion = f" Did you mean '{match}'?"
+
+    section = path_to_section_name(section_path)
+    valid_values_str = ", ".join(repr(v) for v in valid_values)
+    return (
+        f"Error in {section} section:\n  Invalid value:\n\n"
+        f"  - {description} → '{error.instance}' is not a valid value.{suggestion}\n\n"
+        f"Valid values are: {valid_values_str}."
+    )
+
+
+def _format_type_error(error: ValidationError) -> str:
+    expected = error.validator_value
+    assert isinstance(expected, (str, list))
+    section = path_to_section_name(list(error.path)[:-1] if error.path else [])
+    assert error.path
+
+    type_phrases = {
+        "object": "an object",
+        "array": "an array",
+        "number": "a number",
+        "boolean": "a boolean",
+        "string": "a string",
+        "integer": "an integer",
+        "null": "null",
+    }
+    message = f"Error in {section} section:\n  Type error:\n\n  - '{error.path[-1]}' → Must be "
+
+    if isinstance(expected, list):
+        message += f"one of: {' or '.join(expected)}"
+    else:
+        message += type_phrases[expected]
+    actual = type(error.instance).__name__
+    message += f", but got {actual}: {error.instance}"
+    return message
+
+
+def _format_additional_properties_error(error: ValidationError) -> str:
+    valid = list(error.schema.get("properties", {}))
+    unknown = sorted(set(error.instance) - set(valid))
+    valid_list = ", ".join(f"'{prop}'" for prop in valid)
+    section = path_to_section_name(list(error.path))
+
+    details = []
+    for prop in unknown:
+        match = _find_closest_match(prop, valid)
+        if match:
+            details.append(f"- '{prop}' → Did you mean '{match}'?")
+        else:
+            details.append(f"- '{prop}'")
+
+    return (
+        f"Error in {section} section:\n  Unknown properties:\n\n"
+        + "\n".join(f"  {detail}" for detail in details)
+        + f"\n\nValid properties for {section} are: {valid_list}."
+    )
+
+
+def _format_anyof_error(error: ValidationError) -> str:
+    if list(error.schema_path) == ["properties", "operations", "items", "anyOf"]:
+        section = path_to_section_name(list(error.path))
+        return (
+            f"Error in {section} section:\n  At least one filter is required when defining [[operations]].\n\n"
+            "Please specify at least one include or exclude filter property (e.g., include-path, exclude-tag, etc.)."
+        )
+    return error.message
+
+
+def path_to_section_name(path: list[int | str]) -> str:
+    """Convert a JSON path to a TOML-like section name."""
+    if not path:
+        return "root"
+
+    return f"[{'.'.join(str(p) for p in path)}]"
+
+
+def _find_closest_match(value: str, variants: list[str]) -> str | None:
+    matches = difflib.get_close_matches(value, variants, n=1, cutoff=0.6)
+    return matches[0] if matches else None

schemathesis/config/_generation.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from schemathesis.config._diff_base import DiffBase
+from schemathesis.generation.modes import GenerationMode
+
+if TYPE_CHECKING:
+    from schemathesis.generation.metrics import MetricFunction
+
+
+@dataclass(repr=False)
+class GenerationConfig(DiffBase):
+    modes: list[GenerationMode]
+    max_examples: int | None
+    no_shrink: bool
+    deterministic: bool
+    # Allow generating `\x00` bytes in strings
+    allow_x00: bool
+    # Generate strings using the given codec
+    codec: str | None
+    maximize: list[MetricFunction]
+    # Whether to generate security parameters
+    with_security_parameters: bool
+    # Allowing using `null` for optional arguments in GraphQL queries
+    graphql_allow_null: bool
+    database: str | None
+    unique_inputs: bool
+    exclude_header_characters: str | None
+
+    __slots__ = (
+        "modes",
+        "max_examples",
+        "no_shrink",
+        "deterministic",
+        "allow_x00",
+        "codec",
+        "maximize",
+        "with_security_parameters",
+        "graphql_allow_null",
+        "database",
+        "unique_inputs",
+        "exclude_header_characters",
+    )
+
+    def __init__(
+        self,
+        *,
+        modes: list[GenerationMode] | None = None,
+        max_examples: int | None = None,
+        no_shrink: bool = False,
+        deterministic: bool = False,
+        allow_x00: bool = True,
+        codec: str | None = "utf-8",
+        maximize: list[MetricFunction] | None = None,
+        with_security_parameters: bool = True,
+        graphql_allow_null: bool = True,
+        database: str | None = None,
+        unique_inputs: bool = False,
+        exclude_header_characters: str | None = None,
+    ) -> None:
+        from schemathesis.generation import GenerationMode
+
+        self.modes = modes or list(GenerationMode)
+        self.max_examples = max_examples
+        self.no_shrink = no_shrink
+        self.deterministic = deterministic
+        self.allow_x00 = allow_x00
+        self.codec = codec
+        self.maximize = maximize or []
+        self.with_security_parameters = with_security_parameters
+        self.graphql_allow_null = graphql_allow_null
+        self.database = database
+        self.unique_inputs = unique_inputs
+        self.exclude_header_characters = exclude_header_characters
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> GenerationConfig:
+        mode_raw = data.get("mode")
+        if mode_raw == "all":
+            modes = list(GenerationMode)
+        elif mode_raw is not None:
+            modes = [GenerationMode(mode_raw)]
+        else:
+            modes = None
+        maximize = _get_maximize(data.get("maximize"))
+        return cls(
+            modes=modes,
+            max_examples=data.get("max-examples"),
+            no_shrink=data.get("no-shrink", False),
+            deterministic=data.get("deterministic", False),
+            allow_x00=data.get("allow-x00", True),
+            codec=data.get("codec", "utf-8"),
+            maximize=maximize,
+            with_security_parameters=data.get("with-security-parameters", True),
+            graphql_allow_null=data.get("graphql-allow-null", True),
+            database=data.get("database"),
+            unique_inputs=data.get("unique-inputs", False),
+            exclude_header_characters=data.get("exclude-header-characters"),
+        )
+
+    def update(
+        self,
+        *,
+        modes: list[GenerationMode] | None = None,
+        max_examples: int | None = None,
+        no_shrink: bool = False,
+        deterministic: bool | None = None,
+        allow_x00: bool = True,
+        codec: str | None = None,
+        maximize: list[MetricFunction] | None = None,
+        with_security_parameters: bool | None = None,
+        graphql_allow_null: bool = True,
+        database: str | None = None,
+        unique_inputs: bool = False,
+        exclude_header_characters: str | None = None,
+    ) -> None:
+        if modes is not None:
+            self.modes = modes
+        if max_examples is not None:
+            self.max_examples = max_examples
+        self.no_shrink = no_shrink
+        self.deterministic = deterministic or False
+        self.allow_x00 = allow_x00
+        if codec is not None:
+            self.codec = codec
+        if maximize is not None:
+            self.maximize = maximize
+        if with_security_parameters is not None:
+            self.with_security_parameters = with_security_parameters
+        self.graphql_allow_null = graphql_allow_null
+        if database is not None:
+            self.database = database
+        self.unique_inputs = unique_inputs
+        if exclude_header_characters is not None:
+            self.exclude_header_characters = exclude_header_characters
+
+
+def _get_maximize(value: Any) -> list[MetricFunction]:
+    from schemathesis.generation.metrics import METRICS
+
+    if isinstance(value, list):
+        metrics = value
+    elif isinstance(value, str):
+        metrics = [value]
+    else:
+        metrics = []
+    return METRICS.get_by_names(metrics)