erioon 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

erioon/client.py

@@ -1,106 +1,108 @@
+import os
+import json
 import requests
 from erioon.database import Database
 
 class ErioonClient:
-    """
-    Represents an authenticated Erioon client session.
-
-    Handles user login via email and password, and stores either the user's ID 
-    on success or an error message on failure.
-
-    Usage:
-    >>> client = ErioonClient("<EMAIL>:<PASSWORD>")
-    """
-
-    def __init__(self, email, password, base_url="https://sdk.erioon.com"):
-        """
-        Initializes the client and attempts login.
-
-        Args:
-            email (str): User email address.
-            password (str): User password.
-            base_url (str): The base URL of the Erioon API.
-        """
+    def __init__(self, email, password, base_url="http://127.0.0.1:5000"):
         self.email = email
         self.password = password
         self.base_url = base_url
         self.user_id = None
-        self.error = None 
+        self.error = None
+        self.token_path = os.path.expanduser(f"~/.erioon_token_{self._safe_filename(email)}")
 
         try:
-            self.user_id = self.login()
+            self.user_id = self._load_or_login()
         except Exception as e:
             self.error = str(e)
 
-    def login(self):
-        """
-        Sends a login request to the Erioon API.
+    def _safe_filename(self, text):
+        return "".join(c if c.isalnum() else "_" for c in text)
+
+    def _load_or_login(self):
+        # Try to load from local cache
+        if os.path.exists(self.token_path):
+            with open(self.token_path, "r") as f:
+                token_data = json.load(f)
+                user_id = token_data.get("user_id")
+                if user_id:
+                    return user_id  # ✅ Use cached value without API call
+
+        # Fallback: login and cache
+        return self._do_login_and_cache()
 
-        Returns:
-            str: User ID on successful login.
+    def _do_login_and_cache(self):
+        user_id = self._login()
+        with open(self.token_path, "w") as f:
+            json.dump({"user_id": user_id}, f)
+        return user_id
 
-        Raises:
-            Exception: If the login fails, with the error message from the server.
-        """
+    def _login(self):
         url = f"{self.base_url}/login_with_credentials"
         payload = {"email": self.email, "password": self.password}
         headers = {"Content-Type": "application/json"}
 
         response = requests.post(url, json=payload, headers=headers)
-
         if response.status_code == 200:
             return response.text.strip()
         else:
-            raise Exception(response.text.strip())
-
-    def __str__(self):
-        """
-        Called when print() or str() is used on the object.
+            raise Exception("Invalid account")
 
-        Returns:
-            str: User ID if authenticated, or error message if not.
-        """
-        return self.user_id if self.user_id else self.error
-
-    def __repr__(self):
-        """
-        Called in developer tools or when inspecting the object.
-
-        Returns:
-            str: Formatted string showing either user ID or error.
-        """
-        if self.user_id:
-            return f"<ErioonClient user_id={self.user_id}>"
-        else:
-            return f"<ErioonClient error='{self.error}'>"
+    def _clear_cached_token(self):
+        if os.path.exists(self.token_path):
+            os.remove(self.token_path)
+        self.user_id = None
 
     def __getitem__(self, db_id):
-        """
-        Get a Database object by its ID.
-
-        Calls the API to retrieve DB metadata and initializes a Database instance.
-        """
         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()
+            # Check if error is a database error mentioning the db_id
+            if f"database with {db_id.lower()}" in err_msg or "database" in err_msg:
+                # Try relogin once
+                self._clear_cached_token()
+                try:
+                    self.user_id = self._do_login_and_cache()
+                except Exception:
+                    return "Login error"
+    
+                # Retry fetching database info
+                try:
+                    return self._get_database_info(db_id)
+                except Exception as e2:
+                    print(f"❌ Database with _id {db_id} ...")
+                    # Optionally you could also return or raise the error here
+                    return f"❌ Database with _id {db_id} ..."
+            else:
+                # Not a DB-related error, just propagate or raise
+                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_error = response.json()
-            return db_error["error"]
-
-        db_info = response.json()
-        return Database(db_info)
+        if response.status_code == 200:
+            db_info = response.json()
+            return Database(self.user_id, db_info)
+        else:
+            # Try parse error json
+            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):
         return self.user_id if self.user_id else self.error
 
     def __repr__(self):
-        if self.user_id:
-            return f"<ErioonClient user_id={self.user_id}>"
-        else:
-            return f"<ErioonClient error='{self.error}'>"
+        return f"<ErioonClient user_id={self.user_id}>" if self.user_id else f"<ErioonClient error='{self.error}'>"

erioon/collection.py

