memorisdk 1.0.0__py3-none-any.whl

memoriai/database/__init__.py

@@ -0,0 +1,5 @@
+"""Database components for Memoriai"""
+
+from .connectors import MySQLConnector, PostgreSQLConnector, SQLiteConnector
+
+__all__ = ["SQLiteConnector", "PostgreSQLConnector", "MySQLConnector"]

memoriai/database/connectors/__init__.py

@@ -0,0 +1,9 @@
+"""
+Database connectors for different database backends
+"""
+
+from .mysql_connector import MySQLConnector
+from .postgres_connector import PostgreSQLConnector
+from .sqlite_connector import SQLiteConnector
+
+__all__ = ["SQLiteConnector", "PostgreSQLConnector", "MySQLConnector"]

memoriai/database/connectors/mysql_connector.py

@@ -0,0 +1,159 @@
+"""
+MySQL connector for Memori v1.0
+"""
+
+from typing import Any, Dict, List, Optional
+
+from loguru import logger
+
+from ...utils.exceptions import DatabaseError
+
+
+class MySQLConnector:
+    """MySQL database connector"""
+
+    def __init__(self, connection_config: Dict[str, str]):
+        """Initialize MySQL connector"""
+        self.connection_config = connection_config
+        self._mysql = None
+        self._setup_mysql()
+
+    def _setup_mysql(self):
+        """Setup MySQL connection library"""
+        try:
+            import mysql.connector
+
+            self._mysql = mysql.connector
+        except ImportError:
+            raise DatabaseError(
+                "mysql-connector-python is required for MySQL support. "
+                "Install it with: pip install mysql-connector-python"
+            )
+
+    def get_connection(self):
+        """Get MySQL connection"""
+        try:
+            conn = self._mysql.connect(**self.connection_config)
+            return conn
+
+        except Exception as e:
+            raise DatabaseError(f"Failed to connect to MySQL database: {e}")
+
+    def execute_query(
+        self, query: str, params: Optional[List] = None
+    ) -> List[Dict[str, Any]]:
+        """Execute a query and return results"""
+        try:
+            with self.get_connection() as conn:
+                cursor = conn.cursor(dictionary=True)
+
+                if params:
+                    cursor.execute(query, params)
+                else:
+                    cursor.execute(query)
+
+                results = cursor.fetchall()
+                cursor.close()
+
+                return results
+
+        except Exception as e:
+            raise DatabaseError(f"Failed to execute query: {e}")
+
+    def execute_insert(self, query: str, params: Optional[List] = None) -> str:
+        """Execute an insert query and return the inserted row ID"""
+        try:
+            with self.get_connection() as conn:
+                cursor = conn.cursor()
+
+                if params:
+                    cursor.execute(query, params)
+                else:
+                    cursor.execute(query)
+
+                conn.commit()
+                inserted_id = str(cursor.lastrowid)
+                cursor.close()
+
+                return inserted_id
+
+        except Exception as e:
+            raise DatabaseError(f"Failed to execute insert: {e}")
+
+    def execute_update(self, query: str, params: Optional[List] = None) -> int:
+        """Execute an update query and return number of affected rows"""
+        try:
+            with self.get_connection() as conn:
+                cursor = conn.cursor()
+
+                if params:
+                    cursor.execute(query, params)
+                else:
+                    cursor.execute(query)
+
+                conn.commit()
+                affected_rows = cursor.rowcount
+                cursor.close()
+
+                return affected_rows
+
+        except Exception as e:
+            raise DatabaseError(f"Failed to execute update: {e}")
+
+    def execute_delete(self, query: str, params: Optional[List] = None) -> int:
+        """Execute a delete query and return number of affected rows"""
+        try:
+            with self.get_connection() as conn:
+                cursor = conn.cursor()
+
+                if params:
+                    cursor.execute(query, params)
+                else:
+                    cursor.execute(query)
+
+                conn.commit()
+                affected_rows = cursor.rowcount
+                cursor.close()
+
+                return affected_rows
+
+        except Exception as e:
+            raise DatabaseError(f"Failed to execute delete: {e}")
+
+    def execute_transaction(self, queries: List[tuple]) -> bool:
+        """Execute multiple queries in a transaction"""
+        try:
+            with self.get_connection() as conn:
+                cursor = conn.cursor()
+
+                try:
+                    for query, params in queries:
+                        if params:
+                            cursor.execute(query, params)
+                        else:
+                            cursor.execute(query)
+
+                    conn.commit()
+                    cursor.close()
+                    return True
+
+                except Exception as e:
+                    conn.rollback()
+                    cursor.close()
+                    raise e
+
+        except Exception as e:
+            logger.error(f"Transaction failed: {e}")
+            return False
+
+    def test_connection(self) -> bool:
+        """Test if the database connection is working"""
+        try:
+            with self.get_connection() as conn:
+                cursor = conn.cursor()
+                cursor.execute("SELECT 1")
+                cursor.close()
+                return True
+        except Exception as e:
+            logger.error(f"Connection test failed: {e}")
+            return False

