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

schemathesis/serializers.py

@@ -1,315 +0,0 @@
-from __future__ import annotations
-import binascii
-import os
-from dataclasses import dataclass
-from io import BytesIO
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Collection,
-    Dict,
-    Generator,
-    cast,
-    Protocol,
-    runtime_checkable,
-)
-
-from .internal.copy import fast_deepcopy
-from ._xml import _to_xml
-from .transports.content_types import (
-    is_json_media_type,
-    is_plain_text_media_type,
-    is_xml_media_type,
-    parse_content_type,
-)
-
-if TYPE_CHECKING:
-    from .models import Case
-
-
-SERIALIZERS: dict[str, type[Serializer]] = {}
-
-
-@dataclass
-class Binary(str):
-    """A wrapper around `bytes` to resolve OpenAPI and JSON Schema `format` discrepancies.
-
-    Treat `bytes` as a valid type, allowing generation of bytes for OpenAPI `format` values like `binary` or `file`
-    that JSON Schema expects to be strings.
-    """
-
-    data: bytes
-
-
-@dataclass
-class SerializerContext:
-    """The context for serialization process.
-
-    :ivar Case case: Generated example that is being processed.
-    """
-
-    case: Case
-
-    @property
-    def media_type(self) -> str:
-        # `media_type` is a string, otherwise we won't serialize anything
-        return cast(str, self.case.media_type)
-
-    # Note on type casting below.
-    # If we serialize data, then there should be non-empty definition for it in the first place
-    # Therefore `schema` is never `None` if called from here. However, `APIOperation.get_raw_payload_schema` is
-    # generic and can be called from other places where it may return `None`
-
-    def get_raw_payload_schema(self) -> dict[str, Any]:
-        schema = self.case.operation.get_raw_payload_schema(self.media_type)
-        return cast(Dict[str, Any], schema)
-
-    def get_resolved_payload_schema(self) -> dict[str, Any]:
-        schema = self.case.operation.get_resolved_payload_schema(self.media_type)
-        return cast(Dict[str, Any], schema)
-
-
-@runtime_checkable
-class Serializer(Protocol):
-    """Transform generated data to a form supported by the transport layer.
-
-    For example, to handle multipart payloads, we need to serialize them differently for
-    `requests` and `werkzeug` transports.
-    """
-
-    def as_requests(self, context: SerializerContext, payload: Any) -> dict[str, Any]:
-        raise NotImplementedError
-
-    def as_werkzeug(self, context: SerializerContext, payload: Any) -> dict[str, Any]:
-        raise NotImplementedError
-
-
-def register(media_type: str, *, aliases: Collection[str] = ()) -> Callable[[type[Serializer]], type[Serializer]]:
-    """Register a serializer for the given media type.
-
-    Schemathesis uses ``requests`` for regular network calls and ``werkzeug`` for WSGI applications. Your serializer
-    should have two methods, ``as_requests`` and ``as_werkzeug``, providing keyword arguments that Schemathesis will
-    pass to ``requests.request`` and ``werkzeug.Client.open`` respectively.
-
-    .. code-block:: python
-
-        @register("text/csv")
-        class CSVSerializer:
-            def as_requests(self, context, value):
-                return {"data": to_csv(value)}
-
-            def as_werkzeug(self, context, value):
-                return {"data": to_csv(value)}
-
-    The primary purpose of serializers is to transform data from its Python representation to the format suitable
-    for making an API call. The generated data structure depends on your schema, but its type matches
-    Python equivalents to the JSON Schema types.
-
-    """
-
-    def wrapper(serializer: type[Serializer]) -> type[Serializer]:
-        if not issubclass(serializer, Serializer):
-            raise TypeError(
-                f"`{serializer.__name__}` is not a valid serializer. "
-                f"Check `schemathesis.serializers.Serializer` documentation for examples."
-            )
-        SERIALIZERS[media_type] = serializer
-        for alias in aliases:
-            SERIALIZERS[alias] = serializer
-        return serializer
-
-    return wrapper
-
-
-def unregister(media_type: str) -> None:
-    """Remove registered serializer for the given media type."""
-    del SERIALIZERS[media_type]
-
-
-def _to_json(value: Any) -> dict[str, Any]:
-    if isinstance(value, bytes):
-        # Possible to get via explicit examples, e.g. `externalValue`
-        return {"data": value}
-    if isinstance(value, Binary):
-        return {"data": value.data}
-    if value is None:
-        # If the body is `None`, then the app expects `null`, but `None` is also the default value for the `json`
-        # argument in `requests.request` and `werkzeug.Client.open` which makes these cases indistinguishable.
-        # Therefore we explicitly create such payload
-        return {"data": b"null"}
-    return {"json": value}
-
-
-@register("application/json", aliases=("text/json",))
-class JSONSerializer:
-    def as_requests(self, context: SerializerContext, value: Any) -> dict[str, Any]:
-        return _to_json(value)
-
-    def as_werkzeug(self, context: SerializerContext, value: Any) -> dict[str, Any]:
-        return _to_json(value)
-
-
-def _to_yaml(value: Any) -> dict[str, Any]:
-    import yaml
-
-    try:
-        from yaml import CSafeDumper as SafeDumper
-    except ImportError:
-        from yaml import SafeDumper  # type: ignore
-
-    if isinstance(value, bytes):
-        return {"data": value}
-    if isinstance(value, Binary):
-        return {"data": value.data}
-    return {"data": yaml.dump(value, Dumper=SafeDumper)}
-
-
-@register("text/yaml", aliases=("text/x-yaml", "application/x-yaml", "text/vnd.yaml"))
-class YAMLSerializer:
-    def as_requests(self, context: SerializerContext, value: Any) -> dict[str, Any]:
-        return _to_yaml(value)
-
-    def as_werkzeug(self, context: SerializerContext, value: Any) -> dict[str, Any]:
-        return _to_yaml(value)
-
-
-@register("application/xml", aliases=("text/xml",))
-class XMLSerializer:
-    def as_requests(self, context: SerializerContext, value: Any) -> dict[str, Any]:
-        return _to_xml(value, context.get_raw_payload_schema(), context.get_resolved_payload_schema())
-
-    def as_werkzeug(self, context: SerializerContext, value: Any) -> dict[str, Any]:
-        return _to_xml(value, context.get_raw_payload_schema(), context.get_resolved_payload_schema())
-
-
-def _should_coerce_to_bytes(item: Any) -> bool:
-    """Whether the item should be converted to bytes."""
-    # These types are OK in forms, others should be coerced to bytes
-    return isinstance(item, Binary) or not isinstance(item, (bytes, str, int))
-
-
-def _prepare_form_data(data: dict[str, Any]) -> dict[str, Any]:
-    """Make the generated data suitable for sending as multipart.
-
-    If the schema is loose, Schemathesis can generate data that can't be sent as multipart. In these cases,
-    we convert it to bytes and send it as-is, ignoring any conversion errors.
-
-    NOTE. This behavior might change in the future.
-    """
-    for name, value in data.items():
-        if isinstance(value, list):
-            data[name] = [_to_bytes(item) if _should_coerce_to_bytes(item) else item for item in value]
-        elif _should_coerce_to_bytes(value):
-            data[name] = _to_bytes(value)
-    return data
-
-
-def _to_bytes(value: Any) -> bytes:
-    """Convert the input value to bytes and ignore any conversion errors."""
-    if isinstance(value, bytes):
-        return value
-    if isinstance(value, Binary):
-        return value.data
-    return str(value).encode(errors="ignore")
-
-
-def choose_boundary() -> str:
-    """Random boundary name."""
-    return binascii.hexlify(os.urandom(16)).decode("ascii")
-
-
-def _encode_multipart(value: Any, boundary: str) -> bytes:
-    """Encode any value as multipart.
-
-    NOTE. It doesn't aim to be 100% correct multipart payload, but rather a way to send data which is not intended to
-    be used as multipart, in cases when the API schema dictates so.
-    """
-    # For such cases we stringify the value and wrap it to a randomly-generated boundary
-    body = BytesIO()
-    body.write(f"--{boundary}\r\n".encode())
-    body.write(str(value).encode())
-    body.write(f"--{boundary}--\r\n".encode("latin-1"))
-    return body.getvalue()
-
-
-@register("multipart/form-data")
-class MultipartSerializer:
-    def as_requests(self, context: SerializerContext, value: Any) -> dict[str, Any]:
-        if isinstance(value, bytes):
-            return {"data": value}
-        if isinstance(value, dict):
-            value = fast_deepcopy(value)
-            multipart = _prepare_form_data(value)
-            files, data = context.case.operation.prepare_multipart(multipart)
-            return {"files": files, "data": data}
-        # Uncommon schema. For example - `{"type": "string"}`
-        boundary = choose_boundary()
-        raw_data = _encode_multipart(value, boundary)
-        content_type = f"multipart/form-data; boundary={boundary}"
-        return {"data": raw_data, "headers": {"Content-Type": content_type}}
-
-    def as_werkzeug(self, context: SerializerContext, value: Any) -> dict[str, Any]:
-        return {"data": value}
-
-
-@register("application/x-www-form-urlencoded")
-class URLEncodedFormSerializer:
-    def as_requests(self, context: SerializerContext, value: Any) -> dict[str, Any]:
-        return {"data": value}
-
-    def as_werkzeug(self, context: SerializerContext, value: Any) -> dict[str, Any]:
-        return {"data": value}
-
-
-@register("text/plain")
-class TextSerializer:
-    def as_requests(self, context: SerializerContext, value: Any) -> dict[str, Any]:
-        if isinstance(value, bytes):
-            return {"data": value}
-        return {"data": str(value).encode("utf8")}
-
-    def as_werkzeug(self, context: SerializerContext, value: Any) -> dict[str, Any]:
-        if isinstance(value, bytes):
-            return {"data": value}
-        return {"data": str(value)}
-
-
-@register("application/octet-stream")
-class OctetStreamSerializer:
-    def as_requests(self, context: SerializerContext, value: Any) -> dict[str, Any]:
-        return {"data": _to_bytes(value)}
-
-    def as_werkzeug(self, context: SerializerContext, value: Any) -> dict[str, Any]:
-        return {"data": _to_bytes(value)}
-
-
-def get_matching_media_types(media_type: str) -> Generator[str, None, None]:
-    """Get all registered media types matching the given media type."""
-    if media_type == "*/*":
-        # Shortcut to avoid comparing all values
-        yield from iter(SERIALIZERS)
-    else:
-        main, sub = parse_content_type(media_type)
-        if main == "application" and (sub == "json" or sub.endswith("+json")):
-            yield media_type
-        else:
-            for registered_media_type in SERIALIZERS:
-                target_main, target_sub = parse_content_type(registered_media_type)
-                if main in ("*", target_main) and sub in ("*", target_sub):
-                    yield registered_media_type
-
-
-def get_first_matching_media_type(media_type: str) -> str | None:
-    return next(get_matching_media_types(media_type), None)
-
-
-def get(media_type: str) -> type[Serializer] | None:
-    """Get an appropriate serializer for the given media type."""
-    if is_json_media_type(media_type):
-        media_type = "application/json"
-    if is_plain_text_media_type(media_type):
-        media_type = "text/plain"
-    if is_xml_media_type(media_type):
-        media_type = "application/xml"
-    return SERIALIZERS.get(media_type)

