aetherforge-platform 1.0.0__py3-none-any.whl

ai-life-assistant-copy/daemon/daemon.py

@@ -0,0 +1,174 @@
+"""生活助手守护进程"""
+
+import threading
+import time
+import schedule
+from typing import Dict, Any, List
+import json
+import os
+from datetime import datetime
+
+class LifeAssistantDaemon:
+    """生活助手守护进程"""
+    
+    def __init__(self, user_id: str = "default"):
+        self.user_id = user_id
+        self.running = False
+        self.thread = None
+        self.memory = self._load_memory()
+        self.triggers = {
+            "stock_check": self._check_stock,
+            "weather_alert": self._check_weather,
+            "reminder_check": self._check_reminders,
+            "habit_analysis": self._analyze_habits
+        }
+        
+    def start(self):
+        """启动守护进程"""
+        if self.running:
+            return
+        
+        self.running = True
+        self.thread = threading.Thread(target=self._run, daemon=True)
+        self.thread.start()
+        print(f"[Daemon] 生活助手守护进程已启动")
+    
+    def stop(self):
+        """停止守护进程"""
+        self.running = False
+        if self.thread:
+            self.thread.join()
+        print(f"[Daemon] 生活助手守护进程已停止")
+    
+    def _run(self):
+        """运行守护进程"""
+        # 初始化定时任务
+        self._schedule_tasks()
+        
+        while self.running:
+            schedule.run_pending()
+            time.sleep(1)
+    
+    def _schedule_tasks(self):
+        """调度任务"""
+        # 每天检查库存
+        schedule.every().day.at("08:00").do(self._check_stock)
+        # 每天检查天气
+        schedule.every().day.at("07:00").do(self._check_weather)
+        # 每分钟检查提醒
+        schedule.every().minute.do(self._check_reminders)
+        # 每周分析习惯
+        schedule.every().sunday.at("22:00").do(self._analyze_habits)
+    
+    def _check_stock(self):
+        """检查库存"""
+        print(f"[Daemon] 检查库存 - {datetime.now()}")
+        # 示例：检查常用商品库存
+        stocks = self.memory.get("stocks", {})
+        low_stock_items = []
+        
+        for item, info in stocks.items():
+            if info.get("stock", 0) < info.get("threshold", 5):
+                low_stock_items.append(item)
+        
+        if low_stock_items:
+            alert = f"您的以下商品库存不足：{', '.join(low_stock_items)}"
+            self._send_alert("stock", alert)
+    
+    def _check_weather(self):
+        """检查天气"""
+        print(f"[Daemon] 检查天气 - {datetime.now()}")
+        # 示例：检查天气并发送提醒
+        from tools.weather_tool import get_weather
+        weather = get_weather()
+        
+        if weather.get("success"):
+            data = weather.get("data", {})
+            temp = data.get("temperature", "")
+            desc = data.get("description", "")
+            
+            alert = f"今日天气：{temp}，{desc}"
+            self._send_alert("weather", alert)
+    
+    def _check_reminders(self):
+        """检查提醒"""
+        now = datetime.now()
+        current_time = now.strftime("%H:%M")
+        current_date = now.strftime("%Y-%m-%d")
+        
+        # 示例：检查提醒
+        from tools.reminder_tool import get_reminders
+        reminders = get_reminders(current_date)
+        
+        if reminders.get("success"):
+            for reminder in reminders.get("reminders", []):
+                if reminder.get("time") == current_time:
+                    alert = f"提醒：{reminder.get('title')}"
+                    self._send_alert("reminder", alert)
+    
+    def _analyze_habits(self):
+        """分析习惯"""
+        print(f"[Daemon] 分析习惯 - {datetime.now()}")
+        # 示例：分析用户习惯
+        habits = self.memory.get("habits", {})
+        
+        # 简单的习惯分析
+        if habits:
+            analysis = "习惯分析：\n"
+            for habit, data in habits.items():
+                frequency = data.get("frequency", 0)
+                analysis += f"- {habit}: 频率 {frequency}次/周\n"
+            
+            self._send_alert("habit", analysis)
+    
+    def _send_alert(self, type: str, message: str):
+        """发送提醒"""
+        print(f"[Alert] {type}: {message}")
+        # 这里可以集成到前端通知系统
+    
+    def _load_memory(self) -> Dict[str, Any]:
+        """加载记忆"""
+        memory_file = f"memory_{self.user_id}.json"
+        if os.path.exists(memory_file):
+            try:
+                with open(memory_file, "r", encoding="utf-8") as f:
+                    return json.load(f)
+            except:
+                pass
+        return {
+            "stocks": {
+                "纸巾": {"stock": 3, "threshold": 5},
+                "牙膏": {"stock": 2, "threshold": 3},
+                "洗发水": {"stock": 1, "threshold": 2}
+            },
+            "habits": {
+                "购物": {"frequency": 3},
+                "外卖": {"frequency": 2},
+                "打车": {"frequency": 1}
+            }
+        }
+    
+    def save_memory(self):
+        """保存记忆"""
+        memory_file = f"memory_{self.user_id}.json"
+        with open(memory_file, "w", encoding="utf-8") as f:
+            json.dump(self.memory, f, ensure_ascii=False, indent=2)
+    
+    def add_habit(self, habit: str):
+        """添加习惯"""
+        if "habits" not in self.memory:
+            self.memory["habits"] = {}
+        
+        if habit not in self.memory["habits"]:
+            self.memory["habits"][habit] = {"frequency": 0}
+        
+        self.memory["habits"][habit]["frequency"] += 1
+        self.save_memory()
+    
+    def update_stock(self, item: str, stock: int):
+        """更新库存"""
+        if "stocks" not in self.memory:
+            self.memory["stocks"] = {}
+        
+        self.memory["stocks"][item] = {"stock": stock, "threshold": 5}
+        self.save_memory()

