schemathesis 3.39.7__py3-none-any.whl → 4.0.0a2__py3-none-any.whl

schemathesis/internal/transformation.py

@@ -1,26 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from ..constants import FALSE_VALUES, TRUE_VALUES
-
-
-def merge_recursively(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_recursively(a[key], b[key])
-            else:
-                a[key] = b[key]
-        else:
-            a[key] = b[key]
-    return a
-
-
-def convert_boolean_string(value: str) -> str | bool:
-    if value.lower() in TRUE_VALUES:
-        return True
-    if value.lower() in FALSE_VALUES:
-        return False
-    return value

schemathesis/internal/validation.py

@@ -1,34 +0,0 @@
-import pathlib
-import re
-from typing import Any
-
-
-def require_relative_url(url: str) -> None:
-    """Raise an error if the URL is not relative."""
-    from yarl import URL
-
-    if URL(url).is_absolute():
-        raise ValueError("Schema path should be relative for WSGI/ASGI loaders")
-
-
-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_filename(value: str) -> bool:
-    """Detect if the input string is a filename by checking its extension."""
-    return bool(pathlib.Path(value).suffix)
-
-
-SURROGATE_PAIR_RE = re.compile(r"[\ud800-\udfff]")
-has_surrogate_pair = SURROGATE_PAIR_RE.search
-
-
-def is_illegal_surrogate(item: Any) -> bool:
-    if isinstance(item, list):
-        return any(isinstance(item_, str) and bool(has_surrogate_pair(item_)) for item_ in item)
-    return isinstance(item, str) and bool(has_surrogate_pair(item))

schemathesis/lazy.py

@@ -1,474 +0,0 @@
-from __future__ import annotations
-
-from contextlib import nullcontext
-from dataclasses import dataclass, field
-from inspect import signature
-from typing import TYPE_CHECKING, Any, Callable, Generator, Type
-
-import pytest
-from hypothesis.core import HypothesisHandle
-from hypothesis.errors import Flaky
-from hypothesis.internal.escalation import format_exception, get_trimmed_traceback
-from hypothesis.internal.reflection import impersonate
-from pytest_subtests import SubTests
-
-from ._compat import MultipleFailures, get_interesting_origin
-from ._override import CaseOverride, check_no_override_mark, get_override_from_mark, set_override_mark
-from .auths import AuthStorage
-from .code_samples import CodeSampleStyle
-from .constants import FLAKY_FAILURE_MESSAGE, NOT_SET
-from .exceptions import CheckFailed, OperationSchemaError, SkipTest, get_grouped_exception
-from .filters import FilterSet, FilterValue, MatcherFunc, RegexValue, filter_set_from_components, is_deprecated
-from .hooks import HookDispatcher, HookScope
-from .internal.deprecation import warn_filtration_arguments
-from .internal.result import Ok
-from .schemas import BaseSchema
-from .utils import (
-    GivenInput,
-    fail_on_no_matches,
-    get_given_args,
-    get_given_kwargs,
-    given_proxy,
-    is_given_applied,
-    merge_given_args,
-    validate_given_args,
-)
-
-if TYPE_CHECKING:
-    from _pytest.fixtures import FixtureRequest
-    from pyrate_limiter import Limiter
-
-    from .generation import DataGenerationMethodInput, GenerationConfig
-    from .internal.output import OutputConfig
-    from .models import APIOperation
-    from .types import Filter, GenericTest, NotSet
-
-
-@dataclass
-class LazySchema:
-    fixture_name: str
-    base_url: str | None | NotSet = NOT_SET
-    app: Any = NOT_SET
-    filter_set: FilterSet = field(default_factory=FilterSet)
-    hooks: HookDispatcher = field(default_factory=lambda: HookDispatcher(scope=HookScope.SCHEMA))
-    auth: AuthStorage = field(default_factory=AuthStorage)
-    validate_schema: bool = True
-    data_generation_methods: DataGenerationMethodInput | NotSet = NOT_SET
-    generation_config: GenerationConfig | NotSet = NOT_SET
-    output_config: OutputConfig | NotSet = NOT_SET
-    code_sample_style: CodeSampleStyle = CodeSampleStyle.default()
-    rate_limiter: Limiter | None = None
-    sanitize_output: bool = True
-
-    def include(
-        self,
-        func: MatcherFunc | None = None,
-        *,
-        name: FilterValue | None = None,
-        name_regex: str | None = None,
-        method: FilterValue | None = None,
-        method_regex: str | None = None,
-        path: FilterValue | None = None,
-        path_regex: str | None = None,
-        tag: FilterValue | None = None,
-        tag_regex: RegexValue | None = None,
-        operation_id: FilterValue | None = None,
-        operation_id_regex: RegexValue | None = None,
-    ) -> LazySchema:
-        """Include only operations that match the given filters."""
-        filter_set = self.filter_set.clone()
-        filter_set.include(
-            func,
-            name=name,
-            name_regex=name_regex,
-            method=method,
-            method_regex=method_regex,
-            path=path,
-            path_regex=path_regex,
-            tag=tag,
-            tag_regex=tag_regex,
-            operation_id=operation_id,
-            operation_id_regex=operation_id_regex,
-        )
-        return self.__class__(
-            fixture_name=self.fixture_name,
-            base_url=self.base_url,
-            app=self.app,
-            hooks=self.hooks,
-            auth=self.auth,
-            validate_schema=self.validate_schema,
-            data_generation_methods=self.data_generation_methods,
-            generation_config=self.generation_config,
-            output_config=self.output_config,
-            code_sample_style=self.code_sample_style,
-            rate_limiter=self.rate_limiter,
-            sanitize_output=self.sanitize_output,
-            filter_set=filter_set,
-        )
-
-    def exclude(
-        self,
-        func: MatcherFunc | None = None,
-        *,
-        name: FilterValue | None = None,
-        name_regex: str | None = None,
-        method: FilterValue | None = None,
-        method_regex: str | None = None,
-        path: FilterValue | None = None,
-        path_regex: str | None = None,
-        tag: FilterValue | None = None,
-        tag_regex: RegexValue | None = None,
-        operation_id: FilterValue | None = None,
-        operation_id_regex: RegexValue | None = None,
-        deprecated: bool = False,
-    ) -> LazySchema:
-        """Exclude operations that match the given filters."""
-        filter_set = self.filter_set.clone()
-        if deprecated:
-            if func is None:
-                func = is_deprecated
-            else:
-                filter_set.exclude(is_deprecated)
-        filter_set.exclude(
-            func,
-            name=name,
-            name_regex=name_regex,
-            method=method,
-            method_regex=method_regex,
-            path=path,
-            path_regex=path_regex,
-            tag=tag,
-            tag_regex=tag_regex,
-            operation_id=operation_id,
-            operation_id_regex=operation_id_regex,
-        )
-        return self.__class__(
-            fixture_name=self.fixture_name,
-            base_url=self.base_url,
-            app=self.app,
-            hooks=self.hooks,
-            auth=self.auth,
-            validate_schema=self.validate_schema,
-            data_generation_methods=self.data_generation_methods,
-            generation_config=self.generation_config,
-            output_config=self.output_config,
-            code_sample_style=self.code_sample_style,
-            rate_limiter=self.rate_limiter,
-            sanitize_output=self.sanitize_output,
-            filter_set=filter_set,
-        )
-
-    def hook(self, hook: str | Callable) -> Callable:
-        return self.hooks.register(hook)
-
-    def parametrize(
-        self,
-        method: Filter | None = NOT_SET,
-        endpoint: Filter | None = NOT_SET,
-        tag: Filter | None = NOT_SET,
-        operation_id: Filter | None = NOT_SET,
-        validate_schema: bool | NotSet = NOT_SET,
-        skip_deprecated_operations: bool | NotSet = NOT_SET,
-        data_generation_methods: DataGenerationMethodInput | NotSet = NOT_SET,
-        generation_config: GenerationConfig | NotSet = NOT_SET,
-        output_config: OutputConfig | NotSet = NOT_SET,
-        code_sample_style: str | NotSet = NOT_SET,
-    ) -> Callable:
-        for name in ("method", "endpoint", "tag", "operation_id", "skip_deprecated_operations"):
-            value = locals()[name]
-            if value is not NOT_SET:
-                warn_filtration_arguments(name)
-        if data_generation_methods is NOT_SET:
-            data_generation_methods = self.data_generation_methods
-        if generation_config is NOT_SET:
-            generation_config = self.generation_config
-        if output_config is NOT_SET:
-            output_config = self.output_config
-        if isinstance(code_sample_style, str):
-            _code_sample_style = CodeSampleStyle.from_str(code_sample_style)
-        else:
-            _code_sample_style = self.code_sample_style
-
-        def wrapper(test: Callable) -> Callable:
-            if is_given_applied(test):
-                # The user wrapped the test function with `@schema.given`
-                # These args & kwargs go as extra to the underlying test generator
-                given_args = get_given_args(test)
-                given_kwargs = get_given_kwargs(test)
-                test_function = validate_given_args(test, given_args, given_kwargs)
-                if test_function is not None:
-                    return test_function
-                given_kwargs = merge_given_args(test, given_args, given_kwargs)
-                del given_args
-            else:
-                given_kwargs = {}
-
-            def wrapped_test(request: FixtureRequest) -> None:
-                """The actual test, which is executed by pytest."""
-                __tracebackhide__ = True
-                if hasattr(wrapped_test, "_schemathesis_hooks"):
-                    test._schemathesis_hooks = wrapped_test._schemathesis_hooks  # type: ignore
-                schema = get_schema(
-                    request=request,
-                    name=self.fixture_name,
-                    base_url=self.base_url,
-                    method=method,
-                    endpoint=endpoint,
-                    tag=tag,
-                    operation_id=operation_id,
-                    hooks=self.hooks,
-                    auth=self.auth if self.auth.providers is not None else NOT_SET,
-                    test_function=test,
-                    validate_schema=validate_schema,
-                    skip_deprecated_operations=skip_deprecated_operations,
-                    data_generation_methods=data_generation_methods,
-                    generation_config=generation_config,
-                    output_config=output_config,
-                    code_sample_style=_code_sample_style,
-                    app=self.app,
-                    rate_limiter=self.rate_limiter,
-                    sanitize_output=self.sanitize_output,
-                    filter_set=self.filter_set,
-                )
-                fixtures = get_fixtures(test, request, given_kwargs)
-                # Changing the node id is required for better reporting - the method and path will appear there
-                node_id = request.node._nodeid
-                settings = getattr(wrapped_test, "_hypothesis_internal_use_settings", None)
-
-                as_strategy_kwargs: Callable[[APIOperation], dict[str, Any]] | None = None
-
-                override = get_override_from_mark(test)
-                if override is not None:
-
-                    def as_strategy_kwargs(_operation: APIOperation) -> dict[str, Any]:
-                        nonlocal override
-
-                        return {
-                            location: entry for location, entry in override.for_operation(_operation).items() if entry
-                        }
-
-                tests = list(
-                    schema.get_all_tests(
-                        test,
-                        settings,
-                        hooks=self.hooks,
-                        as_strategy_kwargs=as_strategy_kwargs,
-                        _given_kwargs=given_kwargs,
-                    )
-                )
-                if not tests:
-                    fail_on_no_matches(node_id)
-                request.session.testscollected += len(tests)
-                suspend_capture_ctx = _get_capturemanager(request)
-                subtests = SubTests(request.node.ihook, suspend_capture_ctx, request)
-                for result in tests:
-                    if isinstance(result, Ok):
-                        operation, sub_test = result.ok()
-                        subtests.item._nodeid = _get_node_name(node_id, operation)
-                        run_subtest(operation, fixtures, sub_test, subtests)
-                    else:
-                        _schema_error(subtests, result.err(), node_id)
-                subtests.item._nodeid = node_id
-
-            wrapped_test = pytest.mark.usefixtures(self.fixture_name)(wrapped_test)
-            _copy_marks(test, wrapped_test)
-
-            # Needed to prevent a failure when settings are applied to the test function
-            wrapped_test.is_hypothesis_test = True  # type: ignore
-            wrapped_test.hypothesis = HypothesisHandle(test, wrapped_test, given_kwargs)  # type: ignore
-
-            return wrapped_test
-
-        return wrapper
-
-    def given(self, *args: GivenInput, **kwargs: GivenInput) -> Callable:
-        return given_proxy(*args, **kwargs)
-
-    def override(
-        self,
-        *,
-        query: dict[str, str] | None = None,
-        headers: dict[str, str] | None = None,
-        cookies: dict[str, str] | None = None,
-        path_parameters: dict[str, str] | None = None,
-    ) -> Callable[[GenericTest], GenericTest]:
-        """Override Open API parameters with fixed values."""
-
-        def _add_override(test: GenericTest) -> GenericTest:
-            check_no_override_mark(test)
-            override = CaseOverride(
-                query=query or {}, headers=headers or {}, cookies=cookies or {}, path_parameters=path_parameters or {}
-            )
-            set_override_mark(test, override)
-            return test
-
-        return _add_override
-
-
-def _copy_marks(source: Callable, target: Callable) -> None:
-    marks = getattr(source, "pytestmark", [])
-    # Pytest adds this attribute in `usefixtures`
-    target.pytestmark.extend(marks)  # type: ignore
-
-
-def _get_capturemanager(request: FixtureRequest) -> Generator | Type[nullcontext]:
-    capturemanager = request.node.config.pluginmanager.get_plugin("capturemanager")
-    if capturemanager is not None:
-        return capturemanager.global_and_fixture_disabled
-    return nullcontext
-
-
-def _get_node_name(node_id: str, operation: APIOperation) -> str:
-    """Make a test node name. For example: test_api[GET /users]."""
-    return f"{node_id}[{operation.method.upper()} {operation.full_path}]"
-
-
-def _get_partial_node_name(node_id: str, **kwargs: Any) -> str:
-    """Make a test node name for failing tests caused by schema errors."""
-    name = node_id
-    if "method" in kwargs:
-        name += f"[{kwargs['method']} {kwargs['path']}]"
-    else:
-        name += f"[{kwargs['path']}]"
-    return name
-
-
-def run_subtest(
-    operation: APIOperation,
-    fixtures: dict[str, Any],
-    sub_test: Callable,
-    subtests: SubTests,
-) -> None:
-    """Run the given subtest with pytest fixtures."""
-    __tracebackhide__ = True
-
-    # Deduplicate found checks in case of Hypothesis finding multiple of them
-    failed_checks = {}
-    exceptions = []
-    inner_test = sub_test.hypothesis.inner_test  # type: ignore
-
-    @impersonate(inner_test)  # type: ignore
-    def collecting_wrapper(*args: Any, **kwargs: Any) -> None:
-        __tracebackhide__ = True
-        try:
-            inner_test(*args, **kwargs)
-        except CheckFailed as failed:
-            failed_checks[failed.__class__] = failed
-            raise failed
-        except Exception as exception:
-            # Deduplicate it later, as it is more costly than for `CheckFailed`
-            exceptions.append(exception)
-            raise
-
-    def get_exception_class() -> type[CheckFailed]:
-        return get_grouped_exception("Lazy", *failed_checks.values())
-
-    sub_test.hypothesis.inner_test = collecting_wrapper  # type: ignore
-
-    with subtests.test(verbose_name=operation.verbose_name):
-        try:
-            sub_test(**fixtures)
-        except SkipTest as exc:
-            pytest.skip(exc.args[0])
-        except (MultipleFailures, CheckFailed) as exc:
-            # Hypothesis doesn't report the underlying failures in these circumstances, hence we display them manually
-            exc_class = get_exception_class()
-            failures = "".join(f"{SEPARATOR} {failure.args[0]}" for failure in failed_checks.values())
-            unique_exceptions = {get_interesting_origin(exception): exception for exception in exceptions}
-            total_problems = len(failed_checks) + len(unique_exceptions)
-            if total_problems == 1:
-                raise
-            message = f"Schemathesis found {total_problems} distinct sets of failures.{failures}"
-            for exception in unique_exceptions.values():
-                # Non-check exceptions
-                message += f"{SEPARATOR}\n\n"
-                tb = get_trimmed_traceback(exception)
-                message += format_exception(exception, tb)
-            raise exc_class(message, causes=tuple(failed_checks.values())).with_traceback(exc.__traceback__) from None
-        except Flaky as exc:
-            exc_class = get_exception_class()
-            failure = next(iter(failed_checks.values()))
-            message = f"{FLAKY_FAILURE_MESSAGE}{failure}"
-            # The outer frame is the one for user's test function, take it as the root one
-            traceback = exc.__traceback__.tb_next
-            # The next one comes from Hypothesis internals - remove it
-            traceback.tb_next = None
-            raise exc_class(message, causes=tuple(failed_checks.values())).with_traceback(traceback) from None
-
-
-SEPARATOR = "\n===================="
-
-
-def _schema_error(subtests: SubTests, error: OperationSchemaError, node_id: str) -> None:
-    """Run a failing test, that will show the underlying problem."""
-    sub_test = error.as_failing_test_function()
-    # `full_path` is always available in this case
-    kwargs = {"path": error.full_path}
-    if error.method:
-        kwargs["method"] = error.method.upper()
-    subtests.item._nodeid = _get_partial_node_name(node_id, **kwargs)
-    __tracebackhide__ = True
-    with subtests.test(**kwargs):
-        sub_test()
-
-
-def get_schema(
-    *,
-    request: FixtureRequest,
-    name: str,
-    base_url: str | None | NotSet = None,
-    method: Filter | None = None,
-    endpoint: Filter | None = None,
-    tag: Filter | None = None,
-    operation_id: Filter | None = None,
-    filter_set: FilterSet,
-    app: Any = None,
-    test_function: GenericTest,
-    hooks: HookDispatcher,
-    auth: AuthStorage | NotSet,
-    validate_schema: bool | NotSet = NOT_SET,
-    skip_deprecated_operations: bool | NotSet = NOT_SET,
-    data_generation_methods: DataGenerationMethodInput | NotSet = NOT_SET,
-    generation_config: GenerationConfig | NotSet = NOT_SET,
-    output_config: OutputConfig | NotSet = NOT_SET,
-    code_sample_style: CodeSampleStyle,
-    rate_limiter: Limiter | None,
-    sanitize_output: bool,
-) -> BaseSchema:
-    """Loads a schema from the fixture."""
-    schema = request.getfixturevalue(name)
-    if not isinstance(schema, BaseSchema):
-        raise ValueError(f"The given schema must be an instance of BaseSchema, got: {type(schema)}")
-
-    filter_set = filter_set_from_components(
-        include=True,
-        method=method,
-        endpoint=endpoint,
-        tag=tag,
-        operation_id=operation_id,
-        skip_deprecated_operations=skip_deprecated_operations,
-        parent=schema.filter_set.merge(filter_set),
-    )
-    return schema.clone(
-        base_url=base_url,
-        filter_set=filter_set,
-        app=app,
-        test_function=test_function,
-        hooks=schema.hooks.merge(hooks),
-        auth=auth,
-        validate_schema=validate_schema,
-        data_generation_methods=data_generation_methods,
-        generation_config=generation_config,
-        output_config=output_config,
-        code_sample_style=code_sample_style,
-        rate_limiter=rate_limiter,
-        sanitize_output=sanitize_output,
-    )
-
-
-def get_fixtures(func: Callable, request: FixtureRequest, given_kwargs: dict[str, Any]) -> dict[str, Any]:
-    """Load fixtures, needed for the test function."""
-    sig = signature(func)
-    return {
-        name: request.getfixturevalue(name) for name in sig.parameters if name != "case" and name not in given_kwargs
-    }

schemathesis/loaders.py

@@ -1,122 +0,0 @@
-from __future__ import annotations
-
-import re
-import sys
-from functools import lru_cache
-from typing import TYPE_CHECKING, Any, BinaryIO, Callable, TextIO, TypeVar
-
-from .exceptions import SchemaError, SchemaErrorType, extract_requests_exception_details
-
-if TYPE_CHECKING:
-    import yaml
-
-    from .transports.responses import GenericResponse
-
-R = TypeVar("R", bound="GenericResponse")
-
-
-def load_schema_from_url(loader: Callable[[], R]) -> R:
-    import requests
-
-    try:
-        response = loader()
-    except requests.RequestException as exc:
-        url = exc.request.url if exc.request is not None else None
-        if isinstance(exc, requests.exceptions.SSLError):
-            type_ = SchemaErrorType.CONNECTION_SSL
-        elif isinstance(exc, requests.exceptions.ConnectionError):
-            type_ = SchemaErrorType.CONNECTION_OTHER
-        else:
-            type_ = SchemaErrorType.NETWORK_OTHER
-        message, extras = extract_requests_exception_details(exc)
-        raise SchemaError(message=message, type=type_, url=url, response=exc.response, extras=extras) from exc
-    _raise_for_status(response)
-    return response
-
-
-def _raise_for_status(response: GenericResponse) -> None:
-    from .transports.responses import get_reason
-
-    status_code = response.status_code
-    reason = get_reason(status_code)
-    if status_code >= 500:
-        message = f"Failed to load schema due to server error (HTTP {status_code} {reason})"
-        type_ = SchemaErrorType.HTTP_SERVER_ERROR
-    elif status_code >= 400:
-        message = f"Failed to load schema due to client error (HTTP {status_code} {reason})"
-        if status_code == 403:
-            type_ = SchemaErrorType.HTTP_FORBIDDEN
-        elif status_code == 404:
-            type_ = SchemaErrorType.HTTP_NOT_FOUND
-        else:
-            type_ = SchemaErrorType.HTTP_CLIENT_ERROR
-    else:
-        return
-    raise SchemaError(message=message, type=type_, url=response.request.url, response=response, extras=[])
-
-
-def load_app(path: str) -> Any:
-    """Import an application from a string."""
-    path, name = ([*re.split(":(?![\\\\/])", path, maxsplit=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)
-
-
-@lru_cache
-def get_yaml_loader() -> type[yaml.SafeLoader]:
-    """Create a YAML loader, that doesn't parse specific tokens into Python objects."""
-    import yaml
-
-    try:
-        from yaml import CSafeLoader as SafeLoader
-    except ImportError:
-        from yaml import SafeLoader  # type: ignore
-
-    cls: type[yaml.SafeLoader] = type("YAMLLoader", (SafeLoader,), {})
-    cls.yaml_implicit_resolvers = {
-        key: [(tag, regexp) for tag, regexp in mapping if tag != "tag:yaml.org,2002:timestamp"]
-        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.VERBOSE,
-        ),
-        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
-
-
-def load_yaml(stream: str | bytes | TextIO | BinaryIO) -> Any:
-    import yaml
-
-    return yaml.load(stream, get_yaml_loader())