powermem 0.1.0__py3-none-any.whl

powermem/agent/abstract/manager.py

@@ -0,0 +1,232 @@
+"""
+Abstract base class for agent memory managers.
+
+This module defines the core interface that all agent memory managers must implement,
+providing a unified API for memory operations across different scenarios.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+
+from typing import Any, Dict
+
+
+class AgentMemoryManagerBase(ABC):
+    """
+    Abstract base class for agent memory managers.
+    
+    This class defines the core interface that all agent memory managers must implement,
+    providing a unified API for memory operations across different scenarios.
+    """
+    
+    def __init__(self, config: Dict[str, Any]):
+        """
+        Initialize the agent memory manager.
+        
+        Args:
+            config: Memory configuration object
+        """
+        self.config = config
+        self.initialized = False
+    
+    @abstractmethod
+    def initialize(self) -> None:
+        """
+        Initialize the memory manager.
+        
+        This method should be called after instantiation to set up
+        any required resources or connections.
+        """
+        pass
+    
+    @abstractmethod
+    def process_memory(
+        self,
+        content: str,
+        agent_id: str,
+        context: Optional[Dict[str, Any]] = None,
+        metadata: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """
+        Process and store a new memory.
+        
+        Args:
+            content: The memory content to store
+            agent_id: ID of the agent/user creating the memory
+            context: Additional context information
+            metadata: Additional metadata for the memory
+            
+        Returns:
+            Dictionary containing the processed memory information
+        """
+        pass
+    
+    @abstractmethod
+    def get_memories(
+        self,
+        agent_id: str,
+        query: Optional[str] = None,
+        filters: Optional[Dict[str, Any]] = None
+    ) -> List[Dict[str, Any]]:
+        """
+        Retrieve memories for a specific agent/user.
+        
+        Args:
+            agent_id: ID of the agent/user
+            query: Optional query string for filtering
+            filters: Optional additional filters
+            
+        Returns:
+            List of memory dictionaries
+        """
+        pass
+    
+    @abstractmethod
+    def update_memory(
+        self,
+        memory_id: str,
+        agent_id: str,
+        updates: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Update an existing memory.
+        
+        Args:
+            memory_id: ID of the memory to update
+            agent_id: ID of the agent/user making the update
+            updates: Dictionary of updates to apply
+            
+        Returns:
+            Dictionary containing the updated memory information
+        """
+        pass
+    
+    @abstractmethod
+    def delete_memory(
+        self,
+        memory_id: str,
+        agent_id: str
+    ) -> Dict[str, Any]:
+        """
+        Delete a memory.
+        
+        Args:
+            memory_id: ID of the memory to delete
+            agent_id: ID of the agent/user making the deletion
+            
+        Returns:
+            Dictionary containing the deletion result
+        """
+        pass
+    
+    @abstractmethod
+    def share_memory(
+        self,
+        memory_id: str,
+        from_agent: str,
+        to_agents: List[str],
+        permissions: Optional[List[str]] = None
+    ) -> Dict[str, Any]:
+        """
+        Share a memory with other agents/users.
+        
+        Args:
+            memory_id: ID of the memory to share
+            from_agent: ID of the agent/user sharing the memory
+            to_agents: List of agent/user IDs to share with
+            permissions: Optional list of permissions to grant
+            
+        Returns:
+            Dictionary containing the sharing result
+        """
+        pass
+    
+    @abstractmethod
+    def get_context_info(self, agent_id: str) -> Dict[str, Any]:
+        """
+        Get context information for an agent/user.
+        
+        Args:
+            agent_id: ID of the agent/user
+            
+        Returns:
+            Dictionary containing context information
+        """
+        pass
+    
+    @abstractmethod
+    def update_memory_decay(self) -> Dict[str, Any]:
+        """
+        Update memory decay based on Ebbinghaus forgetting curve.
+        
+        Returns:
+            Dictionary containing the decay update results
+        """
+        pass
+    
+    @abstractmethod
+    def cleanup_forgotten_memories(self) -> Dict[str, Any]:
+        """
+        Clean up memories that have been forgotten.
+        
+        Returns:
+            Dictionary containing the cleanup results
+        """
+        pass
+    
+    @abstractmethod
+    def get_memory_statistics(self) -> Dict[str, Any]:
+        """
+        Get statistics about the memory system.
+        
+        Returns:
+            Dictionary containing memory statistics
+        """
+        pass
+    
+    @abstractmethod
+    def check_permission(
+        self,
+        agent_id: str,
+        memory_id: str,
+        permission: str
+    ) -> bool:
+        """
+        Check if an agent/user has a specific permission for a memory.
+        
+        Args:
+            agent_id: ID of the agent/user
+            memory_id: ID of the memory
+            permission: Permission to check
+            
+        Returns:
+            True if the agent/user has the permission, False otherwise
+        """
+        pass
+    
+    def get_manager_type(self) -> str:
+        """
+        Get the type of this memory manager.
+        
+        Returns:
+            String representing the manager type
+        """
+        return self.__class__.__name__
+    
+    def is_initialized(self) -> bool:
+        """
+        Check if the memory manager is initialized.
+        
+        Returns:
+            True if initialized, False otherwise
+        """
+        return self.initialized
+    
+    def get_config(self) -> Dict[str, Any]:
+        """
+        Get the configuration object.
+        
+        Returns:
+            Memory configuration object
+        """
+        return self.config

