erioon 0.0.6__py3-none-any.whl → 0.0.8__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,69 +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"
-        hashed_key = generate_password_hash(self.api)
-        payload = {"api_key": hashed_key,"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:
@@ -141,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"}
@@ -172,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:
@@ -188,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}'>"

erioon/collection.py

@@ -1,5 +1,10 @@
 import json
-import requests
+from urllib.parse import urlparse
+from erioon.read import handle_get_all, handle_get_data
+from erioon.create import handle_insert_one, handle_insert_many
+from erioon.delete import handle_delete_one, handle_delete_many
+from erioon.update import handle_update_query
+from erioon.ping import handle_connection_ping
 
 class Collection:
     def __init__(
@@ -10,61 +15,76 @@ class Collection:
         metadata,
         database,
         cluster,
-        base_url: str = "https://sdk.erioon.com",
+        sas_url,
     ):
+        
         """
-        Initialize a Collection instance.
+        Initialize a Collection object that wraps Erioon collection access.
 
         Args:
-            user_id (str): Authenticated user ID.
-            db_id   (str): Database ID.
-            coll_id (str): Collection ID.
-            metadata (dict): Collection metadata.
-            base_url (str): Base URL of the Erioon API.
+            user_id (str): The authenticated user's ID.
+            db_id (str): The database ID.
+            coll_id (str): The collection ID.
+            metadata (dict): Metadata info about this collection (e.g., schema, indexing, etc.).
+            database (str): Name or ID of the database.
+            cluster (str): Cluster name or ID hosting the database.
+            sas_url (str): Full SAS URL used to access the storage container.
         """
+        
         self.user_id = user_id
         self.db_id = db_id
         self.coll_id = coll_id
         self.metadata = metadata
-        self.database = database 
+        self.database = database
         self.cluster = cluster
-        self.base_url = base_url.rstrip("/")
 
-    def _print_loading(self) -> None:
-        """Print a green loading message to the terminal."""
+        parsed_url = urlparse(sas_url.rstrip("/"))
+        container_name = parsed_url.path.lstrip("/").split("/")[0]
+        account_url = f"{parsed_url.scheme}://{parsed_url.netloc}"
+        sas_token = parsed_url.query
+        self.container_url = f"{account_url}/{container_name}?{sas_token}"
+
+    def _print_loading(self):
+        """Prints a loading message (likely for UX in CLI or SDK usage)."""
         print("Erioon is loading...")
-        
+
     def _is_read_only(self):
+        """Check if the current database is marked as read-only."""
         return self.database == "read"
+    
+    def _read_only_response(self):
+        """Standardized error response for blocked write operations."""
+        return "This user is not allowed to perform write operations.", 403
 
-
-    # ---------- READ ---------- #
-    def get_all(self):
+    def get_all(self, limit=1000000):
         """
-        Retrieve all documents from this collection.
-
-        Usage:
-            result = collection.get_all()
+        Fetch all records from the collection (up to a limit).
+        
+        Args:
+            limit (int): Max number of records to fetch.
+        Returns:
+            list: Collection of records.
         """
         self._print_loading()
-        url = f"{self.base_url}/{self.user_id}/{self.db_id}/{self.coll_id}/get_all"
-        response = requests.get(url)
-        try:
-            response.raise_for_status()
-            return response.json()
-        except requests.HTTPError as e:
-            return {"status": "KO", "error": str(e), "response": response.json() if response.content else {}}
+        result, status_code = handle_get_all(
+            user_id=self.user_id,
+            db_id=self.db_id,
+            coll_id=self.coll_id,
+            limit=limit,
+            container_url=self.container_url,
+        )
+        return result
 
     def get_specific(self, filters: dict | None = None, limit: int = 1000):
         """
-        Retrieve documents matching filters.
-
+        Fetch records that match specific key-value filters.
+        
         Args:
-            filters (dict): Field/value pairs for filtering.
-            limit (int): Max number of docs to retrieve (max 500,000).
+            filters (dict): Dictionary of exact match filters.
+            limit (int): Max number of matching records to return.
 
-        Usage:
-            result = collection.get_specific(filters={"name": "John"}, limit=100)
+        Returns:
+            list: Filtered records from the collection.
         """
         if limit > 500_000:
             raise ValueError("Limit of 500,000 exceeded")
