erioon 0.1.4__tar.gz → 0.1.5__tar.gz

{erioon-0.1.4 → erioon-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: erioon
-Version: 0.1.4
+Version: 0.1.5
 Summary: Erioon Python SDK for seamless interaction with Erioon data services
 Author: Zyber Pireci
 Author-email: zyber.pireci@erioon.com

{erioon-0.1.4 → erioon-0.1.5}/erioon.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: erioon
-Version: 0.1.4
+Version: 0.1.5
 Summary: Erioon Python SDK for seamless interaction with Erioon data services
 Author: Zyber Pireci
 Author-email: zyber.pireci@erioon.com

erioon-0.1.5/erioon.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+setup.py
+erioon.egg-info/PKG-INFO
+erioon.egg-info/SOURCES.txt
+erioon.egg-info/dependency_links.txt
+erioon.egg-info/not-zip-safe
+erioon.egg-info/requires.txt
+erioon.egg-info/top_level.txt

{erioon-0.1.4 → erioon-0.1.5}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='erioon',
-    version='0.1.4',
+    version='0.1.5',
     author='Zyber Pireci',
     author_email='zyber.pireci@erioon.com',
     description='Erioon Python SDK for seamless interaction with Erioon data services',

erioon-0.1.4/erioon/auth.py

@@ -1,33 +0,0 @@
-# Copyright 2025-present Erioon, Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from erioon.client import ErioonClient
-
-def Auth(credential_string):
-    """
-    Authenticates a user using a colon-separated email:password string.
-
-    Parameters:
-    - credential_string (str): A string in the format "email:password"
-
-    Returns:
-    - ErioonClient instance: An instance representing the authenticated user.
-      If authentication fails, the instance will contain the error message.
-
-    Example usage:
-    >>> from erioon.auth import Auth
-    >>> client = Auth("<API_KEY>:<EMAIL>:<PASSWORD>")
-    >>> print(client)  # prints user_id if successful or error message if not
-    """
-    return ErioonClient(credential_string)

erioon-0.1.4/erioon/client.py

@@ -1,117 +0,0 @@
-# Copyright 2025-present Erioon, Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import requests
-from erioon.database import Database
-
-class ErioonClient:
-    def __init__(self, credential_string, base_url="https://sdk.erioon.com"):
-        self.credential_string = credential_string
-        self.base_url = base_url
-        self.user_id = None
-        self.login_metadata = None
-
-        parts = credential_string.split(":")
-
-        if len(parts) == 1 and credential_string.startswith("erioon"):
-            self.api = credential_string
-            self.email = None
-            self.password = None
-        else:
-            if len(parts) == 2:
-                self.email, self.password = parts
-                self.api = None
-            else:
-                raise ValueError("Invalid credential format. Use 'erioon-xxxxx' or 'email:password'")
-
-        try:
-            self.login_metadata = self._login()
-            self._update_metadata_fields()
-        except Exception as e:
-            print(f"[ErioonClient] Initialization error: {e}")
-
-
-    def _login(self):
-        url = f"{self.base_url}/login"
-        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
-            return data
-        else:
-            try:
-                msg = response.json().get("error", "Login failed")
-            except Exception:
-                msg = response.text
-            print(f"[ErioonClient] Login failed: {msg}")
-            raise RuntimeError(msg)
-
-    def _update_metadata_fields(self):
-        if self.login_metadata:
-            self.user_id = self.login_metadata.get("_id")
-            self.cluster = self.login_metadata.get("cluster")
-            self.database = self.login_metadata.get("database")
-            self.sas_tokens = self.login_metadata.get("sas_tokens", {})
-
-    def __getitem__(self, db_id):
-        if not self.user_id:
-            raise ValueError("Client not authenticated. Cannot access database.")
-
-        return self._get_database_info(db_id)
-
-    def _get_database_info(self, db_id):
-        payload = {"user_id": self.user_id, "db_id": db_id}
-        headers = {"Content-Type": "application/json"}
-        response = requests.post(f"{self.base_url}/db_info", json=payload, headers=headers)
-
-        if response.status_code == 200:
-            db_info = response.json()
-            sas_info = self.sas_tokens.get(db_id)
-            if not sas_info:
-                raise Exception(f"No SAS token info for database id {db_id}")
-
-            container_url = sas_info.get("container_url")
-            sas_token = sas_info.get("sas_token")
-
-            if not container_url or not sas_token:
-                raise Exception("Missing SAS URL components")
-
-            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,
-                sas_url=sas_url
-            )
-        else:
-            try:
-                error_json = response.json()
-                error_msg = error_json.get("error", response.text)
-            except Exception:
-                error_msg = response.text
-            raise Exception(f"Failed to fetch database info: {error_msg}")
-
-    def __str__(self):
-        return self.user_id if self.user_id else "[ErioonClient] Unauthenticated"
-
-    def __repr__(self):
-        return f"<ErioonClient user_id={self.user_id}>" if self.user_id else "<ErioonClient unauthenticated>"