schemathesis/service/__init__.py

@@ -1,18 +0,0 @@
-from . import auth, ci, hosts
-from .constants import (
-    DEFAULT_HOSTNAME,
-    DEFAULT_HOSTS_PATH,
-    DEFAULT_PROTOCOL,
-    DEFAULT_URL,
-    HOSTNAME_ENV_VAR,
-    HOSTS_PATH_ENV_VAR,
-    PROTOCOL_ENV_VAR,
-    REPORT_ENV_VAR,
-    TELEMETRY_ENV_VAR,
-    TOKEN_ENV_VAR,
-    URL_ENV_VAR,
-    WORKER_CHECK_PERIOD,
-    WORKER_FINISH_TIMEOUT,
-)
-from .events import Completed, Error, Event, Failed, Metadata, Timeout
-from .report import FileReportHandler, ServiceReportHandler

schemathesis/service/auth.py

@@ -1,11 +0,0 @@
-from . import metadata
-from .constants import DEFAULT_HOSTNAME, DEFAULT_PROTOCOL
-
-
-def login(token: str, hostname: str = DEFAULT_HOSTNAME, protocol: str = DEFAULT_PROTOCOL, verify: bool = True) -> str:
-    from .client import ServiceClient
-
-    """Make a login request to SaaS."""
-    client = ServiceClient(f"{protocol}://{hostname}", token, verify=verify)
-    response = client.login(metadata=metadata.Metadata())
-    return response.username

