beancount-gocardless 0.1.7__tar.gz → 0.1.8__tar.gz

{beancount_gocardless-0.1.7 → beancount_gocardless-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: beancount-gocardless
-Version: 0.1.7
+Version: 0.1.8
 Summary: 
 License: MIT
 Requires-Python: >=3.12

{beancount_gocardless-0.1.7 → beancount_gocardless-0.1.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "beancount-gocardless"
-version = "0.1.7"
+version = "0.1.8"
 description = ""
 authors = []
 readme = "README.md"

{beancount_gocardless-0.1.7 → beancount_gocardless-0.1.8}/src/beancount_gocardless/client.py

@@ -7,22 +7,24 @@ import logging
 logger = logging.getLogger(__name__)
 
 
-def cleanup_headers(response):
+def strip_headers_hook(response, *args, **kwargs):
     to_preserve = [
         "Content-Type",
         "Date",
         "Content-Encoding",
         "Content-Language",
-        "ETag",
         "Last-Modified",
     ]
     deleted = set()
     to_preserve_lower = [h.lower() for h in to_preserve]
-    for header in response.headers.keys():
-        if header.lower() not in to_preserve_lower:
-            del response.headers[header]
+    header_keys_to_check = response.headers.copy().keys()
+    for header in header_keys_to_check:
+        if header.lower() in to_preserve_lower:
+            continue
+        else:
+            response.headers.pop(header, None)
             deleted.add(header)
-    logger.info("Deleted headers: %s", ", ".join(deleted))
+    logger.debug("Deleted headers: %s", ", ".join(deleted))
     return response
 
 
@@ -39,7 +41,7 @@ class CacheOptions(TypedDict, total=False):
 
     cache_name: requests_cache.StrOrPath
     backend: Optional[requests_cache.BackendSpecifier]
-    expire_after: requests_cache.ExpirationTime
+    expire_after: int
     old_data_on_error: bool
 
 
@@ -80,7 +82,6 @@ class BaseService:
         "old_data_on_error": True,
         "match_headers": False,
         "cache_control": False,
-        "response_hook": cleanup_headers,
     }
 
     def __init__(
@@ -99,21 +100,78 @@ class BaseService:
         """
         self.secret_id = secret_id
         self.secret_key = secret_key
-        self.token = None
+        self._token = None
         merged_options = {**self.DEFAULT_CACHE_OPTIONS, **(cache_options or {})}
         self.session = requests_cache.CachedSession(**merged_options)
+        self.session.hooks["response"].append(strip_headers_hook)
 
-    def _ensure_token_valid(self):
+    def check_cache_status(self, method: str, url: str, params=None, data=None) -> dict:
         """
-        Ensure a valid token exists.  Gets a new token if one doesn't exist.
+        Attempts to predict the cache status for a given request.
+
+        NOTE: This is an approximation and relies on internal mechanisms
+              that might change. It also performs I/O to check the cache.
+
+        Args:
+            method (str): HTTP method ("GET", "POST", etc.).
+            endpoint (str): API endpoint.
+            params (dict, optional): URL parameters.
+            data (dict, optional): Request body data.
+
+        Returns:
+            dict: Information about the potential cache state:
+                  {'key_exists': bool, 'is_expired': Optional[bool], 'cache_key': str}
+                  'is_expired' is None if the key doesn't exist or expiration
+                  cannot be reliably determined without full retrieval.
+        """
+        headers = {"Authorization": f"Bearer {self.token}"}
+
+        req = requests.Request(method, url, params=params, data=data, headers=headers)
+        prepared_request: requests.PreparedRequest = self.session.prepare_request(req)
+        cache = self.session.cache
+        cache_key = cache.create_key(prepared_request)
+        key_exists = cache.contains(cache_key)
+        is_expired = None
+
+        if key_exists:
+            try:
+                # Try to get the response object without triggering expiration side effects
+                # Note: This still reads from the cache backend (I/O)
+                cached_response = cache.get_response(cache_key)
+                if cached_response:
+                    # is_expired is a property calculated on the CachedResponse
+                    is_expired = cached_response.is_expired
+                else:
+                    # get_response might return None if item expired and configured to delete
+                    # Or if backend consistency issue. Treat as expired/absent.
+                    key_exists = False  # Correct the state if get_response fails
+                    is_expired = True  # Assume expired if get_response returns None for existing key
+            except Exception as e:
+                logger.error(
+                    f"Error checking expiration for cache key {cache_key}: {e}"
+                )
+                # Cannot determine expiration reliably
+                is_expired = None  # Mark as unknown
+
+        return {
+            "key_exists": key_exists,
+            "is_expired": is_expired,
+            "cache_key": cache_key,
+        }
+
+    @property
+    def token(self):
+        """
+        Ensure a token exists.  Gets a new token if one doesn't exist.
         Nordigen tokens don't currently have a refresh mechanism, so this just gets a new one if needed.
         """
-        if not self.token:
+        if not self._token:
             self.get_token()
+        return self._token
 
     def get_token(self):
         """
-        Fetch a new API access token using credentials. Sets the `self.token` attribute.
+        Fetch a new API access token using credentials. Sets the `self._token` attribute.
 
         Raises:
             HttpServiceException: If the API request fails.
@@ -123,7 +181,7 @@ class BaseService:
             data={"secret_id": self.secret_id, "secret_key": self.secret_key},
         )
         self._handle_response(response)
-        self.token = response.json()["access"]
+        self._token = response.json()["access"]
 
     def _handle_response(self, response):
         """
@@ -157,9 +215,10 @@ class BaseService:
             HttpServiceException: If the API request fails.
         """
         url = f"{self.BASE_URL}{endpoint}"
-        self._ensure_token_valid()
         headers = {"Authorization": f"Bearer {self.token}"}
 
+        status = self.check_cache_status(method, url, params, data)
+        logger.debug(f"{endpoint}: {'expired' if status["is_expired"] else 'cache ok'}")
         response = self.session.request(
             method, url, headers=headers, params=params, data=data
         )