Make cattrs optional, and other cleanup

4 files changed, 40 insertions, 69 deletions

diff --git a/requests_cache/models/__init__.py b/requests_cache/models/__init__.py
index 4a9d00d..78a340f 100644
--- a/requests_cache/models/__init__.py
+++ b/requests_cache/models/__init__.py
@@ -1,16 +1,4 @@
 # flake8: noqa: F401
-import attr
-
-dataclass = attr.s(
-    auto_attribs=False,
-    auto_detect=True,
-    collect_by_mro=True,
-    kw_only=True,
-    slots=True,
-    weakref_slot=False,
-)
-
-
 from .raw_response import CachedHTTPResponse
 from .request import CachedRequest
 from .response import CachedResponse
diff --git a/requests_cache/models/raw_response.py b/requests_cache/models/raw_response.py
index 63c6d8b..3cdc385 100644
--- a/requests_cache/models/raw_response.py
+++ b/requests_cache/models/raw_response.py
@@ -1,14 +1,14 @@
 from io import BytesIO
 from logging import getLogger
 
-import attr
+from attr import define, field, fields_dict
 from requests import Response
 from urllib3.response import HTTPHeaderDict, HTTPResponse, is_fp_closed
 
 logger = getLogger(__name__)
 
 
-@attr.s(auto_attribs=False, auto_detect=True, kw_only=True)
+@define(auto_attribs=False, slots=False)
 class CachedHTTPResponse(HTTPResponse):
     """A serializable dataclass that extends/emulates :py:class:`~urllib3.response.HTTPResponse`.
     Supports streaming requests and generator usage.
@@ -17,13 +17,13 @@ class CachedHTTPResponse(HTTPResponse):
     ``decode_content=False``, but a use case for this has not come up yet.
     """
 
-    decode_content: bool = attr.ib(default=None)
-    headers: HTTPHeaderDict = attr.ib(factory=dict)
-    reason: str = attr.ib(default=None)
-    request_url: str = attr.ib(default=None)  # TODO: Not available in urllib <=1.21. Is this needed?
-    status: int = attr.ib(default=0)
-    strict: int = attr.ib(default=0)
-    version: int = attr.ib(default=0)
+    decode_content: bool = field(default=None)
+    headers: HTTPHeaderDict = field(factory=dict)
+    reason: str = field(default=None)
+    request_url: str = field(default=None)  # Note: Not available in urllib <=1.21
+    status: int = field(default=0)
+    strict: int = field(default=0)
+    version: int = field(default=0)
 
     def __init__(self, *args, body: bytes = None, **kwargs):
         """First initialize via HTTPResponse, then via attrs"""
@@ -36,8 +36,7 @@ class CachedHTTPResponse(HTTPResponse):
         """Create a CachedHTTPResponse based on an original response"""
         # Copy basic attributes
         raw = original_response.raw
-        kwargs = {k: getattr(raw, k, None) for k in attr.fields_dict(cls).keys()}
-        # TODO: Better means of handling naming differences between class attrs and method kwargs
+        kwargs = {k: getattr(raw, k, None) for k in fields_dict(cls).keys()}
         kwargs['request_url'] = raw._request_url
 
         # Copy response data and restore response object to its original state
diff --git a/requests_cache/models/request.py b/requests_cache/models/request.py
index d5c1ba1..f8f5a54 100644
--- a/requests_cache/models/request.py
+++ b/requests_cache/models/request.py
@@ -2,49 +2,36 @@
 from logging import getLogger
 from typing import Any
 
-import attr
+from attr import define, field, fields_dict
 from requests import PreparedRequest
 from requests.cookies import RequestsCookieJar
 from requests.structures import CaseInsensitiveDict
 
-from . import dataclass
-
 logger = getLogger(__name__)
 
 
-@dataclass
+@define(auto_attribs=False)
 class CachedRequest:
     """A serializable dataclass that emulates :py:class:`requests.PreparedResponse`"""
 
-    body: Any = attr.ib(default=None)
-    cookies: RequestsCookieJar = attr.ib(factory=dict)
-    headers: CaseInsensitiveDict = attr.ib(factory=CaseInsensitiveDict)
-    method: str = attr.ib(default=None)
-    url: str = attr.ib(default=None)
+    body: Any = field(default=None)
+    cookies: RequestsCookieJar = field(factory=dict)
+    headers: CaseInsensitiveDict = field(factory=CaseInsensitiveDict)
+    method: str = field(default=None)
+    url: str = field(default=None)
 
     @classmethod
     def from_request(cls, original_request: PreparedRequest):
         """Create a CachedRequest based on an original request object"""
