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

memori/utils/exceptions.py

@@ -4,7 +4,7 @@ Custom exceptions for Memoriai with comprehensive error handling
 
 import traceback
 from datetime import datetime
-from typing import Any, Dict, Optional, Union
+from typing import Any
 
 
 class MemoriError(Exception):
@@ -13,9 +13,9 @@ class MemoriError(Exception):
     def __init__(
         self,
         message: str,
-        error_code: Optional[str] = None,
-        context: Optional[Dict[str, Any]] = None,
-        cause: Optional[Exception] = None,
+        error_code: str | None = None,
+        context: dict[str, Any] | None = None,
+        cause: Exception | None = None,
     ):
         super().__init__(message)
         self.message = message
@@ -25,7 +25,7 @@ class MemoriError(Exception):
         self.timestamp = datetime.now()
         self.traceback = traceback.format_exc() if cause else None
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         """Convert exception to dictionary for logging/serialization"""
         return {
             "error_type": self.__class__.__name__,
@@ -52,10 +52,10 @@ class DatabaseError(MemoriError):
     def __init__(
         self,
         message: str,
-        query: Optional[str] = None,
-        connection_string: Optional[str] = None,
-        error_code: Optional[str] = None,
-        cause: Optional[Exception] = None,
+        query: str | None = None,
+        connection_string: str | None = None,
+        error_code: str | None = None,
+        cause: Exception | None = None,
     ):
         context = {}
         if query:
@@ -88,12 +88,12 @@ class AgentError(MemoriError):
     def __init__(
         self,
         message: str,
-        agent_type: Optional[str] = None,
-        model: Optional[str] = None,
-        api_endpoint: Optional[str] = None,
-        tokens_used: Optional[int] = None,
-        error_code: Optional[str] = None,
-        cause: Optional[Exception] = None,
+        agent_type: str | None = None,
+        model: str | None = None,
+        api_endpoint: str | None = None,
+        tokens_used: int | None = None,
+        error_code: str | None = None,
+        cause: Exception | None = None,
     ):
         context = {}
         if agent_type:
@@ -119,10 +119,10 @@ class ConfigurationError(MemoriError):
     def __init__(
         self,
         message: str,
-        setting_path: Optional[str] = None,
-        config_file: Optional[str] = None,
-        error_code: Optional[str] = None,
-        cause: Optional[Exception] = None,
+        setting_path: str | None = None,
+        config_file: str | None = None,
+        error_code: str | None = None,
+        cause: Exception | None = None,
     ):
         context = {}
         if setting_path:
@@ -144,11 +144,11 @@ class ValidationError(MemoriError):
     def __init__(
         self,
         message: str,
-        field_name: Optional[str] = None,
-        field_value: Optional[Any] = None,
-        expected_type: Optional[str] = None,
-        error_code: Optional[str] = None,
-        cause: Optional[Exception] = None,
+        field_name: str | None = None,
+        field_value: Any | None = None,
+        expected_type: str | None = None,
+        error_code: str | None = None,
+        cause: Exception | None = None,
     ):
         context = {}
         if field_name:
@@ -172,10 +172,10 @@ class IntegrationError(MemoriError):
     def __init__(
         self,
         message: str,
-        provider: Optional[str] = None,
-        integration_type: Optional[str] = None,
-        error_code: Optional[str] = None,
-        cause: Optional[Exception] = None,
+        provider: str | None = None,
+        integration_type: str | None = None,
+        error_code: str | None = None,
+        cause: Exception | None = None,
     ):
         context = {}
         if provider:
@@ -197,10 +197,10 @@ class AuthenticationError(MemoriError):
     def __init__(
         self,
         message: str,
-        auth_type: Optional[str] = None,
-        endpoint: Optional[str] = None,
-        error_code: Optional[str] = None,
-        cause: Optional[Exception] = None,
+        auth_type: str | None = None,
+        endpoint: str | None = None,
+        error_code: str | None = None,
+        cause: Exception | None = None,
     ):
         context = {}
         if auth_type:
@@ -222,11 +222,11 @@ class RateLimitError(MemoriError):
     def __init__(
         self,
         message: str,
-        provider: Optional[str] = None,
-        limit_type: Optional[str] = None,
-        retry_after: Optional[int] = None,
-        error_code: Optional[str] = None,
-        cause: Optional[Exception] = None,
+        provider: str | None = None,
+        limit_type: str | None = None,
+        retry_after: int | None = None,
+        error_code: str | None = None,
+        cause: Exception | None = None,
     ):
         context = {}
         if provider:
@@ -250,11 +250,11 @@ class MemoryNotFoundError(MemoriError):
     def __init__(
         self,
         message: str,
-        memory_id: Optional[str] = None,
-        namespace: Optional[str] = None,
-        search_criteria: Optional[Dict[str, Any]] = None,
-        error_code: Optional[str] = None,
-        cause: Optional[Exception] = None,
+        memory_id: str | None = None,
+        namespace: str | None = None,
+        search_criteria: dict[str, Any] | None = None,
+        error_code: str | None = None,
+        cause: Exception | None = None,
     ):
         context = {}
         if memory_id:
@@ -278,10 +278,10 @@ class ProcessingError(MemoriError):
     def __init__(
         self,
         message: str,
-        processing_stage: Optional[str] = None,
-        input_data: Optional[Dict[str, Any]] = None,
-        error_code: Optional[str] = None,
-        cause: Optional[Exception] = None,
+        processing_stage: str | None = None,
+        input_data: dict[str, Any] | None = None,
+        error_code: str | None = None,
+        cause: Exception | None = None,
     ):
         context = {}
         if processing_stage:
@@ -308,10 +308,10 @@ class TimeoutError(MemoriError):
     def __init__(
         self,
         message: str,
-        operation: Optional[str] = None,
-        timeout_seconds: Optional[float] = None,
-        error_code: Optional[str] = None,
-        cause: Optional[Exception] = None,
+        operation: str | None = None,
+        timeout_seconds: float | None = None,
+        error_code: str | None = None,
+        cause: Exception | None = None,
     ):
         context = {}
         if operation:
@@ -333,11 +333,11 @@ class ResourceExhaustedError(MemoriError):
     def __init__(
         self,
         message: str,
-        resource_type: Optional[str] = None,
-        current_usage: Optional[Union[int, float]] = None,
-        limit: Optional[Union[int, float]] = None,
-        error_code: Optional[str] = None,
-        cause: Optional[Exception] = None,
+        resource_type: str | None = None,
+        current_usage: int | float | None = None,
+        limit: int | float | None = None,
+        error_code: str | None = None,
+        cause: Exception | None = None,
     ):
         context = {}
         if resource_type:
@@ -361,7 +361,7 @@ class ExceptionHandler:
 
     @staticmethod
     def handle_database_exception(
-        e: Exception, query: Optional[str] = None
+        e: Exception, query: str | None = None
     ) -> DatabaseError:
         """Convert generic exception to DatabaseError with context"""
         if isinstance(e, DatabaseError):
@@ -375,7 +375,7 @@ class ExceptionHandler:
 
     @staticmethod
     def handle_agent_exception(
-        e: Exception, agent_type: Optional[str] = None
+        e: Exception, agent_type: str | None = None
     ) -> AgentError:
         """Convert generic exception to AgentError with context"""
         if isinstance(e, AgentError):
@@ -389,7 +389,7 @@ class ExceptionHandler:
 
     @staticmethod
     def handle_validation_exception(
-        e: Exception, field_name: Optional[str] = None
+        e: Exception, field_name: str | None = None
     ) -> ValidationError:
         """Convert generic exception to ValidationError with context"""
         if isinstance(e, ValidationError):

memori/utils/helpers.py

@@ -7,9 +7,10 @@ import functools
 import hashlib
 import json
 import uuid
+from collections.abc import Awaitable, Callable
 from datetime import datetime, timedelta
 from pathlib import Path
-from typing import Any, Awaitable, Callable, Dict, List, Optional, TypeVar, Union
+from typing import Any, TypeVar
 
 from .exceptions import MemoriError
 
@@ -52,7 +53,7 @@ class StringUtils:
         return hash_obj.hexdigest()
 
     @staticmethod
-    def extract_keywords(text: str, max_keywords: int = 10) -> List[str]:
+    def extract_keywords(text: str, max_keywords: int = 10) -> list[str]:
         """Extract keywords from text (simple implementation)"""
         import re
 
@@ -201,7 +202,7 @@ class JsonUtils:
             return json.dumps(default or {}, indent=indent)
 
     @staticmethod
-    def merge_dicts(base: Dict[str, Any], override: Dict[str, Any]) -> Dict[str, Any]:
+    def merge_dicts(base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any]:
         """Deep merge two dictionaries"""
         result = base.copy()
 
@@ -222,16 +223,14 @@ class FileUtils:
     """File handling utilities"""
 
     @staticmethod
-    def ensure_directory(path: Union[str, Path]) -> Path:
+    def ensure_directory(path: str | Path) -> Path:
         """Ensure directory exists, create if not"""
         path = Path(path)
         path.mkdir(parents=True, exist_ok=True)
         return path
 
     @staticmethod
-    def safe_read_text(
-        file_path: Union[str, Path], encoding: str = "utf-8"
-    ) -> Optional[str]:
+    def safe_read_text(file_path: str | Path, encoding: str = "utf-8") -> str | None:
         """Safely read text file"""
         try:
             return Path(file_path).read_text(encoding=encoding)
@@ -240,7 +239,7 @@ class FileUtils:
 
     @staticmethod
     def safe_write_text(
-        file_path: Union[str, Path], content: str, encoding: str = "utf-8"
+        file_path: str | Path, content: str, encoding: str = "utf-8"
     ) -> bool:
         """Safely write text file"""
         try:
@@ -252,7 +251,7 @@ class FileUtils:
             return False
 
     @staticmethod
-    def get_file_size(file_path: Union[str, Path]) -> int:
+    def get_file_size(file_path: str | Path) -> int:
         """Get file size in bytes"""
         try:
             return Path(file_path).stat().st_size
@@ -260,7 +259,7 @@ class FileUtils:
             return 0
 
     @staticmethod
-    def is_file_recent(file_path: Union[str, Path], hours: int = 24) -> bool:
+    def is_file_recent(file_path: str | Path, hours: int = 24) -> bool:
         """Check if file was modified recently"""
         try:
             mtime = datetime.fromtimestamp(Path(file_path).stat().st_mtime)
@@ -386,7 +385,7 @@ class PerformanceUtils:
         return wrapper
 
     @staticmethod
-    def memory_usage() -> Dict[str, float]:
+    def memory_usage() -> dict[str, float]:
         """Get current memory usage"""
         try:
             import psutil
@@ -417,7 +416,7 @@ class AsyncUtils:
         )
 
     @staticmethod