memoriai/database/connectors/postgres_connector.py

@@ -0,0 +1,158 @@
+"""
+PostgreSQL connector for Memori v1.0
+"""
+
+from typing import Any, Dict, List, Optional
+
+from loguru import logger
+
+from ...utils.exceptions import DatabaseError
+
+
+class PostgreSQLConnector:
+    """PostgreSQL database connector"""
+
+    def __init__(self, connection_string: str):
+        """Initialize PostgreSQL connector"""
+        self.connection_string = connection_string
+        self._psycopg2 = None
+        self._setup_psycopg2()
+
+    def _setup_psycopg2(self):
+        """Setup psycopg2 connection"""
+        try:
+            import psycopg2
+            import psycopg2.extras
+
+            self._psycopg2 = psycopg2
+            self._extras = psycopg2.extras
+        except ImportError:
+            raise DatabaseError(
+                "psycopg2 is required for PostgreSQL support. "
+                "Install it with: pip install psycopg2-binary"
+            )
+
+    def get_connection(self):
+        """Get PostgreSQL connection"""
+        try:
+            conn = self._psycopg2.connect(
+                self.connection_string, cursor_factory=self._extras.RealDictCursor
+            )
+            conn.autocommit = False
+            return conn
+
+        except Exception as e:
+            raise DatabaseError(f"Failed to connect to PostgreSQL database: {e}")
+
+    def execute_query(
+        self, query: str, params: Optional[List] = None
+    ) -> List[Dict[str, Any]]:
+        """Execute a query and return results"""
+        try:
+            with self.get_connection() as conn:
+                with conn.cursor() as cursor:
+                    if params:
+                        cursor.execute(query, params)
+                    else:
+                        cursor.execute(query)
+
+                    # Return results as list of dictionaries
+                    results = []
+                    for row in cursor.fetchall():
+                        results.append(dict(row))
+
+                    return results
+
+        except Exception as e:
+            raise DatabaseError(f"Failed to execute query: {e}")
+
+    def execute_insert(self, query: str, params: Optional[List] = None) -> str:
+        """Execute an insert query and return the inserted row ID"""
+        try:
+            with self.get_connection() as conn:
+                with conn.cursor() as cursor:
+                    if params:
+                        cursor.execute(query, params)
+                    else:
+                        cursor.execute(query)
+
+                    # Try to get the inserted ID
+                    inserted_id = None
+                    if cursor.rowcount > 0:
+                        try:
+                            # For PostgreSQL, we need RETURNING clause for ID
+                            inserted_id = cursor.fetchone()
+                            if inserted_id and hasattr(inserted_id, "values"):
+                                inserted_id = str(list(inserted_id.values())[0])
+                            else:
+                                inserted_id = str(cursor.rowcount)
+                        except Exception:
+                            inserted_id = str(cursor.rowcount)
+
+                    conn.commit()
+                    return inserted_id or "0"
+
+        except Exception as e:
+            raise DatabaseError(f"Failed to execute insert: {e}")
+
+    def execute_update(self, query: str, params: Optional[List] = None) -> int:
+        """Execute an update query and return number of affected rows"""
+        try:
+            with self.get_connection() as conn:
+                with conn.cursor() as cursor:
+                    if params:
+                        cursor.execute(query, params)
+                    else:
+                        cursor.execute(query)
+
+                    conn.commit()
+                    return cursor.rowcount
+
+        except Exception as e:
+            raise DatabaseError(f"Failed to execute update: {e}")
+
+    def execute_delete(self, query: str, params: Optional[List] = None) -> int:
+        """Execute a delete query and return number of affected rows"""
+        try:
+            with self.get_connection() as conn:
+                with conn.cursor() as cursor:
+                    if params:
+                        cursor.execute(query, params)
+                    else:
+                        cursor.execute(query)
+
+                    conn.commit()
+                    return cursor.rowcount
+
+        except Exception as e:
+            raise DatabaseError(f"Failed to execute delete: {e}")
+
+    def execute_transaction(self, queries: List[tuple]) -> bool:
+        """Execute multiple queries in a transaction"""
+        try:
+            with self.get_connection() as conn:
+                with conn.cursor() as cursor:
+
+                    for query, params in queries:
+                        if params:
+                            cursor.execute(query, params)
+                        else:
+                            cursor.execute(query)
+
+                    conn.commit()
+                    return True
+
+        except Exception as e:
+            logger.error(f"Transaction failed: {e}")
+            return False
+
+    def test_connection(self) -> bool:
+        """Test if the database connection is working"""
+        try:
+            with self.get_connection() as conn:
+                with conn.cursor() as cursor:
+                    cursor.execute("SELECT 1")
+                    return True
+        except Exception as e:
+            logger.error(f"Connection test failed: {e}")
+            return False

