schemathesis 3.18.5__py3-none-any.whl → 3.19.1__py3-none-any.whl

schemathesis/cli/context.py

@@ -1,45 +1,46 @@
 import os
 import shutil
+from dataclasses import dataclass, field
 from queue import Queue
 from typing import List, Optional, Union
 
-import attr
 import hypothesis
 
 from ..constants import CodeSampleStyle
 from ..runner.serialization import SerializedTestResult
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class ServiceReportContext:
-    queue: Queue = attr.ib()  # pragma: no mutate
-    service_base_url: str = attr.ib()  # pragma: no mutate
+    queue: Queue
+    service_base_url: str
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class FileReportContext:
-    queue: Queue = attr.ib()  # pragma: no mutate
-    filename: str = attr.ib(default=None)  # pragma: no mutate
+    queue: Queue
+    filename: Optional[str] = None
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class ExecutionContext:
     """Storage for the current context of the execution."""
 
-    hypothesis_settings: hypothesis.settings = attr.ib()  # pragma: no mutate
-    hypothesis_output: List[str] = attr.ib(factory=list)  # pragma: no mutate
-    workers_num: int = attr.ib(default=1)  # pragma: no mutate
-    show_errors_tracebacks: bool = attr.ib(default=False)  # pragma: no mutate
-    validate_schema: bool = attr.ib(default=True)  # pragma: no mutate
-    operations_processed: int = attr.ib(default=0)  # pragma: no mutate
+    hypothesis_settings: hypothesis.settings
+    hypothesis_output: List[str] = field(default_factory=list)
+    workers_num: int = 1
+    rate_limit: Optional[str] = None
+    show_errors_tracebacks: bool = False
+    validate_schema: bool = True
+    operations_processed: int = 0
     # It is set in runtime, from a `Initialized` event
-    operations_count: Optional[int] = attr.ib(default=None)  # pragma: no mutate
-    current_line_length: int = attr.ib(default=0)  # pragma: no mutate
-    terminal_size: os.terminal_size = attr.ib(factory=shutil.get_terminal_size)  # pragma: no mutate
-    results: List[SerializedTestResult] = attr.ib(factory=list)  # pragma: no mutate
-    cassette_path: Optional[str] = attr.ib(default=None)  # pragma: no mutate
-    junit_xml_file: Optional[str] = attr.ib(default=None)  # pragma: no mutate
-    is_interrupted: bool = attr.ib(default=False)  # pragma: no mutate
-    verbosity: int = attr.ib(default=0)  # pragma: no mutate
-    code_sample_style: CodeSampleStyle = attr.ib(default=CodeSampleStyle.default())  # pragma: no mutate
-    report: Optional[Union[ServiceReportContext, FileReportContext]] = attr.ib(default=None)  # pragma: no mutate
+    operations_count: Optional[int] = None
+    current_line_length: int = 0
+    terminal_size: os.terminal_size = field(default_factory=shutil.get_terminal_size)
+    results: List[SerializedTestResult] = field(default_factory=list)
+    cassette_path: Optional[str] = None
+    junit_xml_file: Optional[str] = None
+    is_interrupted: bool = False
+    verbosity: int = 0
+    code_sample_style: CodeSampleStyle = CodeSampleStyle.default()
+    report: Optional[Union[ServiceReportContext, FileReportContext]] = None

schemathesis/cli/debug.py

@@ -1,15 +1,15 @@
 import json
+from dataclasses import dataclass
 
-import attr
 from click.utils import LazyFile
 
 from ..runner import events
 from .handlers import EventHandler, ExecutionContext
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class DebugOutputHandler(EventHandler):
-    file_handle: LazyFile = attr.ib()  # pragma: no mutate
+    file_handle: LazyFile
 
     def handle_event(self, context: ExecutionContext, event: events.ExecutionEvent) -> None:
         stream = self.file_handle.open()

schemathesis/cli/junitxml.py

@@ -1,7 +1,7 @@
 import platform
+from dataclasses import dataclass, field
 from typing import List
 
-import attr
 from click.utils import LazyFile
 from junit_xml import TestCase, TestSuite, to_xml_report_file
 