powermem/agent/abstract/permission.py

@@ -0,0 +1,217 @@
+"""
+Abstract base class for agent permission managers.
+
+This module defines the interface for managing permissions and access control
+in the agent memory system.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+
+from powermem.agent.types import AccessPermission
+
+
+class AgentPermissionManagerBase(ABC):
+    """
+    Abstract base class for agent permission managers.
+    
+    This class defines the interface for managing permissions and access control
+    in the agent memory system.
+    """
+    
+    def __init__(self, config: Dict[str, Any]):
+        """
+        Initialize the permission manager.
+        
+        Args:
+            config: Configuration dictionary
+        """
+        self.config = config
+        self.initialized = False
+    
+    @abstractmethod
+    def initialize(self) -> None:
+        """
+        Initialize the permission manager.
+        """
+        pass
+    
+    @abstractmethod
+    def check_permission(
+        self,
+        agent_id: str,
+        memory_id: str,
+        permission: AccessPermission
+    ) -> bool:
+        """
+        Check if an agent/user has a specific permission for a memory.
+        
+        Args:
+            agent_id: ID of the agent/user
+            memory_id: ID of the memory
+            permission: Permission to check
+            
+        Returns:
+            True if the agent/user has the permission, False otherwise
+        """
+        pass
+    
+    @abstractmethod
+    def grant_permission(
+        self,
+        memory_id: str,
+        agent_id: str,
+        permission: AccessPermission,
+        granted_by: str
+    ) -> Dict[str, Any]:
+        """
+        Grant a permission to an agent/user for a memory.
+        
+        Args:
+            memory_id: ID of the memory
+            agent_id: ID of the agent/user to grant permission to
+            permission: Permission to grant
+            granted_by: ID of the agent/user granting the permission
+            
+        Returns:
+            Dictionary containing the grant result
+        """
+        pass
+    
+    @abstractmethod
+    def revoke_permission(
+        self,
+        memory_id: str,
+        agent_id: str,
+        permission: AccessPermission,
+        revoked_by: str
+    ) -> Dict[str, Any]:
+        """
+        Revoke a permission from an agent/user for a memory.
+        
+        Args:
+            memory_id: ID of the memory
+            agent_id: ID of the agent/user to revoke permission from
+            permission: Permission to revoke
+            revoked_by: ID of the agent/user revoking the permission
+            
+        Returns:
+            Dictionary containing the revoke result
+        """
+        pass
+    
+    @abstractmethod
+    def get_permissions(
+        self,
+        memory_id: str,
+        agent_id: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Get permissions for a memory or agent/user.
+        
+        Args:
+            memory_id: ID of the memory
+            agent_id: Optional ID of the agent/user
+            
+        Returns:
+            Dictionary containing permission information
+        """
+        pass
+    
+    @abstractmethod
+    def set_default_permissions(
+        self,
+        memory_id: str,
+        permissions: Dict[str, List[AccessPermission]],
+        set_by: str
+    ) -> Dict[str, Any]:
+        """
+        Set default permissions for a memory.
+        
+        Args:
+            memory_id: ID of the memory
+            permissions: Dictionary of default permissions
+            set_by: ID of the agent/user setting the permissions
+            
+        Returns:
+            Dictionary containing the set result
+        """
+        pass
+    
+    @abstractmethod
+    def inherit_permissions(
+        self,
+        target_memory_id: str,
+        source_memory_id: str,
+        inherited_by: str
+    ) -> Dict[str, Any]:
+        """
+        Inherit permissions from another memory.
+        
+        Args:
+            target_memory_id: ID of the target memory
+            source_memory_id: ID of the source memory
+            inherited_by: ID of the agent/user inheriting the permissions
+            
+        Returns:
+            Dictionary containing the inherit result
+        """
+        pass
+    
+    @abstractmethod
+    def get_permission_history(
+        self,
+        memory_id: str,
+        agent_id: Optional[str] = None,
+        limit: Optional[int] = None
+    ) -> List[Dict[str, Any]]:
+        """
+        Get permission history for a memory or agent/user.
+        
+        Args:
+            memory_id: ID of the memory
+            agent_id: Optional ID of the agent/user
+            limit: Optional limit on number of entries
+            
+        Returns:
+            List of permission history entries
+        """
+        pass
+    
+    @abstractmethod
+    def validate_permission_chain(
+        self,
+        agent_id: str,
+        memory_id: str,
+        permission: AccessPermission
+    ) -> Dict[str, Any]:
+        """
+        Validate the permission chain for an agent/user and memory.
+        
+        Args:
+            agent_id: ID of the agent/user
+            memory_id: ID of the memory
+            permission: Permission to validate
+            
+        Returns:
+            Dictionary containing validation results
+        """
+        pass
+    
+    def is_initialized(self) -> bool:
+        """
+        Check if the permission manager is initialized.
+        
+        Returns:
+            True if initialized, False otherwise
+        """
+        return self.initialized
+    
+    def get_config(self) -> Dict[str, Any]:
+        """
+        Get the configuration object.
+        
+        Returns:
+            Configuration dictionary
+        """
+        return self.config

