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

schemathesis/auths.py

@@ -1,9 +1,9 @@
 """Support for custom API authentication mechanisms."""
 import threading
 import time
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Callable, Generic, List, Optional, Type, TypeVar, Union
 
-import attr
 import requests.auth
 from typing_extensions import Protocol, runtime_checkable
 
@@ -19,7 +19,7 @@ AUTH_STORAGE_ATTRIBUTE_NAME = "_schemathesis_auth"
 Auth = TypeVar("Auth")
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class AuthContext:
     """Holds state relevant for the authentication process.
 
@@ -27,8 +27,8 @@ class AuthContext:
     :ivar app: Optional Python application if the WSGI / ASGI integration is used.
     """
 
-    operation: "APIOperation" = attr.ib()  # pragma: no mutate
-    app: Optional[Any] = attr.ib()  # pragma: no mutate
+    operation: "APIOperation"
+    app: Optional[Any]
 
 
 @runtime_checkable
@@ -51,19 +51,19 @@ class AuthProvider(Protocol):
         """
 
 
-@attr.s(slots=True)
+@dataclass
 class CacheEntry(Generic[Auth]):
     """Cached auth data."""
 
-    data: Auth = attr.ib()
-    expires: float = attr.ib()
+    data: Auth
+    expires: float
 
 
-@attr.s(slots=True)
+@dataclass
 class RequestsAuth(Generic[Auth]):
     """Provider that sets auth data via `requests` auth instance."""
 
-    auth: requests.auth.AuthBase = attr.ib()
+    auth: requests.auth.AuthBase
 
     def get(self, _: AuthContext) -> Optional[Auth]:
         return self.auth  # type: ignore[return-value]
@@ -72,16 +72,16 @@ class RequestsAuth(Generic[Auth]):
         case._auth = self.auth
 
 
-@attr.s(slots=True)
+@dataclass
 class CachingAuthProvider(Generic[Auth]):
     """Caches the underlying auth provider."""
 
-    provider: AuthProvider = attr.ib()
-    refresh_interval: int = attr.ib(default=DEFAULT_REFRESH_INTERVAL)
-    cache_entry: Optional[CacheEntry[Auth]] = attr.ib(default=None)
+    provider: AuthProvider
+    refresh_interval: int = DEFAULT_REFRESH_INTERVAL
+    cache_entry: Optional[CacheEntry[Auth]] = None
     # The timer exists here to simplify testing
-    timer: Callable[[], float] = attr.ib(default=time.monotonic)
-    _refresh_lock: threading.Lock = attr.ib(factory=threading.Lock)
+    timer: Callable[[], float] = time.monotonic
+    _refresh_lock: threading.Lock = field(default_factory=threading.Lock)
 
     def get(self, context: AuthContext) -> Optional[Auth]:
         """Get cached auth value."""
@@ -200,12 +200,12 @@ class FilterableRequestsAuth(Protocol):
         pass
 
 
-@attr.s(slots=True)
+@dataclass
 class SelectiveAuthProvider(Generic[Auth]):
     """Applies auth depending on the configured filters."""
 
-    provider: AuthProvider = attr.ib()
-    filter_set: FilterSet = attr.ib()
+    provider: AuthProvider
+    filter_set: FilterSet
 
     def get(self, context: AuthContext) -> Optional[Auth]:
         if self.filter_set.match(context):
@@ -216,11 +216,11 @@ class SelectiveAuthProvider(Generic[Auth]):
         self.provider.set(case, data, context)
 
 
-@attr.s(slots=True)
+@dataclass
 class AuthStorage(Generic[Auth]):
     """Store and manage API authentication."""
 
-    providers: List[AuthProvider] = attr.ib(factory=list)
+    providers: List[AuthProvider] = field(default_factory=list)
 
     @property
     def is_defined(self) -> bool:

schemathesis/cli/__init__.py

@@ -4,12 +4,12 @@ import os
 import sys
 import traceback
 from collections import defaultdict
+from dataclasses import dataclass
 from enum import Enum
 from queue import Queue
 from typing import Any, Callable, Dict, Generator, Iterable, List, NoReturn, Optional, Tuple, Union, cast
 from urllib.parse import urlparse
 
-import attr
 import click
 import hypothesis
 import requests
@@ -799,33 +799,33 @@ def prepare_request_cert(cert: Optional[str], key: Optional[str]) -> Optional[Re
     return cert
 
 
-@attr.s(slots=True)
+@dataclass
 class LoaderConfig:
     """Container for API loader parameters.
 
     The main goal is to avoid too many parameters in function signatures.
     """
 
-    schema_location: str = attr.ib()  # pragma: no mutate
-    app: Any = attr.ib()  # pragma: no mutate
-    base_url: Optional[str] = attr.ib()  # pragma: no mutate
-    validate_schema: bool = attr.ib()  # pragma: no mutate
-    skip_deprecated_operations: bool = attr.ib()  # pragma: no mutate
-    data_generation_methods: Tuple[DataGenerationMethod, ...] = attr.ib()  # pragma: no mutate
-    force_schema_version: Optional[str] = attr.ib()  # pragma: no mutate
-    request_tls_verify: Union[bool, str] = attr.ib()  # pragma: no mutate
-    request_cert: Optional[RequestCert] = attr.ib()  # pragma: no mutate
-    wait_for_schema: Optional[float] = attr.ib()  # pragma: no mutate
-    rate_limit: Optional[str] = attr.ib()
+    schema_location: str
+    app: Any
+    base_url: Optional[str]
+    validate_schema: bool
+    skip_deprecated_operations: bool
+    data_generation_methods: Tuple[DataGenerationMethod, ...]
+    force_schema_version: Optional[str]
+    request_tls_verify: Union[bool, str]
+    request_cert: Optional[RequestCert]
+    wait_for_schema: Optional[float]
+    rate_limit: Optional[str]
     # Network request parameters
-    auth: Optional[Tuple[str, str]] = attr.ib()  # pragma: no mutate
-    auth_type: Optional[str] = attr.ib()  # pragma: no mutate
-    headers: Optional[Dict[str, str]] = attr.ib()  # pragma: no mutate
+    auth: Optional[Tuple[str, str]]
+    auth_type: Optional[str]
+    headers: Optional[Dict[str, str]]
     # Schema filters
-    endpoint: Optional[Filter] = attr.ib()  # pragma: no mutate
-    method: Optional[Filter] = attr.ib()  # pragma: no mutate
-    tag: Optional[Filter] = attr.ib()  # pragma: no mutate
-    operation_id: Optional[Filter] = attr.ib()  # pragma: no mutate
+    endpoint: Optional[Filter]
+    method: Optional[Filter]
+    tag: Optional[Filter]
+    operation_id: Optional[Filter]
 
 
 def into_event_stream(

schemathesis/cli/cassettes.py

@@ -3,10 +3,10 @@ import json
 import re
 import sys
 import threading
+from dataclasses import dataclass, field
 from queue import Queue
 from typing import IO, Any, Dict, Generator, Iterator, List, Optional, cast
 
-import attr
 import click
 import requests
 from requests.cookies import RequestsCookieJar
@@ -25,7 +25,7 @@ from .handlers import EventHandler
 WRITER_WORKER_JOIN_TIMEOUT = 1
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class CassetteWriter(EventHandler):
     """Write interactions in a YAML cassette.
 