@@ -73,139 +93,141 @@ class Collection:
         if filters is None:
             filters = {}
 
-        url = f"{self.base_url}/{self.user_id}/{self.db_id}/{self.coll_id}/get_specific"
-        params = {**filters, "limit": limit}
-        response = requests.get(url, params=params)
-        try:
-            response.raise_for_status()
-            return response.json()
-        except requests.HTTPError as e:
-            return {"status": "KO", "error": str(e), "response": response.json() if response.content else {}}
+        search_criteria = [{k: v} for k, v in filters.items()]
+        print(search_criteria)
+
+        result, status_code = handle_get_data(
+            user_id=self.user_id,
+            db_id=self.db_id,
+            coll_id=self.coll_id,
+            search_criteria=search_criteria,
+            limit=limit,
+            container_url=self.container_url,
+        )
+        return result
 
-    # ---------- CREATE ---------- #
-    def insert_one(self, document: dict):
+    def insert_one(self, record):
         """
-        Insert a single document.
+        Insert a single record into the collection.
 
         Args:
-            document (dict): The document to insert.
+            record (dict): Record to insert.
 
-        Usage:
-            new_doc = {"name": "Alice", "age": 25}
-            result = collection.insert_one(new_doc)
+        Returns:
+            tuple: (response message, HTTP status code)
         """
-        self._print_loading()
         if self._is_read_only():
-            return {"status": "KO", "error": "Method not allowed. Access is only read."}
-        
-        url = f"{self.base_url}/{self.user_id}/{self.db_id}/{self.coll_id}/insert_one"
-        response = requests.post(url, json=document, headers={"Content-Type": "application/json"})
-        try:
-            response.raise_for_status()
-            return response.json()
-        except requests.HTTPError as e:
-            return {"status": "KO", "error": str(e), "response": response.json() if response.content else {}}
+            return self._read_only_response()
+        return handle_insert_one(
+            user_id_cont=self.user_id,
+            database=self.db_id,
+            collection=self.coll_id,
+            record=record,
+            container_url=self.container_url,
+        )
 
-    def insert_many(self, documents: list):
+    def insert_many(self, data):
         """
-        Insert multiple documents at once.
+        Insert multiple records into the collection.
 
         Args:
-            documents (list): List of dicts representing documents.
+            data (list of dicts): Multiple records to insert.
 
-        Usage:
-            docs = [{"name": "A"}, {"name": "B"}]
-            result = collection.insert_many(docs)
+        Returns:
+            tuple: (response message, HTTP status code)
         """
-        self._print_loading()
         if self._is_read_only():
-            return {"status": "KO", "error": "Method not allowed. Access is only read."}
-        
-        url = f"{self.base_url}/{self.user_id}/{self.db_id}/{self.coll_id}/insert_many"
-        response = requests.post(url, json={"records": documents})
-        try:
-            response.raise_for_status()
-            return response.json()
-        except requests.HTTPError as e:
-            return {"status": "KO", "error": str(e), "response": response.json() if response.content else {}}
+            return self._read_only_response()
+        return handle_insert_many(
+            user_id_cont=self.user_id,
+            database=self.db_id,
+            collection=self.coll_id,
+            data=data,
+            container_url=self.container_url,
+        )
 
-    # ---------- DELETE ---------- #
-    def delete_one(self, filter_query: dict):
+    def delete_one(self, record_to_delete):
         """
-        Delete a single document matching the query.
+        Delete a single record based on its _id or nested key.
 
         Args:
-            filter_query (dict): A query to match one document.
+            record_to_delete (dict): Identification of the record.
 
-        Usage:
-            result = collection.delete_one({"name": "John"})
+        Returns:
+            tuple: (response message, HTTP status code)
         """
-        self._print_loading()
         if self._is_read_only():