powermem/agent/abstract/privacy.py

@@ -0,0 +1,267 @@
+"""
+Abstract base class for agent privacy managers.
+
+This module defines the interface for managing privacy and data protection
+in the agent memory system.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+
+from powermem.agent.types import PrivacyLevel
+
+
+class AgentPrivacyManagerBase(ABC):
+    """
+    Abstract base class for agent privacy managers.
+    
+    This class defines the interface for managing privacy and data protection
+    in the agent memory system.
+    """
+    
+    def __init__(self, config: Dict[str, Any]):
+        """
+        Initialize the privacy manager.
+        
+        Args:
+            config: Configuration dictionary
+        """
+        self.config = config
+        self.initialized = False
+    
+    @abstractmethod
+    def initialize(self) -> None:
+        """
+        Initialize the privacy manager.
+        """
+        pass
+    
+    @abstractmethod
+    def set_privacy_level(
+        self,
+        memory_id: str,
+        privacy_level: PrivacyLevel,
+        set_by: str
+    ) -> Dict[str, Any]:
+        """
+        Set the privacy level for a memory.
+        
+        Args:
+            memory_id: ID of the memory
+            privacy_level: Privacy level to set
+            set_by: ID of the agent/user setting the privacy level
+            
+        Returns:
+            Dictionary containing the set result
+        """
+        pass
+    
+    @abstractmethod
+    def get_privacy_level(
+        self,
+        memory_id: str
+    ) -> PrivacyLevel:
+        """
+        Get the privacy level for a memory.
+        
+        Args:
+            memory_id: ID of the memory
+            
+        Returns:
+            PrivacyLevel enum value
+        """
+        pass
+    
+    @abstractmethod
+    def encrypt_memory(
+        self,
+        memory_id: str,
+        encryption_key: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Encrypt a memory.
+        
+        Args:
+            memory_id: ID of the memory
+            encryption_key: Optional encryption key
+            
+        Returns:
+            Dictionary containing the encryption result
+        """
+        pass
+    
+    @abstractmethod
+    def decrypt_memory(
+        self,
+        memory_id: str,
+        decryption_key: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Decrypt a memory.
+        
+        Args:
+            memory_id: ID of the memory
+            decryption_key: Optional decryption key
+            
+        Returns:
+            Dictionary containing the decryption result
+        """
+        pass
+    
+    @abstractmethod
+    def anonymize_memory(
+        self,
+        memory_id: str,
+        anonymization_rules: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """
+        Anonymize a memory.
+        
+        Args:
+            memory_id: ID of the memory
+            anonymization_rules: Optional anonymization rules
+            
+        Returns:
+            Dictionary containing the anonymization result
+        """
+        pass
+    
+    @abstractmethod
+    def log_access(
+        self,
+        memory_id: str,
+        agent_id: str,
+        access_type: str,
+        metadata: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """
+        Log access to a memory.
+        
+        Args:
+            memory_id: ID of the memory
+            agent_id: ID of the agent/user accessing
+            access_type: Type of access
+            metadata: Optional metadata about the access
+            
+        Returns:
+            Dictionary containing the log result
+        """
+        pass
+    
+    @abstractmethod
+    def get_access_logs(
+        self,
+        memory_id: str,
+        agent_id: Optional[str] = None,
+        limit: Optional[int] = None
+    ) -> List[Dict[str, Any]]:
+        """
+        Get access logs for a memory.
+        
+        Args:
+            memory_id: ID of the memory
+            agent_id: Optional ID of the agent/user
+            limit: Optional limit on number of entries
+            
+        Returns:
+            List of access log entries
+        """
+        pass
+    
+    @abstractmethod
+    def apply_retention_policy(
+        self,
+        memory_id: str,
+        retention_policy: str
+    ) -> Dict[str, Any]:
+        """
+        Apply a retention policy to a memory.
+        
+        Args:
+            memory_id: ID of the memory
+            retention_policy: Retention policy to apply
+            
+        Returns:
+            Dictionary containing the policy application result
+        """
+        pass
+    
+    @abstractmethod
+    def check_gdpr_compliance(
+        self,
+        memory_id: str
+    ) -> Dict[str, Any]:
+        """
+        Check GDPR compliance for a memory.
+        
+        Args:
+            memory_id: ID of the memory
+            
+        Returns:
+            Dictionary containing compliance check results
+        """
+        pass
+    
+    @abstractmethod
+    def export_user_data(
+        self,
+        agent_id: str,
+        export_format: str = "json"
+    ) -> Dict[str, Any]:
+        """
+        Export user data for GDPR compliance.
+        
+        Args:
+            agent_id: ID of the agent/user
+            export_format: Format for the export
+            
+        Returns:
+            Dictionary containing the export result
+        """
+        pass
+    
+    @abstractmethod
+    def delete_user_data(
+        self,
+        agent_id: str,
+        confirmation_token: str
+    ) -> Dict[str, Any]:
+        """
+        Delete user data for GDPR compliance.
+        
+        Args:
+            agent_id: ID of the agent/user
+            confirmation_token: Confirmation token for deletion
+            
+        Returns:
+            Dictionary containing the deletion result
+        """
+        pass
+    
+    @abstractmethod
+    def get_privacy_statistics(self) -> Dict[str, Any]:
+        """
+        Get privacy statistics.
+        
+        Returns:
+            Dictionary containing privacy statistics
+        """
+        pass
+    
+    def is_initialized(self) -> bool:
+        """
+        Check if the privacy manager is initialized.
+        
+        Returns:
+            True if initialized, False otherwise
+        """
+        return self.initialized
+    
+    def get_config(self) -> Dict[str, Any]:
+        """
+        Get the configuration object.
+        
+        Returns:
+            Configuration dictionary
+        """
+        return self.config