schemathesis 3.25.6__py3-none-any.whl → 4.0.0a1__py3-none-any.whl

schemathesis/service/serialization.py

@@ -1,199 +0,0 @@
-from __future__ import annotations
-from dataclasses import asdict
-from typing import Any, Callable, Dict, Optional, TypeVar, cast
-
-from ..models import Response
-from ..runner import events
-from ..runner.serialization import SerializedCase
-from ..internal.transformation import merge_recursively
-
-S = TypeVar("S", bound=events.ExecutionEvent)
-SerializeFunc = Callable[[S], Optional[Dict[str, Any]]]
-
-
-def serialize_initialized(event: events.Initialized) -> dict[str, Any] | None:
-    return {
-        "operations_count": event.operations_count,
-        "location": event.location or "",
-        "base_url": event.base_url,
-    }
-
-
-def serialize_before_probing(_: events.BeforeProbing) -> None:
-    return None
-
-
-def serialize_after_probing(event: events.AfterProbing) -> dict[str, Any] | None:
-    probes = event.probes or []
-    return {"probes": [probe.serialize() for probe in probes]}
-
-
-def serialize_before_execution(event: events.BeforeExecution) -> dict[str, Any] | None:
-    return {
-        "correlation_id": event.correlation_id,
-        "verbose_name": event.verbose_name,
-        "data_generation_method": event.data_generation_method,
-    }
-
-
-def _serialize_case(case: SerializedCase) -> dict[str, Any]:
-    return {
-        "verbose_name": case.verbose_name,
-        "path_template": case.path_template,
-        "path_parameters": stringify_path_parameters(case.path_parameters),
-        "query": prepare_query(case.query),
-        "cookies": case.cookies,
-        "media_type": case.media_type,
-    }
-
-
-def _serialize_response(response: Response) -> dict[str, Any]:
-    return {
-        "status_code": response.status_code,
-        "headers": response.headers,
-        "body": response.body,
-        "encoding": response.encoding,
-        "elapsed": response.elapsed,
-    }
-
-
-def serialize_after_execution(event: events.AfterExecution) -> dict[str, Any] | None:
-    return {
-        "correlation_id": event.correlation_id,
-        "verbose_name": event.verbose_name,
-        "status": event.status,
-        "elapsed_time": event.elapsed_time,
-        "data_generation_method": event.data_generation_method,
-        "result": {
-            "checks": [
-                {
-                    "name": check.name,
-                    "value": check.value,
-                    "request": {
-                        "method": check.request.method,
-                        "uri": check.request.uri,
-                        "body": check.request.body,
-                        "headers": check.request.headers,
-                    },
-                    "response": _serialize_response(check.response) if check.response is not None else None,
-                    "example": _serialize_case(check.example),
-                    "message": check.message,
-                    "context": asdict(check.context) if check.context is not None else None,  # type: ignore
-                    "history": [
-                        {"case": _serialize_case(entry.case), "response": _serialize_response(entry.response)}
-                        for entry in check.history
-                    ],
-                }
-                for check in event.result.checks
-            ],
-            "errors": [asdict(error) for error in event.result.errors],
-            "skip_reason": event.result.skip_reason,
-        },
-    }
-
-
-def serialize_interrupted(_: events.Interrupted) -> dict[str, Any] | None:
-    return None
-
-
-def serialize_internal_error(event: events.InternalError) -> dict[str, Any] | None:
-    return {
-        "type": event.type.value,
-        "subtype": event.subtype.value if event.subtype else event.subtype,
-        "title": event.title,
-        "message": event.message,
-        "extras": event.extras,
-        "exception_type": event.exception_type,
-        "exception": event.exception,
-        "exception_with_traceback": event.exception_with_traceback,
-    }
-
-
-def serialize_finished(event: events.Finished) -> dict[str, Any] | None:
-    return {
-        "generic_errors": [
-            {
-                "exception": error.exception,
-                "exception_with_traceback": error.exception_with_traceback,
-                "title": error.title,
-            }
-            for error in event.generic_errors
-        ],
-        "running_time": event.running_time,
-    }
-
-
-SERIALIZER_MAP = {
-    events.Initialized: serialize_initialized,
-    events.BeforeProbing: serialize_before_probing,
-    events.AfterProbing: serialize_after_probing,
-    events.BeforeExecution: serialize_before_execution,
-    events.AfterExecution: serialize_after_execution,
-    events.Interrupted: serialize_interrupted,
-    events.InternalError: serialize_internal_error,
-    events.Finished: serialize_finished,
-}
-
-
-def serialize_event(
-    event: events.ExecutionEvent,
-    *,
-    on_initialized: SerializeFunc | None = None,
-    on_before_probing: SerializeFunc | None = None,
-    on_after_probing: SerializeFunc | None = None,
-    on_before_execution: SerializeFunc | None = None,
-    on_after_execution: SerializeFunc | None = None,
-    on_interrupted: SerializeFunc | None = None,
-    on_internal_error: SerializeFunc | None = None,
-    on_finished: SerializeFunc | None = None,
-    extra: dict[str, Any] | None = None,
-) -> dict[str, dict[str, Any] | None]:
-    """Turn an event into JSON-serializable structure."""
-    # Use the explicitly provided serializer for this event and fallback to default one if it is not provided
-    serializer = {
-        events.Initialized: on_initialized,
-        events.BeforeProbing: on_before_probing,
-        events.AfterProbing: on_after_probing,
-        events.BeforeExecution: on_before_execution,
-        events.AfterExecution: on_after_execution,
-        events.Interrupted: on_interrupted,
-        events.InternalError: on_internal_error,
-        events.Finished: on_finished,
-    }.get(event.__class__)
-    if serializer is None:
-        serializer = cast(SerializeFunc, SERIALIZER_MAP[event.__class__])
-    data = serializer(event)
-    if extra is not None:
-        # If `extra` is present, then merge it with the serialized data. If serialized data is empty, then replace it
-        # with `extra` value
-        if data is None:
-            data = extra
-        else:
-            data = merge_recursively(data, extra)
-    # Externally tagged structure
-    return {event.__class__.__name__: data}
-
-
-def stringify_path_parameters(path_parameters: dict[str, Any] | None) -> dict[str, str]:
-    """Cast all path parameter values to strings.
-
-    Path parameter values may be of arbitrary type, but to display them properly they should be casted to strings.
-    """
-    return {key: str(value) for key, value in (path_parameters or {}).items()}
-
-
-def prepare_query(query: dict[str, Any] | None) -> dict[str, list[str]]:
-    """Convert all query values to list of strings.
-
-    Query parameters may be generated in different shapes, including integers, strings, list of strings, etc.
-    It can also be an object, if the schema contains an object, but `style` and `explode` combo is not applicable.
-    """
-
-    def to_list_of_strings(value: Any) -> list[str]:
-        if isinstance(value, list):
-            return list(map(str, value))
-        if isinstance(value, str):
-            return [value]
-        return [str(value)]
-
-    return {key: to_list_of_strings(value) for key, value in (query or {}).items()}