@@ -33,12 +33,12 @@ class CassetteWriter(EventHandler):
     the end of the test run.
     """
 
-    file_handle: click.utils.LazyFile = attr.ib()  # pragma: no mutate
-    preserve_exact_body_bytes: bool = attr.ib()  # pragma: no mutate
-    queue: Queue = attr.ib(factory=Queue)  # pragma: no mutate
-    worker: threading.Thread = attr.ib(init=False)  # pragma: no mutate
+    file_handle: click.utils.LazyFile
+    preserve_exact_body_bytes: bool
+    queue: Queue = field(default_factory=Queue)
+    worker: threading.Thread = field(init=False)
 
-    def __attrs_post_init__(self) -> None:
+    def __post_init__(self) -> None:
         self.worker = threading.Thread(
             target=worker,
             kwargs={
@@ -80,23 +80,23 @@ class CassetteWriter(EventHandler):
         self.worker.join(WRITER_WORKER_JOIN_TIMEOUT)
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class Initialize:
     """Start up, the first message to make preparations before proceeding the input data."""
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class Process:
     """A new chunk of data should be processed."""
 
-    seed: int = attr.ib()  # pragma: no mutate
-    correlation_id: str = attr.ib()  # pragma: no mutate
-    thread_id: int = attr.ib()  # pragma: no mutate
-    data_generation_method: constants.DataGenerationMethod = attr.ib()  # pragma: no mutate
-    interactions: List[SerializedInteraction] = attr.ib()  # pragma: no mutate
+    seed: int
+    correlation_id: str
+    thread_id: int
+    data_generation_method: constants.DataGenerationMethod
+    interactions: List[SerializedInteraction]
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class Finalize:
     """The work is done and there will be no more messages to process."""
 
@@ -274,10 +274,10 @@ def write_double_quoted(stream: IO, text: str) -> None:
     stream.write('"')
 
 
-@attr.s(slots=True)  # pragma: no mutate
+@dataclass
 class Replayed:
-    interaction: Dict[str, Any] = attr.ib()  # pragma: no mutate
-    response: requests.Response = attr.ib()  # pragma: no mutate
+    interaction: Dict[str, Any]
+    response: requests.Response
 
 
 def replay(

schemathesis/cli/context.py

@@ -1,46 +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
-    rate_limit: Optional[str] = attr.ib(default=None)  # 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/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"