-        kwargs = {k: getattr(original_request, k, None) for k in attr.fields_dict(cls).keys()}
-        # TODO: Better means of handling naming differences between class attrs and method kwargs
+        kwargs = {k: getattr(original_request, k, None) for k in fields_dict(cls).keys()}
         kwargs['cookies'] = original_request._cookies
         return cls(**kwargs)
 
-    # TODO: Is this necessary, or will cattr.structure() be sufficient?
-    @classmethod
-    def prepare(self, obj) -> PreparedRequest:
-        """Turn a CachedRequest object back into a PreparedRequest. This lets PreparedRequest do the
-        work of normalizing any values that may have changed during (de)serialization.
-        """
-        req = PreparedRequest()
-        kwargs = attr.asdict(obj)
-        # TODO: Better means of handling naming differences between class attrs and method kwargs
-        kwargs['data'] = kwargs.pop('body')
-        req.prepare(**kwargs)
-        return req
-
     @property
     def _cookies(self):
+        """For compatibility with PreparedRequest, which has an attribute named '_cookies', and a
+        keyword argument named 'cookies'.
+        """
         return self.cookies
 
     def __str__(self):
diff --git a/requests_cache/models/response.py b/requests_cache/models/response.py
index 86b21b9..627a753 100755
--- a/requests_cache/models/response.py
+++ b/requests_cache/models/response.py
@@ -3,27 +3,25 @@ from datetime import datetime, timedelta, timezone
 from logging import getLogger
 from typing import List, Optional, Tuple, Union
 
-import attr
-from requests import Response
+from attr import define, field
+from requests import Response as OriginalResponse
 from requests.cookies import RequestsCookieJar
 from requests.structures import CaseInsensitiveDict
 
 from ..cache_control import ExpirationTime, get_expiration_datetime
-from . import CachedHTTPResponse, CachedRequest, dataclass
+from . import CachedHTTPResponse, CachedRequest
 
 DATETIME_FORMAT = '%Y-%m-%d %H:%M:%S %Z'  # Format used for __str__ only
 DO_NOT_CACHE = 0
 
+# Make a slotted copy of requests.Response to subclass
+Response = define(slots=True)(OriginalResponse)
 HeaderList = List[Tuple[str, str]]
 
 logger = getLogger(__name__)
 
 
-# TODO: Make this fully take advantage of slots
-# Make a slotted copy of Response to subclass; we don't need its attrs, only its methods
-# from requests import Response as OriginalResponse
-# Response = attr.s(slots=True)(OriginalResponse)
-@dataclass
+@define(auto_attribs=False)
 class CachedResponse(Response):
     """A serializable dataclass that emulates :py:class:`requests.Response`. Public attributes and
     methods on CachedResponse objects will behave the same as those from the original response, but
@@ -34,20 +32,19 @@ class CachedResponse(Response):
     saves a bit of memory and deserialization steps when those objects aren't accessed.
     """
 
-    # _content: bytes = attr.ib(default=b'', repr=False, converter=lambda x: x or b'')
-    _content: bytes = attr.ib(default=None)
-    url: str = attr.ib(default=None)
-    status_code: int = attr.ib(default=0)
-    cookies: RequestsCookieJar = attr.ib(factory=dict)
-    created_at: datetime = attr.ib(factory=datetime.utcnow)
-    elapsed: timedelta = attr.ib(factory=timedelta)
-    expires: datetime = attr.ib(default=None)
-    encoding: str = attr.ib(default=None)
-    headers: CaseInsensitiveDict = attr.ib(factory=dict)
-    history: List = attr.ib(factory=list)
-    reason: str = attr.ib(default=None)
-    request: CachedRequest = attr.ib(factory=CachedRequest)
-    raw: CachedHTTPResponse = attr.ib(factory=CachedHTTPResponse, repr=False)
+    _content: bytes = field(default=None)
+    url: str = field(default=None)
+    status_code: int = field(default=0)
+    cookies: RequestsCookieJar = field(factory=dict)
+    created_at: datetime = field(factory=datetime.utcnow)
+    elapsed: timedelta = field(factory=timedelta)
+    expires: datetime = field(default=None)
+    encoding: str = field(default=None)
+    headers: CaseInsensitiveDict = field(factory=dict)
+    history: List = field(factory=list)
+    reason: str = field(default=None)
+    request: CachedRequest = field(factory=CachedRequest)
+    raw: CachedHTTPResponse = field(factory=CachedHTTPResponse, repr=False)
 
     def __attrs_post_init__(self):
         """Re-initialize raw response body after deserialization"""