schemathesis/service/ci.py

@@ -1,201 +0,0 @@
-from __future__ import annotations
-import enum
-import os
-from dataclasses import asdict, dataclass
-from typing import Protocol, runtime_checkable
-
-
-@enum.unique
-class CIProvider(enum.Enum):
-    """A set of supported CI providers."""
-
-    GITHUB = "github"
-    GITLAB = "gitlab"
-
-
-@runtime_checkable
-class Environment(Protocol):
-    provider: CIProvider
-    variable_name: str
-    verbose_name: str
-
-    @classmethod
-    def is_set(cls) -> bool:
-        pass
-
-    @classmethod
-    def from_env(cls) -> Environment:
-        pass
-
-    def asdict(self) -> dict[str, str | None]:
-        pass
-
-    def as_env(self) -> dict[str, str | None]:
-        pass
-
-
-def environment() -> Environment | None:
-    """Collect environment data for a supported CI provider."""
-    provider = detect()
-    if provider == CIProvider.GITHUB:
-        return GitHubActionsEnvironment.from_env()
-    if provider == CIProvider.GITLAB:
-        return GitLabCIEnvironment.from_env()
-    return None
-
-
-def detect() -> CIProvider | None:
-    """Detect the current CI provider."""
-    if GitHubActionsEnvironment.is_set():
-        return GitHubActionsEnvironment.provider
-    if GitLabCIEnvironment.is_set():
-        return GitLabCIEnvironment.provider
-    return None
-
-
-def _asdict(env: Environment) -> dict[str, str | None]:
-    data = asdict(env)  # type: ignore
-    data["provider"] = env.provider.value
-    return data
-
-
-@dataclass
-class GitHubActionsEnvironment:
-    """Useful data to capture from GitHub Actions environment."""
-
-    provider = CIProvider.GITHUB
-    variable_name = "GITHUB_ACTIONS"
-    verbose_name = "GitHub Actions"
-    asdict = _asdict
-
-    # GitHub API URL.
-    # For example, `https://api.github.com`
-    api_url: str
-    # The owner and repository name.
-    # For example, `schemathesis/schemathesis`.
-    repository: str
-    # The name of the person or app that initiated the workflow.
-    # For example, `Stranger6667`
-    actor: str
-    # The commit SHA that triggered the workflow.
-    # For example, `e56e13224f08469841e106449f6467b769e2afca`
-    sha: str
-    # A unique number for each workflow run within a repository.
-    # For example, `1658821493`.
-    run_id: str
-    # The name of the workflow.
-    # For example, `My test workflow`.
-    workflow: str
-    # The head ref or source branch of the pull request in a workflow run.
-    # For example, `dd/report-ci`.
-    head_ref: str | None
-    # The name of the base ref or target branch of the pull request in a workflow run.
-    # For example, `main`.
-    base_ref: str | None
-    # The branch or tag ref that triggered the workflow run.
-    # This is only set if a branch or tag is available for the event type.
-    # For example, `refs/pull/1533/merge`
-    ref: str | None
-    # The Schemathesis GitHub Action version.
-    # For example `v1.0.1`
-    action_ref: str | None
-
-    @classmethod
-    def is_set(cls) -> bool:
-        return os.getenv(cls.variable_name) == "true"
-
-    @classmethod
-    def from_env(cls) -> GitHubActionsEnvironment:
-        return cls(
-            api_url=os.environ["GITHUB_API_URL"],
-            repository=os.environ["GITHUB_REPOSITORY"],
-            actor=os.environ["GITHUB_ACTOR"],
-            sha=os.environ["GITHUB_SHA"],
-            run_id=os.environ["GITHUB_RUN_ID"],
-            workflow=os.environ["GITHUB_WORKFLOW"],
-            head_ref=os.getenv("GITHUB_HEAD_REF"),
-            base_ref=os.getenv("GITHUB_BASE_REF"),
-            ref=os.getenv("GITHUB_REF"),
-            action_ref=os.getenv("SCHEMATHESIS_ACTION_REF"),
-        )
-
-    def as_env(self) -> dict[str, str | None]:
-        return {
-            "GITHUB_API_URL": self.api_url,
-            "GITHUB_REPOSITORY": self.repository,
-            "GITHUB_ACTOR": self.actor,
-            "GITHUB_SHA": self.sha,
-            "GITHUB_RUN_ID": self.run_id,
-            "GITHUB_WORKFLOW": self.workflow,
-            "GITHUB_HEAD_REF": self.head_ref,
-            "GITHUB_BASE_REF": self.base_ref,
-            "GITHUB_REF": self.ref,
-            "SCHEMATHESIS_ACTION_REF": self.action_ref,
-        }
-
-
-@dataclass
-class GitLabCIEnvironment:
-    """Useful data to capture from GitLab CI environment."""
-
-    provider = CIProvider.GITLAB
-    variable_name = "GITLAB_CI"
-    verbose_name = "GitLab CI"
-    asdict = _asdict
-
-    # GitLab API URL
-    # For example, `https://gitlab.com/api/v4`
-    api_v4_url: str
-    # The ID of the current project.
-    # For example, `12345678`
-    project_id: str
-    # The username of the user who started the job.
-    # For example, `Stranger6667`
-    user_login: str
-    # The commit revision the project is built for.
-    # For example, `e56e13224f08469841e106449f6467b769e2afca`
-    commit_sha: str
-    # NOTE: `commit_branch` and `merge_request_source_branch_name` may mean the same thing, but they are available
-    # in different context. There are also a couple of `CI_BUILD_*` variables that could be used, but they are
-    # not documented.
-    # The commit branch name. Not available in merge request pipelines or tag pipelines.
-    # For example, `dd/report-ci`.
-    commit_branch: str | None
-    # The source branch name of the merge request. Only available in merge request pipelines.
-    # For example, `dd/report-ci`.
-    merge_request_source_branch_name: str | None
-    # The target branch name of the merge request.
-    # For example, `main`.
-    merge_request_target_branch_name: str | None
-    # The project-level internal ID of the merge request.
-    # For example, `42`.
-    merge_request_iid: str | None
-
-    @classmethod
-    def is_set(cls) -> bool:
-        return os.getenv(cls.variable_name) == "true"
-
-    @classmethod
-    def from_env(cls) -> GitLabCIEnvironment:
-        return cls(
-            api_v4_url=os.environ["CI_API_V4_URL"],
-            project_id=os.environ["CI_PROJECT_ID"],
-            user_login=os.environ["GITLAB_USER_LOGIN"],
-            commit_sha=os.environ["CI_COMMIT_SHA"],
-            commit_branch=os.getenv("CI_COMMIT_BRANCH"),
-            merge_request_source_branch_name=os.getenv("CI_MERGE_REQUEST_SOURCE_BRANCH_NAME"),
-            merge_request_target_branch_name=os.getenv("CI_MERGE_REQUEST_TARGET_BRANCH_NAME"),
-            merge_request_iid=os.getenv("CI_MERGE_REQUEST_IID"),
-        )
-
-    def as_env(self) -> dict[str, str | None]:
-        return {
-            "CI_API_V4_URL": self.api_v4_url,
-            "CI_PROJECT_ID": self.project_id,
-            "GITLAB_USER_LOGIN": self.user_login,
-            "CI_COMMIT_SHA": self.commit_sha,
-            "CI_COMMIT_BRANCH": self.commit_branch,
-            "CI_MERGE_REQUEST_SOURCE_BRANCH_NAME": self.merge_request_source_branch_name,
-            "CI_MERGE_REQUEST_TARGET_BRANCH_NAME": self.merge_request_target_branch_name,
-            "CI_MERGE_REQUEST_IID": self.merge_request_iid,
-        }