@@ -11,10 +11,10 @@ from ..runner.serialization import deduplicate_failures
 from .handlers import EventHandler, ExecutionContext
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class JunitXMLHandler(EventHandler):
-    file_handle: LazyFile = attr.ib()  # pragma: no mutate
-    test_cases: List = attr.ib(factory=list)  # pragma: no mutate
+    file_handle: LazyFile
+    test_cases: List = field(default_factory=list)
 
     def handle_event(self, context: ExecutionContext, event: events.ExecutionEvent) -> None:
         if isinstance(event, events.AfterExecution):

schemathesis/cli/options.py

@@ -33,7 +33,7 @@ class BaseCsvChoice(click.Choice):
 class CsvEnumChoice(BaseCsvChoice):
     def __init__(self, choices: Type[Enum]):
         self.enum = choices
-        super().__init__(tuple(choices.__members__))
+        super().__init__(tuple(el.name for el in choices))
 
     def convert(  # type: ignore[return]
         self, value: str, param: Optional[click.core.Parameter], ctx: Optional[click.core.Context]

schemathesis/cli/output/default.py

@@ -487,6 +487,8 @@ def handle_initialized(context: ExecutionContext, event: events.Initialized) ->
     click.secho(f"Base URL: {event.base_url}", bold=True)
     click.secho(f"Specification version: {event.specification_name}", bold=True)
     click.secho(f"Workers: {context.workers_num}", bold=True)
+    if context.rate_limit is not None:
+        click.secho(f"Rate limit: {context.rate_limit}", bold=True)
     click.secho(f"Collected API operations: {context.operations_count}", bold=True)
     if isinstance(context.report, ServiceReportContext):
         click.secho("Report to Schemathesis.io: ENABLED", bold=True)

schemathesis/constants.py

@@ -20,9 +20,9 @@ SCHEMATHESIS_TEST_CASE_HEADER = "X-Schemathesis-TestCaseId"
 HYPOTHESIS_IN_MEMORY_DATABASE_IDENTIFIER = ":memory:"
 DISCORD_LINK = "https://discord.gg/R9ASRAmHnA"
 # Maximum test running time
-DEFAULT_DEADLINE = 15000  # pragma: no mutate
-DEFAULT_RESPONSE_TIMEOUT = 10000  # pragma: no mutate
-DEFAULT_STATEFUL_RECURSION_LIMIT = 5  # pragma: no mutate
+DEFAULT_DEADLINE = 15000
+DEFAULT_RESPONSE_TIMEOUT = 10000
+DEFAULT_STATEFUL_RECURSION_LIMIT = 5
 HTTP_METHODS = frozenset({"get", "put", "post", "delete", "options", "head", "patch", "trace"})
 RECURSIVE_REFERENCE_ERROR_MESSAGE = (
     "Currently, Schemathesis can't generate data for this operation due to "

schemathesis/exceptions.py

@@ -1,8 +1,8 @@
+from dataclasses import dataclass
 from hashlib import sha1
 from json import JSONDecodeError
 from typing import TYPE_CHECKING, Any, Callable, Dict, Generator, List, NoReturn, Optional, Tuple, Type, Union
 
-import attr
 import hypothesis.errors
 import requests
 from jsonschema import ValidationError
@@ -139,15 +139,15 @@ def get_timeout_error(deadline: Union[float, int]) -> Type[CheckFailed]:
     return _get_hashed_exception("TimeoutError", str(deadline))
 
 
-@attr.s(slots=True)
+@dataclass
 class InvalidSchema(Exception):
     """Schema associated with an API operation contains an error."""
 
     __module__ = "builtins"
-    message: Optional[str] = attr.ib(default=None)
-    path: Optional[str] = attr.ib(default=None)
-    method: Optional[str] = attr.ib(default=None)
-    full_path: Optional[str] = attr.ib(default=None)
+    message: Optional[str] = None
+    path: Optional[str] = None
+    method: Optional[str] = None
+    full_path: Optional[str] = None
 
     def as_failing_test_function(self) -> Callable:
         """Create a test function that will fail.
@@ -233,10 +233,10 @@ class InvalidRegularExpression(Exception):
     __module__ = "builtins"
 
 
-@attr.s  # pragma: no mutate
+@dataclass
 class HTTPError(Exception):
-    response: "GenericResponse" = attr.ib()  # pragma: no mutate
-    url: str = attr.ib()  # pragma: no mutate
+    response: "GenericResponse"
+    url: str
 
     @classmethod
     def raise_for_status(cls, response: requests.Response) -> None:

schemathesis/extra/pytest_plugin.py

@@ -222,7 +222,7 @@ def skip_unnecessary_hypothesis_output() -> Generator:
         yield
 
 
-@hookimpl(hookwrapper=True)  # pragma: no mutate
+@hookimpl(hookwrapper=True)
 def pytest_pyfunc_call(pyfuncitem):  # type:ignore
     """It is possible to have a Hypothesis exception in runtime.
 

schemathesis/failures.py

@@ -1,9 +1,8 @@
+from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Tuple, Union
 
-import attr
 
-
-@attr.s(slots=True, repr=False)  # pragma: no mutate
+# @dataclass(repr=False)
 class FailureContext:
     """Additional data specific to certain failure kind."""
 
@@ -18,36 +17,36 @@ class FailureContext:
         return (check_message or self.message,)
 
 
-@attr.s(slots=True, repr=False)
+@dataclass(repr=False)
 class ValidationErrorContext(FailureContext):
     """Additional information about JSON Schema validation errors."""
 
-    validation_message: str = attr.ib()
-    schema_path: List[Union[str, int]] = attr.ib()
-    schema: Union[Dict[str, Any], bool] = attr.ib()
-    instance_path: List[Union[str, int]] = attr.ib()
-    instance: Union[None, bool, float, str, list, Dict[str, Any]] = attr.ib()
-    title: str = attr.ib(default="Non-conforming response payload")
-    message: str = attr.ib(default="Response does not conform to the defined schema")
-    type: str = attr.ib(default="json_schema")
+    validation_message: str
+    schema_path: List[Union[str, int]]
+    schema: Union[Dict[str, Any], bool]
+    instance_path: List[Union[str, int]]
+    instance: Union[None, bool, float, str, list, Dict[str, Any]]
+    title: str = "Non-conforming response payload"
+    message: str = "Response does not conform to the defined schema"
+    type: str = "json_schema"
 
     def unique_by_key(self, check_message: Optional[str]) -> Tuple[str, ...]:
         # Deduplicate by JSON Schema path. All errors that happened on this sub-schema will be deduplicated
         return ("/".join(map(str, self.schema_path)),)
 
 
-@attr.s(slots=True, repr=False)
+@dataclass(repr=False)
 class JSONDecodeErrorContext(FailureContext):
     """Failed to decode JSON."""
 
-    validation_message: str = attr.ib()
-    document: str = attr.ib()
-    position: int = attr.ib()
-    lineno: int = attr.ib()
-    colno: int = attr.ib()
-    title: str = attr.ib(default="JSON deserialization error")
-    message: str = attr.ib(default="Response is not a valid JSON")
-    type: str = attr.ib(default="json_decode")
+    validation_message: str
+    document: str
+    position: int
+    lineno: int
+    colno: int
+    title: str = "JSON deserialization error"
+    message: str = "Response is not a valid JSON"
+    type: str = "json_decode"
 
     def unique_by_key(self, check_message: Optional[str]) -> Tuple[str, ...]:
         # Treat different JSON decoding failures as the same issue
@@ -56,90 +55,90 @@ class JSONDecodeErrorContext(FailureContext):
         return (self.title,)
 
 
-@attr.s(slots=True, repr=False)
+@dataclass(repr=False)
 class ServerError(FailureContext):
-    status_code: int = attr.ib()
-    title: str = attr.ib(default="Internal server error")
-    message: str = attr.ib(default="Server got itself in trouble")
-    type: str = attr.ib(default="server_error")
+    status_code: int
+    title: str = "Internal server error"
+    message: str = "Server got itself in trouble"
+    type: str = "server_error"
 
 
-@attr.s(slots=True, repr=False)
+@dataclass(repr=False)
 class MissingContentType(FailureContext):
     """Content type header is missing."""
 
-    media_types: List[str] = attr.ib()
-    title: str = attr.ib(default="Missing Content-Type header")
-    message: str = attr.ib(default="Response is missing the `Content-Type` header")
-    type: str = attr.ib(default="missing_content_type")
+    media_types: List[str]
+    title: str = "Missing Content-Type header"
+    message: str = "Response is missing the `Content-Type` header"
+    type: str = "missing_content_type"
 
 
-@attr.s(slots=True, repr=False)
+@dataclass(repr=False)
 class UndefinedContentType(FailureContext):
     """Response has Content-Type that is not defined in the schema."""
 
-    content_type: str = attr.ib()
-    defined_content_types: List[str] = attr.ib()
-    title: str = attr.ib(default="Undefined Content-Type")
-    message: str = attr.ib(default="Response has `Content-Type` that is not declared in the schema")
-    type: str = attr.ib(default="undefined_content_type")
+    content_type: str
+    defined_content_types: List[str]
+    title: str = "Undefined Content-Type"
+    message: str = "Response has `Content-Type` that is not declared in the schema"
+    type: str = "undefined_content_type"
 
 
-@attr.s(slots=True, repr=False)
+@dataclass(repr=False)
 class UndefinedStatusCode(FailureContext):
     """Response has a status code that is not defined in the schema."""
 
     # Response's status code
-    status_code: int = attr.ib()
+    status_code: int
     # Status codes as defined in schema
-    defined_status_codes: List[str] = attr.ib()
+    defined_status_codes: List[str]
     # Defined status code with expanded wildcards
-    allowed_status_codes: List[int] = attr.ib()
-    title: str = attr.ib(default="Undefined status code")
-    message: str = attr.ib(default="Response has a status code that is not declared in the schema")
-    type: str = attr.ib(default="undefined_status_code")
+    allowed_status_codes: List[int]
+    title: str = "Undefined status code"
+    message: str = "Response has a status code that is not declared in the schema"
+    type: str = "undefined_status_code"
 
 
-@attr.s(slots=True, repr=False)
+@dataclass(repr=False)
 class MissingHeaders(FailureContext):
     """Some required headers are missing."""
 
-    missing_headers: List[str] = attr.ib()
-    title: str = attr.ib(default="Missing required headers")
-    message: str = attr.ib(default="Response is missing headers required by the schema")
-    type: str = attr.ib(default="missing_headers")
+    missing_headers: List[str]
+    title: str = "Missing required headers"
+    message: str = "Response is missing headers required by the schema"
+    type: str = "missing_headers"
 
 
-@attr.s(slots=True, repr=False)
+@dataclass(repr=False)
 class MalformedMediaType(FailureContext):
     """Media type name is malformed.
 
     Example: `application-json` instead of `application/json`
     """
 
-    actual: str = attr.ib()
-    defined: str = attr.ib()
-    title: str = attr.ib(default="Malformed media type name")
-    message: str = attr.ib(default="Media type name is not valid")
-    type: str = attr.ib(default="malformed_media_type")
+    actual: str
+    defined: str
+    title: str = "Malformed media type name"
+    message: str = "Media type name is not valid"
+    type: str = "malformed_media_type"
 
 
-@attr.s(slots=True, repr=False)
+@dataclass(repr=False)
 class ResponseTimeExceeded(FailureContext):
     """Response took longer than expected."""
 
-    elapsed: float = attr.ib()
-    deadline: int = attr.ib()
-    title: str = attr.ib(default="Response time exceeded")
-    message: str = attr.ib(default="Response time exceeds the deadline")
-    type: str = attr.ib(default="response_time_exceeded")
+    elapsed: float
+    deadline: int
+    title: str = "Response time exceeded"
+    message: str = "Response time exceeds the deadline"
+    type: str = "response_time_exceeded"
 
 
-@attr.s(slots=True, repr=False)
+@dataclass(repr=False)
 class RequestTimeout(FailureContext):
     """Request took longer than timeout."""
 
-    timeout: int = attr.ib()
-    title: str = attr.ib(default="Request timeout")
-    message: str = attr.ib(default="The request timed out")
-    type: str = attr.ib(default="request_timeout")
+    timeout: int
+    title: str = "Request timeout"
+    message: str = "The request timed out"
+    type: str = "request_timeout"

schemathesis/filters.py

@@ -0,0 +1,269 @@
+"""Filtering system that allows users to filter API operations based on certain criteria."""
+import re
+from dataclasses import dataclass, field
+from functools import partial
+from types import SimpleNamespace
+from typing import TYPE_CHECKING, Callable, List, Optional, Set, Tuple, Union
+
+from typing_extensions import Protocol
+
+from .exceptions import UsageError
+
+if TYPE_CHECKING:
+    from .models import APIOperation
+
+
+class HasAPIOperation(Protocol):
+    operation: "APIOperation"
+
+
+MatcherFunc = Callable[[HasAPIOperation], bool]
+FilterValue = Union[str, List[str]]
+RegexValue = Union[str, re.Pattern]
+ERROR_EXPECTED_AND_REGEX = "Passing expected value and regex simultaneously is not allowed"
+ERROR_EMPTY_FILTER = "Filter can not be empty"
+ERROR_FILTER_EXISTS = "Filter already exists"
+
+
+@dataclass(repr=False, frozen=True)
+class Matcher:
+    """Encapsulates matching logic by various criteria."""
+
+    func: Callable[..., bool] = field(hash=False, compare=False)
+    # A short description of a matcher. Primarily exists for debugging purposes
+    label: str = field(hash=False, compare=False)
+    # Compare & hash matchers by a pre-computed hash value
+    _hash: int
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__}: {self.label}>"
+
+    @classmethod
+    def for_function(cls, func: MatcherFunc) -> "Matcher":
+        """Matcher that uses the given function for matching operations."""
+        return cls(func, label=func.__name__, _hash=hash(func))
+
+    @classmethod
+    def for_value(cls, attribute: str, expected: FilterValue) -> "Matcher":
+        """Matcher that checks whether the specified attribute has the expected value."""
+        if isinstance(expected, list):
+            func = partial(by_value_list, attribute=attribute, expected=expected)
+        else:
+            func = partial(by_value, attribute=attribute, expected=expected)
+        label = f"{attribute}={repr(expected)}"
+        return cls(func, label=label, _hash=hash(label))
+
+    @classmethod
+    def for_regex(cls, attribute: str, regex: RegexValue) -> "Matcher":
+        """Matcher that checks whether the specified attribute has the provided regex."""
+        if isinstance(regex, str):
+            regex = re.compile(regex)
+        func = partial(by_regex, attribute=attribute, regex=regex)
+        label = f"{attribute}_regex={repr(regex)}"
+        return cls(func, label=label, _hash=hash(label))
+
+    def match(self, ctx: HasAPIOperation) -> bool:
+        """Whether matcher matches the given operation."""
+        return self.func(ctx)
+
+
+def get_operation_attribute(operation: "APIOperation", attribute: str) -> str:
+    # Just uppercase `method`
+    value = getattr(operation, attribute)
+    if attribute == "method":
+        value = value.upper()
+    return value
+
+
+def by_value(ctx: HasAPIOperation, attribute: str, expected: str) -> bool:
+    return get_operation_attribute(ctx.operation, attribute) == expected
+
+
+def by_value_list(ctx: HasAPIOperation, attribute: str, expected: List[str]) -> bool:
+    return get_operation_attribute(ctx.operation, attribute) in expected
+
+
+def by_regex(ctx: HasAPIOperation, attribute: str, regex: re.Pattern) -> bool:
+    value = get_operation_attribute(ctx.operation, attribute)
+    return bool(regex.match(value))
+
+
+@dataclass(repr=False, frozen=True)
+class Filter:
+    """Match API operations against a list of matchers."""
+
+    matchers: Tuple[Matcher, ...]
+
+    def __repr__(self) -> str:
+        inner = " && ".join(matcher.label for matcher in self.matchers)
+        return f"<{self.__class__.__name__}: [{inner}]>"
+
+    def match(self, ctx: HasAPIOperation) -> bool:
+        """Whether the operation matches the filter.
+
+        Returns `True` only if all matchers matched.
+        """
+        return all(matcher.match(ctx) for matcher in self.matchers)
+
+
+@dataclass
+class FilterSet:
+    """Combines multiple filters to apply inclusion and exclusion rules on API operations."""
+
+    _includes: Set[Filter] = field(default_factory=set)
+    _excludes: Set[Filter] = field(default_factory=set)
+
+    def apply_to(self, operations: List["APIOperation"]) -> List["APIOperation"]:
+        """Get a filtered list of the given operations that match the filters."""
+        return [operation for operation in operations if self.match(SimpleNamespace(operation=operation))]
+
+    def match(self, ctx: HasAPIOperation) -> bool:
+        """Determines whether the given operation should be included based on the defined filters.
+
+        Returns True if the operation:
+          - matches at least one INCLUDE filter OR no INCLUDE filters defined;
+          - does not match any EXCLUDE filter;
+        False otherwise.
+        """
+        # Exclude early if the operation is excluded by at least one EXCLUDE filter
+        for filter_ in self._excludes:
+            if filter_.match(ctx):
+                return False
+        if not self._includes:
+            # No includes - nothing to filter out, include the operation
+            return True
+        # Otherwise check if the operation is included by at least one INCLUDE filter
+        return any(filter_.match(ctx) for filter_ in self._includes)
+
+    def is_empty(self) -> bool:
+        """Whether the filter set does not contain any filters."""
+        return not self._includes and not self._excludes
+
+    def include(
+        self,
+        func: Optional[MatcherFunc] = None,
+        *,
+        name: Optional[FilterValue] = None,
+        name_regex: Optional[RegexValue] = None,
+        method: Optional[FilterValue] = None,
+        method_regex: Optional[RegexValue] = None,
+        path: Optional[FilterValue] = None,
+        path_regex: Optional[RegexValue] = None,
+    ) -> None:
+        """Add a new INCLUDE filter."""
+        self._add_filter(
+            True,
+            func=func,
+            name=name,
+            name_regex=name_regex,
+            method=method,
+            method_regex=method_regex,
+            path=path,
+            path_regex=path_regex,
+        )
+
+    def exclude(
+        self,
+        func: Optional[MatcherFunc] = None,
+        *,
+        name: Optional[FilterValue] = None,
+        name_regex: Optional[RegexValue] = None,
+        method: Optional[FilterValue] = None,
+        method_regex: Optional[RegexValue] = None,
+        path: Optional[FilterValue] = None,
+        path_regex: Optional[RegexValue] = None,
+    ) -> None:
+        """Add a new EXCLUDE filter."""
+        self._add_filter(
+            False,
+            func=func,
+            name=name,
+            name_regex=name_regex,
+            method=method,
+            method_regex=method_regex,
+            path=path,
+            path_regex=path_regex,
+        )
+
+    def _add_filter(
+        self,
+        include: bool,
+        *,
+        func: Optional[MatcherFunc] = None,
+        name: Optional[FilterValue] = None,
+        name_regex: Optional[RegexValue] = None,
+        method: Optional[FilterValue] = None,
+        method_regex: Optional[RegexValue] = None,
+        path: Optional[FilterValue] = None,
+        path_regex: Optional[RegexValue] = None,
+    ) -> None:
+        matchers = []
+        if func is not None:
+            matchers.append(Matcher.for_function(func))
+        for attribute, expected, regex in (
+            ("verbose_name", name, name_regex),
+            ("method", method, method_regex),
+            ("path", path, path_regex),
+        ):
+            if expected is not None and regex is not None:
+                # To match anything the regex should match the expected value, hence passing them together is useless
+                raise UsageError(ERROR_EXPECTED_AND_REGEX)
+            if expected is not None:
+                matchers.append(Matcher.for_value(attribute, expected))
+            if regex is not None:
+                matchers.append(Matcher.for_regex(attribute, regex))
+
+        if not matchers:
+            raise UsageError(ERROR_EMPTY_FILTER)
+        filter_ = Filter(matchers=tuple(matchers))
+        if filter_ in self._includes or filter_ in self._excludes:
+            raise UsageError(ERROR_FILTER_EXISTS)
+        if include:
+            self._includes.add(filter_)
+        else:
+            self._excludes.add(filter_)
+
+
+def attach_filter_chain(
+    target: Callable,
+    attribute: str,
+    filter_func: Callable[..., None],
+) -> None:
+    """Attach a filtering function to an object, which allows chaining of filter criteria.
+
+    For example:
+
+    >>> def auth(): ...
+    >>> filter_set = FilterSet()
+    >>> attach_filter_chain(auth, "apply_to", filter_set.include)
+    >>> auth.apply_to(method="GET", path="/users/")
+
+    This will add a new `apply_to` method to `auth` that matches only the `GET /users/` operation.
+    """
+
+    def proxy(
+        func: Optional[MatcherFunc] = None,
+        *,
+        name: Optional[FilterValue] = None,
+        name_regex: Optional[str] = None,
+        method: Optional[FilterValue] = None,
+        method_regex: Optional[str] = None,
+        path: Optional[FilterValue] = None,
+        path_regex: Optional[str] = None,
+    ) -> Callable:
+        __tracebackhide__ = True
+        filter_func(
+            func=func,
+            name=name,
+            name_regex=name_regex,
+            method=method,
+            method_regex=method_regex,
+            path=path,
+            path_regex=path_regex,
+        )
+        return target
+
+    proxy.__qualname__ = attribute
+    proxy.__name__ = attribute
+
+    setattr(target, attribute, proxy)