schemathesis/service/usage.py

@@ -1,65 +0,0 @@
-from __future__ import annotations
-import sys
-from typing import Any
-
-import click
-from click.types import StringParamType
-
-from .. import cli, hooks
-
-
-def collect(args: list[str] | None = None) -> dict[str, Any] | None:
-    """Collect anonymized CLI usage data."""
-    context: click.Context | None = click.get_current_context(silent=True)
-    if context is not None and not sys.argv[0].endswith("pytest"):
-        args = args or sys.argv[2:]
-        parameters, _, types = parse_cli_args(context, args)
-        parameters_data: dict[str, dict[str, Any]] = {}
-        used_headers: list[str] = []
-        schema = parameters["schema"]
-        app = parameters.get("app")
-        if not schema:
-            schema_kind = None
-        else:
-            schema_kind = cli.callbacks.parse_schema_kind(schema, app).name
-        usage = {
-            "schema_kind": schema_kind,
-            "parameters": parameters_data,
-            "used_headers": used_headers,
-            "hooks": hooks.collect_statistic(),
-        }
-        types_iter = iter(types)
-        for option, value in parameters.items():
-            option_type = next(types_iter)
-            if isinstance(option_type, click.Argument):
-                continue
-            if option_type.multiple:
-                # Forward the iterator to the next option type
-                for _ in range(len(value) - 1):
-                    next(types_iter)
-            entry = _collect_option(option, option_type, used_headers, value)
-            if entry:
-                parameters_data[option] = entry
-        return usage
-    return None
-
-
-def _collect_option(option: str, option_type: click.Parameter, used_headers: list[str], value: Any) -> dict[str, Any]:
-    entry = {}
-    if isinstance(option_type.type, (StringParamType, click.types.File)):
-        if option == "headers" and value:
-            used_headers.extend(header.split(":", 1)[0] for header in value)
-        else:
-            # Free-form values are replaced with their number of occurrences, to avoid sending sensitive info
-            if option_type.multiple:
-                entry["count"] = len(value)
-            else:
-                entry["count"] = 1
-    else:
-        entry["value"] = value
-    return entry
-
-
-def parse_cli_args(context: click.Context, args: list[str]) -> tuple[dict[str, Any], list, list[click.Parameter]]:
-    parser = cli.run.make_parser(context)
-    return parser.parse_args(args=args)