schemathesis/service/client.py

@@ -1,100 +0,0 @@
-from __future__ import annotations
-import hashlib
-import http
-from dataclasses import asdict
-from typing import Any
-from urllib.parse import urljoin
-
-import requests
-from requests.adapters import HTTPAdapter, Retry
-
-from ..constants import USER_AGENT
-from .ci import CIProvider
-from .constants import CI_PROVIDER_HEADER, REPORT_CORRELATION_ID_HEADER, REQUEST_TIMEOUT, UPLOAD_SOURCE_HEADER
-from .metadata import Metadata
-from .models import (
-    ProjectDetails,
-    AuthResponse,
-    FailedUploadResponse,
-    UploadResponse,
-    UploadSource,
-    ProjectEnvironment,
-    Specification,
-)
-
-
-def response_hook(response: requests.Response, **_kwargs: Any) -> None:
-    if response.status_code != http.HTTPStatus.REQUEST_ENTITY_TOO_LARGE:
-        response.raise_for_status()
-
-
-class ServiceClient(requests.Session):
-    """A more convenient session to send requests to Schemathesis.io."""
-
-    def __init__(self, base_url: str, token: str | None, *, timeout: int = REQUEST_TIMEOUT, verify: bool = True):
-        super().__init__()
-        self.timeout = timeout
-        self.verify = verify
-        self.base_url = base_url
-        self.headers["User-Agent"] = USER_AGENT
-        if token is not None:
-            self.headers["Authorization"] = f"Bearer {token}"
-        # Automatically check responses for 4XX and 5XX
-        self.hooks["response"] = [response_hook]  # type: ignore
-        adapter = HTTPAdapter(max_retries=Retry(5))
-        self.mount("https://", adapter)
-        self.mount("http://", adapter)
-
-    def request(self, method: str, url: str, *args: Any, **kwargs: Any) -> requests.Response:  # type: ignore
-        kwargs.setdefault("timeout", self.timeout)
-        kwargs.setdefault("verify", self.verify)
-        # All requests will be done against the base url
-        url = urljoin(self.base_url, url)
-        return super().request(method, url, *args, **kwargs)
-
-    def get_api_details(self, name: str) -> ProjectDetails:
-        """Get information about an API."""
-        response = self.get(f"/cli/projects/{name}/")
-        data = response.json()
-        return ProjectDetails(
-            environments=[
-                ProjectEnvironment(
-                    url=environment["url"],
-                    name=environment["name"],
-                    description=environment["description"],
-                    is_default=environment["is_default"],
-                )
-                for environment in data["environments"]
-            ],
-            specification=Specification(schema=data["specification"]["schema"]),
-        )
-
-    def login(self, metadata: Metadata) -> AuthResponse:
-        """Send a login request."""
-        response = self.post("/auth/cli/login/", json={"metadata": asdict(metadata)})
-        data = response.json()
-        return AuthResponse(username=data["username"])
-
-    def upload_report(
-        self,
-        report: bytes,
-        correlation_id: str | None = None,
-        ci_provider: CIProvider | None = None,
-        source: UploadSource = UploadSource.DEFAULT,
-    ) -> UploadResponse | FailedUploadResponse:
-        """Upload test run report to Schemathesis.io."""
-        headers = {
-            "Content-Type": "application/x-gtar",
-            "X-Checksum-Blake2s256": hashlib.blake2s(report).hexdigest(),
-            UPLOAD_SOURCE_HEADER: source.value,
-        }
-        if correlation_id is not None:
-            headers[REPORT_CORRELATION_ID_HEADER] = correlation_id
-        if ci_provider is not None:
-            headers[CI_PROVIDER_HEADER] = ci_provider.value
-        # Do not limit the upload timeout
-        response = self.post("/reports/upload/", report, headers=headers, timeout=None)
-        data = response.json()
-        if response.status_code == http.HTTPStatus.REQUEST_ENTITY_TOO_LARGE:
-            return FailedUploadResponse(detail=data["detail"])
-        return UploadResponse(message=data["message"], next_url=data["next"], correlation_id=data["correlation_id"])

