Hide internals

Author: Colin-b

CHANGELOG.md

@@ -14,6 +14,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Except for `requests_auth.testing`, only direct access via `requests_auth.` was considered publicly exposed. This is now explicit, as inner packages are now using private prefix (`_`).
   If you were relying on some classes or functions that are now internal, feel free to open an issue.
 - `requests_auth.JsonTokenFileCache` and `requests_auth.TokenMemoryCache` `get_token` method does not handle kwargs anymore, the `on_missing_token` callable does not expect any arguments anymore.
+- `requests_auth.JsonTokenFileCache` does not expose `tokens_path` or `last_save_time` attributes anymore and is also allowing `pathlib.Path` instances as cache location.
+- `requests_auth.TokenMemoryCache` does not expose `forbid_concurrent_cache_access` or `forbid_concurrent_missing_token_function_call` attributes anymore.
 
 ### Fixed
 - Type information is now provided following [PEP 561](https://www.python.org/dev/peps/pep-0561/).

requests_auth/_oauth2/tokens.py

@@ -4,6 +4,8 @@
 import datetime
 import threading
 import logging
+from pathlib import Path
+
 from requests_auth._errors import *
 
 logger = logging.getLogger(__name__)
@@ -42,8 +44,8 @@ class TokenMemoryCache:
 
     def __init__(self):
         self.tokens = {}
-        self.forbid_concurrent_cache_access = threading.Lock()
-        self.forbid_concurrent_missing_token_function_call = threading.Lock()
+        self._forbid_concurrent_cache_access = threading.Lock()
+        self._forbid_concurrent_missing_token_function_call = threading.Lock()
 
     def _add_bearer_token(self, key: str, token: str):
         """
@@ -91,7 +93,7 @@ def _add_token(
         :param expiry: UTC timestamp of expiry
         :param refresh_token: refresh token value
         """
-        with self.forbid_concurrent_cache_access:
+        with self._forbid_concurrent_cache_access:
             self.tokens[key] = token, expiry, refresh_token
             self._save_tokens()
             logger.debug(
@@ -121,7 +123,7 @@ def get_token(
         """
         logger.debug(f'Retrieving token with "{key}" key.')
         refresh_token = None
-        with self.forbid_concurrent_cache_access:
+        with self._forbid_concurrent_cache_access:
             self._load_tokens()
             if key in self.tokens:
                 token = self.tokens[key]
@@ -140,13 +142,13 @@ def get_token(
 
         if refresh_token is not None and on_expired_token is not None:
             try:
-                with self.forbid_concurrent_missing_token_function_call:
+                with self._forbid_concurrent_missing_token_function_call:
                     state, token, expires_in, refresh_token = on_expired_token(
                         refresh_token
                     )
                     self._add_access_token(state, token, expires_in, refresh_token)
                     logger.debug(f"Refreshed token with key {key}.")
-                with self.forbid_concurrent_cache_access:
+                with self._forbid_concurrent_cache_access:
                     if state in self.tokens:
                         bearer, expiry, refresh_token = self.tokens[state]
                         logger.debug(
@@ -158,7 +160,7 @@ def get_token(
 
         logger.debug("Token cannot be found in cache.")
         if on_missing_token is not None:
-            with self.forbid_concurrent_missing_token_function_call:
+            with self._forbid_concurrent_missing_token_function_call:
                 new_token = on_missing_token()
                 if len(new_token) == 2:  # Bearer token
                     state, token = new_token
@@ -173,7 +175,7 @@ def get_token(
                     logger.warning(
                         f"Using a token received on another key than expected. Expecting {key} but was {state}."
                     )
-            with self.forbid_concurrent_cache_access:
+            with self._forbid_concurrent_cache_access:
                 if state in self.tokens:
                     bearer, expiry, refresh_token = self.tokens[state]
                     logger.debug(
@@ -187,7 +189,7 @@ def get_token(
         raise AuthenticationFailed()
 
     def clear(self):
-        with self.forbid_concurrent_cache_access:
+        with self._forbid_concurrent_cache_access:
             logger.debug("Clearing token cache.")
             self.tokens = {}
             self._clear()
@@ -207,36 +209,36 @@ class JsonTokenFileCache(TokenMemoryCache):
     Class to manage tokens using a cache file.
     """
 
-    def __init__(self, tokens_path: str):
+    def __init__(self, tokens_path: Union[str, Path]):
         TokenMemoryCache.__init__(self)
-        self.tokens_path = tokens_path
-        self.last_save_time = 0
+        self._tokens_path = Path(tokens_path)
+        self._last_save_time = 0
         self._load_tokens()
 
     def _clear(self):
-        self.last_save_time = 0
+        self._last_save_time = 0
         try:
-            os.remove(self.tokens_path)
+            self._tokens_path.unlink(missing_ok=True)
         except:
             logger.debug("Cannot remove tokens file.")
 
     def _save_tokens(self):
         try:
-            with open(self.tokens_path, "w") as tokens_cache_file:
+            with self._tokens_path.open(mode="w") as tokens_cache_file:
                 json.dump(self.tokens, tokens_cache_file)
-            self.last_save_time = os.path.getmtime(self.tokens_path)
+            self._last_save_time = os.path.getmtime(self._tokens_path)
         except:
             logger.exception("Cannot save tokens.")
 
     def _load_tokens(self):
-        if not os.path.exists(self.tokens_path):
+        if not self._tokens_path.exists():
             logger.debug("No token loaded. Token cache does not exists.")
             return
         try:
-            last_modification_time = os.path.getmtime(self.tokens_path)
-            if last_modification_time > self.last_save_time:
-                self.last_save_time = last_modification_time
-                with open(self.tokens_path, "r") as tokens_cache_file:
+            last_modification_time = os.path.getmtime(self._tokens_path)
+            if last_modification_time > self._last_save_time:
+                self._last_save_time = last_modification_time
+                with self._tokens_path.open(mode="r") as tokens_cache_file:
                     self.tokens = json.load(tokens_cache_file)
         except:
             logger.exception("Cannot load tokens.")