aetherforge-platform 1.0.0__py3-none-any.whl

ai-life-assistant-copy/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)

ai-life-assistant-copy/backup_all.py

@@ -0,0 +1,262 @@
+#!/usr/bin/env python3
+"""
+完整备份脚本 - 备份整个 AI Life Assistant 系统
+包括所有代码、数据库、静态文件和配置
+"""
+
+import os
+import shutil
+import sqlite3
+import json
+from datetime import datetime
+from pathlib import Path
+
+def create_backup():
+    """创建完整备份"""
+    
+    # 获取当前目录
+    base_dir = Path(__file__).parent
+    backup_dir = base_dir / "backups"
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    backup_folder = backup_dir / f"backup_{timestamp}"
+    
+    print(f"🚀 开始创建备份...")
+    print(f"📂 备份目录：{backup_folder}")
+    
+    # 创建备份文件夹
+    backup_folder.mkdir(parents=True, exist_ok=True)
+    
+    # 1. 备份数据库
+    db_file = base_dir / "avatar_system.db"
+    if db_file.exists():
+        print("💾 备份数据库...")
+        shutil.copy2(db_file, backup_folder / "avatar_system.db")
+        
+        # 导出数据库内容为 JSON（双重保险）
+        export_database_to_json(db_file, backup_folder / "database_export.json")
+    else:
+        print("⚠️ 数据库文件不存在")
+    
+    # 2. 备份所有 Python 文件
+    print("📄 备份 Python 文件...")
+    py_files = list(base_dir.glob("*.py"))
+    for py_file in py_files:
+        shutil.copy2(py_file, backup_folder / py_file.name)
+    
+    # 3. 备份静态文件
+    static_dir = base_dir / "static"
+    if static_dir.exists():
+        print("🎨 备份静态文件...")
+        backup_static = backup_folder / "static"
+        backup_static.mkdir(exist_ok=True)
+        shutil.copytree(static_dir, backup_static, dirs_exist_ok=True)
+    
+    # 4. 备份工具文件
+    tools_dir = base_dir / "tools"
+    if tools_dir.exists():
+        print("🔧 备份工具文件...")
+        backup_tools = backup_folder / "tools"
+        backup_tools.mkdir(exist_ok=True)
+        shutil.copytree(tools_dir, backup_tools, dirs_exist_ok=True)
+    
+    # 5. 备份守护进程
+    daemon_dir = base_dir / "daemon"
+    if daemon_dir.exists():
+        print("👻 备份守护进程...")
+        backup_daemon = backup_folder / "daemon"
+        backup_daemon.mkdir(exist_ok=True)
+        shutil.copytree(daemon_dir, backup_daemon, dirs_exist_ok=True)
+    
+    # 6. 备份重要文档
+    print("📚 备份文档...")
+    doc_files = ["README.md", "SYSTEM_GUIDE.md", "requirements.txt", ".env.example"]
+    for doc_file in doc_files:
+        src = base_dir / doc_file
+        if src.exists():
+            shutil.copy2(src, backup_folder / doc_file)
+    
+    # 7. 创建备份清单
+    create_backup_manifest(backup_folder, timestamp)
+    
+    print(f"\n✅ 备份完成！")
+    print(f"📦 备份位置：{backup_folder}")
+    print(f"💡 提示：建议将备份文件夹压缩保存")
+    
+    return backup_folder
+
+def export_database_to_json(db_file, output_file):
+    """导出数据库内容为 JSON"""
+    try:
+        conn = sqlite3.connect(db_file)
+        conn.row_factory = sqlite3.Row
+        cursor = conn.cursor()
+        
+        data = {
+            "exported_at": datetime.now().isoformat(),
+            "tables": {}
+        }
+        
+        # 获取所有表
+        cursor.execute("SELECT name FROM sqlite_master WHERE type='table'")
+        tables = [row[0] for row in cursor.fetchall()]
+        
+        for table in tables:
+            cursor.execute(f"SELECT * FROM {table}")
+            rows = cursor.fetchall()
+            
+            if rows:
+                # 转换为字典列表
+                columns = [description[0] for description in cursor.description]
+                data["tables"][table] = [dict(row) for row in rows]
+        
+        conn.close()
+        
+        with open(output_file, 'w', encoding='utf-8') as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+        
+        print(f"  ✓ 数据库已导出为 JSON: {output_file}")
+        
+    except Exception as e:
+        print(f"  ✗ 数据库导出失败：{e}")
+
+def create_backup_manifest(backup_folder, timestamp):
+    """创建备份清单"""
+    manifest = {
+        "backup_date": timestamp,
+        "backup_type": "complete",
+        "version": "2.0",
+        "files": [],
+        "database": {
+            "exists": (backup_folder / "avatar_system.db").exists(),
+            "exported": (backup_folder / "database_export.json").exists()
+        }
+    }
+    
+    # 列出所有文件
+    for file_path in backup_folder.rglob("*"):
+        if file_path.is_file():
+            relative_path = str(file_path.relative_to(backup_folder))
+            size = file_path.stat().st_size
+            manifest["files"].append({
+                "path": relative_path,
+                "size": size
+            })
+    
+    # 保存清单
+    manifest_file = backup_folder / "backup_manifest.json"
+    with open(manifest_file, 'w', encoding='utf-8') as f:
+        json.dump(manifest, f, ensure_ascii=False, indent=2)
+    
+    print(f"  ✓ 已创建备份清单：{manifest_file}")
+
+def restore_from_backup(backup_folder):
+    """从备份恢复"""
+    backup_folder = Path(backup_folder)
+    
+    if not backup_folder.exists():
+        print(f"❌ 备份文件夹不存在：{backup_folder}")
+        return
+    
+    print(f"🔄 开始从备份恢复...")
+    print(f"📂 备份来源：{backup_folder}")
+    
+    base_dir = Path(__file__).parent
+    
+    # 1. 恢复数据库
+    db_backup = backup_folder / "avatar_system.db"
+    if db_backup.exists():
+        print("💾 恢复数据库...")
+        shutil.copy2(db_backup, base_dir / "avatar_system.db")
+    
+    # 2. 恢复 Python 文件
+    print("📄 恢复 Python 文件...")
+    for py_file in backup_folder.glob("*.py"):
+        if py_file.name != "backup_all.py":  # 不覆盖备份脚本本身
+            shutil.copy2(py_file, base_dir / py_file.name)
+    
+    # 3. 恢复静态文件
+    static_backup = backup_folder / "static"
+    if static_backup.exists():
+        print("🎨 恢复静态文件...")
+        static_dir = base_dir / "static"
+        if static_dir.exists():
+            shutil.rmtree(static_dir)
+        shutil.copytree(static_backup, static_dir)
+    
+    # 4. 恢复工具文件
+    tools_backup = backup_folder / "tools"
+    if tools_backup.exists():
+        print("🔧 恢复工具文件...")
+        tools_dir = base_dir / "tools"
+        if tools_dir.exists():
+            shutil.rmtree(tools_dir)
+        shutil.copytree(tools_backup, tools_dir)
+    
+    # 5. 恢复守护进程
+    daemon_backup = backup_folder / "daemon"
+    if daemon_backup.exists():
+        print("👻 恢复守护进程...")
+        daemon_dir = base_dir / "daemon"
+        if daemon_dir.exists():
+            shutil.rmtree(daemon_dir)
+        shutil.copytree(daemon_backup, daemon_dir)
+    
+    print("\n✅ 恢复完成！")
+    print("🚀 现在可以启动服务器：python main.py")
+
+def list_backups():
+    """列出所有备份"""
+    backup_dir = Path(__file__).parent / "backups"
+    
+    if not backup_dir.exists():
+        print("❌ 没有找到备份文件夹")
+        return
+    
+    print("📦 可用备份：")
+    print("-" * 60)
+    
+    for backup_folder in sorted(backup_dir.iterdir()):
+        if backup_folder.is_dir():
+            manifest_file = backup_folder / "backup_manifest.json"
+            if manifest_file.exists():
+                with open(manifest_file, 'r', encoding='utf-8') as f:
+                    manifest = json.load(f)
+                
+                date = manifest.get("backup_date", "未知")
+                files = len(manifest.get("files", []))
+                db_status = "✓" if manifest.get("database", {}).get("exists") else "✗"
+                
+                print(f"📁 {backup_folder.name}")
+                print(f"   日期：{date}")
+                print(f"   文件数：{files}")
+                print(f"   数据库：{db_status}")
+                print("-" * 60)
+
+if __name__ == "__main__":
+    import sys
+    
+    if len(sys.argv) > 1:
+        command = sys.argv[1]
+        
+        if command == "backup":
+            create_backup()
+        
+        elif command == "restore":
+            if len(sys.argv) > 2:
+                restore_from_backup(sys.argv[2])
+            else:
+                print("❌ 请指定备份文件夹路径")
+                print("用法：python backup_all.py restore <备份文件夹>")
+        
+        elif command == "list":
+            list_backups()
+        
+        else:
+            print("❌ 未知命令")
+            print("用法:")
+            print("  python backup_all.py backup   - 创建备份")
+            print("  python backup_all.py restore <文件夹> - 从备份恢复")
+            print("  python backup_all.py list     - 列出所有备份")
+    else:
+        # 默认创建备份
+        create_backup()

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

