aetherforge-platform 1.0.0__py3-none-any.whl

ai-life-assistant-copy/tree_memory.py

@@ -0,0 +1,340 @@
+import json
+import os
+from typing import List, Dict, Any, Optional
+from datetime import datetime, timedelta
+import uuid
+
+
+class MemoryNode:
+    def __init__(
+        self, 
+        content: str, 
+        memory_id: Optional[str] = None,
+        min_age: int = 0, 
+        max_age: int = 150,
+        clarity: int = 80,
+        emotional_tone: str = "neutral",
+        topic: Optional[str] = None,
+        parent_id: Optional[str] = None,
+        created_at: Optional[str] = None,
+        importance: float = 0.5,
+        access_count: int = 0
+    ):
+        self.memory_id = memory_id or str(uuid.uuid4())
+        self.content = content
+        self.min_age = min_age
+        self.max_age = max_age
+        self.clarity = clarity
+        self.emotional_tone = emotional_tone
+        self.topic = topic
+        self.parent_id = parent_id
+        self.created_at = created_at or datetime.now().isoformat()
+        self.importance = importance
+        self.access_count = access_count
+        self.children: List[str] = []
+    
+    def get_age_in_days(self) -> float:
+        created = datetime.fromisoformat(self.created_at)
+        now = datetime.now()
+        return (now - created).total_seconds() / 86400
+    
+    def get_recency_score(self) -> float:
+        age_days = self.get_age_in_days()
+        if age_days < 1:
+            return 1.0
+        elif age_days < 7:
+            return 0.8
+        elif age_days < 30:
+            return 0.5
+        elif age_days < 90:
+            return 0.2
+        else:
+            return 0.05
+    
+    def get_relevance_score(self, query: str) -> float:
+        query_lower = query.lower()
+        content_lower = self.content.lower()
+        topic_lower = self.topic.lower() if self.topic else ""
+        
+        score = 0.0
+        if query_lower in content_lower:
+            score += 0.6
+        if query_lower in topic_lower:
+            score += 0.3
+        
+        score += self.importance * 0.3
+        score += (self.clarity / 100) * 0.2
+        score += self.get_recency_score() * 0.4
+        
+        return min(1.0, score)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "memory_id": self.memory_id,
+            "content": self.content,
+            "min_age": self.min_age,
+            "max_age": self.max_age,
+            "clarity": self.clarity,
+            "emotional_tone": self.emotional_tone,
+            "topic": self.topic,
+            "parent_id": self.parent_id,
+            "created_at": self.created_at,
+            "importance": self.importance,
+            "access_count": self.access_count,
+            "children": self.children
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'MemoryNode':
+        node = cls(
+            content=data["content"],
+            memory_id=data["memory_id"],
+            min_age=data["min_age"],
+            max_age=data["max_age"],
+            clarity=data["clarity"],
+            emotional_tone=data["emotional_tone"],
+            topic=data.get("topic"),
+            parent_id=data.get("parent_id"),
+            created_at=data.get("created_at"),
+            importance=data.get("importance", 0.5),
+            access_count=data.get("access_count", 0)
+        )
+        node.children = data.get("children", [])
+        return node
+
+
+class InvertedTreeMemory:
+    def __init__(self, tree_id: str = "root"):
+        self.tree_id = tree_id
+        self.nodes: Dict[str, MemoryNode] = {}
+        self.trunk: List[str] = []
+        self.created_at = datetime.now().isoformat()
+    
+    def add_node(self, node: MemoryNode):
+        self.nodes[node.memory_id] = node
+        if not node.parent_id:
+            self.trunk.append(node.memory_id)
+        elif node.parent_id in self.nodes:
+            self.nodes[node.parent_id].children.append(node.memory_id)
+    
+    def get_node(self, memory_id: str) -> Optional[MemoryNode]:
+        return self.nodes.get(memory_id)
+    
+    def filter_by_age(self, target_age: int) -> List[MemoryNode]:
+        filtered = []
+        for node in self.nodes.values():
+            if node.min_age <= target_age <= node.max_age:
+                filtered.append(node)
+        return filtered
+    
+    def search_relevant(self, query: str, min_relevance: float = 0.3, max_results: int = 10) -> List[MemoryNode]:
+        scored_nodes = []
+        for node in self.nodes.values():
+            score = node.get_relevance_score(query)
+            if score >= min_relevance:
+                scored_nodes.append((score, node))
+        
+        scored_nodes.sort(key=lambda x: x[0], reverse=True)
+        return [node for (score, node) in scored_nodes[:max_results]]
+    
+    def get_related_memories(self, memory_id: str) -> List[MemoryNode]:
+        related = []
+        node = self.get_node(memory_id)
+        if not node:
+            return related
+        
+        if node.parent_id:
+            parent = self.get_node(node.parent_id)
+            if parent:
+                related.append(parent)
+        
+        for child_id in node.children:
+            child = self.get_node(child_id)
+            if child:
+                related.append(child)
+        
+        return related
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "tree_id": self.tree_id,
+            "nodes": {k: v.to_dict() for k, v in self.nodes.items()},
+            "trunk": self.trunk,
+            "created_at": self.created_at
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'InvertedTreeMemory':
+        tree = cls(tree_id=data["tree_id"])
+        tree.created_at = data["created_at"]
+        tree.trunk = data.get("trunk", [])
+        for node_data in data.get("nodes", {}).values():
+            node = MemoryNode.from_dict(node_data)
+            tree.nodes[node.memory_id] = node
+        return tree
+
+
+class TreeMemorySystem:
+    def __init__(self, storage_dir: str = "avatar_memory"):
+        self.storage_dir = storage_dir
+        if not os.path.exists(storage_dir):
+            os.makedirs(storage_dir)
+    
+    def _get_tree_file(self, avatar_id: str) -> str:
+        return os.path.join(self.storage_dir, f"{avatar_id}_tree.json")
+    
+    def load_tree(self, avatar_id: str) -> InvertedTreeMemory:
+        file_path = self._get_tree_file(avatar_id)
+        if os.path.exists(file_path):
+            with open(file_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                return InvertedTreeMemory.from_dict(data)
+        return InvertedTreeMemory(tree_id=avatar_id)
+    
+    def save_tree(self, avatar_id: str, tree: InvertedTreeMemory):
+        file_path = self._get_tree_file(avatar_id)
+        with open(file_path, "w", encoding="utf-8") as f:
+            json.dump(tree.to_dict(), f, ensure_ascii=False, indent=2)
+    
+    def add_memory(
+        self, 
+        avatar_id: str, 
+        content: str, 
+        min_age: int = 0,
+        max_age: int = 150,
+        clarity: int = 80,
+        emotional_tone: str = "neutral",
+        topic: Optional[str] = None,
+        parent_id: Optional[str] = None,
+        importance: float = 0.5
+    ) -> str:
+        tree = self.load_tree(avatar_id)
+        node = MemoryNode(
+            content=content,
+            min_age=min_age,
+            max_age=max_age,
+            clarity=clarity,
+            emotional_tone=emotional_tone,
+            topic=topic,
+            parent_id=parent_id,
+            importance=importance
+        )
+        tree.add_node(node)
+        self.save_tree(avatar_id, tree)
+        return node.memory_id
+    
+    def get_memories_by_age(self, avatar_id: str, target_age: int) -> List[Dict[str, Any]]:
+        tree = self.load_tree(avatar_id)
+        nodes = tree.filter_by_age(target_age)
+        return [node.to_dict() for node in nodes]
+    
+    def get_all_memories(self, avatar_id: str) -> List[Dict[str, Any]]:
+        tree = self.load_tree(avatar_id)
+        return [node.to_dict() for node in tree.nodes.values()]
+    
+    def get_tree_structure(self, avatar_id: str) -> Dict[str, Any]:
+        tree = self.load_tree(avatar_id)
+        return tree.to_dict()
+    
+    def delete_memory(self, avatar_id: str, memory_id: str) -> bool:
+        tree = self.load_tree(avatar_id)
+        if memory_id in tree.nodes:
+            del tree.nodes[memory_id]
+            tree.trunk = [mid for mid in tree.trunk if mid != memory_id]
+            for node in tree.nodes.values():
+                node.children = [mid for mid in node.children if mid != memory_id]
+            self.save_tree(avatar_id, tree)
+            return True
+        return False
+    
+    def search_relevant_memories(
+        self, 
+        avatar_id: str, 
+        query: str, 
+        min_relevance: float = 0.3, 
+        max_results: int = 10
+    ) -> List[Dict[str, Any]]:
+        tree = self.load_tree(avatar_id)
+        nodes = tree.search_relevant(query, min_relevance, max_results)
+        results = []
+        for node in nodes:
+            node.access_count += 1
+            results.append(node.to_dict())
+        self.save_tree(avatar_id, tree)
+        return results
+    
+    def get_related_memories(self, avatar_id: str, memory_id: str) -> List[Dict[str, Any]]:
+        tree = self.load_tree(avatar_id)
+        nodes = tree.get_related_memories(memory_id)
+        return [node.to_dict() for node in nodes]
+    
+    def get_relevant_context(
+        self, 
+        avatar_id: str, 
+        current_message: str, 
+        min_relevance: float = 0.3, 
+        max_results: int = 5
+    ) -> str:
+        memories = self.search_relevant_memories(avatar_id, current_message, min_relevance, max_results)
+        if not memories:
+            return ""
+        
+        context_parts = ["【用户背景信息 - 树状记忆系统】"]
+        for mem in memories:
+            age_info = ""
+            if mem["min_age"] != 0 or mem["max_age"] != 150:
+                if mem["min_age"] == mem["max_age"]:
+                    age_info = f" [年龄: {mem['min_age']}]"
+                else:
+                    age_info = f" [年龄: {mem['min_age']}-{mem['max_age']}]"
+            
+            clarity_info = f" [清晰度: {mem['clarity']}%]"
+            emotion_info = f" [情感: {mem['emotional_tone']}]"
+            topic_info = f" [主题: {mem['topic']}]" if mem['topic'] else ""
+            
+            context_parts.append(f"- {mem['content']}{age_info}{clarity_info}{emotion_info}{topic_info}")
+        
+        return "\n".join(context_parts)
+    
+    def extract_and_save_memory(
+        self, 
+        avatar_id: str, 
+        message: str, 
+        response: str = "",
+        current_age: int = 25
+    ) -> Optional[str]:
+        message_lower = message.lower()
+        
+        importance = 0.5
+        if "永远" in message_lower or "绝对" in message_lower or "绝不" in message_lower:
+            importance = 0.9
+        elif "非常" in message_lower or "特别" in message_lower:
+            importance = 0.75
+        
+        emotional_tone = "neutral"
+        positive_words = ["开心", "快乐", "高兴", "喜欢", "爱", "好", "棒", "完美"]
+        negative_words = ["难过", "伤心", "讨厌", "恨", "不好", "糟糕", "生气", "愤怒"]
+        
+        if any(word in message_lower for word in positive_words):
+            emotional_tone = "positive"
+        elif any(word in message_lower for word in negative_words):
+            emotional_tone = "negative"
+        
+        user_keywords = ["我是", "我喜欢", "我偏好", "我不喜欢", "我讨厌", "我想要", "我爱吃", "我爱玩", "记得", "小时候", "曾经"]
+        should_save = any(keyword in message_lower for keyword in user_keywords) or len(message) > 20
+        
+        if should_save:
+            return self.add_memory(
+                avatar_id=avatar_id,
+                content=message,
+                min_age=current_age,
+                max_age=current_age,
+                clarity=80,
+                emotional_tone=emotional_tone,
+                importance=importance
+            )
+        
+        return None
+
+
+tree_memory_system = TreeMemorySystem()