feat(sdk): add ability to disable auto save

Author: wakonig

sdk/python/scilog/authmixin.py

@@ -14,13 +14,15 @@ def typename(obj):
 class AuthMixin(ABC):
     def __init__(self, address, options=None):
         self.address = address.rstrip("/")
+        if not options:
+            options = {}
+        self._auto_save_token = options.get("auto_save_token", True)
         tn = typename(self).lower()
         try:
-            self.config = Config(f".{tn}-tokens")
+            self.config = Config(f".{tn}-tokens", auto_save_token=self._auto_save_token)
         except JSONDecodeError:
             self.config = {}
-        if not options:
-            options = {}
+
         self._token = options.get("token")
         self._username = options.get("username")
         self._password = options.get("password")
@@ -39,19 +41,33 @@ def authenticate(self, username, password):
     def token(self):
         return self._retrieve_token()
 
+    def reset_token(self):
+        self._token = None
+
     def _retrieve_token(self):
         username = self._username or getpass.getuser()
-        token = self._token
-        if token is None:
-            try:
-                token = self.config[username]
-            except KeyError:
-                tn = typename(self)
-                password = self._password or getpass.getpass(
-                    prompt=f"{tn} password for {username}: "
-                )
-                token = self.authenticate(username, password)
-        self.config[username] = self._token = token
+
+        if self._token:
+            # If a token is already set (either from options or from a previous authentication), use it.
+            return self._token
+
+        if not self._auto_save_token:
+            # If auto-saving is disabled, authenticate without checking the config.
+            self._token = self._authenticate()
+            return self._token
+
+        try:
+            self._token = self.config[username]
+        except KeyError:
+            self._token = self._authenticate()
+        self.config[username] = self._token
+        return self._token
+
+    def _authenticate(self):
+        tn = typename(self)
+        username = self._username or getpass.getuser()
+        password = self._password or getpass.getpass(prompt=f"{tn} password for {username}: ")
+        token = self.authenticate(username, password)
         return token
 
 

sdk/python/scilog/config.py

@@ -3,12 +3,13 @@
 
 
 class Config(dict):
-    def __init__(self, fname, folder=None):
+    def __init__(self, fname, folder=None, auto_save_token=True):
         if folder is not None:
             folder = Path(folder)
         else:
             folder = Path.home()
         self.fname = folder / fname
+        self.auto_save_token = auto_save_token
         content = self._load()
         super().__init__(content)
 
@@ -30,7 +31,8 @@ def _save(self):
         json_save(self, self.fname)
 
     def delete(self):
-        self.fname.unlink()
+        if self.fname.exists():
+            self.fname.unlink()
 
 
 def json_save(what, filename, *args, indent=4, sort_keys=True, **kwargs):

sdk/python/scilog/httpclient.py

@@ -60,19 +60,15 @@ def authenticate(self, username, password):
     def get_request(self, url, params=None, headers=None, timeout=10):
         logger.debug(f"Getting data request: {url} , {params}")
         response = requests.get(
-            url,
-            params=params,
-            headers=headers,
-            timeout=timeout,
-            verify=self._verify_certificate,
+            url, params=params, headers=headers, timeout=timeout, verify=self._verify_certificate
         )
         if response.ok:
             logger.debug(f"Getting data response: {response.json()}")
             return response.json()
-        else:
-            if response.reason == "Unauthorized":
-                self.config.delete()
-            raise response.raise_for_status()
+
+        if response.reason == "Unauthorized":
+            self.config.delete()
+        raise response.raise_for_status()
 
     @authenticated
     @formatted_http_error

sdk/python/scilog/scilog.py

@@ -375,8 +375,19 @@ def patch_snippet(self, snippet: T, **kwargs) -> T:
 
 
 class SciLog:
-    def __init__(self, *args, **kwargs):
-        self.http_client = SciLogRestAPI(*args, **kwargs)
+    def __init__(self, address: str, options: dict | None = None, **kwargs):
+        """
+        Initialize the SciLog client.
+
+        Args:
+            address (str): The base URL of the SciLog server, e.g. "https://scilog.psi.ch/api/v1"
+            options (dict | None): Optional dictionary containing authentication options such as
+                    "token", "username", "password", "login_path" and "auto_save_token". If not
+                    provided, the client will attempt to retrieve these from the environment or
+                    prompt the user.
+            **kwargs: Additional keyword arguments for authentication, if needed.
+        """
+        self.http_client = SciLogRestAPI(address=address, options=options, **kwargs)
         self.logbook = None
         self.core = SciLogCore(self)
 

sdk/python/tests/test_scilog.py

@@ -271,3 +271,19 @@ def test_get_snippets_with_kwargs_calls_http(scilog):
     assert headers == HEADER_JSON
     filt = json.loads(params["filter"])
     assert filt == {"where": {"and": [{"textcontent": "text", "parentId": "logbook_id_test"}]}}
+
+
+def test_scilog_without_auto_save_does_not_use_config(scilog):
+    log = SciLog("fake_url", options={"auto_save_token": False})
+    assert log.http_client._auto_save_token is False
+    with mock.patch.object(
+        log.core.http_client, "_authenticate", return_value="dummy_token"
+    ) as mock_authenticate:
+        with mock.patch.object(log.core.http_client, "config") as mock_config:
+            token = log.http_client.token
+        mock_authenticate.assert_called_once()
+
+        # Ensure that the config is neither read from nor written to when auto_save_token is False
+        mock_config.__getitem__.assert_not_called()
+        mock_config.__setitem__.assert_not_called()
+        assert token == "dummy_token"