memorisdk 2.0.0__py3-none-any.whl → 2.1.0__py3-none-any.whl

memori/utils/pydantic_models.py

@@ -4,7 +4,7 @@ Pydantic Models for Structured Memory Processing
 
 from datetime import datetime
 from enum import Enum
-from typing import Annotated, Dict, List, Literal, Optional, Tuple
+from typing import Annotated, Literal
 
 from pydantic import BaseModel, Field
 
@@ -85,7 +85,7 @@ class ExtractedEntity(BaseModel):
     relevance_score: RelevanceScore = Field(
         description="How relevant this entity is to the memory"
     )
-    context: Optional[str] = Field(
+    context: str | None = Field(
         default=None, description="Additional context about this entity"
     )
 
@@ -93,28 +93,28 @@ class ExtractedEntity(BaseModel):
 class ExtractedEntities(BaseModel):
     """All entities extracted from a conversation"""
 
-    people: List[str] = Field(
+    people: list[str] = Field(
         default_factory=list, description="Names of people mentioned"
     )
-    technologies: List[str] = Field(
+    technologies: list[str] = Field(
         default_factory=list, description="Technologies, tools, libraries mentioned"
     )
-    topics: List[str] = Field(
+    topics: list[str] = Field(
         default_factory=list, description="Main topics or subjects discussed"
     )
-    skills: List[str] = Field(
+    skills: list[str] = Field(
         default_factory=list, description="Skills, abilities, or competencies mentioned"
     )
-    projects: List[str] = Field(
+    projects: list[str] = Field(
         default_factory=list,
         description="Projects, repositories, or initiatives mentioned",
     )
-    keywords: List[str] = Field(
+    keywords: list[str] = Field(
         default_factory=list, description="Important keywords for search"
     )
 
     # Structured entities with metadata
-    structured_entities: List[ExtractedEntity] = Field(
+    structured_entities: list[ExtractedEntity] = Field(
         default_factory=list, description="Detailed entity extraction"
     )
 
@@ -150,13 +150,13 @@ class MemorySearchQuery(BaseModel):
     intent: str = Field(description="Interpreted intent of the query")
 
     # Search parameters
-    entity_filters: List[str] = Field(
+    entity_filters: list[str] = Field(
         default_factory=list, description="Specific entities to search for"
     )
-    category_filters: List[MemoryCategoryType] = Field(
+    category_filters: list[MemoryCategoryType] = Field(
         default_factory=list, description="Memory categories to include"
     )
-    time_range: Optional[str] = Field(
+    time_range: str | None = Field(
         default=None, description="Time range for search (e.g., 'last_week')"
     )
     min_importance: ImportanceScore = Field(
@@ -164,10 +164,10 @@ class MemorySearchQuery(BaseModel):
     )
 
     # Search strategy
-    search_strategy: List[str] = Field(
+    search_strategy: list[str] = Field(
         default_factory=list, description="Recommended search strategies"
     )
-    expected_result_types: List[str] = Field(
+    expected_result_types: list[str] = Field(
         default_factory=list, description="Expected types of results"
     )
 
@@ -190,7 +190,7 @@ class UserRule(BaseModel):
     rule_text: str = Field(description="The rule or preference in natural language")
     rule_type: Literal["preference", "instruction", "constraint", "goal"]
     priority: PriorityLevel = Field(default=5, description="Priority level (1-10)")
-    context: Optional[str] = Field(default=None, description="When this rule applies")
+    context: str | None = Field(default=None, description="When this rule applies")
     active: bool = Field(
         default=True, description="Whether this rule is currently active"
     )
@@ -201,29 +201,29 @@ class ConversationContext(BaseModel):
 
     model_config = {"protected_namespaces": ()}
 
-    user_id: Optional[str] = Field(default=None)
+    user_id: str | None = Field(default=None)
     session_id: str
     conversation_id: str
     model_used: str
 
     # User context
-    user_preferences: List[str] = Field(default_factory=list)
-    current_projects: List[str] = Field(default_factory=list)
-    relevant_skills: List[str] = Field(default_factory=list)
+    user_preferences: list[str] = Field(default_factory=list)
+    current_projects: list[str] = Field(default_factory=list)
+    relevant_skills: list[str] = Field(default_factory=list)
 
     # Conversation metadata
     conversation_length: int = Field(
         default=1, description="Number of exchanges in this conversation"
     )
-    topic_thread: Optional[str] = Field(
+    topic_thread: str | None = Field(
         default=None, description="Main topic thread being discussed"
     )
 
     # Memory context
-    recent_memories: List[str] = Field(
+    recent_memories: list[str] = Field(
         default_factory=list, description="IDs of recently accessed memories"
     )
-    applied_rules: List[str] = Field(
+    applied_rules: list[str] = Field(
         default_factory=list, description="Rules that were applied"
     )
 
@@ -239,7 +239,7 @@ class ProcessedMemory(BaseModel):
         description="Why this memory should or shouldn't be stored"
     )
     timestamp: datetime = Field(default_factory=datetime.now)
-    processing_metadata: Optional[Dict[str, str]] = Field(default=None)
+    processing_metadata: dict[str, str] | None = Field(default=None)
 
 
 class ProcessedLongTermMemory(BaseModel):
@@ -252,11 +252,11 @@ class ProcessedLongTermMemory(BaseModel):
     importance: MemoryImportanceLevel = Field(description="Importance level")
 
     # Context Information
-    topic: Optional[str] = Field(default=None, description="Main topic/subject")
-    entities: List[str] = Field(
+    topic: str | None = Field(default=None, description="Main topic/subject")
+    entities: list[str] = Field(
         default_factory=list, description="People, places, technologies mentioned"
     )
-    keywords: List[str] = Field(
+    keywords: list[str] = Field(
         default_factory=list, description="Key terms for search"
     )
 
@@ -271,13 +271,13 @@ class ProcessedLongTermMemory(BaseModel):
     is_current_project: bool = Field(default=False, description="Current work context")
 
     # Memory Management
-    duplicate_of: Optional[str] = Field(
+    duplicate_of: str | None = Field(
         default=None, description="Links to original if duplicate"
     )
-    supersedes: List[str] = Field(
+    supersedes: list[str] = Field(
         default_factory=list, description="Previous memories this replaces"
     )
-    related_memories: List[str] = Field(
+    related_memories: list[str] = Field(
         default_factory=list, description="Connected memory IDs"
     )
 
@@ -287,7 +287,7 @@ class ProcessedLongTermMemory(BaseModel):
         default=0.8, description="AI confidence in extraction"
     )
     extraction_timestamp: datetime = Field(default_factory=datetime.now)
-    last_accessed: Optional[datetime] = Field(default=None)
+    last_accessed: datetime | None = Field(default=None)
     access_count: int = Field(default=0)
 
     # Classification Reasoning
@@ -308,38 +308,38 @@ class UserContextProfile(BaseModel):
     """Permanent user context for conscious ingestion"""
 
     # Core Identity
-    name: Optional[str] = None
-    pronouns: Optional[str] = None
-    location: Optional[str] = None
-    timezone: Optional[str] = None
+    name: str | None = None
+    pronouns: str | None = None
+    location: str | None = None
+    timezone: str | None = None
 
     # Professional Context
-    job_title: Optional[str] = None
-    company: Optional[str] = None
-    industry: Optional[str] = None
-    experience_level: Optional[str] = None
-    specializations: List[str] = Field(default_factory=list)
+    job_title: str | None = None
+    company: str | None = None
+    industry: str | None = None
+    experience_level: str | None = None
+    specializations: list[str] = Field(default_factory=list)
 
     # Technical Stack
-    primary_languages: List[str] = Field(default_factory=list)
-    frameworks: List[str] = Field(default_factory=list)
-    tools: List[str] = Field(default_factory=list)
-    environment: Optional[str] = None
+    primary_languages: list[str] = Field(default_factory=list)
+    frameworks: list[str] = Field(default_factory=list)
+    tools: list[str] = Field(default_factory=list)
+    environment: str | None = None
 
     # Behavioral Preferences
-    communication_style: Optional[str] = None
-    technical_depth: Optional[str] = None
-    response_preference: Optional[str] = None
+    communication_style: str | None = None
+    technical_depth: str | None = None
+    response_preference: str | None = None
 
     # Current Context
-    active_projects: List[str] = Field(default_factory=list)
-    learning_goals: List[str] = Field(default_factory=list)
-    domain_expertise: List[str] = Field(default_factory=list)
+    active_projects: list[str] = Field(default_factory=list)
+    learning_goals: list[str] = Field(default_factory=list)
+    domain_expertise: list[str] = Field(default_factory=list)
 
     # Values & Constraints
-    code_standards: List[str] = Field(default_factory=list)
-    time_constraints: Optional[str] = None
-    technology_preferences: List[str] = Field(default_factory=list)
+    code_standards: list[str] = Field(default_factory=list)
+    time_constraints: str | None = None
+    technology_preferences: list[str] = Field(default_factory=list)
 
     # Metadata
     last_updated: datetime = Field(default_factory=datetime.now)
@@ -350,11 +350,11 @@ class MemoryStats(BaseModel):
     """Statistics about stored memories"""
 
     total_memories: int
-    memories_by_category: Dict[str, int]
-    memories_by_retention: Dict[str, int]
+    memories_by_category: dict[str, int]
+    memories_by_retention: dict[str, int]
     average_importance: float
     total_entities: int
-    most_common_entities: List[Tuple[str, int]]
+    most_common_entities: list[tuple[str, int]]
     storage_size_mb: float
-    oldest_memory_date: Optional[datetime]
-    newest_memory_date: Optional[datetime]
+    oldest_memory_date: datetime | None
+    newest_memory_date: datetime | None

memori/utils/query_builder.py

@@ -4,7 +4,7 @@ Provides consistent parameter handling across SQLite, PostgreSQL, and MySQL
 """
 
 from enum import Enum
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any
 
 from loguru import logger
 
@@ -43,14 +43,14 @@ class QueryBuilder:
 
     def build_search_query(
         self,
-        tables: List[str],
-        search_columns: List[str],
+        tables: list[str],
+        search_columns: list[str],
         query_text: str,
         namespace: str,
-        category_filter: Optional[List[str]] = None,
+        category_filter: list[str] | None = None,
         limit: int = 10,
         use_fts: bool = False,
-    ) -> Tuple[str, List[Any]]:
+    ) -> tuple[str, list[Any]]:
         """Build a database-specific search query with proper parameter binding"""
 
         try:
@@ -148,8 +148,8 @@ class QueryBuilder:
         return query, params
 
     def build_insert_query(
-        self, table: str, data: Dict[str, Any], on_conflict: str = "REPLACE"
-    ) -> Tuple[str, List[Any]]:
+        self, table: str, data: dict[str, Any], on_conflict: str = "REPLACE"
+    ) -> tuple[str, list[Any]]:
         """Build database-specific insert query with proper parameter binding"""
 
         try:
@@ -210,8 +210,8 @@ class QueryBuilder:
         return query, values
 
     def build_update_query(
-        self, table: str, data: Dict[str, Any], where_conditions: Dict[str, Any]
-    ) -> Tuple[str, List[Any]]:
+        self, table: str, data: dict[str, Any], where_conditions: dict[str, Any]
+    ) -> tuple[str, list[Any]]:
         """Build database-specific update query"""
 
         try:
@@ -248,8 +248,8 @@ class QueryBuilder:
         return query, params
 
     def build_delete_query(
-        self, table: str, where_conditions: Dict[str, Any]
-    ) -> Tuple[str, List[Any]]:
+        self, table: str, where_conditions: dict[str, Any]
+    ) -> tuple[str, list[Any]]:
         """Build database-specific delete query"""
 
         try:
@@ -276,9 +276,9 @@ class QueryBuilder:
         self,
         query_text: str,
         namespace: str,
-        category_filter: Optional[List[str]] = None,
+        category_filter: list[str] | None = None,
         limit: int = 10,
-    ) -> Tuple[str, List[Any]]:
+    ) -> tuple[str, list[Any]]:
         """Build database-specific full-text search query"""
 
         try:
@@ -420,7 +420,7 @@ class QueryBuilder:
         params.append(limit)
         return query, params
 
-    def _get_primary_key_column(self, columns: List[str]) -> Optional[str]:
+    def _get_primary_key_column(self, columns: list[str]) -> str | None:
         """Detect likely primary key column from column names"""
         pk_candidates = [
             "id",
@@ -454,10 +454,10 @@ class DatabaseQueryExecutor:
         self,
         query_text: str,
         namespace: str = "default",
-        category_filter: Optional[List[str]] = None,
+        category_filter: list[str] | None = None,
         limit: int = 10,
         use_fts: bool = True,
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Execute search with proper error handling"""
         try:
             if use_fts:
@@ -493,8 +493,8 @@ class DatabaseQueryExecutor:
             return []
 
     def execute_safe_insert(
-        self, table: str, data: Dict[str, Any], on_conflict: str = "REPLACE"
-    ) -> Optional[str]:
+        self, table: str, data: dict[str, Any], on_conflict: str = "REPLACE"
+    ) -> str | None:
         """Execute insert with proper error handling"""
         try:
             sql_query, params = self.query_builder.build_insert_query(
@@ -506,7 +506,7 @@ class DatabaseQueryExecutor:
             raise DatabaseError(f"Failed to insert into {table}: {e}")
 
     def execute_safe_update(
-        self, table: str, data: Dict[str, Any], where_conditions: Dict[str, Any]
+        self, table: str, data: dict[str, Any], where_conditions: dict[str, Any]
     ) -> int:
         """Execute update with proper error handling"""
         try:
@@ -518,7 +518,7 @@ class DatabaseQueryExecutor:
             logger.error(f"Update execution failed: {e}")
             raise DatabaseError(f"Failed to update {table}: {e}")
 
-    def execute_safe_delete(self, table: str, where_conditions: Dict[str, Any]) -> int:
+    def execute_safe_delete(self, table: str, where_conditions: dict[str, Any]) -> int:
         """Execute delete with proper error handling"""
         try:
             sql_query, params = self.query_builder.build_delete_query(

memori/utils/security_audit.py

@@ -7,7 +7,7 @@ import re
 import time
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any
 
 from .exceptions import SecurityError
 from .input_validator import InputValidator
@@ -44,15 +44,15 @@ class SecurityFinding:
     description: str
     location: str
     recommendation: str
-    evidence: Optional[str] = None
-    remediation_code: Optional[str] = None
+    evidence: str | None = None
+    remediation_code: str | None = None
 
 
 @dataclass
 class SecurityAuditReport:
     """Security audit report"""
 
-    findings: List[SecurityFinding]
+    findings: list[SecurityFinding]
     total_queries_audited: int
     critical_count: int
     high_count: int
@@ -143,9 +143,9 @@ class DatabaseSecurityAuditor:
     def audit_query(
         self,
         query: str,
-        params: Optional[List[Any]] = None,
-        context: Optional[str] = None,
-    ) -> List[SecurityFinding]:
+        params: list[Any] | None = None,
+        context: str | None = None,
+    ) -> list[SecurityFinding]:
         """Audit a single database query for security vulnerabilities"""
         findings = []
         self.queries_audited += 1
@@ -169,8 +169,8 @@ class DatabaseSecurityAuditor:
         return findings
 
     def _audit_sql_injection(
-        self, query: str, params: Optional[List[Any]], context: Optional[str]
-    ) -> List[SecurityFinding]:
+        self, query: str, params: list[Any] | None, context: str | None
+    ) -> list[SecurityFinding]:
         """Audit for SQL injection vulnerabilities"""
         findings = []
         query_lower = query.lower()
@@ -219,8 +219,8 @@ class DatabaseSecurityAuditor:
         return findings
 
     def _audit_parameter_validation(
-        self, query: str, params: Optional[List[Any]], context: Optional[str]
-    ) -> List[SecurityFinding]:
+        self, query: str, params: list[Any] | None, context: str | None
+    ) -> list[SecurityFinding]:
         """Audit parameter validation"""
         findings = []
 
@@ -285,8 +285,8 @@ class DatabaseSecurityAuditor:
         return findings
 
     def _audit_privilege_operations(
-        self, query: str, context: Optional[str]
-    ) -> List[SecurityFinding]:
+        self, query: str, context: str | None
+    ) -> list[SecurityFinding]:
         """Audit for privilege escalation attempts"""
         findings = []
         query_upper = query.upper().strip()
@@ -334,8 +334,8 @@ class DatabaseSecurityAuditor:
         return findings
 
     def _audit_data_exposure(
-        self, query: str, context: Optional[str]
-    ) -> List[SecurityFinding]:
+        self, query: str, context: str | None
+    ) -> list[SecurityFinding]:
         """Audit for potential data exposure issues"""
         findings = []
         query_upper = query.upper()
@@ -397,10 +397,10 @@ class DatabaseSecurityAuditor:
     def validate_query_safety(
         self,
         query: str,
-        params: Optional[List[Any]] = None,
-        context: Optional[str] = None,
+        params: list[Any] | None = None,
+        context: str | None = None,
         strict_mode: bool = True,
-    ) -> Tuple[bool, List[SecurityFinding]]:
+    ) -> tuple[bool, list[SecurityFinding]]:
         """Validate if a query is safe to execute"""
         findings = self.audit_query(query, params, context)
 
@@ -444,7 +444,7 @@ class DatabaseSecurityAuditor:
             overall_risk_score=risk_score,
         )
 
-    def get_remediation_suggestions(self) -> Dict[VulnerabilityType, List[str]]:
+    def get_remediation_suggestions(self) -> dict[VulnerabilityType, list[str]]:
         """Get remediation suggestions grouped by vulnerability type"""
         suggestions = {
             VulnerabilityType.SQL_INJECTION: [
@@ -503,10 +503,10 @@ class SecureQueryBuilder:
     def build_safe_select(
         self,
         table: str,
-        columns: List[str],
-        where_conditions: Dict[str, Any],
-        limit: Optional[int] = None,
-    ) -> Tuple[str, List[Any]]:
+        columns: list[str],
+        where_conditions: dict[str, Any],
+        limit: int | None = None,
+    ) -> tuple[str, list[Any]]:
         """Build a safe SELECT query"""
         # Validate inputs
         table = InputValidator.sanitize_sql_identifier(table)
@@ -541,8 +541,8 @@ class SecureQueryBuilder:
         return query, params
 
     def build_safe_insert(
-        self, table: str, data: Dict[str, Any]
-    ) -> Tuple[str, List[Any]]:
+        self, table: str, data: dict[str, Any]
+    ) -> tuple[str, list[Any]]:
         """Build a safe INSERT query"""
         # Validate inputs
         table = InputValidator.sanitize_sql_identifier(table)
@@ -580,14 +580,14 @@ def get_security_auditor() -> DatabaseSecurityAuditor:
 
 
 def audit_query(
-    query: str, params: Optional[List[Any]] = None, context: Optional[str] = None
-) -> List[SecurityFinding]:
+    query: str, params: list[Any] | None = None, context: str | None = None
+) -> list[SecurityFinding]:
     """Convenience function to audit a single query"""
     return _global_auditor.audit_query(query, params, context)
 
 
 def validate_query_safety(
-    query: str, params: Optional[List[Any]] = None, context: Optional[str] = None
+    query: str, params: list[Any] | None = None, context: str | None = None
 ) -> bool:
     """Convenience function to validate query safety"""
     is_safe, _ = _global_auditor.validate_query_safety(query, params, context)

memori/utils/security_integration.py

@@ -3,7 +3,7 @@ Security Integration Module for Memori
 Integrates all security components into a unified system
 """
 
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 from loguru import logger
 
@@ -29,10 +29,10 @@ class SecureMemoriDatabase:
         self,
         query_text: str,
         namespace: str = "default",
-        category_filter: Optional[List[str]] = None,
+        category_filter: list[str] | None = None,
         limit: int = 10,
         use_fts: bool = True,
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Execute secure search with comprehensive validation"""
         try:
             # Phase 1: Input validation
@@ -96,8 +96,8 @@ class SecureMemoriDatabase:
             return []
 
     def secure_insert(
-        self, table: str, data: Dict[str, Any], on_conflict: str = "REPLACE"
-    ) -> Optional[str]:
+        self, table: str, data: dict[str, Any], on_conflict: str = "REPLACE"
+    ) -> str | None:
         """Execute secure insert with comprehensive validation"""
         try:
             # Phase 1: Input validation
@@ -135,7 +135,7 @@ class SecureMemoriDatabase:
             raise DatabaseError(f"Secure insert failed: {e}")
 
     def secure_update(
-        self, table: str, data: Dict[str, Any], where_conditions: Dict[str, Any]
+        self, table: str, data: dict[str, Any], where_conditions: dict[str, Any]
     ) -> int:
         """Execute secure update with comprehensive validation"""
         try:
@@ -188,7 +188,7 @@ class SecureMemoriDatabase:
             logger.error(f"Secure update failed: {e}")
             raise DatabaseError(f"Secure update failed: {e}")
 
-    def secure_delete(self, table: str, where_conditions: Dict[str, Any]) -> int:
+    def secure_delete(self, table: str, where_conditions: dict[str, Any]) -> int:
         """Execute secure delete with comprehensive validation"""
         try:
             # Phase 1: Input validation
@@ -235,7 +235,7 @@ class SecureMemoriDatabase:
             logger.error(f"Secure delete failed: {e}")
             raise DatabaseError(f"Secure delete failed: {e}")
 
-    def get_security_report(self) -> Dict[str, Any]:
+    def get_security_report(self) -> dict[str, Any]:
         """Get comprehensive security report"""
         audit_report = self.security_auditor.generate_audit_report()
 
@@ -279,7 +279,7 @@ def create_secure_database(connector, dialect: DatabaseDialect) -> SecureMemoriD
     return SecureMemoriDatabase(connector, dialect)
 
 
-def validate_memori_security_config() -> Dict[str, Any]:
+def validate_memori_security_config() -> dict[str, Any]:
     """Validate that all security components are properly configured"""
     validation_results = {
         "input_validator": False,