memorisdk 2.0.1__py3-none-any.whl → 2.1.1__py3-none-any.whl

memori/database/adapters/mysql_adapter.py

@@ -2,7 +2,7 @@
 MySQL-specific search adapter with FULLTEXT support and proper security
 """
 
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from loguru import logger
 
@@ -25,9 +25,9 @@ class MySQLSearchAdapter(BaseSearchAdapter):
         self,
         query: str,
         namespace: str = "default",
-        category_filter: Optional[List[str]] = None,
+        category_filter: list[str] | None = None,
         limit: int = 10,
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Execute MySQL FULLTEXT search with proper validation"""
         try:
             # Validate all parameters
@@ -65,7 +65,7 @@ class MySQLSearchAdapter(BaseSearchAdapter):
                 query, namespace, category_filter, limit
             )
 
-    def create_search_indexes(self) -> List[str]:
+    def create_search_indexes(self) -> list[str]:
         """Create MySQL-specific search indexes"""
         indexes = []
 
@@ -182,9 +182,9 @@ class MySQLSearchAdapter(BaseSearchAdapter):
         self,
         query: str,
         namespace: str = "default",
-        category_filter: Optional[List[str]] = None,
+        category_filter: list[str] | None = None,
         limit: int = 10,
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Execute LIKE-based fallback search for MySQL"""
         try:
             return self.query_executor.execute_search(
@@ -231,7 +231,7 @@ class MySQLSearchAdapter(BaseSearchAdapter):
                 current_settings = {}
                 if hasattr(cursor, "description") and cursor.description:
                     for row in settings:
-                        if isinstance(row, (list, tuple)) and len(row) >= 2:
+                        if isinstance(row, list | tuple) and len(row) >= 2:
                             current_settings[row[0]] = row[1]
 
                 logger.debug(f"Current MySQL FULLTEXT settings: {current_settings}")
@@ -277,7 +277,7 @@ class MySQLSearchAdapter(BaseSearchAdapter):
         except Exception as e:
             logger.warning(f"FULLTEXT index repair failed: {e}")
 
-    def get_fulltext_statistics(self) -> Dict[str, Any]:
+    def get_fulltext_statistics(self) -> dict[str, Any]:
         """Get statistics about FULLTEXT usage and performance"""
         stats = {}
 

memori/database/adapters/postgresql_adapter.py

@@ -2,7 +2,7 @@
 PostgreSQL-specific search adapter with tsvector support and proper security
 """
 
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from loguru import logger
 
@@ -26,9 +26,9 @@ class PostgreSQLSearchAdapter(BaseSearchAdapter):
         self,
         query: str,
         namespace: str = "default",
-        category_filter: Optional[List[str]] = None,
+        category_filter: list[str] | None = None,
         limit: int = 10,
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Execute PostgreSQL full-text search with tsvector"""
         try:
             # Validate all parameters
@@ -66,7 +66,7 @@ class PostgreSQLSearchAdapter(BaseSearchAdapter):
                 query, namespace, category_filter, limit
             )
 
-    def create_search_indexes(self) -> List[str]:
+    def create_search_indexes(self) -> list[str]:
         """Create PostgreSQL-specific search indexes"""
         indexes = []
 
@@ -170,9 +170,9 @@ class PostgreSQLSearchAdapter(BaseSearchAdapter):
         self,
         query: str,
         namespace: str = "default",
-        category_filter: Optional[List[str]] = None,
+        category_filter: list[str] | None = None,
         limit: int = 10,
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Execute LIKE-based fallback search for PostgreSQL"""
         try:
             return self.query_executor.execute_search(

memori/database/adapters/sqlite_adapter.py

@@ -3,7 +3,7 @@ SQLite-specific search adapter with FTS5 support and proper security
 """
 
 import sqlite3
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from loguru import logger
 
@@ -25,9 +25,9 @@ class SQLiteSearchAdapter(BaseSearchAdapter):
         self,
         query: str,
         namespace: str = "default",
-        category_filter: Optional[List[str]] = None,
+        category_filter: list[str] | None = None,
         limit: int = 10,
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Execute SQLite FTS5 search with proper validation"""
         try:
             # Validate all parameters
@@ -64,7 +64,7 @@ class SQLiteSearchAdapter(BaseSearchAdapter):
                 query, namespace, category_filter, limit
             )
 
-    def create_search_indexes(self) -> List[str]:
+    def create_search_indexes(self) -> list[str]:
         """Create SQLite-specific search indexes"""
         indexes = []
 
@@ -189,9 +189,9 @@ class SQLiteSearchAdapter(BaseSearchAdapter):
         self,
         query: str,
         namespace: str = "default",
-        category_filter: Optional[List[str]] = None,
+        category_filter: list[str] | None = None,
         limit: int = 10,
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Execute LIKE-based fallback search for SQLite"""
         try:
             return self.query_executor.execute_search(

memori/database/auto_creator.py

@@ -6,7 +6,6 @@ PostgreSQL and MySQL with proper error handling and security validation.
 """
 
 import ssl
