aetherforge-platform 1.0.0__py3-none-any.whl

ai-life-assistant-copy/backups/backup_20260404_193836/avatar_manager.py

@@ -0,0 +1,231 @@
+import json
+import os
+import uuid
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+from tree_memory import tree_memory_system, InvertedTreeMemory
+
+
+class Avatar:
+    def __init__(
+        self,
+        avatar_id: Optional[str] = None,
+        name: str = "虚拟形象",
+        description: str = "",
+        personality_traits: List[str] = None,
+        current_age: int = 25,
+        birth_year: Optional[int] = None,
+        avatar_image: Optional[str] = None,
+        is_public: bool = False,
+        price: Optional[float] = None,
+        creator_id: Optional[str] = None,
+        created_at: Optional[str] = None,
+        updated_at: Optional[str] = None
+    ):
+        self.avatar_id = avatar_id or str(uuid.uuid4())
+        self.name = name
+        self.description = description
+        self.personality_traits = personality_traits or ["友好", "好奇"]
+        self.current_age = current_age
+        self.birth_year = birth_year or (datetime.now().year - current_age)
+        self.avatar_image = avatar_image
+        self.is_public = is_public
+        self.price = price
+        self.creator_id = creator_id
+        self.created_at = created_at or datetime.now().isoformat()
+        self.updated_at = updated_at or datetime.now().isoformat()
+        self.settings = {
+            "developer_mode": False,
+            "auto_organize": True,
+            "privacy_level": "private"
+        }
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "avatar_id": self.avatar_id,
+            "name": self.name,
+            "description": self.description,
+            "personality_traits": self.personality_traits,
+            "current_age": self.current_age,
+            "birth_year": self.birth_year,
+            "avatar_image": self.avatar_image,
+            "is_public": self.is_public,
+            "price": self.price,
+            "creator_id": self.creator_id,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+            "settings": self.settings
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'Avatar':
+        avatar = cls(
+            avatar_id=data.get("avatar_id"),
+            name=data.get("name", "虚拟形象"),
+            description=data.get("description", ""),
+            personality_traits=data.get("personality_traits"),
+            current_age=data.get("current_age", 25),
+            birth_year=data.get("birth_year"),
+            avatar_image=data.get("avatar_image"),
+            is_public=data.get("is_public", False),
+            price=data.get("price"),
+            creator_id=data.get("creator_id"),
+            created_at=data.get("created_at"),
+            updated_at=data.get("updated_at")
+        )
+        avatar.settings = data.get("settings", avatar.settings)
+        return avatar
+    
+    def calculate_real_age(self) -> int:
+        return datetime.now().year - self.birth_year
+
+
+class AvatarManager:
+    def __init__(self, storage_dir: str = "avatar_data"):
+        self.storage_dir = storage_dir
+        self.avatars_dir = os.path.join(storage_dir, "avatars")
+        self.market_dir = os.path.join(storage_dir, "market")
+        
+        for dir_path in [self.storage_dir, self.avatars_dir, self.market_dir]:
+            if not os.path.exists(dir_path):
+                os.makedirs(dir_path)
+    
+    def _get_avatar_file(self, avatar_id: str) -> str:
+        return os.path.join(self.avatars_dir, f"{avatar_id}.json")
+    
+    def create_avatar(
+        self,
+        name: str,
+        description: str = "",
+        personality_traits: List[str] = None,
+        current_age: int = 25,
+        creator_id: Optional[str] = None
+    ) -> Avatar:
+        avatar = Avatar(
+            name=name,
+            description=description,
+            personality_traits=personality_traits,
+            current_age=current_age,
+            creator_id=creator_id
+        )
+        self.save_avatar(avatar)
+        return avatar
+    
+    def save_avatar(self, avatar: Avatar):
+        avatar.updated_at = datetime.now().isoformat()
+        file_path = self._get_avatar_file(avatar.avatar_id)
+        with open(file_path, "w", encoding="utf-8") as f:
+            json.dump(avatar.to_dict(), f, ensure_ascii=False, indent=2)
+    
+    def load_avatar(self, avatar_id: str) -> Optional[Avatar]:
+        file_path = self._get_avatar_file(avatar_id)
+        if os.path.exists(file_path):
+            with open(file_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                return Avatar.from_dict(data)
+        return None
+    
+    def update_avatar(self, avatar_id: str, **kwargs) -> Optional[Avatar]:
+        avatar = self.load_avatar(avatar_id)
+        if not avatar:
+            return None
+        
+        for key, value in kwargs.items():
+            if hasattr(avatar, key):
+                setattr(avatar, key, value)
+        
+        self.save_avatar(avatar)
+        return avatar
+    
+    def delete_avatar(self, avatar_id: str) -> bool:
+        file_path = self._get_avatar_file(avatar_id)
+        if os.path.exists(file_path):
+            os.remove(file_path)
+            return True
+        return False
+    
+    def list_avatars(self, creator_id: Optional[str] = None) -> List[Dict[str, Any]]:
+        avatars = []
+        for filename in os.listdir(self.avatars_dir):
+            if filename.endswith(".json"):
+                file_path = os.path.join(self.avatars_dir, filename)
+                with open(file_path, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+                    if creator_id is None or data.get("creator_id") == creator_id:
+                        avatars.append(data)
+        return avatars
+    
+    def set_age(self, avatar_id: str, age: int) -> Optional[Avatar]:
+        avatar = self.load_avatar(avatar_id)
+        if avatar:
+            avatar.current_age = age
+            self.save_avatar(avatar)
+            return avatar
+        return None
+    
+    def get_memories_for_age(self, avatar_id: str, target_age: int) -> List[Dict[str, Any]]:
+        return tree_memory_system.get_memories_by_age(avatar_id, target_age)
+    
+    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
+    ) -> str:
+        return tree_memory_system.add_memory(
+            avatar_id=avatar_id,
+            content=content,
+            min_age=min_age,
+            max_age=max_age,
+            clarity=clarity,
+            emotional_tone=emotional_tone,
+            topic=topic
+        )
+    
+    def get_tree_structure(self, avatar_id: str) -> Optional[Dict[str, Any]]:
+        return tree_memory_system.get_tree_structure(avatar_id)
+    
+    def toggle_developer_mode(self, avatar_id: str) -> Optional[bool]:
+        avatar = self.load_avatar(avatar_id)
+        if avatar:
+            avatar.settings["developer_mode"] = not avatar.settings["developer_mode"]
+            self.save_avatar(avatar)
+            return avatar.settings["developer_mode"]
+        return None
+    
+    def list_market_avatars(self) -> List[Dict[str, Any]]:
+        avatars = []
+        for filename in os.listdir(self.avatars_dir):
+            if filename.endswith(".json"):
+                file_path = os.path.join(self.avatars_dir, filename)
+                with open(file_path, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+                    if data.get("is_public") and data.get("price") is not None:
+                        avatars.append(data)
+        return avatars
+    
+    def purchase_avatar(self, avatar_id: str, buyer_id: str) -> Optional[Avatar]:
+        avatar = self.load_avatar(avatar_id)
+        if avatar and avatar.is_public and avatar.price is not None:
+            new_avatar = Avatar(
+                name=avatar.name,
+                description=avatar.description,
+                personality_traits=avatar.personality_traits.copy(),
+                current_age=avatar.current_age,
+                birth_year=avatar.birth_year,
+                creator_id=buyer_id
+            )
+            
+            src_tree = tree_memory_system.load_tree(avatar_id)
+            tree_memory_system.save_tree(new_avatar.avatar_id, src_tree)
+            
+            self.save_avatar(new_avatar)
+            return new_avatar
+        return None
+
+
+avatar_manager = AvatarManager()

ai-life-assistant-copy/backups/backup_20260404_193836/avatar_packer.py

@@ -0,0 +1,261 @@
+import json
+import zipfile
+import os
+from typing import Dict, Any, Optional
+from datetime import datetime
+from avatar_manager import Avatar, avatar_manager
+from tree_memory import tree_memory_system, InvertedTreeMemory
+
+
+class AvatarPacker:
+    def __init__(self, export_dir: str = "avatar_exports"):
+        self.export_dir = export_dir
+        if not os.path.exists(export_dir):
+            os.makedirs(export_dir)
+    
+    def export_avatar(self, avatar_id: str, export_format: str = "avatar") -> Optional[str]:
+        avatar = avatar_manager.load_avatar(avatar_id)
+        if not avatar:
+            return None
+        
+        tree = tree_memory_system.load_tree(avatar_id)
+        
+        if export_format == "avatar":
+            return self._export_as_avatar_file(avatar, tree)
+        elif export_format == "json":
+            return self._export_as_json(avatar, tree)
+        elif export_format == "sql":
+            return self._export_as_sql(avatar, tree)
+        else:
+            return None
+    
+    def _export_as_avatar_file(self, avatar: Avatar, tree: InvertedTreeMemory) -> str:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"{avatar.name.replace(' ', '_')}_{timestamp}.avatar"
+        filepath = os.path.join(self.export_dir, filename)
+        
+        package_data = {
+            "version": "1.0",
+            "type": "avatar_package",
+            "created_at": datetime.now().isoformat(),
+            "avatar": avatar.to_dict(),
+            "memory_tree": tree.to_dict()
+        }
+        
+        with open(filepath, "w", encoding="utf-8") as f:
+            json.dump(package_data, f, ensure_ascii=False, indent=2)
+        
+        return filepath
+    
+    def _export_as_json(self, avatar: Avatar, tree: InvertedTreeMemory) -> str:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"{avatar.name.replace(' ', '_')}_{timestamp}.json"
+        filepath = os.path.join(self.export_dir, filename)
+        
+        export_data = {
+            "avatar": avatar.to_dict(),
+            "memories": [node.to_dict() for node in tree.nodes.values()]
+        }
+        
+        with open(filepath, "w", encoding="utf-8") as f:
+            json.dump(export_data, f, ensure_ascii=False, indent=2)
+        
+        return filepath
+    
+    def _export_as_sql(self, avatar: Avatar, tree: InvertedTreeMemory) -> str:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"{avatar.name.replace(' ', '_')}_{timestamp}.sql"
+        filepath = os.path.join(self.export_dir, filename)
+        
+        sql_content = []
+        
+        sql_content.append("-- Avatar System SQL Export")
+        sql_content.append(f"-- Generated at: {datetime.now().isoformat()}")
+        sql_content.append("")
+        
+        sql_content.append("-- Create avatars table if not exists")
+        sql_content.append("""
+CREATE TABLE IF NOT EXISTS avatars (
+    id VARCHAR(50) PRIMARY KEY,
+    name VARCHAR(255) NOT NULL,
+    description TEXT,
+    personality_traits JSON,
+    current_age INT DEFAULT 25,
+    birth_year INT,
+    avatar_image TEXT,
+    is_public BOOLEAN DEFAULT FALSE,
+    price DECIMAL(10, 2),
+    creator_id VARCHAR(50),
+    created_at TIMESTAMP,
+    updated_at TIMESTAMP,
+    settings JSON
+);
+""")
+        
+        sql_content.append("-- Create memories table if not exists")
+        sql_content.append("""
+CREATE TABLE IF NOT EXISTS memories (
+    id VARCHAR(50) PRIMARY KEY,
+    avatar_id VARCHAR(50) NOT NULL,
+    content TEXT NOT NULL,
+    min_age INT DEFAULT 0,
+    max_age INT DEFAULT 150,
+    clarity INT DEFAULT 80,
+    emotional_tone VARCHAR(50) DEFAULT 'neutral',
+    topic VARCHAR(255),
+    parent_id VARCHAR(50),
+    created_at TIMESTAMP,
+    INDEX idx_avatar_id (avatar_id),
+    FOREIGN KEY (avatar_id) REFERENCES avatars(id)
+);
+""")
+        
+        sql_content.append("")
+        sql_content.append("-- Insert avatar data")
+        sql_content.append(f"""
+INSERT INTO avatars (id, name, description, personality_traits, current_age, 
+    birth_year, avatar_image, is_public, price, creator_id, created_at, updated_at, settings)
+VALUES (
+    '{avatar.avatar_id}',
+    '{avatar.name.replace("'", "''")}',
+    '{avatar.description.replace("'", "''")}',
+    '{json.dumps(avatar.personality_traits, ensure_ascii=False)}',
+    {avatar.current_age},
+    {avatar.birth_year},
+    '{avatar.avatar_image or ''}',
+    {1 if avatar.is_public else 0},
+    {avatar.price if avatar.price else 'NULL'},
+    '{avatar.creator_id or ''}',
+    '{avatar.created_at}',
+    '{avatar.updated_at}',
+    '{json.dumps(avatar.settings, ensure_ascii=False)}'
+);
+""")
+        
+        sql_content.append("")
+        sql_content.append("-- Insert memories")
+        for node in tree.nodes.values():
+            sql_content.append(f"""
+INSERT INTO memories (id, avatar_id, content, min_age, max_age, clarity, 
+    emotional_tone, topic, parent_id, created_at)
+VALUES (
+    '{node.memory_id}',
+    '{avatar.avatar_id}',
+    '{node.content.replace("'", "''")}',
+    {node.min_age},
+    {node.max_age},
+    {node.clarity},
+    '{node.emotional_tone}',
+    '{node.topic or ''}',
+    '{node.parent_id or ''}',
+    '{node.created_at}'
+);
+""")
+        
+        with open(filepath, "w", encoding="utf-8") as f:
+            f.write("\n".join(sql_content))
+        
+        return filepath
+    
+    def import_avatar(self, filepath: str, new_creator_id: Optional[str] = None) -> Optional[str]:
+        if not os.path.exists(filepath):
+            return None
+        
+        if filepath.endswith(".avatar") or filepath.endswith(".json"):
+            with open(filepath, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            
+            if "type" in data and data["type"] == "avatar_package":
+                avatar_data = data["avatar"]
+                tree_data = data["memory_tree"]
+            else:
+                avatar_data = data.get("avatar")
+                tree_data = None
+            
+            if avatar_data:
+                avatar = Avatar.from_dict(avatar_data)
+                avatar.avatar_id = None
+                avatar.created_at = datetime.now().isoformat()
+                avatar.updated_at = datetime.now().isoformat()
+                avatar.is_public = False
+                avatar.price = None
+                if new_creator_id:
+                    avatar.creator_id = new_creator_id
+                
+                avatar_manager.save_avatar(avatar)
+                
+                if tree_data:
+                    tree = InvertedTreeMemory.from_dict(tree_data)
+                    tree.tree_id = avatar.avatar_id
+                    for node in tree.nodes.values():
+                        node.memory_id = None
+                        node.parent_id = None
+                    tree_memory_system.save_tree(avatar.avatar_id, tree)
+                
+                return avatar.avatar_id
+        
+        return None
+    
+    def list_exports(self) -> list:
+        exports = []
+        for filename in os.listdir(self.export_dir):
+            filepath = os.path.join(self.export_dir, filename)
+            if os.path.isfile(filepath):
+                stat = os.stat(filepath)
+                exports.append({
+                    "filename": filename,
+                    "size": stat.st_size,
+                    "created_at": datetime.fromtimestamp(stat.st_ctime).isoformat(),
+                    "filepath": filepath
+                })
+        return sorted(exports, key=lambda x: x["created_at"], reverse=True)
+    
+    def delete_export(self, filename: str) -> bool:
+        filepath = os.path.join(self.export_dir, filename)
+        if os.path.exists(filepath):
+            os.remove(filepath)
+            return True
+        return False
+
+
+class MarketPlace:
+    def __init__(self, avatar_packer: AvatarPacker):
+        self.avatar_packer = avatar_packer
+    
+    def list_for_sale(
+        self,
+        avatar_id: str,
+        price: float,
+        description: Optional[str] = None
+    ) -> bool:
+        avatar = avatar_manager.load_avatar(avatar_id)
+        if avatar:
+            avatar.is_public = True
+            avatar.price = price
+            if description:
+                avatar.description = description
+            avatar_manager.save_avatar(avatar)
+            return True
+        return False
+    
+    def remove_from_sale(self, avatar_id: str) -> bool:
+        avatar = avatar_manager.load_avatar(avatar_id)
+        if avatar:
+            avatar.is_public = False
+            avatar.price = None
+            avatar_manager.save_avatar(avatar)
+            return True
+        return False
+    
+    def get_market_listings(self) -> list:
+        return avatar_manager.list_market_avatars()
+    
+    def purchase_avatar(self, avatar_id: str, buyer_id: str) -> Optional[str]:
+        new_avatar = avatar_manager.purchase_avatar(avatar_id, buyer_id)
+        if new_avatar:
+            return new_avatar.avatar_id
+        return None
+
+
+avatar_packer = AvatarPacker()
+marketplace = MarketPlace(avatar_packer)