schemathesis/service/constants.py

@@ -1,38 +0,0 @@
-import os
-import pathlib
-
-IS_CI = os.getenv("CI") == "true"
-
-DEFAULT_HOSTNAME = "api.schemathesis.io"
-# The main Schemathesis.io API address
-DEFAULT_URL = f"https://{DEFAULT_HOSTNAME}/"
-DEFAULT_PROTOCOL = "https"
-# An HTTP header name to store report correlation id
-REPORT_CORRELATION_ID_HEADER = "X-Schemathesis-Report-Correlation-Id"
-CI_PROVIDER_HEADER = "X-Schemathesis-CI-Provider"
-UPLOAD_SOURCE_HEADER = "X-Schemathesis-Upload-Source"
-# A sentinel to signal the worker thread to stop
-STOP_MARKER = object()
-# Timeout for each API call
-REQUEST_TIMEOUT = 1
-# The time the main thread will wait for the worker thread to finish its job before exiting
-WORKER_FINISH_TIMEOUT = 10.0
-# A period between checking the worker thread for events
-# Decrease the frequency for CI environment to avoid too much output from the waiting spinner
-WORKER_CHECK_PERIOD = 0.1 if IS_CI else 0.005
-# Wait until the worker terminates
-WORKER_JOIN_TIMEOUT = 10
-# Version of the hosts file format
-HOSTS_FORMAT_VERSION = "0.1"
-# Upload report version
-REPORT_FORMAT_VERSION = "1"
-# Default path to the hosts file
-DEFAULT_HOSTS_PATH = pathlib.Path.home() / ".config/schemathesis/hosts.toml"
-TOKEN_ENV_VAR = "SCHEMATHESIS_TOKEN"
-HOSTNAME_ENV_VAR = "SCHEMATHESIS_HOSTNAME"
-PROTOCOL_ENV_VAR = "SCHEMATHESIS_PROTOCOL"
-HOSTS_PATH_ENV_VAR = "SCHEMATHESIS_HOSTS_PATH"
-URL_ENV_VAR = "SCHEMATHESIS_URL"
-REPORT_ENV_VAR = "SCHEMATHESIS_REPORT"
-TELEMETRY_ENV_VAR = "SCHEMATHESIS_TELEMETRY"
-DOCKER_IMAGE_ENV_VAR = "SCHEMATHESIS_DOCKER_IMAGE"