erioon 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

erioon-0.1.3.dist-info/METADATA

@@ -0,0 +1,30 @@
+Metadata-Version: 2.2
+Name: erioon
+Version: 0.1.3
+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.3.dist-info/RECORD

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

erioon-0.1.3.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,191 +0,0 @@
-import os
-import json
-import requests
-from datetime import datetime, timezone
-from erioon.database import Database
-
-class ErioonClient:
-    """
-    Client SDK for interacting with the Erioon API.
-
-    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"):
-        self.api = api
-        self.email = email
-        self.password = password
-        self.base_url = base_url
-        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:
-            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 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):
-        """
-        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:
-            json.dump(metadata, f)
-        return metadata
-
-    def _load_or_login(self):
-        """
-        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 self._is_sas_expired(metadata):
-                metadata = self._do_login_and_cache()
-            return metadata
-        else:
-            return self._do_login_and_cache()
-
-    def _login(self):
-        """
-        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}
-        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):
-        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):
-        """
-        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 _is_sas_expired(self, metadata):
-        """
-        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")
-
-        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):
-        """
-        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:
-            err_msg = str(e).lower()
-            if f"database with {db_id.lower()}" in err_msg or "database" in err_msg:
-                self._clear_cached_token()
-                try:
-                    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):
-        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 found 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 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,
-                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(error_msg)
-    
-    def __str__(self):
-        """
-        Returns user_id or error string when printed.
-        """
-        return self.user_id if self.user_id else self.error
-
-    def __repr__(self):
-        """
-        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,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}>"