ai-life-assistant-copy/database.py

@@ -0,0 +1,292 @@
+import sqlite3
+import json
+import os
+from typing import Dict, Any, List, Optional
+from datetime import datetime
+
+
+class AvatarDatabase:
+    def __init__(self, db_path: str = "avatar_system.db"):
+        self.db_path = db_path
+        self._init_database()
+    
+    def _get_connection(self):
+        conn = sqlite3.connect(self.db_path)
+        conn.row_factory = sqlite3.Row
+        return conn
+    
+    def _init_database(self):
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS avatars (
+                avatar_id TEXT PRIMARY KEY,
+                name TEXT NOT NULL,
+                description TEXT,
+                personality_traits TEXT,
+                current_age INTEGER DEFAULT 25,
+                birth_year INTEGER,
+                avatar_image TEXT,
+                is_public INTEGER DEFAULT 0,
+                price REAL,
+                creator_id TEXT,
+                created_at TEXT,
+                updated_at TEXT,
+                settings TEXT
+            )
+        """)
+        
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS memories (
+                memory_id TEXT PRIMARY KEY,
+                avatar_id TEXT NOT NULL,
+                content TEXT NOT NULL,
+                min_age INTEGER DEFAULT 0,
+                max_age INTEGER DEFAULT 150,
+                clarity INTEGER DEFAULT 80,
+                emotional_tone TEXT DEFAULT 'neutral',
+                topic TEXT,
+                parent_id TEXT,
+                created_at TEXT,
+                FOREIGN KEY (avatar_id) REFERENCES avatars(avatar_id)
+            )
+        """)
+        
+        cursor.execute("""
+            CREATE INDEX IF NOT EXISTS idx_memories_avatar ON memories(avatar_id)
+        """)
+        
+        cursor.execute("""
+            CREATE INDEX IF NOT EXISTS idx_memories_age ON memories(avatar_id, min_age, max_age)
+        """)
+        
+        conn.commit()
+        conn.close()
+    
+    def save_avatar(self, avatar_data: Dict[str, Any]):
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        
+        cursor.execute("""
+            INSERT OR REPLACE INTO avatars 
+            (avatar_id, name, description, personality_traits, current_age, birth_year,
+             avatar_image, is_public, price, creator_id, created_at, updated_at, settings)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """, (
+            avatar_data["avatar_id"],
+            avatar_data["name"],
+            avatar_data.get("description", ""),
+            json.dumps(avatar_data.get("personality_traits", []), ensure_ascii=False),
+            avatar_data.get("current_age", 25),
+            avatar_data.get("birth_year"),
+            avatar_data.get("avatar_image"),
+            1 if avatar_data.get("is_public") else 0,
+            avatar_data.get("price"),
+            avatar_data.get("creator_id"),
+            avatar_data.get("created_at"),
+            avatar_data.get("updated_at"),
+            json.dumps(avatar_data.get("settings", {}), ensure_ascii=False)
+        ))
+        
+        conn.commit()
+        conn.close()
+    
+    def get_avatar(self, avatar_id: str) -> Optional[Dict[str, Any]]:
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        
+        cursor.execute("SELECT * FROM avatars WHERE avatar_id = ?", (avatar_id,))
+        row = cursor.fetchone()
+        
+        if row:
+            data = dict(row)
+            data["personality_traits"] = json.loads(data["personality_traits"])
+            data["settings"] = json.loads(data["settings"])
+            data["is_public"] = bool(data["is_public"])
+            conn.close()
+            return data
+        
+        conn.close()
+        return None
+    
+    def list_avatars(self, creator_id: Optional[str] = None) -> List[Dict[str, Any]]:
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        
+        if creator_id:
+            cursor.execute("SELECT * FROM avatars WHERE creator_id = ?", (creator_id,))
+        else:
+            cursor.execute("SELECT * FROM avatars")
+        
+        avatars = []
+        for row in cursor.fetchall():
+            data = dict(row)
+            data["personality_traits"] = json.loads(data["personality_traits"])
+            data["settings"] = json.loads(data["settings"])
+            data["is_public"] = bool(data["is_public"])
+            avatars.append(data)
+        
+        conn.close()
+        return avatars
+    
+    def delete_avatar(self, avatar_id: str) -> bool:
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        
+        cursor.execute("DELETE FROM memories WHERE avatar_id = ?", (avatar_id,))
+        cursor.execute("DELETE FROM avatars WHERE avatar_id = ?", (avatar_id,))
+        
+        deleted = cursor.rowcount > 0
+        conn.commit()
+        conn.close()
+        return deleted
+    
+    def save_memory(self, memory_data: Dict[str, Any]):
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        
+        cursor.execute("""
+            INSERT OR REPLACE INTO memories 
+            (memory_id, avatar_id, content, min_age, max_age, clarity,
+             emotional_tone, topic, parent_id, created_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """, (
+            memory_data["memory_id"],
+            memory_data["avatar_id"],
+            memory_data["content"],
+            memory_data.get("min_age", 0),
+            memory_data.get("max_age", 150),
+            memory_data.get("clarity", 80),
+            memory_data.get("emotional_tone", "neutral"),
+            memory_data.get("topic"),
+            memory_data.get("parent_id"),
+            memory_data.get("created_at")
+        ))
+        
+        conn.commit()
+        conn.close()
+    
+    def get_memories_by_age(self, avatar_id: str, target_age: int) -> List[Dict[str, Any]]:
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        
+        cursor.execute("""
+            SELECT * FROM memories 
+            WHERE avatar_id = ? AND min_age <= ? AND max_age >= ?
+            ORDER BY created_at DESC
+        """, (avatar_id, target_age, target_age))
+        
+        memories = [dict(row) for row in cursor.fetchall()]
+        conn.close()
+        return memories
+    
+    def get_all_memories(self, avatar_id: str) -> List[Dict[str, Any]]:
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        
+        cursor.execute("""
+            SELECT * FROM memories WHERE avatar_id = ?
+            ORDER BY created_at DESC
+        """, (avatar_id,))
+        
+        memories = [dict(row) for row in cursor.fetchall()]
+        conn.close()
+        return memories
+    
+    def delete_memory(self, memory_id: str) -> bool:
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        
+        cursor.execute("DELETE FROM memories WHERE memory_id = ?", (memory_id,))
+        
+        deleted = cursor.rowcount > 0
+        conn.commit()
+        conn.close()
+        return deleted
+    
+    def list_market_avatars(self) -> List[Dict[str, Any]]:
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        
+        cursor.execute("""
+            SELECT * FROM avatars 
+            WHERE is_public = 1 AND price IS NOT NULL
+        """)
+        
+        avatars = []
+        for row in cursor.fetchall():
+            data = dict(row)
+            data["personality_traits"] = json.loads(data["personality_traits"])
+            data["settings"] = json.loads(data["settings"])
+            data["is_public"] = bool(data["is_public"])
+            avatars.append(data)
+        
+        conn.close()
+        return avatars
+
+
+avatar_database = AvatarDatabase()
+
+
+def init_sample_data():
+    sample_avatar = {
+        "avatar_id": "sample_001",
+        "name": "Alex",
+        "description": "一个友好、好奇的虚拟形象",
+        "personality_traits": ["友好", "好奇", "创造力"],
+        "current_age": 25,
+        "birth_year": 2000,
+        "is_public": False,
+        "creator_id": "demo_user",
+        "created_at": datetime.now().isoformat(),
+        "updated_at": datetime.now().isoformat(),
+        "settings": {"developer_mode": False, "auto_organize": True}
+    }
+    
+    avatar_database.save_avatar(sample_avatar)
+    
+    sample_memories = [
+        {
+            "memory_id": "mem_001",
+            "avatar_id": "sample_001",
+            "content": "我第一次学会骑自行车，那天很开心",
+            "min_age": 5,
+            "max_age": 10,
+            "clarity": 90,
+            "emotional_tone": "happy",
+            "topic": "童年",
+            "created_at": datetime.now().isoformat()
+        },
+        {
+            "memory_id": "mem_002",
+            "avatar_id": "sample_001",
+            "content": "高中时参加了数学竞赛，获得了二等奖",
+            "min_age": 15,
+            "max_age": 18,
+            "clarity": 85,
+            "emotional_tone": "proud",
+            "topic": "学业",
+            "created_at": datetime.now().isoformat()
+        },
+        {
+            "memory_id": "mem_003",
+            "avatar_id": "sample_001",
+            "content": "大学毕业后的第一份工作是软件开发工程师",
+            "min_age": 22,
+            "max_age": 30,
+            "clarity": 95,
+            "emotional_tone": "excited",
+            "topic": "职业",
+            "created_at": datetime.now().isoformat()
+        }
+    ]
+    
+    for memory in sample_memories:
+        avatar_database.save_memory(memory)
+    
+    print("Sample data initialized!")
+
+
+if __name__ == "__main__":
+    init_sample_data()