erioon 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

erioon-0.1.4.dist-info/METADATA

@@ -0,0 +1,30 @@
+Metadata-Version: 2.2
+Name: erioon
+Version: 0.1.4
+Summary: Erioon Python SDK for seamless interaction with Erioon data services
+Author: Zyber Pireci
+Author-email: zyber.pireci@erioon.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.6
+Description-Content-Type: text/plain
+License-File: LICENSE
+Requires-Dist: requests>=2.25.1
+Requires-Dist: pyodbc
+Requires-Dist: azure-storage-blob
+Requires-Dist: msgpack
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+The Erioon SDK for Python provides a robust interface to interact with Erioon resources such as collections, databases, and clusters. It supports CRUD operations, querying, and connection management with ease, enabling developers to integrate Erioon data services into their applications efficiently.

erioon-0.1.4.dist-info/RECORD

@@ -0,0 +1,5 @@
+erioon-0.1.4.dist-info/LICENSE,sha256=xwnq3DNlZpQyteOK9HvtHRhMdYviXTTaCDljEodFRnQ,569
+erioon-0.1.4.dist-info/METADATA,sha256=hOjsdNViFMKZGlj6vtQR9hxPbZtfoyFMOtFAVX_Bz6E,1165
+erioon-0.1.4.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+erioon-0.1.4.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+erioon-0.1.4.dist-info/RECORD,,

erioon-0.1.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+

erioon/auth.py

@@ -1,20 +0,0 @@
-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
-    """
-    api, email, password = credential_string.split(":")
-    return ErioonClient(api ,email, password)

erioon/client.py

@@ -1,150 +0,0 @@
-import os
-import json
-import requests
-from datetime import datetime, timezone
-from erioon.database import Database
-
-class ErioonClient:
-    def __init__(self, api, email, password, base_url="https://sdk.erioon.com"):
-        self.api = api
-        self.email = email
-        self.password = password
-        self.base_url = base_url
-        self.user_id = None
-        self.token_path = os.path.expanduser(f"~/.erioon_token_{self._safe_filename(email)}")
-        self.login_metadata = None
-
-        try:
-            self.login_metadata = self._load_or_login()
-            self._update_metadata_fields()
-        except Exception as e:
-            print(f"[ErioonClient] Initialization error: {e}")
-
-    def _safe_filename(self, text):
-        return "".join(c if c.isalnum() else "_" for c in text)
-
-    def _do_login_and_cache(self):
-        metadata = self._login()
-        with open(self.token_path, "w") as f:
-            json.dump(metadata, f)
-        return metadata
-
-    def _load_or_login(self):
-        if os.path.exists(self.token_path):
-            with open(self.token_path, "r") as f:
-                metadata = json.load(f)
-            if self._is_sas_expired(metadata):
-                return self._do_login_and_cache()
-            return metadata
-        else:
-            return self._do_login_and_cache()
-
-    def _login(self):
-        url = f"{self.base_url}/login_with_credentials"
-        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:
-            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 _clear_cached_token(self):
-        if os.path.exists(self.token_path):
-            os.remove(self.token_path)
-        self.user_id = None
-        self.login_metadata = None
-
-    def _is_sas_expired(self, metadata):
-        expiry_str = metadata.get("sas_token_expiry") or metadata.get("expiry")
-        if not expiry_str:
-            return True
-        try:
-            expiry_dt = datetime.fromisoformat(expiry_str.replace("Z", "+00:00"))
-            now = datetime.now(timezone.utc)
-            return now >= expiry_dt
-        except Exception:
-            return True
-
-    def __getitem__(self, db_id):
-        if not self.user_id:
-            print(f"[ErioonClient] Not authenticated. Cannot access database {db_id}.")
-            raise ValueError("Client not authenticated.")
-
-        try:
-            return self._get_database_info(db_id)
-        except Exception as e:
-            print(f"[ErioonClient] Access failed for DB {db_id}, retrying login... ({e})")
-            self._clear_cached_token()
-
-            try:
-                self.login_metadata = self._do_login_and_cache()
-                self._update_metadata_fields()
-            except Exception as login_error:
-                print(f"[ErioonClient] Re-login failed: {login_error}")
-                raise RuntimeError(login_error)
-
-            try:
-                return self._get_database_info(db_id)
-            except Exception as second_error:
-                print(f"[ErioonClient] DB fetch after re-auth failed: {second_error}")
-                raise RuntimeError(second_error)
-
-    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/collection.py

@@ -1,298 +0,0 @@
-import json
-from urllib.parse import urlparse
-from erioon.read import handle_get_all, handle_get_data, handle_classify_vector
-from erioon.create import handle_insert_one, handle_insert_many, handle_vector, handle_insert_many_vectors
-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 insert_one_vector(self, vector_data, metadata):
-        """
-        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()
-        self._print_loading()
-        return handle_vector(
-            user_id_cont=self.user_id,
-            database=self.db_id,
-            collection=self.coll_id,
-            vector=vector_data,
-            metadata=metadata,
-            container_url=self.container_url,
-        )
-        
-    def insert_many_vectors(self, records):
-        """
-        Insert multiple vector records into the collection.
-
-        Args:
-            records (list): List of dicts, each with keys 'vector', 'metadata', and optional '_id'.
-
-        Returns:
-            tuple: (response message, HTTP status code)
-        """
-        if self._is_read_only():
-            return self._read_only_response()
-        self._print_loading()
-        return handle_insert_many_vectors(
-            user_id_cont=self.user_id,
-            database=self.db_id,
-            collection=self.coll_id,
-            records=records,
-            container_url=self.container_url,
-        )
-        
-    def classify_vector(self, k=3):
-        """
-        Retrieve all vector records from the collection and classify them using k-NN.
-
-        Args:
-            k (int): Number of neighbors to use for classification.
-
-        Returns:
-            tuple: (response message, HTTP status code)
-        """
-        if self._is_read_only():
-            return self._read_only_response()
-        self._print_loading()
-        return handle_classify_vector(
-            user_id=self.user_id,
-            db_id=self.db_id,
-            coll_id=self.coll_id,
-            container_url=self.container_url,
-            k=k
-        )
-
-
-    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}>"