-from typing import Dict
 from urllib.parse import parse_qs, urlparse
 
 from loguru import logger
@@ -77,7 +76,7 @@ class DatabaseAutoCreator:
             # This allows graceful degradation if user has manual setup
             return connection_string
 
-    def _database_exists(self, components: Dict[str, str]) -> bool:
+    def _database_exists(self, components: dict[str, str]) -> bool:
         """Check if target database exists."""
         try:
             engine = components["engine"]
@@ -94,7 +93,7 @@ class DatabaseAutoCreator:
             logger.error(f"Failed to check database existence: {e}")
             return False
 
-    def _postgresql_database_exists(self, components: Dict[str, str]) -> bool:
+    def _postgresql_database_exists(self, components: dict[str, str]) -> bool:
         """Check if PostgreSQL database exists."""
         try:
             # Connect to postgres system database
@@ -114,7 +113,7 @@ class DatabaseAutoCreator:
             logger.error(f"PostgreSQL database existence check failed: {e}")
             return False
 
-    def _get_mysql_connect_args(self, original_url: str) -> Dict:
+    def _get_mysql_connect_args(self, original_url: str) -> dict:
         """Get MySQL connection arguments with SSL support for system database connections."""
         connect_args = {"charset": "utf8mb4"}
 
@@ -146,7 +145,7 @@ class DatabaseAutoCreator:
 
         return connect_args
 
-    def _mysql_database_exists(self, components: Dict[str, str]) -> bool:
+    def _mysql_database_exists(self, components: dict[str, str]) -> bool:
         """Check if MySQL database exists."""
         try:
             # Connect to mysql system database with SSL support
@@ -180,7 +179,7 @@ class DatabaseAutoCreator:
             logger.error(f"MySQL database existence check failed: {e}")
             return False
 
-    def _create_database(self, components: Dict[str, str]) -> None:
+    def _create_database(self, components: dict[str, str]) -> None:
         """Create the target database."""
         engine = components["engine"]
 
@@ -191,7 +190,7 @@ class DatabaseAutoCreator:
         else:
             raise ValueError(f"Database creation not supported for {engine}")
 
-    def _create_postgresql_database(self, components: Dict[str, str]) -> None:
+    def _create_postgresql_database(self, components: dict[str, str]) -> None:
         """Create PostgreSQL database."""
         try:
             logger.info(f"Creating PostgreSQL database '{components['database']}'...")
@@ -230,7 +229,7 @@ class DatabaseAutoCreator:
         except Exception as e:
             raise RuntimeError(f"Unexpected error creating PostgreSQL database: {e}")
 
-    def _create_mysql_database(self, components: Dict[str, str]) -> None:
+    def _create_mysql_database(self, components: dict[str, str]) -> None:
         """Create MySQL database."""
         try:
             logger.info(f"Creating MySQL database '{components['database']}'...")
@@ -281,7 +280,7 @@ class DatabaseAutoCreator:
         except Exception as e:
             raise RuntimeError(f"Unexpected error creating MySQL database: {e}")
 
-    def get_database_info(self, connection_string: str) -> Dict[str, str]:
+    def get_database_info(self, connection_string: str) -> dict[str, str]:
         """
         Get detailed information about database from connection string.
 

memori/database/connection_utils.py

@@ -6,7 +6,6 @@ and managing multi-database scenarios for memori instances.
 """
 
 import re
-from typing import Dict, Tuple
 from urllib.parse import urlparse
 
 from loguru import logger
@@ -20,10 +19,11 @@ class DatabaseConnectionUtils:
         "postgresql": "postgres",
         "mysql": "mysql",
         "sqlite": None,  # SQLite doesn't need default DB
+        "mongodb": None,  # MongoDB doesn't need default DB for connection
     }
 
     @classmethod
-    def parse_connection_string(cls, connection_string: str) -> Dict[str, str]:
+    def parse_connection_string(cls, connection_string: str) -> dict[str, str]:
         """
         Parse database connection string and extract components.
 
@@ -91,7 +91,7 @@ class DatabaseConnectionUtils:
                 "default_url": default_url,
                 "original_url": connection_string,
                 "needs_creation": engine
-                in ["postgresql", "mysql"],  # SQLite auto-creates
+                in ["postgresql", "mysql"],  # SQLite and MongoDB auto-create
             }
 
         except Exception as e:
@@ -100,7 +100,7 @@ class DatabaseConnectionUtils:
 
     @classmethod
     def build_connection_string(
-        cls, components: Dict[str, str], target_database: str
+        cls, components: dict[str, str], target_database: str
     ) -> str:
         """
         Build connection string with specific database name.
@@ -189,7 +189,7 @@ class DatabaseConnectionUtils:
         return database_name
 
     @classmethod