schemathesis/specs/graphql/loaders.py

@@ -1,344 +0,0 @@
-from __future__ import annotations
-
-import json
-import pathlib
-from functools import lru_cache
-from json import JSONDecodeError
-from typing import IO, TYPE_CHECKING, Any, Callable, Dict, NoReturn, cast
-
-from ...code_samples import CodeSampleStyle
-from ...constants import WAIT_FOR_SCHEMA_INTERVAL
-from ...exceptions import SchemaError, SchemaErrorType
-from ...generation import (
-    DEFAULT_DATA_GENERATION_METHODS,
-    DataGenerationMethod,
-    DataGenerationMethodInput,
-    GenerationConfig,
-)
-from ...hooks import HookContext, dispatch
-from ...internal.validation import require_relative_url
-from ...loaders import load_schema_from_url
-from ...throttling import build_limiter
-from ...transports.headers import setup_default_headers
-from ...types import PathLike
-
-if TYPE_CHECKING:
-    from graphql import DocumentNode
-    from pyrate_limiter import Limiter
-
-    from ...transports.responses import GenericResponse
-    from .schemas import GraphQLSchema
-
-
-@lru_cache
-def get_introspection_query() -> str:
-    import graphql
-
-    return graphql.get_introspection_query()
-
-
-@lru_cache
-def get_introspection_query_ast() -> DocumentNode:
-    import graphql
-
-    query = get_introspection_query()
-    return graphql.parse(query)
-
-
-def from_path(
-    path: PathLike,
-    *,
-    app: Any = None,
-    base_url: str | None = None,
-    data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
-    generation_config: GenerationConfig | None = None,
-    code_sample_style: str = CodeSampleStyle.default().name,
-    rate_limit: str | None = None,
-    encoding: str = "utf8",
-    sanitize_output: bool = True,
-) -> GraphQLSchema:
-    """Load GraphQL schema via a file from an OS path.
-
-    :param path: A path to the schema file.
-    :param encoding: The name of the encoding used to decode the file.
-    """
-    with open(path, encoding=encoding) as fd:
-        return from_file(
-            fd,
-            app=app,
-            base_url=base_url,
-            data_generation_methods=data_generation_methods,
-            code_sample_style=code_sample_style,
-            location=pathlib.Path(path).absolute().as_uri(),
-            rate_limit=rate_limit,
-            sanitize_output=sanitize_output,
-        )
-
-
-def extract_schema_from_response(response: GenericResponse) -> dict[str, Any]:
-    from requests import Response
-
-    try:
-        if isinstance(response, Response):
-            decoded = response.json()
-        else:
-            decoded = response.json
-    except JSONDecodeError as exc:
-        raise SchemaError(
-            SchemaErrorType.UNEXPECTED_CONTENT_TYPE,
-            "Received unsupported content while expecting a JSON payload for GraphQL",
-        ) from exc
-    return decoded
-
-
-def from_url(
-    url: str,
-    *,
-    app: Any = None,
-    base_url: str | None = None,
-    port: int | None = None,
-    data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
-    generation_config: GenerationConfig | None = None,
-    code_sample_style: str = CodeSampleStyle.default().name,
-    wait_for_schema: float | None = None,
-    rate_limit: str | None = None,
-    sanitize_output: bool = True,
-    **kwargs: Any,
-) -> GraphQLSchema:
-    """Load GraphQL schema from the network.
-
-    :param url: Schema URL.
-    :param Optional[str] base_url: Base URL to send requests to.
-    :param Optional[int] port: An optional port if you don't want to pass the ``base_url`` parameter, but only to change
-                               port in ``url``.
-    :param app: A WSGI app instance.
-    :return: GraphQLSchema
-    """
-    import backoff
-    import requests
-
-    setup_default_headers(kwargs)
-    kwargs.setdefault("json", {"query": get_introspection_query()})
-    if port:
-        from yarl import URL
-
-        url = str(URL(url).with_port(port))
-        if not base_url:
-            base_url = url
-
-    if wait_for_schema is not None:
-
-        @backoff.on_exception(  # type: ignore
-            backoff.constant,
-            requests.exceptions.ConnectionError,
-            max_time=wait_for_schema,
-            interval=WAIT_FOR_SCHEMA_INTERVAL,
-        )
-        def _load_schema(_uri: str, **_kwargs: Any) -> requests.Response:
-            return requests.post(_uri, **kwargs)
-
-    else:
-        _load_schema = requests.post
-
-    response = load_schema_from_url(lambda: _load_schema(url, **kwargs))
-    raw_schema = extract_schema_from_response(response)
-    return from_dict(
-        raw_schema=raw_schema,
-        location=url,
-        base_url=base_url,
-        app=app,
-        data_generation_methods=data_generation_methods,
-        code_sample_style=code_sample_style,
-        rate_limit=rate_limit,
-        sanitize_output=sanitize_output,
-    )
-
-
-def from_file(
-    file: IO[str] | str,
-    *,
-    app: Any = None,
-    base_url: str | None = None,
-    data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
-    generation_config: GenerationConfig | None = None,
-    code_sample_style: str = CodeSampleStyle.default().name,
-    location: str | None = None,
-    rate_limit: str | None = None,
-    sanitize_output: bool = True,
-) -> GraphQLSchema:
-    """Load GraphQL schema from a file descriptor or a string.
-
-    :param file: Could be a file descriptor, string or bytes.
-    """
-    import graphql
-
-    if isinstance(file, str):
-        data = file
-    else:
-        data = file.read()
-    try:
-        document = graphql.build_schema(data)
-        result = graphql.execute(document, get_introspection_query_ast())
-        # TYPES: We don't pass `is_awaitable` above, therefore `result` is of the `ExecutionResult` type
-        result = cast(graphql.ExecutionResult, result)
-        # TYPES:
-        #  - `document` is a valid schema, because otherwise `build_schema` will rise an error;
-        #  - `INTROSPECTION_QUERY` is a valid query - it is known upfront;
-        # Therefore the execution result is always valid at this point and `result.data` is not `None`
-        raw_schema = cast(Dict[str, Any], result.data)
-    except Exception as exc:
-        try:
-            raw_schema = json.loads(data)
-            if not isinstance(raw_schema, dict) or "__schema" not in raw_schema:
-                _on_invalid_schema(exc)
-        except json.JSONDecodeError:
-            _on_invalid_schema(exc, extras=[entry for entry in str(exc).splitlines() if entry])
-    return from_dict(
-        raw_schema,
-        app=app,
-        base_url=base_url,
-        data_generation_methods=data_generation_methods,
-        code_sample_style=code_sample_style,
-        location=location,
-        rate_limit=rate_limit,
-        sanitize_output=sanitize_output,
-    )
-
-
-def _on_invalid_schema(exc: Exception, extras: list[str] | None = None) -> NoReturn:
-    raise SchemaError(
-        SchemaErrorType.GRAPHQL_INVALID_SCHEMA,
-        "The provided API schema does not appear to be a valid GraphQL schema",
-        extras=extras or [],
-    ) from exc
-
-
-def from_dict(
-    raw_schema: dict[str, Any],
-    *,
-    app: Any = None,
-    base_url: str | None = None,
-    location: str | None = None,
-    data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
-    generation_config: GenerationConfig | None = None,
-    code_sample_style: str = CodeSampleStyle.default().name,
-    rate_limit: str | None = None,
-    sanitize_output: bool = True,
-) -> GraphQLSchema:
-    """Load GraphQL schema from a Python dictionary.
-
-    :param dict raw_schema: A schema to load.
-    :param Optional[str] location: Optional schema location. Either a full URL or a filesystem path.
-    :param Optional[str] base_url: Base URL to send requests to.
-    :param app: A WSGI app instance.
-    :return: GraphQLSchema
-    """
-    from .schemas import GraphQLSchema
-
-    _code_sample_style = CodeSampleStyle.from_str(code_sample_style)
-    hook_context = HookContext()
-    if "data" in raw_schema:
-        raw_schema = raw_schema["data"]
-    dispatch("before_load_schema", hook_context, raw_schema)
-    rate_limiter: Limiter | None = None
-    if rate_limit is not None:
-        rate_limiter = build_limiter(rate_limit)
-    instance = GraphQLSchema(
-        raw_schema,
-        location=location,
-        base_url=base_url,
-        app=app,
-        data_generation_methods=DataGenerationMethod.ensure_list(data_generation_methods),
-        code_sample_style=_code_sample_style,
-        rate_limiter=rate_limiter,
-        sanitize_output=sanitize_output,
-    )  # type: ignore
-    dispatch("after_load_schema", hook_context, instance)
-    return instance
-
-
-def from_wsgi(
-    schema_path: str,
-    app: Any,
-    *,
-    base_url: str | None = None,
-    data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
-    generation_config: GenerationConfig | None = None,
-    code_sample_style: str = CodeSampleStyle.default().name,
-    rate_limit: str | None = None,
-    sanitize_output: bool = True,
-    **kwargs: Any,
-) -> GraphQLSchema:
-    """Load GraphQL schema from a WSGI app.
-
-    :param str schema_path: An in-app relative URL to the schema.
-    :param app: A WSGI app instance.
-    :param Optional[str] base_url: Base URL to send requests to.
-    :return: GraphQLSchema
-    """
-    from werkzeug import Client
-
-    from ...transports.responses import WSGIResponse
-
-    require_relative_url(schema_path)
-    setup_default_headers(kwargs)
-    kwargs.setdefault("json", {"query": get_introspection_query()})
-    client = Client(app, WSGIResponse)
-    response = load_schema_from_url(lambda: client.post(schema_path, **kwargs))
-    raw_schema = extract_schema_from_response(response)
-    return from_dict(
-        raw_schema=raw_schema,
-        location=schema_path,
-        base_url=base_url,
-        app=app,
-        data_generation_methods=data_generation_methods,
-        code_sample_style=code_sample_style,
-        rate_limit=rate_limit,
-        sanitize_output=sanitize_output,
-    )
-
-
-def from_asgi(
-    schema_path: str,
-    app: Any,
-    *,
-    base_url: str | None = None,
-    data_generation_methods: DataGenerationMethodInput = DEFAULT_DATA_GENERATION_METHODS,
-    generation_config: GenerationConfig | None = None,
-    code_sample_style: str = CodeSampleStyle.default().name,
-    rate_limit: str | None = None,
-    sanitize_output: bool = True,
-    **kwargs: Any,
-) -> GraphQLSchema:
-    """Load GraphQL schema from an ASGI app.
-
-    :param str schema_path: An in-app relative URL to the schema.
-    :param app: An ASGI app instance.
-    :param Optional[str] base_url: Base URL to send requests to.
-    """
-    from starlette_testclient import TestClient as ASGIClient
-
-    require_relative_url(schema_path)
-    setup_default_headers(kwargs)
-    kwargs.setdefault("json", {"query": get_introspection_query()})
-    client = ASGIClient(app)
-    response = load_schema_from_url(lambda: client.post(schema_path, **kwargs))
-    raw_schema = extract_schema_from_response(response)
-    return from_dict(
-        raw_schema=raw_schema,
-        location=schema_path,
-        base_url=base_url,
-        app=app,
-        data_generation_methods=data_generation_methods,
-        code_sample_style=code_sample_style,
-        rate_limit=rate_limit,
-        sanitize_output=sanitize_output,
-    )
-
-
-def get_loader_for_app(app: Any) -> Callable:
-    from starlette.applications import Starlette
-
-    if isinstance(app, Starlette):
-        return from_asgi
-    return from_wsgi

