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

schemathesis/specs/openapi/expressions/nodes.py

@@ -1,8 +1,8 @@
 """Expression nodes description and evaluation logic."""
+from dataclasses import dataclass
 from enum import Enum, unique
 from typing import Any, Dict, Optional, Union
 
-import attr
 from requests.structures import CaseInsensitiveDict
 
 from ....utils import WSGIResponse
@@ -10,7 +10,7 @@ from .. import references
 from .context import ExpressionContext
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class Node:
     """Generic expression node."""
 
@@ -27,11 +27,11 @@ class NodeType(Enum):
     RESPONSE = "$response"
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class String(Node):
     """A simple string that is not evaluated somehow specifically."""
 
-    value: str = attr.ib()  # pragma: no mutate
+    value: str
 
     def evaluate(self, context: ExpressionContext) -> str:
         """String tokens are passed as they are.
@@ -43,7 +43,7 @@ class String(Node):
         return self.value
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class URL(Node):
     """A node for `$url` expression."""
 
@@ -51,7 +51,7 @@ class URL(Node):
         return context.case.get_full_url()
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class Method(Node):
     """A node for `$method` expression."""
 
@@ -59,7 +59,7 @@ class Method(Node):
         return context.case.operation.method.upper()
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class StatusCode(Node):
     """A node for `$statusCode` expression."""
 
@@ -67,12 +67,12 @@ class StatusCode(Node):
         return str(context.response.status_code)
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class NonBodyRequest(Node):
     """A node for `$request` expressions where location is not `body`."""
 
-    location: str = attr.ib()  # pragma: no mutate
-    parameter: str = attr.ib()  # pragma: no mutate
+    location: str
+    parameter: str
 
     def evaluate(self, context: ExpressionContext) -> str:
         container: Union[Dict, CaseInsensitiveDict] = {
@@ -85,11 +85,11 @@ class NonBodyRequest(Node):
         return container[self.parameter]
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class BodyRequest(Node):
     """A node for `$request` expressions where location is `body`."""
 
-    pointer: Optional[str] = attr.ib(default=None)  # pragma: no mutate
+    pointer: Optional[str] = None
 
     def evaluate(self, context: ExpressionContext) -> Any:
         document = context.case.body
@@ -98,21 +98,21 @@ class BodyRequest(Node):
         return references.resolve_pointer(document, self.pointer[1:])
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class HeaderResponse(Node):
     """A node for `$response.header` expressions."""
 
-    parameter: str = attr.ib()  # pragma: no mutate
+    parameter: str
 
     def evaluate(self, context: ExpressionContext) -> str:
         return context.response.headers[self.parameter]
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class BodyResponse(Node):
     """A node for `$response.body` expressions."""
 
-    pointer: Optional[str] = attr.ib(default=None)  # pragma: no mutate
+    pointer: Optional[str] = None
 
     def evaluate(self, context: ExpressionContext) -> Any:
         if isinstance(context.response, WSGIResponse):

schemathesis/specs/openapi/expressions/parser.py

@@ -5,7 +5,7 @@ from . import lexer, nodes
 from .errors import RuntimeExpressionError, UnknownToken
 
 
-@lru_cache()  # pragma: no mutate
+@lru_cache()
 def parse(expr: str) -> List[nodes.Node]:
     """Parse lexical tokens into concrete expression nodes."""
     return list(_parse(expr))

schemathesis/specs/openapi/links.py

@@ -2,11 +2,10 @@
 
 Based on https://swagger.io/docs/specification/links/
 """
+from dataclasses import dataclass, field
 from difflib import get_close_matches
 from typing import Any, Dict, Generator, List, NoReturn, Optional, Sequence, Tuple, Union
 
-import attr
-
 from ...models import APIOperation, Case
 from ...parameters import ParameterSet
 from ...stateful import Direction, ParsedData, StatefulTest
@@ -17,15 +16,14 @@ from .constants import LOCATION_TO_CONTAINER
 from .parameters import OpenAPI20Body, OpenAPI30Body, OpenAPIParameter
 
 
-@attr.s(slots=True, repr=False)  # pragma: no mutate
+@dataclass(repr=False)
 class Link(StatefulTest):
