schemathesis 3.15.4__py3-none-any.whl → 4.4.2__py3-none-any.whl

schemathesis/utils.py

@@ -1,475 +0,0 @@
-import cgi
-import functools
-import pathlib
-import re
-import sys
-import traceback
-import warnings
-from contextlib import contextmanager
-from copy import copy, deepcopy
-from inspect import getfullargspec
-from json import JSONDecodeError
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Generator,
-    Generic,
-    List,
-    NoReturn,
-    Optional,
-    Set,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-    overload,
-)
-
-import pytest
-import requests
-import yaml
-import yarl
-from hypothesis.core import is_invalid_test
-from hypothesis.reporting import with_reporter
-from hypothesis.strategies import SearchStrategy
-from requests.auth import HTTPDigestAuth
-from requests.exceptions import InvalidHeader  # type: ignore
-from requests.utils import check_header_validity  # type: ignore
-from werkzeug.wrappers import Response as BaseResponse
-
-from ._compat import InferType, JSONMixin
-from .constants import USER_AGENT, DataGenerationMethod
-from .exceptions import UsageError
-from .types import DataGenerationMethodInput, Filter, GenericTest, NotSet, RawAuth
-
-try:
-    from yaml import CSafeLoader as SafeLoader
-except ImportError:
-    # pylint: disable=unused-import
-    from yaml import SafeLoader  # type: ignore
-
-
-NOT_SET = NotSet()
-
-
-def file_exists(path: str) -> bool:
-    try:
-        return pathlib.Path(path).is_file()
-    except OSError:
-        # For example, path could be too long
-        return False
-
-
-def is_latin_1_encodable(value: str) -> bool:
-    """Header values are encoded to latin-1 before sending."""
-    try:
-        value.encode("latin-1")
-        return True
-    except UnicodeEncodeError:
-        return False
-
-
-# Adapted from http.client._is_illegal_header_value
-INVALID_HEADER_RE = re.compile(r"\n(?![ \t])|\r(?![ \t\n])")  # pragma: no mutate
-
-
-def has_invalid_characters(name: str, value: str) -> bool:
-    try:
-        check_header_validity((name, value))
-        return bool(INVALID_HEADER_RE.search(value))
-    except InvalidHeader:
-        return True
-
-
-def is_schemathesis_test(func: Callable) -> bool:
-    """Check whether test is parametrized with schemathesis."""
-    try:
-        from .schemas import BaseSchema  # pylint: disable=import-outside-toplevel
-
-        item = getattr(func, PARAMETRIZE_MARKER, None)
-        # Comparison is needed to avoid false-positives when mocks are collected by pytest
-        return isinstance(item, BaseSchema)
-    except Exception:
-        return False
-
-
-def fail_on_no_matches(node_id: str) -> NoReturn:  # type: ignore
-    pytest.fail(f"Test function {node_id} does not match any API operations and therefore has no effect")
-
-
-def force_tuple(item: Filter) -> Union[List, Set, Tuple]:
-    if not isinstance(item, (list, set, tuple)):
-        return (item,)
-    return item
-
-
-def dict_true_values(**kwargs: Any) -> Dict[str, Any]:
-    """Create a dict with given kwargs while skipping items where bool(value) evaluates to False."""
-    return {key: value for key, value in kwargs.items() if bool(value)}
-
-
-def dict_not_none_values(**kwargs: Any) -> Dict[str, Any]:
-    return {key: value for key, value in kwargs.items() if value is not None}
-
-
-IGNORED_PATTERNS = (
-    "Falsifying example: ",
-    "Falsifying explicit example: ",
-    "You can add @seed",
-    "Failed to reproduce exception. Expected:",
-    "Flaky example!",
-    "Traceback (most recent call last):",
-    "You can reproduce this example by temporarily",
-    "Unreliable test timings",
-)
-
-
-@contextmanager
-def capture_hypothesis_output() -> Generator[List[str], None, None]:
-    """Capture all output of Hypothesis into a list of strings.
-
-    It allows us to have more granular control over Schemathesis output.
-
-    Usage::
-
-        @given(i=st.integers())
-        def test(i):
-            assert 0
-
-        with capture_hypothesis_output() as output:
-            test()  # hypothesis test
-            # output == ["Falsifying example: test(i=0)"]
-    """
-    output = []
-
-    def get_output(value: str) -> None:
-        # Drop messages that could be confusing in the Schemathesis context
-        if value.startswith(IGNORED_PATTERNS):
-            return
-        output.append(value)
-
-    # the following context manager is untyped
-    with with_reporter(get_output):  # type: ignore
-        yield output
-
-
-def format_exception(error: Exception, include_traceback: bool = False) -> str:
-    """Format exception as text."""
-    error_type = type(error)
-    if include_traceback:
-        lines = traceback.format_exception(error_type, error, error.__traceback__)
-    else:
-        lines = traceback.format_exception_only(error_type, error)
-    return "".join(lines)
-
-
-def parse_content_type(content_type: str) -> Tuple[str, str]:
-    """Parse Content Type and return main type and subtype."""
-    try:
-        content_type, _ = cgi.parse_header(content_type)
-        main_type, sub_type = content_type.split("/", 1)
-    except ValueError as exc:
-        raise ValueError(f"Malformed media type: `{content_type}`") from exc
-    return main_type.lower(), sub_type.lower()
-
-
-def is_json_media_type(value: str) -> bool:
-    """Detect whether the content type is JSON-compatible.
-
-    For example - ``application/problem+json`` matches.
-    """
-    main, sub = parse_content_type(value)
-    return main == "application" and (sub == "json" or sub.endswith("+json"))
-
-
-def is_plain_text_media_type(value: str) -> bool:
-    """Detect variations of the ``text/plain`` media type."""
-    return parse_content_type(value) == ("text", "plain")
-
-
-def make_loader(*tags_to_remove: str) -> Type[yaml.SafeLoader]:
-    """Create a YAML loader, that doesn't parse specific tokens into Python objects."""
-    cls: Type[yaml.SafeLoader] = type("YAMLLoader", (SafeLoader,), {})
-    cls.yaml_implicit_resolvers = {
-        key: [(tag, regexp) for tag, regexp in mapping if tag not in tags_to_remove]
-        for key, mapping in cls.yaml_implicit_resolvers.copy().items()
-    }
-
-    # Fix pyyaml scientific notation parse bug
-    # See PR: https://github.com/yaml/pyyaml/pull/174 for upstream fix
-    cls.add_implicit_resolver(  # type: ignore
-        "tag:yaml.org,2002:float",
-        re.compile(
-            r"""^(?:[-+]?(?:[0-9][0-9_]*)\.[0-9_]*(?:[eE][-+]?[0-9]+)?
-                       |[-+]?(?:[0-9][0-9_]*)(?:[eE][-+]?[0-9]+)
-                       |\.[0-9_]+(?:[eE][-+]?[0-9]+)?
-                       |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*
-                       |[-+]?\.(?:inf|Inf|INF)
-                       |\.(?:nan|NaN|NAN))$""",
-            re.X,
-        ),
-        list("-+0123456789."),
-    )
-
-    def construct_mapping(self: SafeLoader, node: yaml.Node, deep: bool = False) -> Dict[str, Any]:
-        if isinstance(node, yaml.MappingNode):
-            self.flatten_mapping(node)  # type: ignore
-        mapping = {}
-        for key_node, value_node in node.value:
-            # If the key has a tag different from `str` - use its string value.
-            # With this change all integer keys or YAML 1.1 boolean-ish values like "on" / "off" will not be cast to
-            # a different type
-            if key_node.tag != "tag:yaml.org,2002:str":
-                key = key_node.value
-            else:
-                key = self.construct_object(key_node, deep)  # type: ignore
-            mapping[key] = self.construct_object(value_node, deep)  # type: ignore
-        return mapping
-
-    cls.construct_mapping = construct_mapping  # type: ignore
-    return cls
-
-
-StringDatesYAMLLoader = make_loader("tag:yaml.org,2002:timestamp")
-
-
-class WSGIResponse(BaseResponse, JSONMixin):  # pylint: disable=too-many-ancestors
-    # We store "requests" request to build a reproduction code
-    request: requests.PreparedRequest
-
-    def on_json_loading_failed(self, e: JSONDecodeError) -> NoReturn:
-        # We don't need a werkzeug-specific exception when JSON parsing error happens
-        raise e
-
-
-def get_requests_auth(auth: Optional[RawAuth], auth_type: Optional[str]) -> Optional[Union[HTTPDigestAuth, RawAuth]]:
-    if auth and auth_type == "digest":
-        return HTTPDigestAuth(*auth)
-    return auth
-
-
-GenericResponse = Union[requests.Response, WSGIResponse]  # pragma: no mutate
-
-
-def copy_response(response: GenericResponse) -> GenericResponse:
-    """Create a copy of the given response as far as it makes sense."""
-    if isinstance(response, requests.Response):
-        copied_response = deepcopy(response)
-        setattr(copied_response, "raw", response.raw)
-        return copied_response
-    # Can't deepcopy WSGI response due to generators inside (`response.freeze` doesn't completely help)
-    response.freeze()
-    copied_response = copy(response)
-    copied_response.request = deepcopy(response.request)
-    return copied_response
-
-
-def get_response_payload(response: GenericResponse) -> str:
-    if isinstance(response, requests.Response):
-        return response.text
-    return response.get_data(as_text=True)
-
-
-def import_app(path: str) -> Any:
-    """Import an application from a string."""
-    path, name = (re.split(r":(?![\\/])", path, 1) + [""])[:2]
-    __import__(path)
-    # accessing the module from sys.modules returns a proper module, while `__import__`
-    # may return a parent module (system dependent)
-    module = sys.modules[path]
-    return getattr(module, name)
-
-
-Schema = Union[Dict[str, Any], List, str, float, int]
-
-
-@overload
-def traverse_schema(schema: Dict[str, Any], callback: Callable, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-    pass
-
-
-@overload
-def traverse_schema(schema: List, callback: Callable, *args: Any, **kwargs: Any) -> List:
-    pass
-
-
-@overload
-def traverse_schema(schema: str, callback: Callable, *args: Any, **kwargs: Any) -> str:
-    pass
-
-
-@overload
-def traverse_schema(schema: float, callback: Callable, *args: Any, **kwargs: Any) -> float:
-    pass
-
-
-def traverse_schema(schema: Schema, callback: Callable[..., Dict[str, Any]], *args: Any, **kwargs: Any) -> Schema:
-    """Apply callback recursively to the given schema."""
-    if isinstance(schema, dict):
-        schema = callback(schema, *args, **kwargs)
-        for key, sub_item in schema.items():
-            schema[key] = traverse_schema(sub_item, callback, *args, **kwargs)
-    elif isinstance(schema, list):
-        schema = [traverse_schema(sub_item, callback, *args, **kwargs) for sub_item in schema]
-    return schema
-
-
-def _warn_deprecation(*, thing: str, removed_in: str, replacement: str) -> None:
-    warnings.warn(
-        f"Property `{thing}` is deprecated and will be removed in Schemathesis {removed_in}. "
-        f"Use `{replacement}` instead.",
-        DeprecationWarning,
-    )
-
-
-def deprecated_property(*, removed_in: str, replacement: str) -> Callable:
-    def wrapper(prop: Callable) -> Callable:
-        @property  # type: ignore
-        def inner(self: Any) -> Any:
-            _warn_deprecation(thing=prop.__name__, removed_in=removed_in, replacement=replacement)
-            return prop(self)
-
-        return inner
-
-    return wrapper
-
-
-def deprecated(*, removed_in: str, replacement: str) -> Callable:
-    def wrapper(func: Callable) -> Callable:
-        def inner(*args: Any, **kwargs: Any) -> Any:
-            _warn_deprecation(thing=func.__name__, removed_in=removed_in, replacement=replacement)
-            return func(*args, **kwargs)
-
-        return inner
-
-    return wrapper
-
-
-def setup_headers(kwargs: Dict[str, Any]) -> None:
-    headers = kwargs.setdefault("headers", {})
-    if "user-agent" not in {header.lower() for header in headers}:
-        kwargs["headers"]["User-Agent"] = USER_AGENT
-
-
-def require_relative_url(url: str) -> None:
-    """Raise an error if the URL is not relative."""
-    if yarl.URL(url).is_absolute():
-        raise ValueError("Schema path should be relative for WSGI/ASGI loaders")
-
-
-T = TypeVar("T")
-E = TypeVar("E", bound=Exception)
-
-
-class Ok(Generic[T]):
-    __slots__ = ("_value",)
-
-    def __init__(self, value: T):
-        self._value = value
-
-    def ok(self) -> T:
-        return self._value
-
-
-class Err(Generic[E]):
-    __slots__ = ("_error",)
-
-    def __init__(self, error: E):
-        self._error = error
-
-    def err(self) -> E:
-        return self._error
-
-
-Result = Union[Ok[T], Err[E]]
-GivenInput = Union[SearchStrategy, InferType]
-PARAMETRIZE_MARKER = "_schemathesis_test"
-GIVEN_ARGS_MARKER = "_schemathesis_given_args"
-GIVEN_KWARGS_MARKER = "_schemathesis_given_kwargs"
-
-
-def get_given_args(func: GenericTest) -> Tuple:
-    return getattr(func, GIVEN_ARGS_MARKER, ())
-
-
-def get_given_kwargs(func: GenericTest) -> Dict[str, Any]:
-    return getattr(func, GIVEN_KWARGS_MARKER, {})
-
-
-def is_given_applied(func: GenericTest) -> bool:
-    return hasattr(func, GIVEN_ARGS_MARKER) or hasattr(func, GIVEN_KWARGS_MARKER)
-
-
-def given_proxy(*args: GivenInput, **kwargs: GivenInput) -> Callable[[GenericTest], GenericTest]:
-    """Proxy Hypothesis strategies to ``hypothesis.given``."""
-
-    def wrapper(func: GenericTest) -> GenericTest:
-        if hasattr(func, GIVEN_ARGS_MARKER):
-
-            def wrapped_test(*_: Any, **__: Any) -> NoReturn:
-                raise UsageError(
-                    f"You have applied `given` to the `{func.__name__}` test more than once, which "
-                    "overrides the previous decorator. You need to pass all arguments to the same `given` call."
-                )
-
-            return wrapped_test
-
-        setattr(func, GIVEN_ARGS_MARKER, args)
-        setattr(func, GIVEN_KWARGS_MARKER, kwargs)
-        return func
-
-    return wrapper
-
-
-def merge_given_args(func: GenericTest, args: Tuple, kwargs: Dict[str, Any]) -> Dict[str, Any]:
-    """Merge positional arguments to ``@schema.given`` into a dictionary with keyword arguments.
-
-    Kwargs are modified inplace.
-    """
-    if args:
-        argspec = getfullargspec(func)
-        for name, strategy in zip(reversed([arg for arg in argspec.args if arg != "case"]), reversed(args)):
-            kwargs[name] = strategy
-    return kwargs
-
-
-def validate_given_args(func: GenericTest, args: Tuple, kwargs: Dict[str, Any]) -> Optional[Callable]:
-    argspec = getfullargspec(func)
-    return is_invalid_test(func, argspec, args, kwargs)  # type: ignore
-
-
-def compose(*functions: Callable) -> Callable:
-    """Compose multiple functions into a single one."""
-
-    def noop(x: Any) -> Any:
-        return x
-
-    return functools.reduce(lambda f, g: lambda x: f(g(x)), functions, noop)
-
-
-def maybe_set_assertion_message(exc: AssertionError, check_name: str) -> str:
-    message = str(exc)
-    if not message:
-        message = f"Check '{check_name}' failed"
-        exc.args = (message,)
-    return message
-
-
-def prepare_data_generation_methods(data_generation_methods: DataGenerationMethodInput) -> List[DataGenerationMethod]:
-    if isinstance(data_generation_methods, DataGenerationMethod):
-        return [data_generation_methods]
-    return list(data_generation_methods)
-
-
-def merge(a: Dict[str, Any], b: Dict[str, Any]) -> Dict[str, Any]:
-    """Merge two dictionaries recursively."""
-    for key in b:
-        if key in a:
-            if isinstance(a[key], dict) and isinstance(b[key], dict):
-                merge(a[key], b[key])
-            else:
-                a[key] = b[key]
-        else:
-            a[key] = b[key]
-    return a

schemathesis-3.15.4.dist-info/METADATA

@@ -1,202 +0,0 @@
-Metadata-Version: 2.1
-Name: schemathesis
-Version: 3.15.4
-Summary: Property-based testing framework for Open API and GraphQL based apps
-Home-page: https://github.com/schemathesis/schemathesis
-License: MIT
-Keywords: pytest,hypothesis,openapi,swagger,graphql,testing
-Author: Dmitry Dygalo
-Author-email: dadygalo@gmail.com
-Maintainer: Dmitry Dygalo
-Maintainer-email: dadygalo@gmail.com
-Requires-Python: >=3.7,<4.0
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Console
-Classifier: Framework :: Hypothesis
-Classifier: Framework :: Pytest
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Topic :: Software Development :: Testing
-Requires-Dist: PyYAML (>=5.1,<7.0)
-Requires-Dist: attrs (>=19.2,<=21.4)
-Requires-Dist: click (>=7.0,<9.0)
-Requires-Dist: colorama (>=0.4,<0.5)
-Requires-Dist: curlify (>=2.2.1,<3.0.0)
-Requires-Dist: hypothesis (>=6.13.3,<7.0.0)
-Requires-Dist: hypothesis_graphql (>=0.9.0,<0.10.0)
-Requires-Dist: hypothesis_jsonschema (>=0.22.0,<0.23.0)
-Requires-Dist: importlib_metadata (>=1.1,!=3.8,<5); python_version < "3.8"
-Requires-Dist: jsonschema (>=4.3.2,<5.0.0)
-Requires-Dist: junit-xml (>=1.9,<2.0)
-Requires-Dist: pytest (>4.6.4,<8)
-Requires-Dist: pytest-subtests (>=0.2.1,<0.8.0)
-Requires-Dist: requests (>=2.22,<2.28.0)
-Requires-Dist: starlette (>=0.13,<1)
-Requires-Dist: tomli (>=2.0.1,<3.0.0)
-Requires-Dist: tomli-w (>=1.0.0,<2.0.0)
-Requires-Dist: typing-extensions (>=3.7,<5)
-Requires-Dist: werkzeug (>=0.16.0,<2.2)
-Requires-Dist: yarl (>=1.5,<2.0)
-Project-URL: Change Log, https://github.com/schemathesis/schemathesis/blob/master/docs/changelog.rst
-Project-URL: Documentation, https://schemathesis.readthedocs.io/en/stable/
-Project-URL: Funding, https://github.com/sponsors/Stranger6667
-Project-URL: Repository, https://github.com/schemathesis/schemathesis
-Project-URL: Source Code, https://github.com/schemathesis/schemathesis
-Description-Content-Type: text/x-rst
-
-Schemathesis
-============
-
-|Build| |Coverage| |Version| |Python versions| |Docs| |Chat| |License|
-
-Schemathesis is a modern API testing tool for web applications built with Open API and GraphQL specifications.
-
-It reads the application schema and generates test cases, which will ensure that your application is compliant with its schema (read more about how it works in `our research paper <https://arxiv.org/abs/2112.10328>`_).
-
-The application under test could be written in any language; the only thing you need is a valid API schema in a supported format.
-
-Simple to use and yet powerful to uncover hard-to-find errors thanks to the property-based testing approach backed by state-of-the-art `Hypothesis <http://hypothesis.works/>`_ library.
-
-🚀 Schemathesis is available as a `service <https://schemathesis.io/?utm_source=github>`_, standalone CLI, or a Python library 🚀
-
-The service enables you to verify your API schema in a few clicks, CLI gives more control.
-Schemathesis.io has a free tier, so you can combine the CLI flexibility with rich visuals by uploading your test results there.
-
-`Signup to reveal all issues on a dashboard <https://app.schemathesis.io/auth/sign-up/?utm_source=oss_readme>`_.
-
-Features
---------
-
-- Content-Type, schema, and status code conformance checks for Open API;
-- Testing of explicit examples from the input schema;
-- Stateful testing via Open API links;
-- Concurrent test execution;
-- Targeted testing;
-- Storing and replaying network requests;
-- Built-in ASGI / WSGI application support;
-- Code samples for easy failure reproduction;
-- Ready-to-go Docker image;
-- Configurable with user-defined checks, string formats, hooks, and targets.
-
-CLI installation
-----------------
-
-To install Schemathesis via ``pip`` run the following command:
-
-.. code:: bash
-
-    pip install schemathesis
-
-This command installs the ``schemathesis`` entrypoint + ``st`` as its alias.
-
-You can also use our Docker image without installing Schemathesis as a Python package.
-
-Usage
------
-
-You can use Schemathesis in the command line directly (``st`` is an alias to ``schemathesis``):
-
-.. code:: bash
-
-  st run --checks all https://example.schemathesis.io/openapi.json
-
-Or via Docker:
-
-.. code:: bash
-
-  docker run schemathesis/schemathesis:stable \
-      run --checks all https://example.schemathesis.io/openapi.json
-
-.. image:: https://raw.githubusercontent.com/schemathesis/schemathesis/master/img/schemathesis.gif
-
-Or in your Python tests:
-
-.. code:: python
-
-    import schemathesis
-
-    schema = schemathesis.from_uri("https://example.schemathesis.io/openapi.json")
-
-
-    @schema.parametrize()
-    def test_api(case):
-        case.call_and_validate()
-
-CLI is simple to use and requires no coding; the in-code approach gives more flexibility.
-
-Both examples above will run hundreds of requests against the API under test and report all found failures and inconsistencies along with instructions to reproduce them.
-
-💡 See a complete working example project in the ``/example`` directory. 💡
-
-Contributing
-------------
-
-Any contribution to development, testing, or any other area is highly appreciated and useful to the project.
-For guidance on how to contribute to Schemathesis, see the `contributing guidelines <https://github.com/schemathesis/schemathesis/blob/master/CONTRIBUTING.rst>`_.
-
-Support this project
---------------------
-
-Hi, my name is Dmitry! I started this project during my work at `Kiwi.com <https://kiwi.com/>`_. I am grateful to them for all the support they
-provided to this project during its early days and for the opportunity to evolve Schemathesis independently.
-
-In order to grow the community of contributors and users, and allow me to devote more time to this project, please `donate today <https://github.com/sponsors/Stranger6667>`_.
-
-Also, I occasionally write posts about Schemathesis in `my blog <https://dygalo.dev/>`_.
-
-Links
------
-
-- **Documentation**: https://schemathesis.readthedocs.io/en/stable/
-- **Releases**: https://pypi.org/project/schemathesis/
-- **Code**: https://github.com/schemathesis/schemathesis
-- **Issue tracker**: https://github.com/schemathesis/schemathesis/issues
-- **Chat**: https://discord.gg/R9ASRAmHnA
-
-Additional content:
-
-- Research paper: `Deriving Semantics-Aware Fuzzers from Web API Schemas <https://arxiv.org/abs/2112.10328>`_ by **@Zac-HD** and **@Stranger6667**
-- `An article <https://dygalo.dev/blog/schemathesis-property-based-testing-for-api-schemas/>`_ about Schemathesis by **@Stranger6667**
-- `Effective API schemas testing <https://youtu.be/VVLZ25JgjD4>`_ from DevConf.cz by **@Stranger6667**
-- `A video <https://www.youtube.com/watch?v=9FHRwrv-xuQ>`_ from EuroPython 2020 by **@hultner**
-- `Schemathesis tutorial <https://appdev.consulting.redhat.com/tracks/contract-first/automated-testing-with-schemathesis.html>`_  with an accompanying `video <https://www.youtube.com/watch?v=4r7OC-lBKMg>`_ by Red Hat
-- `Using Hypothesis and Schemathesis to Test FastAPI <https://testdriven.io/blog/fastapi-hypothesis/>`_ by **@amalshaji**
-
-Non-English content:
-
-- `A tutorial <https://habr.com/ru/company/oleg-bunin/blog/576496/>`_ (RUS) about Schemathesis by **@Stranger6667**
-
-License
--------
-
-The code in this project is licensed under `MIT license`_.
-By contributing to Schemathesis, you agree that your contributions will be licensed under its MIT license.
-
-.. |Build| image:: https://github.com/schemathesis/schemathesis/workflows/build/badge.svg
-   :target: https://github.com/schemathesis/schemathesis/actions
-.. |Coverage| image:: https://codecov.io/gh/schemathesis/schemathesis/branch/master/graph/badge.svg
-   :target: https://codecov.io/gh/schemathesis/schemathesis/branch/master
-   :alt: codecov.io status for master branch
-.. |Version| image:: https://img.shields.io/pypi/v/schemathesis.svg
-   :target: https://pypi.org/project/schemathesis/
-.. |Python versions| image:: https://img.shields.io/pypi/pyversions/schemathesis.svg
-   :target: https://pypi.org/project/schemathesis/
-.. |License| image:: https://img.shields.io/pypi/l/schemathesis.svg
-   :target: https://opensource.org/licenses/MIT
-.. |Chat| image:: https://img.shields.io/discord/938139740912369755
-   :target: https://discord.gg/R9ASRAmHnA
-   :alt: Discord
-.. |Docs| image:: https://readthedocs.org/projects/schemathesis/badge/?version=stable
-   :target: https://schemathesis.readthedocs.io/en/stable/?badge=stable
-   :alt: Documentation Status
-
-.. _MIT license: https://opensource.org/licenses/MIT
-