schemathesis/specs/openapi/filters.py

@@ -1,49 +0,0 @@
-from __future__ import annotations
-import re
-
-from ...types import Filter
-
-
-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: Filter | None) -> bool:
-    if pattern is None:
-        return False
-    return not _match_any_pattern(endpoint, pattern)
-
-
-def should_skip_by_tag(tags: list[str] | None, pattern: Filter | None) -> bool:
-    if pattern is None:
-        return False
-    if not tags:
-        return True
-    patterns = _ensure_tuple(pattern)
-    return not any(re.search(item, tag) for item in patterns for tag in tags)
-
-
-def should_skip_by_operation_id(operation_id: str | None, pattern: Filter | None) -> bool:
-    if pattern is None:
-        return False
-    if not operation_id:
-        return True
-    return not _match_any_pattern(operation_id, pattern)
-
-
-def should_skip_deprecated(is_deprecated: bool, skip_deprecated_operations: bool) -> bool:
-    return skip_deprecated_operations and is_deprecated
-
-
-def _match_any_pattern(target: str, pattern: Filter) -> bool:
-    patterns = _ensure_tuple(pattern)
-    return any(re.search(item, target) for item in patterns)
-
-
-def _ensure_tuple(item: Filter) -> list | set | tuple:
-    if not isinstance(item, (list, set, tuple)):
-        return (item,)
-    return item