erioon 0.0.7__tar.gz → 0.0.8__tar.gz

{erioon-0.0.7 → erioon-0.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: erioon
-Version: 0.0.7
+Version: 0.0.8
 Summary: Erioon SDF for Python
 Author: Zyber Pireci
 Author-email: zyber.pireci@erioon.com

{erioon-0.0.7 → erioon-0.0.8}/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-0.0.7 → erioon-0.0.8}/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}'>"

erioon-0.0.8/erioon/collection.py

@@ -0,0 +1,233 @@
+import json
+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__(
+        self,
+        user_id,
+        db_id,
+        coll_id,
+        metadata,
+        database,
+        cluster,
+        sas_url,
+    ):
+        
+        """
+        Initialize a Collection object that wraps Erioon collection access.
+
+        Args:
+            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.cluster = cluster
+
+        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
+
+    def get_all(self, limit=1000000):
+        """
+        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()
+        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):
+        """
+        Fetch records that match specific key-value filters.
+        
+        Args:
+            filters (dict): Dictionary of exact match filters.
+            limit (int): Max number of matching records to return.
+
+        Returns:
+            list: Filtered records from the collection.
+        """
+        if limit > 500_000:
+            raise ValueError("Limit of 500,000 exceeded")
+        self._print_loading()
+
+        if filters is None:
+            filters = {}
+
+        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
+
+    def insert_one(self, record):
+        """
+        Insert a single record into the collection.
+
+        Args:
+            record (dict): Record to insert.
+
+        Returns:
+            tuple: (response message, HTTP status code)
+        """
+        if self._is_read_only():
+            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, data):
+        """
+        Insert multiple records into the collection.
+
+        Args:
+            data (list of dicts): Multiple records to insert.
+
+        Returns:
+            tuple: (response message, HTTP status code)
+        """
+        if self._is_read_only():
+            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,
+        )
+
+    def delete_one(self, record_to_delete):
+        """
+        Delete a single record based on its _id or nested key.
+
+        Args:
+            record_to_delete (dict): Identification of the record.
+
+        Returns:
+            tuple: (response message, HTTP status code)
+        """
+        if self._is_read_only():
+            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, records_to_delete_list, batch_size=10):
+        """
+        Delete multiple records in batches.
+
+        Args:
+            records_to_delete_list (list): List of record identifiers.
+            batch_size (int): How many to delete at once (for efficiency).
+
+        Returns:
+            tuple: (response message, HTTP status code)
+        """
+        if self._is_read_only():
+            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 a record in-place by filtering and applying update logic.
+
+        Args:
+            filter_query (dict): Dict describing what record(s) to match.
+            update_query (dict): Dict describing update operators ($set, $push, $remove).
+
+        Returns:
+            tuple: (response message, HTTP status code)
+        """
+        if self._is_read_only():
+            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,
+        )
+        
+    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):
+        """Simplified representation for debugging or introspection."""
+        return f"<Collection coll_id={self.coll_id}>"

erioon-0.0.8/erioon/create.py

@@ -0,0 +1,159 @@
+from azure.storage.blob import ContainerClient
+import uuid
+import json
+from erioon.functions import (
+    create_msgpack_file,
+    update_index_file_insert,
+    calculate_shard_number,
+    async_log
+)
+
+def get_index_data(user_id_cont, database, collection, container_url):
+    """
+    Retrieves the content of the index.json file that tracks which records are stored in which shards.
+
+    Args:
+        user_id_cont: User identifier or context.
+        database: Database name.
+        collection: Collection name.
+        container_url: Blob Storage container SAS URL.
+
+    Returns:
+        List of shard mappings (list of dicts) or empty list if file not found or error.
+    """
+    container_client = ContainerClient.from_container_url(container_url)
+    index_blob_client = container_client.get_blob_client(blob=f"{database}/{collection}/index.json")
+
+    try:
+        index_data = index_blob_client.download_blob().readall()
+        return json.loads(index_data) if index_data else []
+    except Exception:
+        return []
+
+def is_duplicate_id(user_id_cont, database, collection, _id, container_url):
+    """
+    Checks if the given record _id is already present in the index.json across shards.
+
+    Args:
+        user_id_cont: User identifier.
+        database: Database name.
+        collection: Collection name.
+        _id: Record ID to check.
+        container_url: Blob Storage container SAS URL.
+
+    Returns:
+        True if _id exists in any shard, else False.
+    """
+    index_data = get_index_data(user_id_cont, database, collection, container_url)
+
+    for shard in index_data:
+        for shard_name, ids in shard.items():
+            if _id in ids:
+                return True 
+    return False
+
+def handle_insert_one(user_id_cont, database, collection, record, container_url):
+    """
+    Insert a single record into the collection.
+
+    - If no '_id' provided, generate a new UUID.
+    - If provided '_id' is duplicate, generate a new one and update the record.
+    - Create or append the record in a shard file.
+    - Update index.json to map the record to the appropriate shard.
+    - Log success or errors asynchronously.
+
+    Args:
+        user_id_cont: User identifier.
+        database: Database name.
+        collection: Collection name.
+        record: Dict representing the record to insert.
+        container_url: Blob Storage container SAS URL.
+
+    Returns:
+        Tuple (response dict, status code) indicating success or failure.
+    """
+    try:
+        if "_id" not in record or not record["_id"]:
+            record["_id"] = str(uuid.uuid4())
+
+        rec_id = record["_id"]
+
+        if is_duplicate_id(user_id_cont, database, collection, rec_id, container_url):
+            new_id = str(uuid.uuid4())
+            record["_id"] = new_id
+            rec_id = new_id
+            msg = f"Record inserted successfully in {collection} with a new _id {rec_id} because the provided _id was already present."
+        else:
+            msg = f"Record inserted successfully in {collection} with _id {rec_id}"
+
+        async_log(user_id_cont, database, collection, "POST", "SUCCESS", msg, 1, container_url)
+
+        create_msgpack_file(user_id_cont, database, collection, record, container_url)
+
+        shard_number = calculate_shard_number(user_id_cont, database, collection, container_url)
+        update_index_file_insert(user_id_cont, database, collection, rec_id, shard_number, container_url)
+
+        return {"status": "OK", "message": msg, "record": record}, 200
+
+    except Exception as e:
+        error_msg = f"An error occurred during insert in {collection}: {str(e)}"
+        async_log(user_id_cont, database, collection,"POST", "ERROR", error_msg, 1, container_url)
+        return {"status": "KO", "message": "Failed to insert record.", "error": str(e)}, 500
+
+def handle_insert_many(user_id_cont, database, collection, data, container_url):
+    """
+    Insert multiple records in bulk.
+
+    - For each record:
+      - Ensure it has a unique _id (generate new UUID if missing or duplicate).
+      - Write the record to the appropriate shard.
+      - Update index.json with _id to shard mapping.
+    - Log the batch insert operation with details.
+    - Return aggregate success or failure response.
+
+    Args:
+        user_id_cont: User identifier.
+        database: Database name.
+        collection: Collection name.
+        data: Dict with key "records" containing list of record dicts.
+        container_url: Blob Storage container SAS URL.
+
+    Returns:
+        Tuple (response dict, status code) with summary of insert results.
+    """
+    insert_results = []
+    records = data.get("records", [])
+    count = len(records)
+    
+    try:
+        for record in records:
+            if "_id" not in record or not record["_id"]:
+                record["_id"] = str(uuid.uuid4())
+
+            rec_id = record["_id"]
+
+            if is_duplicate_id(user_id_cont, database, collection, rec_id, container_url):
+                new_id = str(uuid.uuid4())
+                record["_id"] = new_id
+                rec_id = new_id
+                msg = f"Inserted with new _id {rec_id} (original _id was already present)."
+            else:
+                msg = f"Inserted with _id {rec_id}."
+
+            create_msgpack_file(user_id_cont, database, collection, record, container_url)
+
+            shard_number = calculate_shard_number(user_id_cont, database, collection, container_url)
+            update_index_file_insert(
+                user_id_cont, database, collection, rec_id, shard_number, container_url
+            )
+
+            insert_results.append({"_id": rec_id, "message": msg})
+
+        async_log(user_id_cont, database, collection, "POST", "SUCCESS", insert_results, count, container_url)
+        return {"success": "Records inserted successfully", "details": insert_results}, 200
+        
+
+    except Exception as e:
+        general_error_msg = f"Unexpected error during bulk insert: {str(e)}"
+        async_log(user_id_cont, database, collection, "POST", "ERROR", general_error_msg, 1, container_url)
+        return {"status": "KO", "message": general_error_msg}, 500