erioon-0.1.4/erioon/collection.py

@@ -1,370 +0,0 @@
-# Copyright 2025-present Erioon, Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import json
-from urllib.parse import urlparse
-from erioon.read import handle_get_all, handle_find_one, handle_find_many, handle_count_records
-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_one, handle_update_many, handle_replace_one
-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}"
-
-    # PRINT ERIOON 
-    def _print_loading(self):
-        """Prints a loading message (likely for UX in CLI or SDK usage)."""
-        print("Erioon is loading...")
-
-    # CHECK READ / WRITE LICENCE
-    def _is_read_only(self):
-        """Check if the current database is marked as read-only."""
-        return self.database == "read"
-
-    # RESPONSE FOR ONLY WRITE
-    def _read_only_response(self):
-        """Standardized error response for blocked write operations."""
-        return "This user is not allowed to perform write operations.", 403
-
-    # GET ALL RECORDS OF A COLLECTION
-    def get_all(self, limit=1000000):
-        """
-        Fetch all records from the collection (up to a limit).
-        """
-        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
-
-    # FINDS A SPECIFIC RECORD OF A COLLECTION
-    def find_one(self, filters: dict | None = None):
-        """
-        Fetch a single record that matches specific key-value filters.
-        """
-        if self._is_read_only():
-            return self._read_only_response()
-
-        if filters is None:
-            filters = {}
-
-        search_criteria = [{k: v} for k, v in filters.items()]
-
-        result, status_code = handle_find_one(
-            user_id=self.user_id,
-            db_id=self.db_id,
-            coll_id=self.coll_id,
-            search_criteria=search_criteria,
-            container_url=self.container_url,
-        )
-        return result
-    
-    # FINDS MULTIPLE RECORDS OF A COLLECTION
-    def find_many(self, filters: dict | None = None, limit: int = 1000):
-        """
-        Fetch multiple records that match specific key-value filters.
-
-        Args:
-            filters (dict): Filters to match records.
-            limit (int): Maximum number of records to return (default: 1000).
-
-        Returns:
-            dict: Result from `handle_find_many()`
-        """
-        if self._is_read_only():
-            return self._read_only_response()
-
-        self._print_loading()
-
-        if filters is None:
-            filters = {}
-
-        if limit > 500_000:
-            raise ValueError("Limit of 500,000 exceeded")
-
-        search_criteria = [{k: v} for k, v in filters.items()]
-
-        result, status_code = handle_find_many(
-            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
-
-    # INSERT A SINGLE RECORD IN A COLLECTION
-    def insert_one(self, record):
-        """
-        Insert a single record into the collection.
-        """
-        if self._is_read_only():
-            return self._read_only_response()
-        response, status = handle_insert_one(
-            user_id_cont=self.user_id,
-            database=self.db_id,
-            collection=self.coll_id,
-            record=record,
-            container_url=self.container_url,
-        )
-        if status == 200:
-            print("Insertion was successful.")
-        else:
-            print(f"Error inserting record: {response}")
-        return response, status
-
-    # INSERT MULTIPLE RECORDS INTO A COLLECTION
-    def insert_many(self, data):
-        """
-        Insert multiple records into the collection.
-
-        Args:
-            data (list): List of record dicts.
-
-        Returns:
-            tuple: (response message, HTTP status code)
-        """
-        if self._is_read_only():
-            return self._read_only_response()
-        self._print_loading()
-        response, status = handle_insert_many(
-            user_id_cont=self.user_id,
-            database=self.db_id,
-            collection=self.coll_id,
-            data=data,
-            container_url=self.container_url,
-        )
-        if status == 200:
-            print("Insertion of multiple records was successful.")
-        else:
-            print(f"Error inserting records: {response}")
-        return response, status
-
-    # DELETE A SINGLE RECORD BASED ON _ID OR KEY
-    def delete_one(self, record_to_delete):
-        """
-        Delete a single record based on its _id or nested key.
-        """
-        if self._is_read_only():
-            return self._read_only_response()
-        response, status = 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,
-        )
-        if status == 200:
-            print("Deletion was successful.")
-        else:
-            print(f"Error deleting record: {response}")
-        return response, status
-
-    # DELETE MANY RECORDS IN BATCHES
-    def delete_many(self, records_to_delete_list, batch_size=10):
-        """
-        Delete multiple records in batches.
-        """
-        if self._is_read_only():
-            return self._read_only_response()
-        self._print_loading()
-        response, status = 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,
-        )
-        if status == 200:
-            print("Batch deletion was successful.")
-        else:
-            print(f"Error deleting records: {response}")
-        return response, status
-
-    # UPDATE A RECORD
-    def update_one(self, filter_query: dict, update_query: dict):
-        """
-        Update a record in-place by filtering and applying update logic.
-        """
-        if self._is_read_only():
-            return self._read_only_response()
-        response, status = handle_update_one(
-            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,
-        )
-        if status == 200:
-            print("Update was successful.")
-        else:
-            print(f"Error updating record: {response}")
-        return response, status
-
-    # UPDATE MULTIPLE RECORDS
-    def update_many(self, update_tasks: list):
-        """
-        Update multiple records in-place by applying a list of filter + update operations.
-
-        Each item in `update_tasks` should be a dict:
-            {
-                "filter": { ... },
-                "update": {
-                    "$set": {...}, "$push": {...}, "$remove": [...]
-                }
-            }
-
-        Returns:
-            (dict, int): Summary response and HTTP status code.
-        """
-        if self._is_read_only():
-            return self._read_only_response()
-        self._print_loading()
-        
-        response, status = handle_update_many(
-            user_id=self.user_id,
-            db_id=self.db_id,
-            coll_id=self.coll_id,
-            update_tasks=update_tasks,
-            container_url=self.container_url,
-        )
-
-        if status == 200:
-            print(f"Successfully updated {response.get('success')}")
-        else:
-            print(f"Error updating records: {response}")
-
-        return response, status
-
-    # REPLACE A SINGLE RECORDS BASED ON THE FILTER QUERY
-    def replace_one(self, filter_query: dict, replacement: dict):
-        """
-        Replaces a single record matching `filter_query` with the full `replacement` document.
-
-        - If `_id` is **not** in the replacement, preserves the original `_id`.
-        - If `_id` **is** in the replacement, uses the new `_id`.
-
-        Args:
-            filter_query (dict): Must contain a single key-value pair.
-            replacement (dict): New record to replace the old one.
-
-        Returns:
-            (dict, int): Response message and HTTP status code.
-        """
-        if self._is_read_only():
-            return self._read_only_response()
-
-        response, status = handle_replace_one(
-            user_id=self.user_id,
-            db_id=self.db_id,
-            coll_id=self.coll_id,
-            filter_query=filter_query,
-            replacement=replacement,
-            container_url=self.container_url,
-        )
-
-        if status == 200:
-            print("Replacement was successful.")
-        else:
-            print(f"Error replacing record: {response}")
-
-        return response, status
-
-    # PING AND CHECK CONNECTION
-    def ping(self):
-        """
-        Health check / ping to verify collection accessibility.
-        """
-        self._print_loading()
-        response, status = handle_connection_ping(
-            user_id=self.user_id,
-            db_id=self.db_id,
-            coll_id=self.coll_id,
-            container_url=self.container_url,
-        )
-        if status == 200:
-            print("Connection ping successful.")
-        else:
-            print(f"Ping failed: {response}")
-        return response, status
-
-    # COUNT ALL THE RECORDS
-    def count_records(self) -> int:
-        """
-        Count the total number of documents in the collection (across all shards).
-
-        Returns:
-            int: Total document count.
-        """
-        if self._is_read_only():
-            return 0
-        self._print_loading()
-
-        count, status = handle_count_records(
-            user_id=self.user_id,
-            db_id=self.db_id,
-            coll_id=self.coll_id,
-            container_url=self.container_url,
-        )
-        return count
-
-
-    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.1.4/erioon/create.py

@@ -1,130 +0,0 @@
-# Copyright 2025-present Erioon, Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-import uuid
-from erioon.functions import (
-    create_msgpack_file,
-    update_index_file_insert,
-    calculate_shard_number,
-    async_log,
-    is_duplicate_id
-)
-
-# INSERT ONE RECORD
-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
-
-# INSERT MANY RECORDS
-def handle_insert_many(user_id_cont, database, collection, data, container_url):
-    """
-    Insert multiple records in bulk.
-
-    - `data` is a list of dicts, each representing a record.
-    - 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: List of record dicts.
-        container_url: Blob Storage container SAS URL.
-
-    Returns:
-        Tuple (response dict, status code) with summary of insert results.
-    """
-    insert_results = []
-    count = len(data)
-
-    try:
-        for record in data:
-            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