-    async def gather_with_concurrency(limit: int, *tasks) -> List[Any]:
+    async def gather_with_concurrency(limit: int, *tasks) -> list[Any]:
         """Run tasks with concurrency limit"""
         semaphore = asyncio.Semaphore(limit)
 

memori/utils/input_validator.py

@@ -7,7 +7,7 @@ import html
 import json
 import re
 from datetime import datetime
-from typing import Any, Dict, List, Optional, Union
+from typing import Any
 
 from loguru import logger
 
@@ -40,7 +40,7 @@ class InputValidator:
     @classmethod
     def validate_and_sanitize_query(cls, query: str, max_length: int = 10000) -> str:
         """Validate and sanitize search query input"""
-        if not isinstance(query, (str, type(None))):
+        if not isinstance(query, str | type(None)):
             raise ValidationError("Query must be a string or None")
 
         if query is None:
@@ -95,9 +95,7 @@ class InputValidator:
         return sanitized_namespace
 
     @classmethod
-    def validate_category_filter(
-        cls, category_filter: Optional[List[str]]
-    ) -> List[str]:
+    def validate_category_filter(cls, category_filter: list[str] | None) -> list[str]:
         """Validate and sanitize category filter list"""
         if category_filter is None:
             return []
@@ -130,7 +128,7 @@ class InputValidator:
         return sanitized_categories
 
     @classmethod