memoriai/database/connectors/sqlite_connector.py

@@ -0,0 +1,148 @@
+"""
+SQLite connector for Memori v1.0
+"""
+
+import sqlite3
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from loguru import logger
+
+from ...utils.exceptions import DatabaseError
+
+
+class SQLiteConnector:
+    """SQLite database connector with FTS5 support"""
+
+    def __init__(self, db_path: str):
+        """Initialize SQLite connector"""
+        self.db_path = db_path
+        self._ensure_directory_exists()
+
+    def _ensure_directory_exists(self):
+        """Ensure the database directory exists"""
+        db_dir = Path(self.db_path).parent
+        db_dir.mkdir(parents=True, exist_ok=True)
+
+    def get_connection(self) -> sqlite3.Connection:
+        """Get SQLite connection with proper configuration"""
+        try:
+            conn = sqlite3.connect(self.db_path)
+            conn.row_factory = sqlite3.Row  # Enable dict-like access
+
+            # Enable foreign keys
+            conn.execute("PRAGMA foreign_keys = ON")
+
+            # Enable WAL mode for better concurrency
+            conn.execute("PRAGMA journal_mode = WAL")
+
+            # Enable FTS5 tokenizer if available
+            try:
+                conn.execute("PRAGMA enable_fts3_tokenizer=1")
+            except sqlite3.Error:
+                # FTS3 tokenizer not available, continue without it
+                pass
+
+            return conn
+
+        except Exception as e:
+            raise DatabaseError(f"Failed to connect to SQLite database: {e}")
+
+    def execute_query(
+        self, query: str, params: Optional[List] = None
+    ) -> List[Dict[str, Any]]:
+        """Execute a query and return results"""
+        try:
+            with self.get_connection() as conn:
+                cursor = conn.cursor()
+                if params:
+                    cursor.execute(query, params)
+                else:
+                    cursor.execute(query)
+
+                # Return results as list of dictionaries
+                results = []
+                for row in cursor.fetchall():
+                    results.append(dict(row))
+
+                return results
+
+        except Exception as e:
+            raise DatabaseError(f"Failed to execute query: {e}")
+
+    def execute_insert(self, query: str, params: Optional[List] = None) -> str:
+        """Execute an insert query and return the inserted row ID"""
+        try:
+            with self.get_connection() as conn:
+                cursor = conn.cursor()
+                if params:
+                    cursor.execute(query, params)
+                else:
+                    cursor.execute(query)
+
+                conn.commit()
+                return str(cursor.lastrowid)
+
+        except Exception as e:
+            raise DatabaseError(f"Failed to execute insert: {e}")
+
+    def execute_update(self, query: str, params: Optional[List] = None) -> int:
+        """Execute an update query and return number of affected rows"""
+        try:
+            with self.get_connection() as conn:
+                cursor = conn.cursor()
+                if params:
+                    cursor.execute(query, params)
+                else:
+                    cursor.execute(query)
+
+                conn.commit()
+                return cursor.rowcount
+
+        except Exception as e:
+            raise DatabaseError(f"Failed to execute update: {e}")
+
+    def execute_delete(self, query: str, params: Optional[List] = None) -> int:
+        """Execute a delete query and return number of affected rows"""
+        try:
+            with self.get_connection() as conn:
+                cursor = conn.cursor()
+                if params:
+                    cursor.execute(query, params)
+                else:
+                    cursor.execute(query)
+
+                conn.commit()
+                return cursor.rowcount
+
+        except Exception as e:
+            raise DatabaseError(f"Failed to execute delete: {e}")
+
+    def execute_transaction(self, queries: List[tuple]) -> bool:
+        """Execute multiple queries in a transaction"""
+        try:
+            with self.get_connection() as conn:
+                cursor = conn.cursor()
+
+                for query, params in queries:
+                    if params:
+                        cursor.execute(query, params)
+                    else:
+                        cursor.execute(query)
+
+                conn.commit()
+                return True
+
+        except Exception as e:
+            logger.error(f"Transaction failed: {e}")
+            return False
+
+    def test_connection(self) -> bool:
+        """Test if the database connection is working"""
+        try:
+            with self.get_connection() as conn:
+                conn.execute("SELECT 1")
+                return True
+        except Exception as e:
+            logger.error(f"Connection test failed: {e}")
+            return False

memoriai/database/queries/__init__.py

@@ -0,0 +1,15 @@
+"""
+Database queries module for centralized SQL management
+"""
+
+from .base_queries import BaseQueries
+from .chat_queries import ChatQueries
+from .entity_queries import EntityQueries
+from .memory_queries import MemoryQueries
+
+__all__ = [
+    "BaseQueries",
+    "MemoryQueries",
+    "ChatQueries",
+    "EntityQueries",
+]