-            return {"status": "KO", "error": "Method not allowed. Access is only read."}
-        
-        url = f"{self.base_url}/{self.user_id}/{self.db_id}/{self.coll_id}/delete_one"
-        response = requests.delete(url, json=filter_query)
-        try:
-            response.raise_for_status()
-            return response.json()
-        except requests.HTTPError as e:
-            return {"status": "KO", "error": str(e), "response": response.json() if response.content else {}}
+            return self._read_only_response()
+        return handle_delete_one(
+            user_id=self.user_id,
+            db_id=self.db_id,
+            coll_id=self.coll_id,
+            data_to_delete=record_to_delete,
+            container_url=self.container_url,
+        )
 
-    def delete_many(self, filter_query: dict):
+    def delete_many(self, records_to_delete_list, batch_size=10):
         """
-        Delete all documents matching the query.
+        Delete multiple records in batches.
 
         Args:
-            filter_query (dict): A query to match multiple documents.
+            records_to_delete_list (list): List of record identifiers.
+            batch_size (int): How many to delete at once (for efficiency).
 
-        Usage:
-            result = collection.delete_many({"status": "inactive"})
+        Returns:
+            tuple: (response message, HTTP status code)
         """
-        self._print_loading()
         if self._is_read_only():
-            return {"status": "KO", "error": "Method not allowed. Access is only read."}
-        
-        url = f"{self.base_url}/{self.user_id}/{self.db_id}/{self.coll_id}/delete_many"
-        response = requests.delete(url, json=filter_query)
-        try:
-            response.raise_for_status()
-            return response.json()
-        except requests.HTTPError as e:
-            return {"status": "KO", "error": str(e), "response": response.json() if response.content else {}}
-
-    # ---------- UPDATE ---------- #
+            return self._read_only_response()
+        return handle_delete_many(
+            user_id=self.user_id,
+            db_id=self.db_id,
+            coll_id=self.coll_id,
+            data_to_delete_list=records_to_delete_list,
+            batch_size=batch_size,
+            container_url=self.container_url,
+        )
+
     def update_query(self, filter_query: dict, update_query: dict):
         """
-        Update documents matching a filter query.
+        Update a record in-place by filtering and applying update logic.
 
         Args:
-            filter_query (dict): Query to find documents.
-            update_query (dict): Update operations to apply.
+            filter_query (dict): Dict describing what record(s) to match.
+            update_query (dict): Dict describing update operators ($set, $push, $remove).
 
-        Usage:
-            result = collection.update_query(
-                {"age": {"$gt": 30}},
-                {"$set": {"status": "senior"}}
-            )
+        Returns:
+            tuple: (response message, HTTP status code)
         """
-        self._print_loading()
         if self._is_read_only():
-            return {"status": "KO", "error": "Method not allowed. Access is only read."}
+            return self._read_only_response()
+        return handle_update_query(
+            user_id=self.user_id,
+            db_id=self.db_id,
+            coll_id=self.coll_id,
+            filter_query=filter_query,
+            update_query=update_query,
+            container_url=self.container_url,
+        )
         
-        url = f"{self.base_url}/{self.user_id}/{self.db_id}/{self.coll_id}/update_query"
-        response = requests.patch(url, json={"filter_query": filter_query, "update_query": update_query})
-        try:
-            response.raise_for_status()
-            return response.json()
-        except requests.HTTPError as e:
-            return {"status": "KO", "error": str(e), "response": response.json() if response.content else {}}
-
-    # ---------- dunder helpers ---------- #
-    def __str__(self) -> str:
-        """Return a human-readable JSON string of collection metadata."""
+    def ping(self):
+        """
+        Health check / ping to verify collection accessibility.
+
+        Returns:
+            tuple: (response message, HTTP status code)
+        """
+        return handle_connection_ping(
+            user_id=self.user_id,
+            db_id=self.db_id,
+            coll_id=self.coll_id,
+            container_url=self.container_url,
+        )
+
+    def __str__(self):
+        """Pretty print the collection metadata."""
         return json.dumps(self.metadata, indent=4)
 
-    def __repr__(self) -> str:
-        """Return a developer-friendly representation of the object."""
+    def __repr__(self):
+        """Simplified representation for debugging or introspection."""
         return f"<Collection coll_id={self.coll_id}>"