-    def validate_limit(cls, limit: Union[int, str]) -> int:
+    def validate_limit(cls, limit: int | str) -> int:
         """Validate and sanitize limit parameter"""
         try:
             int_limit = int(limit)
@@ -223,7 +221,7 @@ class InputValidator:
         return sanitized_content.strip()
 
     @classmethod
-    def validate_timestamp(cls, timestamp: Union[datetime, str, None]) -> datetime:
+    def validate_timestamp(cls, timestamp: datetime | str | None) -> datetime:
         """Validate and normalize timestamp"""
         if timestamp is None:
             return datetime.now()
@@ -246,7 +244,7 @@ class InputValidator:
 
     @classmethod
     def validate_score(
-        cls, score: Union[float, int, str], field_name: str = "score"
+        cls, score: float | int | str, field_name: str = "score"
     ) -> float:
         """Validate and normalize score values (0.0 to 1.0)"""
         try:
@@ -328,8 +326,8 @@ class DatabaseInputValidator:
 
     @classmethod
     def validate_insert_params(
-        cls, table: str, params: Dict[str, Any]
-    ) -> Dict[str, Any]:
+        cls, table: str, params: dict[str, Any]
+    ) -> dict[str, Any]:
         """Validate parameters for database insert operations"""
         sanitized_params = {}
 
@@ -383,9 +381,9 @@ class DatabaseInputValidator:
         cls,
         query: str,
         namespace: str,
-        category_filter: Optional[List[str]],
+        category_filter: list[str] | None,
         limit: int,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Validate all search parameters together"""
         return {
             "query": InputValidator.validate_and_sanitize_query(query),

memori/utils/logging.py

@@ -4,7 +4,7 @@ Centralized logging configuration for Memoriai
 
 import sys
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any
 
 from loguru import logger
 
@@ -16,7 +16,7 @@ class LoggingManager:
     """Centralized logging management"""
 
     _initialized = False
-    _current_config: Optional[LoggingSettings] = None
+    _current_config: LoggingSettings | None = None
 
     @classmethod
     def setup_logging(cls, settings: LoggingSettings, verbose: bool = False) -> None:
@@ -107,7 +107,7 @@ class LoggingManager:
             logger.error(f"Failed to update log level: {e}")
 
     @classmethod
-    def add_custom_handler(cls, handler_config: Dict[str, Any]) -> None:
+    def add_custom_handler(cls, handler_config: dict[str, Any]) -> None:
         """Add a custom logging handler"""
         try:
             logger.add(**handler_config)
@@ -121,7 +121,7 @@ class LoggingManager:
         return cls._initialized
 
     @classmethod
-    def get_current_config(cls) -> Optional[LoggingSettings]:
+    def get_current_config(cls) -> LoggingSettings | None:
         """Get current logging configuration"""
         return cls._current_config