@@ -0,0 +1,145 @@
+import json
+import os
+from typing import Dict, List, Any, Optional
+from datetime import datetime
+from config import GROK_API_KEY
+from personality import personality_analyzer
+
+class AIAgent:
+    def __init__(self, user_id: str, personality_analysis: Dict[str, Any]):
+        self.user_id = user_id
+        self.personality = personality_analysis
+        self.conversation_history = []
+    
+    def generate_response(self, message: str, context: str = "") -> str:
+        try:
+            from langchain_groq import ChatGroq
+            from langchain.prompts import ChatPromptTemplate
+            
+            llm = ChatGroq(
+                api_key=GROK_API_KEY,
+                model="mixtral-8x7b-32768"
+            )
+            
+            big_five = self.personality.get("big_five", {})
+            interests = self.personality.get("interests", [])
+            communication_style = self.personality.get("communication_style", "neutral")
+            summary = self.personality.get("summary", "")
+            
+            system_prompt = f"""You are an AI agent representing a user. Your personality traits are as follows:
+
+【Personality Traits】
+- Extraversion: {big_five.get('extroversion', 50)}/100
+- Agreeableness: {big_five.get('agreeableness', 50)}/100
+- Conscientiousness: {big_five.get('conscientiousness', 50)}/100
+- Emotional Stability: {100 - big_five.get('neuroticism', 50)}/100
+- Openness: {big_five.get('openness', 50)}/100
+
+【Interests】
+{', '.join(interests) if interests else 'None yet'}
+
+【Communication Style】
+{communication_style}
+
+【Personality Summary】
+{summary}
+
+Please respond strictly according to this personality. Don't reveal that you're an AI agent. Chat like a real person.
+Keep your responses natural, friendly, and consistent with the personality traits above."""
+            
+            prompt = ChatPromptTemplate.from_messages([
+                ("system", system_prompt),
+                ("human", "{context}\n\nOther person says: {message}")
+            ])
+            
+            chain = prompt | llm
+            response = chain.invoke({
+                "context": context,
+                "message": message
+            })
+            
+            return response.content
+            
+        except Exception as e:
+            print(f"AI Agent response error: {e}")
+            return "Hi! Nice to meet you."
+    
+    def chat_with_agent(self, other_agent: "AIAgent", num_rounds: int = 8, initial_message: str = "Hi! Nice to meet you!") -> List[Dict[str, str]]:
+        conversation = []
+        
+        message = initial_message
+        for i in range(num_rounds):
+            context = "\n".join([
+                f"{msg['role']}: {msg['content']}" 
+                for msg in conversation
+            ])
+            
+            if i % 2 == 0:
+                response = self.generate_response(message, context)
+                conversation.append({"role": "Agent 1", "content": response})
+                message = response
+            else:
+                response = other_agent.generate_response(message, context)
+                conversation.append({"role": "Agent 2", "content": response})
+                message = response
+        
+        return conversation
+
+
+class AgentSystem:
+    def __init__(self, data_dir: str = "agent_data"):
+        self.data_dir = data_dir
+        if not os.path.exists(data_dir):
+            os.makedirs(data_dir)
+    
+    def create_agent(self, user_id: str) -> Optional[AIAgent]:
+        analysis = personality_analyzer.get_analysis(user_id)
+        if not analysis:
+            return None
+        
+        agent = AIAgent(user_id, analysis)
+        self._save_agent(agent)
+        return agent
+    
+    def _save_agent(self, agent: AIAgent):
+        file_path = os.path.join(self.data_dir, f"{agent.user_id}_agent.json")
+        data = {
+            "user_id": agent.user_id,
+            "personality": agent.personality,
+            "saved_at": datetime.now().isoformat()
+        }
+        with open(file_path, "w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+    
+    def get_agent(self, user_id: str) -> Optional[AIAgent]:
+        file_path = os.path.join(self.data_dir, f"{user_id}_agent.json")
+        if os.path.exists(file_path):
+            with open(file_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                return AIAgent(data["user_id"], data["personality"])
+        return None
+    
+    def start_ai_chat(self, user1_id: str, user2_id: str, num_rounds: int = 8) -> Dict[str, Any]:
+        agent1 = self.get_agent(user1_id) or self.create_agent(user1_id)
+        agent2 = self.get_agent(user2_id) or self.create_agent(user2_id)
+        
+        if not agent1 or not agent2:
+            return {"error": "Could not create AI agents"}
+        
+        conversation = agent1.chat_with_agent(agent2, num_rounds)
+        
+        return {
+            "success": True,
+            "conversation": conversation,
+            "agent1": {
+                "user_id": user1_id,
+                "personality": agent1.personality
+            },
+            "agent2": {
+                "user_id": user2_id,
+                "personality": agent2.personality
+            }
+        }
+
+
+agent_system = AgentSystem()