@@ -0,0 +1,191 @@
+import json
+import requests
+from colorama import Fore, Style, init
+
+init(autoreset=True)
+
+class Collection:
+    def __init__(
+        self,
+        user_id,
+        db_id,
+        coll_id,
+        metadata,
+        base_url: str = "http://127.0.0.1:5000",
+    ):
+        """
+        Initialize a Collection instance.
+
+        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.
+        """
+        self.user_id = user_id
+        self.db_id = db_id
+        self.coll_id = coll_id
+        self.metadata = metadata
+        self.base_url = base_url.rstrip("/")
+
+    def _print_loading(self) -> None:
+        """Print a green loading message to the terminal."""
+        print(Fore.CYAN + "Erioon is loading..." + Style.RESET_ALL)
+
+    # ---------- READ ---------- #
+    def get_all(self):
+        """
+        Retrieve all documents from this collection.
+
+        Usage:
+            result = collection.get_all()
+        """
+        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 {}}
+
+    def get_specific(self, filters: dict | None = None, limit: int = 1000):
+        """
+        Retrieve documents matching filters.
+
+        Args:
+            filters (dict): Field/value pairs for filtering.
+            limit (int): Max number of docs to retrieve (max 500,000).
+
+        Usage:
+            result = collection.get_specific(filters={"name": "John"}, limit=100)
+        """
+        if limit > 500_000:
+            raise ValueError("Limit of 500,000 exceeded")
+        self._print_loading()
+
+        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 {}}
+
+    # ---------- CREATE ---------- #
+    def insert_one(self, document: dict):
+        """
+        Insert a single document.
+
+        Args:
+            document (dict): The document to insert.
+
+        Usage:
+            new_doc = {"name": "Alice", "age": 25}
+            result = collection.insert_one(new_doc)
+        """
+        self._print_loading()
+        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 {}}
+
+    def insert_many(self, documents: list):
+        """
+        Insert multiple documents at once.
+
+        Args:
+            documents (list): List of dicts representing documents.
+
+        Usage:
+            docs = [{"name": "A"}, {"name": "B"}]
+            result = collection.insert_many(docs)
+        """
+        self._print_loading()
+        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 {}}
+
+    # ---------- DELETE ---------- #
+    def delete_one(self, filter_query: dict):
+        """
+        Delete a single document matching the query.
+
+        Args:
+            filter_query (dict): A query to match one document.
+
+        Usage:
+            result = collection.delete_one({"name": "John"})
+        """
+        self._print_loading()
+        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 {}}
+
+    def delete_many(self, filter_query: dict):
+        """
+        Delete all documents matching the query.
+
+        Args:
+            filter_query (dict): A query to match multiple documents.
+
+        Usage:
+            result = collection.delete_many({"status": "inactive"})
+        """
+        self._print_loading()
+        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 ---------- #
+    def update_query(self, filter_query: dict, update_query: dict):
+        """
+        Update documents matching a filter query.
+
+        Args:
+            filter_query (dict): Query to find documents.
+            update_query (dict): Update operations to apply.
+
+        Usage:
+            result = collection.update_query(
+                {"age": {"$gt": 30}},
+                {"$set": {"status": "senior"}}
+            )
+        """
+        self._print_loading()
+        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."""
+        return json.dumps(self.metadata, indent=4)
+
+    def __repr__(self) -> str:
+        """Return a developer-friendly representation of the object."""
+        return f"<Collection coll_id={self.coll_id}>"

erioon/database.py

@@ -1,17 +1,31 @@
 import json
+from erioon.collection import Collection
 
 class Database:
-    def __init__(self, metadata):
+    def __init__(self, user_id, metadata):
+        self.user_id = user_id
         self.metadata = metadata
+        self.db_id = metadata.get("database_info", {}).get("_id")
 
     def __getitem__(self, collection_id):
-        """
-        Will return a Collection object (to be implemented in next steps).
-        """
-        raise NotImplementedError("Collection access not implemented yet.")
+        try:
+            collections = self.metadata.get("database_info", {}).get("collections", {})
+            coll_meta = collections.get(collection_id)
+
+            if not coll_meta:
+                return "No collection found"
+
+            return Collection(
+                user_id=self.user_id,
+                db_id=self.db_id,
+                coll_id=collection_id,
+                metadata=coll_meta
+            )
+        except Exception:
+            return "Connection error"
 
     def __str__(self):
         return json.dumps(self.metadata, indent=4)
 
     def __repr__(self):
-        return f"{self.metadata}"
+        return f"<Database db_id={self.db_id}>"

{erioon-0.0.1.dist-info → erioon-0.0.2.dist-info}/METADATA

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

erioon-0.0.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+erioon/auth.py,sha256=-a8g7JZKsQ_yir_iZMYbfhiBJT0hYDmfJSj6B1u3M84,704
+erioon/client.py,sha256=D5QHIdEL-13-dAoT5CITqbW9RqKUGEfswtTY8kTZH8w,3990
+erioon/collection.py,sha256=55CXEdB7ZmuqyHzHa39-SVRk2WJN-n_Yovb9rSlL-fg,6923
+erioon/database.py,sha256=n3arbUCYzJ1WAIh_1hgjJjUuCpyRVRP1quXGkTVgrsQ,953
+erioon-0.0.2.dist-info/LICENSE,sha256=xwnq3DNlZpQyteOK9HvtHRhMdYviXTTaCDljEodFRnQ,569
+erioon-0.0.2.dist-info/METADATA,sha256=0KLMfL0VvGu3Z9igmof68t5jip8CRyUi2zOVmlqLF9Q,715
+erioon-0.0.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+erioon-0.0.2.dist-info/top_level.txt,sha256=yjKEg85X5Q5ot46IMML_xukvIGG5YfdrLWcemjalItc,7
+erioon-0.0.2.dist-info/RECORD,,

erioon-0.0.1.dist-info/RECORD

@@ -1,8 +0,0 @@
-erioon/auth.py,sha256=-a8g7JZKsQ_yir_iZMYbfhiBJT0hYDmfJSj6B1u3M84,704
-erioon/client.py,sha256=GNr1q7MM9oxkfWyXFV2wCb78hEIYtIYJc03ziUxQ8Vw,3249
-erioon/database.py,sha256=vGCx3SvVpeEHB2kj54VD637A0fHbgpl9DUxMPzQKNH8,465
-erioon-0.0.1.dist-info/LICENSE,sha256=xwnq3DNlZpQyteOK9HvtHRhMdYviXTTaCDljEodFRnQ,569
-erioon-0.0.1.dist-info/METADATA,sha256=mvV_1TjduIMHHqm5P7UDiNphkR4E42JHlUoadxZ9qjU,715
-erioon-0.0.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-erioon-0.0.1.dist-info/top_level.txt,sha256=yjKEg85X5Q5ot46IMML_xukvIGG5YfdrLWcemjalItc,7
-erioon-0.0.1.dist-info/RECORD,,