-    def extract_database_info(cls, connection_string: str) -> Tuple[str, str, bool]:
+    def extract_database_info(cls, connection_string: str) -> tuple[str, str, bool]:
         """
         Extract database engine, name, and creation requirement.
 

memori/database/connectors/__init__.py

@@ -6,4 +6,15 @@ from .mysql_connector import MySQLConnector
 from .postgres_connector import PostgreSQLConnector
 from .sqlite_connector import SQLiteConnector
 
+try:
+    from .mongodb_connector import MongoDBConnector
+
+    MONGODB_AVAILABLE = True
+except ImportError:
+    MongoDBConnector = None  # type: ignore
+    MONGODB_AVAILABLE = False
+
 __all__ = ["SQLiteConnector", "PostgreSQLConnector", "MySQLConnector"]
+
+if MONGODB_AVAILABLE:
+    __all__.append("MongoDBConnector")

memori/database/connectors/base_connector.py

@@ -5,7 +5,7 @@ Provides abstraction layer for different database backends
 
 from abc import ABC, abstractmethod
 from enum import Enum
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any
 
 
 class DatabaseType(str, Enum):
@@ -14,6 +14,7 @@ class DatabaseType(str, Enum):
     SQLITE = "sqlite"
     MYSQL = "mysql"
     POSTGRESQL = "postgresql"
+    MONGODB = "mongodb"
 
 
 class SearchStrategy(str, Enum):
@@ -28,7 +29,7 @@ class SearchStrategy(str, Enum):
 class BaseDatabaseConnector(ABC):
     """Abstract base class for database connectors"""
 
-    def __init__(self, connection_config: Dict[str, Any]):
+    def __init__(self, connection_config: dict[str, Any]):
         self.connection_config = connection_config
         self.database_type = self._detect_database_type()
 
@@ -44,30 +45,28 @@ class BaseDatabaseConnector(ABC):
 
     @abstractmethod
     def execute_query(
-        self, query: str, params: Optional[List[Any]] = None
-    ) -> List[Dict[str, Any]]:
+        self, query: str, params: list[Any] | None = None
+    ) -> list[dict[str, Any]]:
         """Execute a query and return results"""
         pass
 
     @abstractmethod
-    def execute_insert(self, query: str, params: Optional[List[Any]] = None) -> str:
+    def execute_insert(self, query: str, params: list[Any] | None = None) -> str:
         """Execute an insert query and return the inserted row ID"""
         pass
 
     @abstractmethod
-    def execute_update(self, query: str, params: Optional[List[Any]] = None) -> int:
+    def execute_update(self, query: str, params: list[Any] | None = None) -> int:
         """Execute an update query and return number of affected rows"""
         pass
 
     @abstractmethod
-    def execute_delete(self, query: str, params: Optional[List[Any]] = None) -> int:
+    def execute_delete(self, query: str, params: list[Any] | None = None) -> int:
         """Execute a delete query and return number of affected rows"""
         pass
 
     @abstractmethod
-    def execute_transaction(
-        self, queries: List[Tuple[str, Optional[List[Any]]]]
-    ) -> bool:
+    def execute_transaction(self, queries: list[tuple[str, list[Any] | None]]) -> bool:
         """Execute multiple queries in a transaction"""
         pass
 
@@ -77,7 +76,7 @@ class BaseDatabaseConnector(ABC):
         pass
 
     @abstractmethod
-    def initialize_schema(self, schema_sql: Optional[str] = None):
+    def initialize_schema(self, schema_sql: str | None = None):
         """Initialize database schema"""
         pass
 
@@ -88,13 +87,13 @@ class BaseDatabaseConnector(ABC):
 
     @abstractmethod
     def create_full_text_index(
-        self, table: str, columns: List[str], index_name: str
+        self, table: str, columns: list[str], index_name: str
     ) -> str:
         """Create database-specific full-text search index"""
         pass
 
     @abstractmethod
-    def get_database_info(self) -> Dict[str, Any]:
+    def get_database_info(self) -> dict[str, Any]:
         """Get database information and capabilities"""
         pass
 
@@ -111,14 +110,14 @@ class BaseSearchAdapter(ABC):
         self,
         query: str,
         namespace: str = "default",
-        category_filter: Optional[List[str]] = None,
+        category_filter: list[str] | None = None,
         limit: int = 10,
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Execute full-text search using database-specific methods"""
         pass
 
     @abstractmethod
-    def create_search_indexes(self) -> List[str]:
+    def create_search_indexes(self) -> list[str]:
         """Create search indexes for optimal performance"""
         pass
 
@@ -131,9 +130,9 @@ class BaseSearchAdapter(ABC):
         self,
         query: str,
         namespace: str = "default",
-        category_filter: Optional[List[str]] = None,
+        category_filter: list[str] | None = None,
         limit: int = 10,
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Execute fallback LIKE-based search with proper parameterization"""
         try:
             # Input validation and sanitization
@@ -265,7 +264,7 @@ class BaseSchemaGenerator(ABC):
         pass
 
     @abstractmethod
-    def get_data_type_mappings(self) -> Dict[str, str]:
+    def get_data_type_mappings(self) -> dict[str, str]:
         """Get database-specific data type mappings"""
         pass