-    operation: APIOperation = attr.ib()  # pragma: no mutate
-    parameters: Dict[str, Any] = attr.ib()  # pragma: no mutate
-    request_body: Any = attr.ib(default=NOT_SET)  # pragma: no mutate
+    operation: APIOperation
+    parameters: Dict[str, Any]
+    request_body: Any = NOT_SET
 
-    @request_body.validator
-    def is_defined(self, attribute: attr.Attribute, value: Any) -> None:
-        if value is not NOT_SET and not self.operation.body:
+    def __post_init__(self) -> None:
+        if self.request_body is not NOT_SET and not self.operation.body:
             # Link defines `requestBody` for a parameter that does not accept one
             raise ValueError(
                 f"Request body is not defined in API operation {self.operation.method.upper()} {self.operation.path}"
@@ -159,21 +157,21 @@ def get_links(response: GenericResponse, operation: APIOperation, field: str) ->
     return [Link.from_definition(name, definition, operation) for name, definition in links.items()]
 
 
-@attr.s(slots=True, repr=False)  # pragma: no mutate
+@dataclass(repr=False)
 class OpenAPILink(Direction):
     """Alternative approach to link processing.
 
     NOTE. This class will replace `Link` in the future.
     """
 
-    name: str = attr.ib()  # pragma: no mutate
-    status_code: str = attr.ib()  # pragma: no mutate
-    definition: Dict[str, Any] = attr.ib()  # pragma: no mutate
-    operation: APIOperation = attr.ib()  # pragma: no mutate
-    parameters: List[Tuple[Optional[str], str, str]] = attr.ib(init=False)  # pragma: no mutate
-    body: Union[Dict[str, Any], NotSet] = attr.ib(init=False)  # pragma: no mutate
+    name: str
+    status_code: str
+    definition: Dict[str, Any]
+    operation: APIOperation
+    parameters: List[Tuple[Optional[str], str, str]] = field(init=False)
+    body: Union[Dict[str, Any], NotSet] = field(init=False)
 
-    def __attrs_post_init__(self) -> None:
+    def __post_init__(self) -> None:
         self.parameters = [
             normalize_parameter(parameter, expression)
             for parameter, expression in self.definition.get("parameters", {}).items()

schemathesis/specs/openapi/negative/__init__.py

@@ -1,8 +1,8 @@
+from dataclasses import dataclass
 from functools import lru_cache
 from typing import Any, Dict, Optional, Tuple
 from urllib.parse import urlencode
 
-import attr
 import jsonschema
 from hypothesis import strategies as st
 from hypothesis_jsonschema import from_schema
@@ -12,16 +12,16 @@ from .mutations import MutationContext
 from .types import Draw, Schema
 
 
-@attr.s(slots=True, hash=False)
+@dataclass
 class CacheKey:
     """A cache key for API Operation / location.
 
     Carries the schema around but don't use it for hashing to simplify LRU cache usage.
     """
 
-    operation_name: str = attr.ib()
-    location: str = attr.ib()
-    schema: Schema = attr.ib()
+    operation_name: str
+    location: str
+    schema: Schema
 
     def __hash__(self) -> int:
         return hash((self.operation_name, self.location))

schemathesis/specs/openapi/negative/mutations.py

@@ -1,9 +1,9 @@
 """Schema mutations."""
 import enum
+from dataclasses import dataclass
 from functools import wraps
 from typing import Any, Callable, List, Optional, Sequence, Set, Tuple, TypeVar
 
-import attr
 from hypothesis import reject
 from hypothesis import strategies as st
 from hypothesis.strategies._internal.featureflags import FeatureStrategy
@@ -58,17 +58,17 @@ TYPE_SPECIFIC_KEYS = {
 }
 
 
-@attr.s(slots=True)
+@dataclass
 class MutationContext:
     """Meta information about the current mutation state."""
 
     # The original schema
-    keywords: Schema = attr.ib()  # only keywords
-    non_keywords: Schema = attr.ib()  # everything else
+    keywords: Schema  # only keywords
+    non_keywords: Schema  # everything else
     # Schema location within API operation (header, query, etc)
-    location: str = attr.ib()
+    location: str
     # Payload media type, if available
-    media_type: Optional[str] = attr.ib()
+    media_type: Optional[str]
 
     @property
     def is_header_location(self) -> bool:

schemathesis/specs/openapi/parameters.py

@@ -1,15 +1,14 @@
 import json
+from dataclasses import dataclass
 from typing import Any, ClassVar, Dict, Iterable, List, Optional, Tuple
 
-import attr
-
 from ...exceptions import InvalidSchema
 from ...models import APIOperation
 from ...parameters import Parameter
 from .converter import to_json_schema_recursive
 
 
-@attr.s(eq=False)
+@dataclass(eq=False)
 class OpenAPIParameter(Parameter):
     """A single Open API operation parameter."""
 
@@ -122,7 +121,7 @@ class OpenAPIParameter(Parameter):
         return json.dumps(self.as_json_schema(operation), sort_keys=True)
 
 
-@attr.s(eq=False)
+@dataclass(eq=False)
 class OpenAPI20Parameter(OpenAPIParameter):
     """Open API 2.0 parameter.
 
@@ -167,7 +166,7 @@ class OpenAPI20Parameter(OpenAPIParameter):
         return None
 
 
-@attr.s(eq=False)
+@dataclass(eq=False)
 class OpenAPI30Parameter(OpenAPIParameter):
     """Open API 3.0 parameter.
 
@@ -217,9 +216,9 @@ class OpenAPI30Parameter(OpenAPIParameter):
         return super().from_open_api_to_json_schema(operation, open_api_schema)
 
 
-@attr.s(eq=False)
+@dataclass(eq=False)
 class OpenAPIBody(OpenAPIParameter):
-    media_type: str = attr.ib()
+    media_type: str
 
     @property
     def location(self) -> str:
@@ -231,7 +230,7 @@ class OpenAPIBody(OpenAPIParameter):
         return "body"
 
 
-@attr.s(slots=True, eq=False)
+@dataclass(eq=False)
 class OpenAPI20Body(OpenAPIBody, OpenAPI20Parameter):
     """Open API 2.0 body variant."""
 
@@ -280,7 +279,7 @@ class OpenAPI20Body(OpenAPIBody, OpenAPI20Parameter):
 FORM_MEDIA_TYPES = ("multipart/form-data", "application/x-www-form-urlencoded")
 
 
-@attr.s(slots=True, eq=False)
+@dataclass(eq=False)
 class OpenAPI30Body(OpenAPIBody, OpenAPI30Parameter):
     """Open API 3.0 body variant.
 
@@ -290,8 +289,8 @@ class OpenAPI30Body(OpenAPIBody, OpenAPI30Parameter):
 
     # The `required` keyword is located above the schema for concrete media-type;
     # Therefore, it is passed here explicitly
-    required: bool = attr.ib(default=False)
-    description: Optional[str] = attr.ib(default=None)
+    required: bool = False
+    description: Optional[str] = None
 
     def as_json_schema(self, operation: APIOperation) -> Dict[str, Any]:
         """Convert body definition to JSON Schema."""
@@ -315,11 +314,11 @@ class OpenAPI30Body(OpenAPIBody, OpenAPI30Parameter):
         return self.required
 
 
-@attr.s(slots=True, eq=False)
+@dataclass(eq=False)
 class OpenAPI20CompositeBody(OpenAPIBody, OpenAPI20Parameter):
     """A special container to abstract over multiple `formData` parameters."""
 
-    definition: List[OpenAPI20Parameter] = attr.ib()
+    definition: List[OpenAPI20Parameter]
 
     @classmethod
     def from_parameters(cls, *parameters: Dict[str, Any], media_type: str) -> "OpenAPI20CompositeBody":

schemathesis/specs/openapi/references.py

@@ -52,11 +52,11 @@ class InliningResolver(jsonschema.RefResolver):
         )
         super().__init__(*args, **kwargs)
 
-    @overload  # pragma: no mutate
+    @overload
     def resolve_all(self, item: Dict[str, Any], recursion_level: int = 0) -> Dict[str, Any]:
         pass
 
-    @overload  # pragma: no mutate
+    @overload
     def resolve_all(self, item: List, recursion_level: int = 0) -> List:
         pass
 

schemathesis/specs/openapi/schemas.py

@@ -2,6 +2,7 @@ import itertools
 import json
 from collections import defaultdict
 from contextlib import ExitStack, contextmanager
+from dataclasses import dataclass, field
 from difflib import get_close_matches
 from hashlib import sha1
 from json import JSONDecodeError
@@ -23,7 +24,6 @@ from typing import (
 )
 from urllib.parse import urlsplit
 
-import attr
 import jsonschema
 import requests
 from hypothesis.strategies import SearchStrategy
@@ -82,24 +82,20 @@ SCHEMA_ERROR_MESSAGE = "Schema parsing failed. Please check your schema."
 SCHEMA_PARSING_ERRORS = (KeyError, AttributeError, jsonschema.exceptions.RefResolutionError)
 
 
-@attr.s(eq=False, repr=False)
+@dataclass(eq=False, repr=False)
 class BaseOpenAPISchema(BaseSchema):
-    nullable_name: str
-    links_field: str
-    header_required_field: str
-    security: BaseSecurityProcessor
-    component_locations: ClassVar[Tuple[Tuple[str, ...], ...]] = ()
-    _operations_by_id: Dict[str, APIOperation]
-    _inline_reference_cache: Dict[str, Any]
+    nullable_name: ClassVar[str] = ""
+    links_field: ClassVar[str] = ""
+    header_required_field: ClassVar[str] = ""
+    security: ClassVar[BaseSecurityProcessor] = None  # type: ignore
+    _operations_by_id: Dict[str, APIOperation] = field(init=False)
+    _inline_reference_cache: Dict[str, Any] = field(default_factory=dict)
     # Inline references cache can be populated from multiple threads, therefore we need some synchronisation to avoid
     # excessive resolving
-    _inline_reference_cache_lock: RLock
-
-    def __attrs_post_init__(self) -> None:
-        self._inline_reference_cache = {}
-        self._inline_reference_cache_lock = RLock()
+    _inline_reference_cache_lock: RLock = field(default_factory=RLock)
+    component_locations: ClassVar[Tuple[Tuple[str, ...], ...]] = ()
 
-    @property  # pragma: no mutate
+    @property
     def spec_version(self) -> str:
         raise NotImplementedError
 

schemathesis/specs/openapi/security.py

@@ -1,17 +1,17 @@
 """Processing of ``securityDefinitions`` or ``securitySchemes`` keywords."""
+from dataclasses import dataclass
 from typing import Any, ClassVar, Dict, Generator, List, Tuple, Type
 
-import attr
 from jsonschema import RefResolver
 
 from ...models import APIOperation
 from .parameters import OpenAPI20Parameter, OpenAPI30Parameter, OpenAPIParameter
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class BaseSecurityProcessor:
-    api_key_locations: Tuple[str, ...] = ("header", "query")
-    http_security_name = "basic"
+    api_key_locations: ClassVar[Tuple[str, ...]] = ("header", "query")
+    http_security_name: ClassVar[str] = "basic"
     parameter_cls: ClassVar[Type[OpenAPIParameter]] = OpenAPI20Parameter
 
     def process_definitions(self, schema: Dict[str, Any], operation: APIOperation, resolver: RefResolver) -> None:
@@ -112,10 +112,10 @@ def make_api_key_schema(definition: Dict[str, Any], **kwargs: Any) -> Dict[str,
 SwaggerSecurityProcessor = BaseSecurityProcessor
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class OpenAPISecurityProcessor(BaseSecurityProcessor):
-    api_key_locations = ("header", "cookie", "query")
-    http_security_name = "http"
+    api_key_locations: ClassVar[Tuple[str, ...]] = ("header", "cookie", "query")
+    http_security_name: ClassVar[str] = "http"
     parameter_cls: ClassVar[Type[OpenAPIParameter]] = OpenAPI30Parameter
 
     def get_security_definitions(self, schema: Dict[str, Any], resolver: RefResolver) -> Dict[str, Any]:

schemathesis/specs/openapi/stateful/links.py

@@ -1,6 +1,6 @@
+from dataclasses import dataclass
 from typing import TYPE_CHECKING, Callable, Dict, List, Tuple
 
-import attr
 import hypothesis.strategies as st
 from requests.structures import CaseInsensitiveDict
 
@@ -14,10 +14,10 @@ if TYPE_CHECKING:
 FilterFunction = Callable[[StepResult], bool]
 
 
-@attr.s(slots=True)
+@dataclass
 class Connection:
-    source: str = attr.ib()
-    strategy: st.SearchStrategy[Tuple[StepResult, OpenAPILink]] = attr.ib()
+    source: str
+    strategy: st.SearchStrategy[Tuple[StepResult, OpenAPILink]]
 
 
 APIOperationConnections = Dict[str, List[Connection]]

schemathesis/stateful.py

@@ -1,9 +1,9 @@
 import enum
 import json
 import time
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Callable, ClassVar, Dict, Generator, List, Optional, Tuple, Type
 
-import attr
 import hypothesis
 from hypothesis.stateful import RuleBasedStateMachine
 from hypothesis.stateful import run_state_machine_as_test as _run_state_machine_as_test
@@ -25,15 +25,15 @@ class Stateful(enum.Enum):
     links = 2
 
 
-@attr.s(slots=True, hash=False)  # pragma: no mutate
+@dataclass
 class ParsedData:
     """A structure that holds information parsed from a test outcome.
 
     It is used later to create a new version of an API operation that will reuse this data.
     """
 
-    parameters: Dict[str, Any] = attr.ib()  # pragma: no mutate
-    body: Any = attr.ib(default=NOT_SET)  # pragma: no mutate
+    parameters: Dict[str, Any]
+    body: Any = NOT_SET
 
     def __hash__(self) -> int:
         """Custom hash simplifies deduplication of parsed data."""
@@ -48,11 +48,11 @@ class ParsedData:
         return value
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class StatefulTest:
     """A template for a test that will be executed after another one by reusing the outcomes from it."""
 
-    name: str = attr.ib()  # pragma: no mutate
+    name: str
 
     def parse(self, case: Case, response: GenericResponse) -> ParsedData:
         raise NotImplementedError
@@ -61,12 +61,12 @@ class StatefulTest:
         raise NotImplementedError
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class StatefulData:
     """Storage for data that will be used in later tests."""
 
-    stateful_test: StatefulTest = attr.ib()  # pragma: no mutate
-    container: List[ParsedData] = attr.ib(factory=list)  # pragma: no mutate
+    stateful_test: StatefulTest
+    container: List[ParsedData] = field(default_factory=list)
 
     def make_operation(self) -> APIOperation:
         return self.stateful_test.make_operation(self.container)
@@ -77,16 +77,16 @@ class StatefulData:
         self.container.append(parsed)
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class Feedback:
     """Handler for feedback from tests.
 
     Provides a way to control runner's behavior from tests.
     """
 
-    stateful: Optional[Stateful] = attr.ib()  # pragma: no mutate
-    operation: APIOperation = attr.ib(repr=False)  # pragma: no mutate
-    stateful_tests: Dict[str, StatefulData] = attr.ib(factory=dict, repr=False)  # pragma: no mutate
+    stateful: Optional[Stateful]
+    operation: APIOperation = field(repr=False)
+    stateful_tests: Dict[str, StatefulData] = field(default_factory=dict, repr=False)
 
     def add_test_case(self, case: Case, response: GenericResponse) -> None:
         """Store test data to reuse it in the future additional tests."""
@@ -117,13 +117,13 @@ class Feedback:
             yield Ok((operation, test_function))
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class StepResult:
     """Output from a single transition of a state machine."""
 
-    response: GenericResponse = attr.ib()  # pragma: no mutate
-    case: Case = attr.ib()  # pragma: no mutate
-    elapsed: float = attr.ib()  # pragma: no mutate
+    response: GenericResponse
+    case: Case
+    elapsed: float
 
 
 class Direction:
@@ -148,11 +148,11 @@ def _print_case(case: Case, kwargs: Dict[str, Any]) -> str:
     return f"{operation}.make_case({', '.join(data)})"
 
 
-@attr.s(slots=True, repr=False)  # pragma: no mutate
+@dataclass(repr=False)
 class _DirectionWrapper:
     """Purely to avoid modification of `Direction.__repr__`."""
 
-    direction: Direction = attr.ib()  # pragma: no mutate
+    direction: Direction
 
     def __repr__(self) -> str:
         path = self.direction.operation.path

schemathesis/targets.py

@@ -1,14 +1,13 @@
+from dataclasses import dataclass
 from typing import TYPE_CHECKING, Callable, Tuple
 
-import attr
-
 from .utils import GenericResponse
 
 if TYPE_CHECKING:
     from .models import Case
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class TargetContext:
     """Context for targeted testing.
 
@@ -17,9 +16,9 @@ class TargetContext:
     :ivar float response_time: API response time.
     """
 
-    case: "Case" = attr.ib()  # pragma: no mutate
-    response: GenericResponse = attr.ib()  # pragma: no mutate
-    response_time: float = attr.ib()  # pragma: no mutate
+    case: "Case"
+    response: GenericResponse
+    response_time: float
 
 
 def response_time(context: TargetContext) -> float:

schemathesis/types.py

@@ -7,15 +7,15 @@ if TYPE_CHECKING:
     from . import DataGenerationMethod
     from .hooks import HookContext
 
-PathLike = Union[Path, str]  # pragma: no mutate
+PathLike = Union[Path, str]
 
-Query = Dict[str, Any]  # pragma: no mutate
+Query = Dict[str, Any]
 # Body can be of any Python type that corresponds to JSON Schema types + `bytes`
-Body = Union[List, Dict[str, Any], str, int, float, bool, bytes]  # pragma: no mutate
-PathParameters = Dict[str, Any]  # pragma: no mutate
-Headers = Dict[str, Any]  # pragma: no mutate
-Cookies = Dict[str, Any]  # pragma: no mutate
-FormData = Dict[str, Any]  # pragma: no mutate
+Body = Union[List, Dict[str, Any], str, int, float, bool, bytes]
+PathParameters = Dict[str, Any]
+Headers = Dict[str, Any]
+Cookies = Dict[str, Any]
+FormData = Dict[str, Any]
 
 
 class NotSet:
@@ -26,13 +26,11 @@ RequestCert = Union[str, Tuple[str, str]]
 
 
 # A filter for path / method
-Filter = Union[str, List[str], Tuple[str], Set[str], NotSet]  # pragma: no mutate
+Filter = Union[str, List[str], Tuple[str], Set[str], NotSet]
 
-Hook = Union[
-    Callable[[SearchStrategy], SearchStrategy], Callable[[SearchStrategy, "HookContext"], SearchStrategy]
-]  # pragma: no mutate
+Hook = Union[Callable[[SearchStrategy], SearchStrategy], Callable[[SearchStrategy, "HookContext"], SearchStrategy]]
 
-RawAuth = Tuple[str, str]  # pragma: no mutate
+RawAuth = Tuple[str, str]
 # Generic test with any arguments and no return
-GenericTest = Callable[..., None]  # pragma: no mutate
+GenericTest = Callable[..., None]
 DataGenerationMethodInput = Union["DataGenerationMethod", Iterable["DataGenerationMethod"]]

schemathesis/utils.py

@@ -80,7 +80,7 @@ def is_latin_1_encodable(value: str) -> bool:
 
 
 # Adapted from http.client._is_illegal_header_value
-INVALID_HEADER_RE = re.compile(r"\n(?![ \t])|\r(?![ \t\n])")  # pragma: no mutate
+INVALID_HEADER_RE = re.compile(r"\n(?![ \t])|\r(?![ \t\n])")
 
 
 def has_invalid_characters(name: str, value: str) -> bool:
@@ -258,7 +258,7 @@ def get_requests_auth(auth: Optional[RawAuth], auth_type: Optional[str]) -> Opti
     return auth
 
 
-GenericResponse = Union[requests.Response, WSGIResponse]  # pragma: no mutate
+GenericResponse = Union[requests.Response, WSGIResponse]
 
 
 def copy_response(response: GenericResponse) -> GenericResponse: