erioon 0.0.7__py3-none-any.whl → 0.0.9__py3-none-any.whl

erioon/auth.py

@@ -13,7 +13,7 @@ def Auth(credential_string):
 
     Example usage:
     >>> from erioon.auth import Auth
-    >>> client = Auth("<EMAIL>:<PASSWORD>")
+    >>> client = Auth("<API_KEY>:<EMAIL>:<PASSWORD>")
     >>> print(client)  # prints user_id if successful or error message if not
     """
     api, email, password = credential_string.split(":")

erioon/client.py

@@ -1,33 +1,21 @@
 import os
 import json
 import requests
-from werkzeug.security import generate_password_hash
+from datetime import datetime, timezone
 from erioon.database import Database
 
 class ErioonClient:
     """
     Client SDK for interacting with the Erioon API.
 
-    Handles user authentication, token caching, and accessing user databases.
-
-    Attributes:
-        email (str): User email for login.
-        password (str): User password for login.
-        base_url (str): Base URL of the Erioon API.
-        user_id (str | None): Authenticated user ID.
-        error (str | None): Stores error messages if login fails.
-        token_path (str): Local path to cached authentication token.
+    Handles:
+    - User authentication with email/password and API key
+    - Token caching to avoid re-authenticating every time
+    - SAS token expiration detection and auto-renewal
+    - Access to user-specific databases
     """
 
     def __init__(self, api, email, password, base_url="https://sdk.erioon.com"):
-        """
-        Initialize ErioonClient instance, attempts to load cached token or perform login.
-
-        Args:
-            email (str): User email for authentication.
-            password (str): User password for authentication.
-            base_url (str, optional): Base API URL. Defaults to "https://sdk.erioon.com".
-        """
         self.api = api
         self.email = email
         self.password = password
@@ -35,34 +23,23 @@ class ErioonClient:
         self.user_id = None
         self.error = None
         self.token_path = os.path.expanduser(f"~/.erioon_token_{self._safe_filename(email)}")
+        self.login_metadata = None
 
         try:
-            metadata = self._load_or_login()
-            self.user_id = metadata.get("_id")
-            self.database = metadata.get("database")
-            self.cluster = metadata.get("cluster")
-            self.login_metadata = metadata
+            self.login_metadata = self._load_or_login()
+            self._update_metadata_fields()
         except Exception as e:
             self.error = str(e)
 
     def _safe_filename(self, text):
         """
-        Converts a string into a safe filename by replacing non-alphanumeric chars with underscores.
-
-        Args:
-            text (str): Input string to convert.
-
-        Returns:
-            str: Sanitized filename-safe string.
+        Converts unsafe filename characters to underscores for cache file naming.
         """
         return "".join(c if c.isalnum() else "_" for c in text)
 
     def _do_login_and_cache(self):
         """
-        Perform login to API and cache the metadata locally.
-
-        Returns:
-            dict: Login metadata including user_id, database, cluster.
+        Logs in to the API and writes the returned metadata (e.g. SAS token, user ID) to a local file.
         """
         metadata = self._login()
         with open(self.token_path, "w") as f:
@@ -71,68 +48,80 @@ class ErioonClient:
 
     def _load_or_login(self):
         """
-        Load cached metadata or perform login.
-
-        Returns:
-            dict: Login metadata.
+        Tries to load the cached login metadata.
+        If token is expired or file does not exist, performs a fresh login.
         """
         if os.path.exists(self.token_path):
             with open(self.token_path, "r") as f:
                 metadata = json.load(f)
-                if "user_id" in metadata:
-                    return metadata
-
-        return self._do_login_and_cache()
+            if self._is_sas_expired(metadata):
+                metadata = self._do_login_and_cache()
+            return metadata
+        else:
+            return self._do_login_and_cache()
 
     def _login(self):
         """
-        Authenticate and return full login metadata.
-
-        Returns:
-            dict: Metadata with user_id, database, cluster, etc.
+        Sends login request to Erioon API using API key, email, and password.
+        Returns authentication metadata including SAS token.
         """
         url = f"{self.base_url}/login_with_credentials"
-        payload = {"api_key": self.api,"email": self.email, "password": self.password}
+        payload = {"api_key": self.api, "email": self.email, "password": self.password}
         headers = {"Content-Type": "application/json"}
 
         response = requests.post(url, json=payload, headers=headers)
         if response.status_code == 200:
             data = response.json()
             self.login_metadata = data
+            self._update_metadata_fields()
             return data
         else:
             raise Exception("Invalid account")
 
+    def _update_metadata_fields(self):
+        """
+        Updates internal fields like user_id, database name, and cluster info
+        from login metadata.
+        """
+        if self.login_metadata:
+            self.user_id = self.login_metadata.get("_id")
+            self.database = self.login_metadata.get("database")
+            self.cluster = self.login_metadata.get("cluster")
 
     def _clear_cached_token(self):
         """
-        Remove cached token file and reset user_id to None.
+        Clears the locally cached authentication token and resets internal state.
         """
         if os.path.exists(self.token_path):
             os.remove(self.token_path)
         self.user_id = None
+        self.login_metadata = None
 
-    def __getitem__(self, db_id):
+    def _is_sas_expired(self, metadata):
         """
-        Access a Database object by database ID.
-
-        Args:
-            db_id (str): The ID of the database to access.
+        Determines whether the SAS token has expired by comparing the 'sas_token_expiry'
+        or 'expiry' field with the current UTC time.
+        """
+        expiry_str = metadata.get("sas_token_expiry") or metadata.get("expiry")
 
-        Returns:
-            Database: An instance representing the database.
+        if not expiry_str:
+            return True
 
-        Raises:
-            ValueError: If client is not authenticated.
-            Exception: For other API errors not related to database existence.
+        try:
+            expiry_dt = datetime.fromisoformat(expiry_str.replace("Z", "+00:00"))
+            now = datetime.now(timezone.utc)
+            return now >= expiry_dt
+        except Exception:
+            return True
 
-        Handles:
-            On database-related errors, tries to relogin once. If relogin fails, returns "Login error".
-            If database still not found after relogin, returns a formatted error message.
+    def __getitem__(self, db_id):
+        """
+        Allows syntax like `client["my_database_id"]` to access a database.
+        If the token is expired or invalid, it attempts reauthentication.
         """
         if not self.user_id:
             raise ValueError("Client not authenticated. Cannot access database.")
-    
+
         try:
             return self._get_database_info(db_id)
         except Exception as e:
@@ -140,29 +129,22 @@ class ErioonClient:
             if f"database with {db_id.lower()}" in err_msg or "database" in err_msg:
                 self._clear_cached_token()
                 try:
-                    self.user_id = self._do_login_and_cache()
+                    self.login_metadata = self._do_login_and_cache()
+                    self._update_metadata_fields()
                 except Exception:
                     return "Login error"
-    
+
                 try:
                     return self._get_database_info(db_id)
                 except Exception:
                     return f"❌ Database with _id {db_id} ..."
             else:
                 raise e
-    
+
     def _get_database_info(self, db_id):
         """
-        Helper method to fetch database info from API and instantiate a Database object.
-
-        Args:
-            db_id (str): The database ID to fetch.
-
-        Returns:
-            Database: Database instance with the fetched info.
-
-        Raises:
-            Exception: If API returns an error.
+        Sends a POST request to fetch metadata for a given database ID.
+        Returns a `Database` instance initialized with SAS URL and metadata.
         """
         payload = {"user_id": self.user_id, "db_id": db_id}
         headers = {"Content-Type": "application/json"}
@@ -171,11 +153,24 @@ class ErioonClient:
 
         if response.status_code == 200:
             db_info = response.json()
+
+            container_url = self.login_metadata.get("container_url")
+            sas_token = self.login_metadata.get("sas_token")
+
+            if not container_url or not sas_token:
+                raise Exception("Missing SAS URL components for storage access")
+
+            if not sas_token.startswith("?"):
+                sas_token = "?" + sas_token
+
+            sas_url = container_url.split("?")[0] + sas_token
+
             return Database(
                 user_id=self.user_id,
                 metadata=db_info,
                 database=self.database,
-                cluster=self.cluster
+                cluster=self.cluster,
+                sas_url=sas_url
             )
         else:
             try:
@@ -187,12 +182,12 @@ class ErioonClient:
 
     def __str__(self):
         """
-        String representation: returns user_id if authenticated, else the error message.
+        Returns user_id or error string when printed.
         """
         return self.user_id if self.user_id else self.error
 
     def __repr__(self):
         """
-        Developer-friendly string representation of the client instance.
+        Developer-friendly representation of the client.
         """
         return f"<ErioonClient user_id={self.user_id}>" if self.user_id else f"<ErioonClient error='{self.error}'>"