.comet/config.yaml

@@ -1,6 +0,0 @@
-# context_compression: off | beta
-context_compression: off
-# review_mode: off | standard | thorough
-review_mode: off
-# auto_transition: true | false
-auto_transition: true

.env

@@ -22,17 +22,3 @@ CONTAINER_PORT=8600
 
 # 数据目录
 DATA_DIR=E:\docker_workspace\futures_datas
-
-# MySQL 配置
-MYSQL_HOST=192.168.0.222
-MYSQL_PORT=3306
-MYSQL_USER=root
-MYSQL_PASSWORD=1qazse42W3
-MYSQL_DATABASE=buffer_platform
-
-# Redis 配置
-REDIS_HOST=192.168.0.222
-REDIS_PORT=6380
-REDIS_DB=1
-REDIS_PASSWORD=
-REDIS_TTL_SECONDS=2592000

.gitignore

@@ -27,6 +27,3 @@ Thumbs.db
 
 # Cache
 cache/*.pkl
-
-# Worktrees
-.worktrees/

app/analysis_db.py

@@ -1,14 +1,11 @@
 """
 期货智析数据库 - 独立存储
 """
-import logging
 from pathlib import Path
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker, declarative_base
 from datetime import datetime
 
-logger = logging.getLogger(__name__)
-
 # 数据目录
 DATA_DIR = Path(__file__).resolve().parent.parent / "data"
 DATA_DIR.mkdir(parents=True, exist_ok=True)
@@ -26,11 +23,7 @@ AnalysisBase = declarative_base()
 
 
 def get_analysis_db():
-    """获取期货智析数据库会话。
-
-    分析数据量较小（复盘计划、评分等），始终使用 SQLite 以保证稳定性。
-    AnalysisBase 绑定的是 analysis_engine (SQLite)，ORM 模型均基于此定义。
-    """
+    """获取期货智析数据库会话"""
     db = AnalysisSessionLocal()
     try:
         yield db
@@ -39,7 +32,7 @@ def get_analysis_db():
 
 
 def init_analysis_db():
-    """初始化期货智析数据库表（SQLite 兜底）。"""
+    """初始化期货智析数据库表"""
     # 确保导入所有模型类，使其注册到 AnalysisBase
     from app import analysis_models
     # 直接导入 analysis_models 模块中的所有类
@@ -55,19 +48,6 @@ def init_analysis_db():
     _migrate_add_columns()
 
 
-def init_analysis_mysql(mysql_engine):
-    """初始化期货智析数据库表（MySQL）。"""
-    from app import analysis_models
-    from app.analysis_models import (
-        FuturesAnalysis, WatchedSymbol, AIModelConfig, AnalysisSettings,
-        AIAnalysisCache, ReviewDate, SymbolRanking, TradingPlan,
-        SymbolScoreV2, TradingPlanV2, SectorHeat, ReviewPlanV2,
-        TradeRecord, TradeImportBatch,
-    )
-    AnalysisBase.metadata.create_all(bind=mysql_engine)
-    logger.info("MySQL analysis 表结构初始化完成")
-
-
 def _migrate_add_columns():
     """为已有表添加新增列（兼容旧数据库）"""
     import sqlite3

app/analysis_migration.py

@@ -1,116 +0,0 @@
-"""
-期货智析数据库迁移 - SQLite → MySQL
-"""
-import logging
-
-from sqlalchemy.orm import sessionmaker, make_transient
-
-from app.analysis_db import analysis_engine, AnalysisBase
-from app.analysis_models import (
-    FuturesAnalysis, WatchedSymbol, AIModelConfig, AnalysisSettings,
-    AIAnalysisCache, ReviewDate, SymbolRanking, TradingPlan,
-    SymbolScoreV2, TradingPlanV2, SectorHeat, ReviewPlanV2,
-    TradeRecord, TradeImportBatch,
-)
-from app.mysql_database import mysql_engine
-
-logger = logging.getLogger(__name__)
-
-# 所有 analysis 模型类，按依赖顺序排列
-ANALYSIS_MODELS = [
-    FuturesAnalysis, WatchedSymbol, AIModelConfig, AnalysisSettings,
-    AIAnalysisCache, ReviewDate, SymbolRanking, TradingPlan,
-    SymbolScoreV2, TradingPlanV2, SectorHeat, ReviewPlanV2,
-    TradeRecord, TradeImportBatch,
-]
-
-
-def migrate_analysis_sqlite_to_mysql():
-    """
-    将 SQLite futures_analysis.db 中的数据迁移到 MySQL。
-
-    Returns:
-        bool: 迁移是否成功（跳过也视为成功）
-    """
-    if mysql_engine is None:
-        logger.warning("MySQL 未初始化，跳过 analysis 数据迁移")
-        return True
-
-    try:
-        mysql_count = _count_mysql_analysis_records()
-        if mysql_count > 0:
-            logger.info(f"MySQL analysis 表已有数据 ({mysql_count} 条)，跳过迁移")
-            return True
-
-        logger.info("开始将 SQLite analysis 数据迁移到 MySQL...")
-        data = _read_sqlite_analysis_data()
-        if not data:
-            logger.info("SQLite analysis 数据库为空，无需迁移")
-            return True
-
-        if _write_mysql_analysis_data(data):
-            total = sum(len(records) for records in data.values())
-            logger.info(f"Analysis 数据迁移完成，共迁移 {total} 条记录")
-            return True
-        else:
-            logger.error("Analysis 数据迁移失败")
-            return False
-
-    except Exception as e:
-        logger.error(f"Analysis 数据迁移异常: {e}")
-        return False
-
-
-def _count_mysql_analysis_records():
-    """统计 MySQL 中 analysis 表的总记录数。"""
-    SessionLocal = sessionmaker(bind=mysql_engine)
-    total = 0
-    with SessionLocal() as db:
-        for model in ANALYSIS_MODELS:
-            try:
-                total += db.query(model).count()
-            except Exception as e:
-                logger.warning(f"统计 MySQL {model.__tablename__} 记录数失败: {e}")
-    return total
-
-
-def _read_sqlite_analysis_data():
-    """从 SQLite 读取所有 analysis 数据。"""
-    SessionLocal = sessionmaker(bind=analysis_engine)
-    data = {}
-
-    with SessionLocal() as db:
-        for model in ANALYSIS_MODELS:
-            try:
-                records = db.query(model).all()
-                if records:
-                    data[model.__tablename__] = records
-                    logger.info(f"从 SQLite 读取 {model.__tablename__}: {len(records)} 条")
-            except Exception as e:
-                logger.warning(f"读取 SQLite {model.__tablename__} 失败: {e}")
-
-    return data
-
-
-def _write_mysql_analysis_data(data):
-    """将 analysis 数据写入 MySQL。"""
-    SessionLocal = sessionmaker(bind=mysql_engine)
-
-    with SessionLocal() as db:
-        try:
-            for model in ANALYSIS_MODELS:
-                records = data.get(model.__tablename__, [])
-                if not records:
-                    continue
-
-                for record in records:
-                    # 将对象从原 session 中脱离，使其可加入新 session
-                    make_transient(record)
-                    db.add(record)
-
-            db.commit()
-            return True
-        except Exception as e:
-            db.rollback()
-            logger.error(f"写入 MySQL analysis 数据失败: {e}")
-            return False

app/api/ai_config.py

@@ -1,14 +1,14 @@
 """
 AI模型配置接口 - 管理AI分析模型的配置
 """
+import json
 import logging
+from pathlib import Path
 from typing import Optional
 
 from fastapi import APIRouter, Depends, HTTPException
 from pydantic import BaseModel
 
-from app.config_store import get_config_store
-
 logger = logging.getLogger(__name__)
 router = APIRouter(prefix="/ai-config", tags=["AI模型配置"])
 
@@ -38,26 +38,45 @@ class SaveAIConfigRequest(BaseModel):
     analysis_settings: Optional[dict] = None
 
 
-def _default_ai_config() -> dict:
-    """AI 配置默认值"""
-    return {
-        "models": [],
-        "active_model": None,
-        "analysis_settings": {
-            "enable_technical_analysis": True,
-            "enable_fundamental_analysis": False,
-            "enable_sentiment_analysis": False,
-            "risk_tolerance": "medium",
-            "max_position_pct": 10
+CONFIG_DIR = Path(__file__).resolve().parent.parent.parent / "config"
+AI_CONFIG_FILE = CONFIG_DIR / "ai_config.json"
+
+
+def _ensure_config_dir():
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def _load_ai_config() -> dict:
+    """加载AI配置"""
+    _ensure_config_dir()
+    if not AI_CONFIG_FILE.exists():
+        return {
+            "models": [],
+            "active_model": None,
+            "analysis_settings": {
+                "enable_technical_analysis": True,
+                "enable_fundamental_analysis": False,
+                "enable_sentiment_analysis": False,
+                "risk_tolerance": "medium",
+                "max_position_pct": 10
+            }
         }
-    }
+    with open(AI_CONFIG_FILE, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def _save_ai_config(config: dict):
+    """保存AI配置"""
+    _ensure_config_dir()
+    with open(AI_CONFIG_FILE, "w", encoding="utf-8") as f:
+        json.dump(config, f, ensure_ascii=False, indent=4)
 
 
 @router.get("", response_model=AIConfigResponse)
 def get_ai_config():
     """获取当前AI模型配置"""
     try:
-        config = get_config_store().get_config("ai", _default_ai_config())
+        config = _load_ai_config()
         return {"success": True, "data": config}
     except Exception as e:
         logger.error(f"加载AI配置失败: {e}")
@@ -73,7 +92,7 @@ def save_ai_config(config: SaveAIConfigRequest):
             "active_model": config.active_model,
             "analysis_settings": config.analysis_settings or {}
         }
-        get_config_store().set_config("ai", config_dict)
+        _save_ai_config(config_dict)
         return {"success": True, "message": "AI配置保存成功"}
     except Exception as e:
         logger.error(f"保存AI配置失败: {e}")

app/api/config.py

@@ -3,9 +3,12 @@
 """
 import json
 import logging
+import shutil
+from pathlib import Path
 from typing import Optional
 
 from fastapi import APIRouter, Depends, HTTPException, UploadFile, File, Body, Request
+from fastapi.responses import JSONResponse
 from sqlalchemy.orm import Session
 from pydantic import BaseModel
 
@@ -14,7 +17,6 @@ from app.services.collector import fetch_symbol_data
 from app.services.cache import save_market_data, check_cache_status, get_cached_data, create_task
 from app.services.scheduler import add_job
 from app.schemas import CandleItem, TimeframeData, SymbolDataResponse
-from app.config_store import get_config_store
 
 logger = logging.getLogger(__name__)
 router = APIRouter(prefix="/config", tags=["品种配置"])
@@ -26,11 +28,23 @@ class BatchFetchRequest(BaseModel):
     data_type: str = "futures"
     selected_symbols: Optional[str] = None  # 逗号分隔的合约代码
 
+# 配置文件存储路径
+CONFIG_DIR = Path(__file__).resolve().parent.parent.parent / "config"
+CONFIG_FILE = CONFIG_DIR / "symbols_config.json"
+
+
+def _ensure_config_dir():
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
 
 @router.get("")
 def get_config():
     """获取当前品种配置"""
-    return get_config_store().get_config("symbols", {"futures": {}, "stock": {}})
+    _ensure_config_dir()
+    if not CONFIG_FILE.exists():
+        return {"futures": {}, "stock": {}}
+    with open(CONFIG_FILE, "r", encoding="utf-8") as f:
+        return json.load(f)
 
 
 @router.post("/upload")
@@ -46,6 +60,8 @@ async def upload_config(
         "stock": {"平安银行": "000001"}
     }
     """
+    _ensure_config_dir()
+    
     try:
         if file:
             content = await file.read()
@@ -60,7 +76,8 @@ async def upload_config(
         if not isinstance(data, dict):
             raise HTTPException(status_code=400, detail="配置文件必须是 JSON 对象")
 
-        get_config_store().set_config("symbols", data)
+        with open(CONFIG_FILE, "w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False, indent=4)
 
         futures_count = len(data.get("futures", {}))
         stock_count = len(data.get("stock", {}))
@@ -87,7 +104,13 @@ def batch_fetch_all(
     periods = request.periods
     data_type = request.data_type
     selected_symbols = request.selected_symbols
-    config = get_config_store().get_config("symbols", {"futures": {}, "stock": {}})
+    _ensure_config_dir()
+    if not CONFIG_FILE.exists():
+        raise HTTPException(status_code=400, detail="请先上传品种配置文件")
+
+    with open(CONFIG_FILE, "r", encoding="utf-8") as f:
+        config = json.load(f)
+
     symbols_dict = config.get(data_type, {})
     if not symbols_dict:
         raise HTTPException(status_code=400, detail=f"配置中没有 {data_type} 类型的品种")
@@ -213,7 +236,13 @@ def batch_create_tasks(
     """
     根据配置文件为所有品种批量创建定时任务。
     """
-    config = get_config_store().get_config("symbols", {"futures": {}, "stock": {}})
+    _ensure_config_dir()
+    if not CONFIG_FILE.exists():
+        raise HTTPException(status_code=400, detail="请先上传品种配置文件")
+
+    with open(CONFIG_FILE, "r", encoding="utf-8") as f:
+        config = json.load(f)
+
     symbols_dict = config.get(data_type, {})
     if not symbols_dict:
         raise HTTPException(status_code=400, detail=f"配置中没有 {data_type} 类型的品种")

app/api/futures_analysis.py

@@ -3,6 +3,7 @@
 """
 import json
 import logging
+from pathlib import Path
 from typing import Optional
 import threading
 
@@ -14,20 +15,25 @@ from app.analysis_db import get_analysis_db
 from app.analysis_models import FuturesAnalysis, WatchedSymbol, AIModelConfig, AnalysisSettings, AIAnalysisCache
 from app.services.cache import get_cached_data, get_latest_cached, save_market_data
 from app.services.collector import fetch_symbol_data
-from app.config_store import get_config_store
 
 logger = logging.getLogger(__name__)
 router = APIRouter(prefix="/futures", tags=["期货智析"])
 
+CONFIG_DIR = Path(__file__).resolve().parent.parent.parent / "config"
+SYMBOLS_CONFIG_FILE = CONFIG_DIR / "symbols_config.json"
+
 
 def _load_symbols_config() -> dict:
     """加载品种配置文件"""
-    return get_config_store().get_config("symbols", {"futures": {}, "stock": {}})
+    if not SYMBOLS_CONFIG_FILE.exists():
+        return {"futures": {}, "stock": {}}
+    with open(SYMBOLS_CONFIG_FILE, "r", encoding="utf-8") as f:
+        return json.load(f)
 
 
 @router.get("/list")
 def get_futures_list(db: Session = Depends(get_db)):
-    """获取所有期货品种列表及摘要信息"""
+    """获取所有期货品种列表及摘要信息（从symbols_config.json读取）"""
     config = _load_symbols_config()
     futures_config = config.get("futures", {})
     

app/api/trade_review.py

@@ -487,8 +487,13 @@ def get_kline_with_trades(
 
 def _resolve_symbol_from_config(variety_code: str) -> str:
     """从品种配置中查找品种代码对应的当前合约"""
-    from app.config_store import get_config_store
-    config = get_config_store().get_config("symbols", {"futures": {}, "stock": {}})
+    import json as _json
+    from pathlib import Path
+    config_path = Path(__file__).resolve().parent.parent.parent / "config" / "symbols_config.json"
+    if not config_path.exists():
+        return variety_code
+    with open(config_path, "r", encoding="utf-8") as f:
+        config = _json.load(f)
     for name, contract in config.get("futures", {}).items():
         if contract.upper().startswith(variety_code.upper()):
             return contract

app/config.py

@@ -3,10 +3,6 @@
 """
 import os
 from pathlib import Path
-from dotenv import load_dotenv
-
-# 加载 .env 文件
-load_dotenv()
 
 # 项目根目录
 BASE_DIR = Path(__file__).resolve().parent.parent.parent
@@ -38,17 +34,3 @@ LOG_LEVEL = os.getenv("BUFFER_LOG_LEVEL", "INFO")
 
 # 调度器
 SCHEDULER_MAX_INSTANCES = 1  # 同一任务不允许重叠执行
-
-# Redis 配置
-REDIS_HOST = os.getenv("REDIS_HOST", "localhost")
-REDIS_PORT = int(os.getenv("REDIS_PORT", "6379"))
-REDIS_DB = int(os.getenv("REDIS_DB", "0"))
-REDIS_PASSWORD = os.getenv("REDIS_PASSWORD", "")
-REDIS_TTL_SECONDS = int(os.getenv("REDIS_TTL_SECONDS", "2592000"))  # 30 天
-
-# MySQL 配置
-MYSQL_HOST = os.getenv("MYSQL_HOST", "localhost")
-MYSQL_PORT = int(os.getenv("MYSQL_PORT", "3306"))
-MYSQL_USER = os.getenv("MYSQL_USER", "root")
-MYSQL_PASSWORD = os.getenv("MYSQL_PASSWORD", "")
-MYSQL_DATABASE = os.getenv("MYSQL_DATABASE", "buffer_platform")

app/config_migration.py

@@ -1,52 +0,0 @@
-"""
-配置迁移 - JSON 配置文件 → MySQL
-"""
-import logging
-
-from app.config_store import get_config_store, CONFIG_FILES, DEFAULT_CONFIGS
-
-logger = logging.getLogger(__name__)
-
-CONFIG_KEYS = ["symbols", "ai"]
-
-
-def migrate_configs_to_mysql():
-    """
-    将 JSON 配置文件迁移到 MySQL。
-
-    Returns:
-        bool: 迁移是否成功
-    """
-    store = get_config_store()
-
-    if not store.storage_manager.check_mysql():
-        logger.warning("MySQL 不可用，跳过配置迁移")
-        return True
-
-    if store.session_maker is None:
-        logger.warning("MySQL session 未初始化，跳过配置迁移")
-        return True
-
-    migrated_count = 0
-    skipped_count = 0
-
-    for key in CONFIG_KEYS:
-        try:
-            if store._config_exists_in_mysql(key):
-                logger.info(f"MySQL 配置 [{key}] 已存在，跳过迁移")
-                skipped_count += 1
-                continue
-
-            value = store._load_json_from_file(key)
-            if value is None:
-                value = DEFAULT_CONFIGS.get(key, {})
-                logger.info(f"JSON 配置 [{key}] 不存在或损坏，使用默认值迁移")
-            store._save_to_mysql(key, value)
-            migrated_count += 1
-            logger.info(f"配置 [{key}] 已从 JSON 迁移到 MySQL")
-        except Exception as e:
-            logger.error(f"迁移配置 [{key}] 失败: {e}")
-            return False
-
-    logger.info(f"配置迁移完成: 迁移 {migrated_count} 项，跳过 {skipped_count} 项")
-    return True

app/config_store.py

@@ -1,186 +0,0 @@
-"""
-统一配置存储模块
-
-支持 MySQL 优先、JSON 文件 fallback 的读写策略。
-"""
-import json
-import logging
-from pathlib import Path
-from typing import Optional
-
-from app.models import AppConfig
-from app.storage_manager import get_storage_manager
-
-logger = logging.getLogger(__name__)
-
-
-def _get_mysql_session_local():
-    """动态读取 app.mysql_database.MySQLSessionLocal，避免模块导入顺序问题。"""
-    import sys
-    module = sys.modules.get("app.mysql_database")
-    if module is None:
-        return None
-    return getattr(module, "MySQLSessionLocal", None)
-
-CONFIG_DIR = Path(__file__).resolve().parent.parent / "config"
-CONFIG_FILES = {
-    "symbols": CONFIG_DIR / "symbols_config.json",
-    "ai": CONFIG_DIR / "ai_config.json",
-}
-
-DEFAULT_CONFIGS = {
-    "symbols": {"futures": {}, "stock": {}},
-    "ai": {
-        "models": [],
-        "active_model": None,
-        "analysis_settings": {
-            "enable_technical_analysis": True,
-            "enable_fundamental_analysis": False,
-            "enable_sentiment_analysis": False,
-            "risk_tolerance": "medium",
-            "max_position_pct": 10,
-        },
-    },
-}
-
-
-class ConfigStore:
-    """统一配置存储入口。"""
-
-    def __init__(
-        self,
-        storage_manager=None,
-        config_dir: Path = CONFIG_DIR,
-        session_maker=None,
-    ):
-        self.storage_manager = storage_manager or get_storage_manager()
-        self.config_dir = config_dir
-        self._session_maker_override = session_maker
-        self.config_files = {
-            "symbols": self.config_dir / "symbols_config.json",
-            "ai": self.config_dir / "ai_config.json",
-        }
-
-    @property
-    def session_maker(self):
-        """动态读取 MySQLSessionLocal，避免初始化顺序问题。"""
-        if self._session_maker_override is not None:
-            return self._session_maker_override
-        return _get_mysql_session_local()
-
-    def get_config(self, key: str, fallback: Optional[dict] = None) -> dict:
-        """读取配置，优先从 MySQL，其次 JSON 文件。"""
-        if key not in self.config_files:
-            raise ValueError(f"未知配置键: {key}")
-
-        if self.storage_manager.check_mysql():
-            try:
-                db_value = self._get_from_mysql(key)
-                if db_value is not None:
-                    return db_value
-
-                # 数据库未命中：从 JSON 读取并回填
-                json_value = self._load_json_from_file(key)
-                if json_value is not None:
-                    self._save_to_mysql(key, json_value)
-                    return json_value
-                # JSON 不存在或损坏，使用 fallback 但不回填
-                return fallback if fallback is not None else DEFAULT_CONFIGS.get(key, {})
-            except Exception as e:
-                logger.warning(f"从 MySQL 读取配置 [{key}] 失败，降级到 JSON: {e}")
-
-        json_value = self._load_json_from_file(key)
-        if json_value is not None:
-            return json_value
-        return fallback if fallback is not None else DEFAULT_CONFIGS.get(key, {})
-
-    def set_config(self, key: str, value: dict) -> bool:
-        """写入配置，MySQL 可用时先写数据库再写 JSON；MySQL 不可用时只写 JSON。"""
-        if key not in self.config_files:
-            raise ValueError(f"未知配置键: {key}")
-
-        if self.storage_manager.check_mysql():
-            try:
-                if not self._save_to_mysql(key, value):
-                    logger.warning(f"写入 MySQL 配置 [{key}] 失败，保留 JSON 旧值")
-                    return False
-            except Exception as e:
-                logger.warning(f"写入 MySQL 配置 [{key}] 失败，保留 JSON 旧值: {e}")
-                return False
-
-        # MySQL 写入成功或 MySQL 不可用，都更新 JSON fallback
-        self._save_to_json(key, value)
-        return True
-
-    def _get_from_mysql(self, key: str) -> Optional[dict]:
-        """从 MySQL 读取配置。"""
-        if self.session_maker is None:
-            return None
-
-        with self.session_maker() as db:
-            record = db.query(AppConfig).filter(AppConfig.config_key == key).first()
-            if record:
-                return record.config_value
-        return None
-
-    def _save_to_mysql(self, key: str, value: dict) -> bool:
-        """保存配置到 MySQL。"""
-        if self.session_maker is None:
-            return False
-
-        with self.session_maker() as db:
-            record = db.query(AppConfig).filter(AppConfig.config_key == key).first()
-            if record:
-                record.config_value = value
-            else:
-                record = AppConfig(config_key=key, config_value=value)
-                db.add(record)
-            db.commit()
-        return True
-
-    def _load_json_from_file(self, key: str) -> Optional[dict]:
-        """从 JSON 文件读取配置，文件不存在或损坏时返回 None。"""
-        file_path = self.config_files[key]
-        if file_path.exists():
-            try:
-                with open(file_path, "r", encoding="utf-8") as f:
-                    return json.load(f)
-            except Exception as e:
-                logger.warning(f"读取 JSON 配置 [{key}] 失败: {e}")
-        return None
-
-    def _load_json(self, key: str, fallback: Optional[dict] = None) -> dict:
-        """从 JSON 文件读取配置，文件不存在或损坏时返回 fallback。"""
-        value = self._load_json_from_file(key)
-        if value is not None:
-            return value
-        return fallback if fallback is not None else DEFAULT_CONFIGS.get(key, {})
-
-    def _save_to_json(self, key: str, value: dict) -> None:
-        """保存配置到 JSON 文件（原子写入）。"""
-        file_path = self.config_files[key]
-        self.config_dir.mkdir(parents=True, exist_ok=True)
-        tmp_path = file_path.with_suffix(".tmp")
-        try:
-            with open(tmp_path, "w", encoding="utf-8") as f:
-                json.dump(value, f, ensure_ascii=False, indent=4)
-            tmp_path.replace(file_path)
-        except Exception:
-            if tmp_path.exists():
-                tmp_path.unlink()
-            raise
-
-    def _config_exists_in_mysql(self, key: str) -> bool:
-        """检查 MySQL 中是否已存在配置。"""
-        return self._get_from_mysql(key) is not None
-
-
-_config_store = None
-
-
-def get_config_store() -> ConfigStore:
-    """获取 ConfigStore 单例。"""
-    global _config_store
-    if _config_store is None:
-        _config_store = ConfigStore()
-    return _config_store

app/main.py

@@ -36,64 +36,6 @@ async def lifespan(app: FastAPI):
     init_analysis_db()
     logger.info("期货智析数据库初始化完成")
     
-    # 初始化 Redis 和 MySQL
-    from app.redis_client import init_redis
-    from app.mysql_database import init_mysql
-    from app.storage_manager import get_storage_manager
-
-    redis_client = None
-    mysql_engine = None
-
-    try:
-        redis_client = init_redis()
-    except Exception:
-        redis_client = None
-
-    try:
-        mysql_engine = init_mysql()
-    except Exception:
-        mysql_engine = None
-
-    redis_ok = redis_client is not None
-    mysql_ok = mysql_engine is not None
-
-    if redis_ok and mysql_ok:
-        logger.info("存储模式: Redis + MySQL")
-    elif mysql_ok:
-        logger.warning("存储模式: MySQL (Redis 不可用)")
-    else:
-        logger.error("存储模式: SQLite (Redis 和 MySQL 均不可用)")
-
-    # 将初始化后的客户端注入 StorageManager 全局单例
-    storage_manager = get_storage_manager()
-    storage_manager.initialize(redis_client, mysql_engine)
-
-    if mysql_ok and mysql_engine is not None:
-        from app.models import Base as MarketBase, MarketData, SymbolTimestamp
-        # 在 MySQL 中创建行情相关表
-        MarketBase.metadata.create_all(bind=mysql_engine, tables=[MarketData.__table__, SymbolTimestamp.__table__])
-        logger.info("行情数据 MySQL 表结构初始化完成")
-
-        from app.migration import migrate_sqlite_to_mysql
-        migrate_sqlite_to_mysql()
-
-        # 在 MySQL 中创建 analysis 相关表
-        from app.analysis_db import init_analysis_mysql
-        init_analysis_mysql(mysql_engine)
-
-        # 迁移 SQLite analysis 数据到 MySQL
-        from app.analysis_migration import migrate_analysis_sqlite_to_mysql
-        migrate_analysis_sqlite_to_mysql()
-
-        # 在 MySQL 中创建配置表
-        from app.models import AppConfig
-        MarketBase.metadata.create_all(bind=mysql_engine, tables=[AppConfig.__table__])
-        logger.info("配置表 MySQL 表结构初始化完成")
-
-        # 迁移 JSON 配置到 MySQL
-        from app.config_migration import migrate_configs_to_mysql
-        migrate_configs_to_mysql()
-
     # 创建默认管理员账户
     from app.database import SessionLocal
     from app import auth_service

app/migration.py

@@ -1,91 +0,0 @@
-"""
-数据缓冲平台 - SQLite 到 MySQL 数据迁移
-"""
-import logging
-
-from sqlalchemy import create_engine
-from sqlalchemy.orm import make_transient, sessionmaker
-
-from app.config import DB_PATH
-from app.models import MarketData, SymbolTimestamp
-from app.mysql_database import MySQLSessionLocal
-
-
-def _prepare_records_for_new_session(records):
-    """将 ORM 实例转换为可在新 session 中插入的 transient 状态。"""
-    for record in records:
-        make_transient(record)
-        record.id = None
-
-logger = logging.getLogger(__name__)
-
-
-def migrate_sqlite_to_mysql():
-    """从 SQLite 迁移 market_data 和 symbol_timestamps 数据到 MySQL。
-
-    幂等设计：当 MySQL 对应表已存在数据时直接跳过，避免重复写入。
-    返回 True 表示执行了迁移，False 表示跳过或失败。
-    """
-    if MySQLSessionLocal is None:
-        logger.warning("MySQL 未初始化，跳过数据迁移")
-        return False
-
-    sqlite_engine = create_engine(
-        f"sqlite:///{DB_PATH}",
-        connect_args={"check_same_thread": False},
-    )
-    SQLiteSession = sessionmaker(bind=sqlite_engine)
-
-    mysql_session = MySQLSessionLocal()
-    try:
-        market_data_count = mysql_session.query(MarketData).count()
-        symbol_timestamp_count = mysql_session.query(SymbolTimestamp).count()
-
-        migrated_market_data = False
-        migrated_symbol_timestamps = False
-
-        sqlite_session = SQLiteSession()
-        try:
-            market_data_records = sqlite_session.query(MarketData).all()
-            symbol_timestamp_records = sqlite_session.query(SymbolTimestamp).all()
-        finally:
-            sqlite_session.close()
-
-        if market_data_count > 0:
-            logger.info(
-                f"MySQL market_data 表已存在数据，跳过迁移 "
-                f"(market_data: {market_data_count})"
-            )
-        else:
-            _prepare_records_for_new_session(market_data_records)
-            if market_data_records:
-                mysql_session.add_all(market_data_records)
-            migrated_market_data = True
-
-        if symbol_timestamp_count > 0:
-            logger.info(
-                f"MySQL symbol_timestamps 表已存在数据，跳过迁移 "
-                f"(symbol_timestamps: {symbol_timestamp_count})"
-            )
-        else:
-            _prepare_records_for_new_session(symbol_timestamp_records)
-            if symbol_timestamp_records:
-                mysql_session.add_all(symbol_timestamp_records)
-            migrated_symbol_timestamps = True
-
-        if not migrated_market_data and not migrated_symbol_timestamps:
-            logger.info("MySQL 已存在数据，跳过迁移")
-            return False
-
-        mysql_session.commit()
-        logger.info(
-            f"迁移完成: market_data: {len(market_data_records)} 条, "
-            f"symbol_timestamps: {len(symbol_timestamp_records)} 条"
-        )
-        return True
-    except Exception as e:
-        logger.error(f"数据迁移失败: {e}")
-        mysql_session.rollback()
-        return False
-    finally:
-        mysql_session.close()

app/models.py

@@ -2,10 +2,7 @@
 数据缓冲平台 - 数据模型 (SQLAlchemy ORM)
 """
 from datetime import datetime
-from sqlalchemy import (
-    Column, String, Integer, Float, Text, DateTime, Boolean,
-    Index, UniqueConstraint, JSON,
-)
+from sqlalchemy import Column, String, Integer, Float, Text, DateTime, Boolean, Index, UniqueConstraint
 from app.database import Base
 
 
@@ -70,20 +67,3 @@ class ScheduledTask(Base):
 
     def __repr__(self):
         return f"<Task {self.symbol} every {self.interval_seconds}s enabled={self.enabled}>"
-
-
-class AppConfig(Base):
-    """应用配置表 - 存储 JSON 配置数据"""
-    __tablename__ = "app_config"
-
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    config_key = Column(
-        String(64), unique=True, nullable=False, index=True,
-        comment="配置键，如 symbols / ai"
-    )
-    config_value = Column(JSON, nullable=False, comment="配置值(JSON)")
-    created_at = Column(DateTime, nullable=False, default=datetime.now, comment="创建时间")
-    updated_at = Column(DateTime, nullable=False, default=datetime.now, onupdate=datetime.now, comment="更新时间")
-
-    def __repr__(self):
-        return f"<AppConfig {self.config_key}>"

app/mysql_database.py

@@ -1,39 +0,0 @@
-"""
-数据缓冲平台 - MySQL 数据库连接
-"""
-import logging
-import urllib.parse
-from sqlalchemy import create_engine, text
-from sqlalchemy.orm import sessionmaker
-from app.config import MYSQL_HOST, MYSQL_PORT, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE
-
-logger = logging.getLogger(__name__)
-
-mysql_engine = None
-MySQLSessionLocal = None
-
-
-def init_mysql():
-    """初始化 MySQL 连接引擎，失败时返回 None"""
-    global mysql_engine, MySQLSessionLocal
-    try:
-        encoded_password = urllib.parse.quote_plus(MYSQL_PASSWORD)
-        url = f"mysql+pymysql://{MYSQL_USER}:{encoded_password}@{MYSQL_HOST}:{MYSQL_PORT}/{MYSQL_DATABASE}?charset=utf8mb4"
-        mysql_engine = create_engine(url, pool_pre_ping=True, pool_recycle=3600)
-        with mysql_engine.connect() as conn:
-            conn.execute(text("SELECT 1"))
-        MySQLSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=mysql_engine)
-        logger.info("MySQL 连接初始化成功")
-        return mysql_engine
-    except Exception as e:
-        logger.warning(f"MySQL 初始化失败: {e}")
-        mysql_engine = None
-        MySQLSessionLocal = None
-        return None
-
-
-def get_mysql_session():
-    """获取 MySQL 会话"""
-    if MySQLSessionLocal is None:
-        raise RuntimeError("MySQL 未初始化")
-    return MySQLSessionLocal()

app/redis_client.py

@@ -1,31 +0,0 @@
-import logging
-import redis
-from app.config import REDIS_HOST, REDIS_PORT, REDIS_DB, REDIS_PASSWORD
-
-logger = logging.getLogger(__name__)
-
-redis_client = None
-
-
-def init_redis():
-    """初始化 Redis 客户端，失败时返回 None"""
-    global redis_client
-    try:
-        redis_client = redis.Redis(
-            host=REDIS_HOST, port=REDIS_PORT, db=REDIS_DB,
-            password=REDIS_PASSWORD or None,
-            decode_responses=True,
-            socket_connect_timeout=5,
-        )
-        redis_client.ping()
-        logger.info("Redis 连接初始化成功")
-        return redis_client
-    except Exception as e:
-        logger.warning(f"Redis 初始化失败: {e}")
-        redis_client = None
-        return None
-
-
-def get_redis():
-    """获取 Redis 客户端实例"""
-    return redis_client

app/services/ai_analysis.py

@@ -10,6 +10,10 @@ from sqlalchemy.orm import Session
 
 from app.analysis_models import AIAnalysisCache
 from app.services.cache import get_cached_data, get_latest_cached
+from pathlib import Path
+
+CONFIG_DIR = Path(__file__).resolve().parent.parent.parent / "config"
+AI_CONFIG_FILE = CONFIG_DIR / "ai_config.json"
 
 logger = logging.getLogger(__name__)
 
@@ -148,11 +152,11 @@ class AIFuturesAnalyzer:
     def get_active_model(self) -> Optional[Dict]:
         """获取当前激活的AI模型配置"""
         try:
-            from app.config_store import get_config_store
-            config = get_config_store().get_config("ai", {
-                "models": [],
-                "active_model": None,
-            })
+            if not AI_CONFIG_FILE.exists():
+                return None
+            
+            with open(AI_CONFIG_FILE, "r", encoding="utf-8") as f:
+                config = json.load(f)
             
             models = config.get("models", [])
             active_model_name = config.get("active_model")

app/services/cache.py

@@ -1,7 +1,6 @@
 """
 缓存服务 - SQLite 数据库操作
 """
-import copy
 import json
 import logging
 from datetime import datetime, timedelta
@@ -11,7 +10,6 @@ from sqlalchemy.orm import Session
 
 from app.models import MarketData, ScheduledTask, SymbolTimestamp
 from app.config import CACHE_TTL_SECONDS
-from app.storage_manager import get_storage_manager
 
 logger = logging.getLogger(__name__)
 
@@ -25,21 +23,7 @@ def is_cache_valid(
     period: str,
     ttl_seconds: int = CACHE_TTL_SECONDS,
 ) -> bool:
-    """检查指定品种+周期的缓存是否在有效期内，优先使用 StorageManager。"""
-    storage = get_storage_manager()
-
-    if storage.is_available():
-        try:
-            result = storage.get_market_data(symbol, data_type, [period])
-            if result and result.get("timeframes"):
-                timestamp_raw = result.get("fetched_at") or result.get("timestamp")
-                if timestamp_raw:
-                    newest = datetime.fromisoformat(timestamp_raw)
-                    age = (datetime.now() - newest).total_seconds()
-                    return age < ttl_seconds
-        except Exception as e:
-            logger.warning(f"StorageManager 缓存有效性检查失败，降级到 SQLite: {e}")
-
+    """检查指定品种+周期的缓存是否在有效期内"""
     record = db.query(MarketData).filter_by(
         symbol=symbol,
         data_type=data_type,
@@ -81,12 +65,11 @@ def check_cache_status(
     }
 
 
-def _save_to_sqlite(db: Session, symbol: str, data: Dict) -> MarketData:
+def save_market_data(db: Session, symbol: str, data: Dict) -> MarketData:
     """
-    将采集结果写入 SQLite 缓存，并同步更新合约时间戳。
+    保存采集结果到缓存，并同步更新合约时间戳。
 
     Args:
-        db: 数据库会话
         symbol: 品种代码
         data: 采集脚本返回的完整数据
 
@@ -123,7 +106,7 @@ def _save_to_sqlite(db: Session, symbol: str, data: Dict) -> MarketData:
             db.add(record)
 
     # 更新合约时间戳
-    _update_symbol_timestamp_sqlite(db, symbol, data.get("type", "futures"), now)
+    update_symbol_timestamp(db, symbol, data.get("type", "futures"), now)
 
     db.commit()
     logger.info(f"缓存已更新: {symbol}, {len(data.get('timeframes', {}))} 个周期")
@@ -135,8 +118,8 @@ def _save_to_sqlite(db: Session, symbol: str, data: Dict) -> MarketData:
     ).order_by(MarketData.fetched_at.desc()).first()
 
 
-def _update_symbol_timestamp_sqlite(db: Session, symbol: str, data_type: str, refresh_time: datetime) -> None:
-    """更新或创建合约时间戳记录（SQLite 兜底）。"""
+def update_symbol_timestamp(db: Session, symbol: str, data_type: str, refresh_time: datetime) -> None:
+    """更新或创建合约时间戳记录"""
     timestamp_record = db.query(SymbolTimestamp).filter_by(
         symbol=symbol,
         data_type=data_type
@@ -154,9 +137,11 @@ def _update_symbol_timestamp_sqlite(db: Session, symbol: str, data_type: str, re
         )
         db.add(timestamp_record)
     
+    db.commit()
+
 
-def _get_symbol_timestamp_sqlite(db: Session, symbol: str, data_type: str = "futures") -> Optional[datetime]:
-    """获取合约最后刷新时间（SQLite 兜底）。"""
+def get_symbol_timestamp(db: Session, symbol: str, data_type: str = "futures") -> Optional[datetime]:
+    """获取合约最后刷新时间"""
     record = db.query(SymbolTimestamp).filter_by(
         symbol=symbol,
         data_type=data_type
@@ -164,182 +149,6 @@ def _get_symbol_timestamp_sqlite(db: Session, symbol: str, data_type: str = "fut
     return record.last_refresh_at if record else None
 
 
-def _filter_candles(
-    candles: List[Dict],
-    end_time: Optional[datetime] = None,
-    max_candles: int = 100,
-) -> List[Dict]:
-    """按结束时间和最大数量过滤 K 线列表。"""
-    filter_end_time = end_time if end_time else datetime.now()
-    if filter_end_time.tzinfo is not None:
-        filter_end_time = filter_end_time.replace(tzinfo=None)
-
-    filtered = []
-    for candle in candles:
-        candle_time = candle.get("datetime") or candle.get("time")
-        if candle_time:
-            if isinstance(candle_time, str):
-                try:
-                    candle_dt = datetime.fromisoformat(candle_time.replace("Z", "+00:00"))
-                    if candle_dt.tzinfo is not None:
-                        candle_dt = candle_dt.replace(tzinfo=None)
-                except Exception:
-                    filtered.append(candle)
-                    continue
-            else:
-                candle_dt = candle_time
-                if candle_dt.tzinfo is not None:
-                    candle_dt = candle_dt.replace(tzinfo=None)
-
-            if candle_dt <= filter_end_time:
-                filtered.append(candle)
-        else:
-            filtered.append(candle)
-
-    if len(filtered) > max_candles:
-        filtered = filtered[-max_candles:]
-
-    return filtered
-
-
-def _get_from_sqlite(
-    db: Session,
-    symbol: str,
-    data_type: str = "futures",
-    periods: Optional[List[str]] = None,
-    end_time: Optional[datetime] = None,
-    max_candles: int = 100,
-) -> Optional[Dict]:
-    """
-    从 SQLite 缓存中获取完整的多周期数据。
-
-    Args:
-        db: 数据库会话
-        symbol: 品种代码
-        data_type: 数据类型
-        periods: 周期列表
-        end_time: 结束时间(可选),默认为当前时间
-        max_candles: 每个周期最大K线数量,默认100
-
-    Returns:
-        与采集脚本相同格式的数据，或 None
-    """
-    query = db.query(MarketData).filter_by(symbol=symbol, data_type=data_type)
-    if periods:
-        query = query.filter(MarketData.period.in_(periods))
-
-    records = query.all()
-    if not records:
-        return None
-
-    # 检查缓存是否过期
-    now = datetime.now()
-    newest = max(r.fetched_at for r in records)
-    is_fresh = (now - newest).total_seconds() < CACHE_TTL_SECONDS
-
-    timeframes = {}
-    current_price = None
-    for r in records:
-        candles = json.loads(r.candles_json)
-        timeframes[r.period] = _filter_candles(candles, end_time, max_candles)
-        if current_price is None:
-            current_price = r.current_price
-
-    return {
-        "symbol": symbol,
-        "type": data_type,
-        "current_price": current_price,
-        "timestamp": newest.isoformat(),
-        "timeframes": timeframes,
-        "is_fresh": is_fresh,
-        "fetched_at": newest.isoformat(),
-    }
-
-
-def _representative_market_data(symbol: str, data: Dict, fetched_at: datetime) -> Optional[MarketData]:
-    """从输入数据构造一条代表性的 MarketData 记录（不写入数据库）。"""
-    data_type = data.get("type", "futures")
-    timeframes = data.get("timeframes", {})
-    if not timeframes:
-        return None
-
-    # 取第一个周期作为代表
-    period = next(iter(timeframes))
-    candles = timeframes[period]
-    return MarketData(
-        symbol=symbol,
-        data_type=data_type,
-        period=period,
-        candles_json=json.dumps(candles, ensure_ascii=False),
-        current_price=data.get("current_price"),
-        fetched_at=fetched_at,
-        candle_count=len(candles),
-    )
-
-
-def save_market_data(db: Session, symbol: str, data: Dict) -> Optional[MarketData]:
-    """
-    保存采集结果到缓存，优先写入 StorageManager（Redis/MySQL），失败时降级到 SQLite。
-
-    Args:
-        symbol: 品种代码
-        data: 采集脚本返回的完整数据
-
-    Returns:
-        返回一条代表性的 MarketData 记录；降级到 SQLite 时返回实际持久化记录
-    """
-    storage = get_storage_manager()
-    data_type = data.get("type", "futures")
-    now = datetime.now()
-
-    if storage.is_available():
-        try:
-            if storage.save_market_data_with_timestamp(symbol, data, now):
-                # 注意：StorageManager 命中时返回的是内存构造的代表性 MarketData，
-                # 不代表 SQLite 持久化记录，因此没有 SQLite 自增 id。
-                return _representative_market_data(symbol, data, now)
-            else:
-                raise Exception("save_market_data_with_timestamp returned False")
-        except Exception as e:
-            logger.warning(f"StorageManager 写入失败，降级到 SQLite: {e}")
-            # 注意：当 StorageManager 不可用时，数据只会写入本地 SQLite 兜底，
-            # 这部分数据不会自动同步到主存储（Redis/MySQL），可能与主存储脱节。
-
-    return _save_to_sqlite(db, symbol, data)
-
-
-def update_symbol_timestamp(db: Session, symbol: str, data_type: str, refresh_time: datetime) -> None:
-    """更新或创建合约时间戳记录，优先使用 StorageManager。"""
-    storage = get_storage_manager()
-
-    if storage.is_available():
-        try:
-            if storage.save_symbol_timestamp(symbol, data_type, refresh_time):
-                return
-            else:
-                raise Exception("save_symbol_timestamp returned False")
-        except Exception as e:
-            logger.warning(f"StorageManager 时间戳写入失败，降级到 SQLite: {e}")
-
-    _update_symbol_timestamp_sqlite(db, symbol, data_type, refresh_time)
-    db.commit()
-
-
-def get_symbol_timestamp(db: Session, symbol: str, data_type: str = "futures") -> Optional[datetime]:
-    """获取合约最后刷新时间，优先使用 StorageManager。"""
-    storage = get_storage_manager()
-
-    if storage.is_available():
-        try:
-            result = storage.get_symbol_timestamp(symbol, data_type)
-            if result:
-                return datetime.fromisoformat(result["last_refresh_at"])
-        except Exception as e:
-            logger.warning(f"StorageManager 时间戳读取失败，降级到 SQLite: {e}")
-
-    return _get_symbol_timestamp_sqlite(db, symbol, data_type)
-
-
 def needs_refresh(db: Session, symbol: str, data_type: str = "futures", threshold_seconds: int = 300) -> bool:
     """
     检查合约是否需要刷新（数据是否超过阈值时间）
@@ -367,42 +176,7 @@ def get_latest_cached(
     data_type: str = "futures",
     period: Optional[str] = None,
 ) -> List[MarketData]:
-    """获取最新缓存数据，优先使用 StorageManager。"""
-    storage = get_storage_manager()
-
-    if storage.is_available():
-        try:
-            result = storage.get_market_data(
-                symbol, data_type, [period] if period else None
-            )
-            if result and result.get("timeframes"):
-                timestamp_raw = result.get("fetched_at") or result.get("timestamp")
-                fetched_at = (
-                    datetime.fromisoformat(timestamp_raw)
-                    if timestamp_raw
-                    else datetime.now()
-                )
-                records = []
-                target_periods = [period] if period else list(result["timeframes"].keys())
-                for p in target_periods:
-                    candles = result["timeframes"].get(p, [])
-                    records.append(
-                        MarketData(
-                            symbol=symbol,
-                            data_type=data_type,
-                            period=p,
-                            candles_json=json.dumps(candles, ensure_ascii=False),
-                            current_price=result.get("current_price"),
-                            fetched_at=fetched_at,
-                            candle_count=len(candles),
-                        )
-                    )
-                # 注意：StorageManager 命中时返回的是内存构造的 MarketData 列表，
-                # 不代表 SQLite 持久化记录，因此没有 SQLite 自增 id。
-                return records
-        except Exception as e:
-            logger.warning(f"StorageManager 最新缓存读取失败，降级到 SQLite: {e}")
-
+    """获取最新缓存数据"""
     query = db.query(MarketData).filter_by(symbol=symbol, data_type=data_type)
     if period:
         query = query.filter_by(period=period)
@@ -418,7 +192,7 @@ def get_cached_data(
     max_candles: int = 100,
 ) -> Optional[Dict]:
     """
-    从缓存中获取完整的多周期数据，优先使用 StorageManager，失败时降级到 SQLite。
+    从缓存中获取完整的多周期数据。
 
     Args:
         db: 数据库会话
@@ -431,21 +205,76 @@ def get_cached_data(
     Returns:
         与采集脚本相同格式的数据，或 None
     """
-    storage = get_storage_manager()
+    query = db.query(MarketData).filter_by(symbol=symbol, data_type=data_type)
+    if periods:
+        query = query.filter(MarketData.period.in_(periods))
 
-    if storage.is_available():
-        try:
-            merged = storage.get_market_data(
-                symbol, data_type, periods, end_time=end_time, max_candles=max_candles
-            )
-            if merged and merged.get("timeframes"):
-                # StorageManager 已负责 end_time / max_candles 过滤，
-                # 这里深拷贝后返回，避免原地修改 StorageManager 内部对象。
-                return copy.deepcopy(merged)
-        except Exception as e:
-            logger.warning(f"StorageManager 读取失败，降级到 SQLite: {e}")
-
-    return _get_from_sqlite(db, symbol, data_type, periods, end_time, max_candles)
+    records = query.all()
+    if not records:
+        return None
+
+    # 检查缓存是否过期
+    now = datetime.now()
+    newest = max(r.fetched_at for r in records)
+    is_fresh = (now - newest).total_seconds() < CACHE_TTL_SECONDS
+
+    # 如果未指定结束时间,默认为当前时间
+    filter_end_time = end_time if end_time else now
+    
+    # 确保filter_end_time是naive datetime(无时区)
+    if filter_end_time.tzinfo is not None:
+        filter_end_time = filter_end_time.replace(tzinfo=None)
+
+    timeframes = {}
+    current_price = None
+    for r in records:
+        candles = json.loads(r.candles_json)
+        
+        # 过滤结束时间之前的K线数据
+        filtered_candles = []
+        for candle in candles:
+            candle_time = candle.get('datetime') or candle.get('time')
+            if candle_time:
+                # 解析K线时间
+                if isinstance(candle_time, str):
+                    try:
+                        candle_dt = datetime.fromisoformat(candle_time.replace('Z', '+00:00'))
+                        # 转换为naive datetime进行比较
+                        if candle_dt.tzinfo is not None:
+                            candle_dt = candle_dt.replace(tzinfo=None)
+                    except:
+                        filtered_candles.append(candle)
+                        continue
+                else:
+                    candle_dt = candle_time
+                    # 如果是aware datetime,转换为naive
+                    if candle_dt.tzinfo is not None:
+                        candle_dt = candle_dt.replace(tzinfo=None)
+                
+                # 只保留结束时间之前的数据
+                if candle_dt <= filter_end_time:
+                    filtered_candles.append(candle)
+            else:
+                filtered_candles.append(candle)
+        
+        # 限制K线数量,超过max_candles则取最新的max_candles条
+        if len(filtered_candles) > max_candles:
+            filtered_candles = filtered_candles[-max_candles:]
+        
+        timeframes[r.period] = filtered_candles
+            
+        if current_price is None:
+            current_price = r.current_price
+
+    return {
+        "symbol": symbol,
+        "type": data_type,
+        "current_price": current_price,
+        "timestamp": newest.isoformat(),
+        "timeframes": timeframes,
+        "is_fresh": is_fresh,
+        "fetched_at": newest.isoformat(),
+    }
 
 
 # ===== 定时任务管理 =====

app/services/plan_generator.py

@@ -4,6 +4,7 @@ V2 交易计划生成器 - 5维度综合评分 + 多周期共振分析
 import json
 import logging
 from collections import Counter
+from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 from datetime import datetime
 
@@ -16,6 +17,9 @@ from app.analysis_models import (
 
 logger = logging.getLogger(__name__)
 
+# 品种配置加载
+CONFIG_DIR = Path(__file__).resolve().parent.parent.parent / "config"
+
 # 板块分类
 SECTOR_MAP = {
     "贵金属": ["沪银", "沪金"],
@@ -42,8 +46,12 @@ WEIGHTS = {
 
 def load_symbols_config() -> Dict[str, str]:
     """加载品种配置 {中文名: 合约代码}"""
-    from app.config_store import get_config_store
-    data = get_config_store().get_config("symbols", {"futures": {}, "stock": {}})
+    config_path = CONFIG_DIR / "symbols_config.json"
+    if not config_path.exists():
+        logger.warning(f"品种配置文件不存在: {config_path}")
+        return {}
+    with open(config_path, "r", encoding="utf-8") as f:
+        data = json.load(f)
     return data.get("futures", {})
 
 
@@ -626,126 +634,121 @@ def save_plan_to_db(db: Session, plan_data: dict) -> int:
     review_date_str = plan_data["review_date"]
     week_day = plan_data["week_day"]
 
-    try:
-        # 清理旧数据
-        existing = db.query(ReviewPlanV2).filter_by(review_date=review_date_str).first()
-        if existing:
-            review_plan_id = existing.id
-            # 清理关联数据
-            db.query(SymbolScoreV2).filter_by(review_date_id=review_plan_id).delete()
-            db.query(TradingPlanV2).filter_by(review_date_id=review_plan_id).delete()
-            db.query(SectorHeat).filter_by(review_date_id=review_plan_id).delete()
-            # 更新元数据
-            existing.week_day = week_day
-            existing.data_basis = plan_data.get("data_basis")
-            existing.core_conclusion = plan_data.get("core_conclusion")
-            existing.bull_count = plan_data.get("bull_count")
-            existing.bear_count = plan_data.get("bear_count")
-            existing.neutral_count = plan_data.get("neutral_count")
-            existing.opportunity_count = plan_data.get("opportunity_count")
-            existing.risk_warnings = plan_data.get("risk_warnings")
-            existing.actual_data_date = plan_data.get("actual_data_date")
-            existing.data_date_matches = 1 if plan_data.get("data_date_matches") else 0
-        else:
-            review_plan = ReviewPlanV2(
-                review_date=review_date_str,
-                week_day=week_day,
-                data_basis=plan_data.get("data_basis"),
-                core_conclusion=plan_data.get("core_conclusion"),
-                bull_count=plan_data.get("bull_count"),
-                bear_count=plan_data.get("bear_count"),
-                neutral_count=plan_data.get("neutral_count"),
-                opportunity_count=plan_data.get("opportunity_count"),
-                risk_warnings=plan_data.get("risk_warnings"),
-                actual_data_date=plan_data.get("actual_data_date"),
-                data_date_matches=1 if plan_data.get("data_date_matches") else 0,
-            )
-            db.add(review_plan)
-            db.flush()
-            review_plan_id = review_plan.id
-
-        # 保存评分数据
-        for s in plan_data.get("scores", []):
-            pivots = s.get("pivots", {})
-            score_record = SymbolScoreV2(
-                review_date_id=review_plan_id,
-                symbol=s["symbol"],
-                name=s["name"],
-                close_price=s.get("close_price"),
-                prev_close=s.get("prev_close"),
-                high_price=s.get("high_price"),
-                low_price=s.get("low_price"),
-                volume=s.get("volume"),
-                avg_volume_5=s.get("avg_volume_5"),
-                amplitude_score=s.get("amplitude_score"),
-                volume_score=s.get("volume_score"),
-                change_score=s.get("change_score"),
-                trend_score=s.get("trend_score"),
-                activity_score=s.get("activity_score"),
-                composite_score=s.get("composite_score"),
-                amplitude_pct=s.get("amplitude_pct"),
-                change_pct=s.get("change_pct"),
-                volume_ratio=s.get("volume_ratio"),
-                trend_60m=s.get("trend_60m"),
-                trend_15m=s.get("trend_15m"),
-                trend_5m=s.get("trend_5m"),
-                direction=s.get("direction"),
-                direction_tag=s.get("direction_tag"),
-                category=s.get("category"),
-                pivot=pivots.get("pivot"),
-                r1=pivots.get("r1"),
-                r2=pivots.get("r2"),
-                s1=pivots.get("s1"),
-                s2=pivots.get("s2"),
-                rank=s.get("rank"),
-                data_date=s.get("data_date"),
-            )
-            db.add(score_record)
-
-        # 保存交易计划
-        for p in plan_data.get("plans", []):
-            plan_record = TradingPlanV2(
-                review_date_id=review_plan_id,
-                symbol=p["symbol"],
-                name=p["name"],
-                direction=p["direction"],
-                composite_score=p.get("composite_score"),
-                entry_low=p.get("entry_low"),
-                entry_high=p.get("entry_high"),
-                stop_loss=p.get("stop_loss"),
-                target1=p.get("target1"),
-                target2=p.get("target2"),
-                trigger=p.get("trigger"),
-                amplitude_score=p.get("amplitude_score"),
-                volume_score=p.get("volume_score"),
-                trend_score=p.get("trend_score"),
-                activity_score=p.get("activity_score"),
-                category=p.get("category"),
-            )
-            db.add(plan_record)
-
-        # 保存板块热度
-        for sec in plan_data.get("sectors", []):
-            sector_record = SectorHeat(
-                review_date_id=review_plan_id,
-                sector_name=sec["sector_name"],
-                avg_score=sec.get("avg_score"),
-                avg_trend=sec.get("avg_trend"),
-                direction=sec.get("direction"),
-                heat_level=sec.get("heat_level"),
-                leader_symbol=sec.get("leader_symbol"),
-                leader_score=sec.get("leader_score"),
-                members=sec.get("members"),
-            )
-            db.add(sector_record)
-
-        db.commit()
-        logger.info(f"交易计划已保存: {review_date_str}, ID={review_plan_id}")
-        return review_plan_id
-    except Exception as e:
-        db.rollback()
-        logger.exception(f"保存交易计划失败: {e}")
-        raise
+    # 清理旧数据
+    existing = db.query(ReviewPlanV2).filter_by(review_date=review_date_str).first()
+    if existing:
+        review_plan_id = existing.id
+        # 清理关联数据
+        db.query(SymbolScoreV2).filter_by(review_date_id=review_plan_id).delete()
+        db.query(TradingPlanV2).filter_by(review_date_id=review_plan_id).delete()
+        db.query(SectorHeat).filter_by(review_date_id=review_plan_id).delete()
+        # 更新元数据
+        existing.week_day = week_day
+        existing.data_basis = plan_data.get("data_basis")
+        existing.core_conclusion = plan_data.get("core_conclusion")
+        existing.bull_count = plan_data.get("bull_count")
+        existing.bear_count = plan_data.get("bear_count")
+        existing.neutral_count = plan_data.get("neutral_count")
+        existing.opportunity_count = plan_data.get("opportunity_count")
+        existing.risk_warnings = plan_data.get("risk_warnings")
+        existing.actual_data_date = plan_data.get("actual_data_date")
+        existing.data_date_matches = 1 if plan_data.get("data_date_matches") else 0
+    else:
+        review_plan = ReviewPlanV2(
+            review_date=review_date_str,
+            week_day=week_day,
+            data_basis=plan_data.get("data_basis"),
+            core_conclusion=plan_data.get("core_conclusion"),
+            bull_count=plan_data.get("bull_count"),
+            bear_count=plan_data.get("bear_count"),
+            neutral_count=plan_data.get("neutral_count"),
+            opportunity_count=plan_data.get("opportunity_count"),
+            risk_warnings=plan_data.get("risk_warnings"),
+            actual_data_date=plan_data.get("actual_data_date"),
+            data_date_matches=1 if plan_data.get("data_date_matches") else 0,
+        )
+        db.add(review_plan)
+        db.flush()
+        review_plan_id = review_plan.id
+
+    # 保存评分数据
+    for s in plan_data.get("scores", []):
+        pivots = s.get("pivots", {})
+        score_record = SymbolScoreV2(
+            review_date_id=review_plan_id,
+            symbol=s["symbol"],
+            name=s["name"],
+            close_price=s.get("close_price"),
+            prev_close=s.get("prev_close"),
+            high_price=s.get("high_price"),
+            low_price=s.get("low_price"),
+            volume=s.get("volume"),
+            avg_volume_5=s.get("avg_volume_5"),
+            amplitude_score=s.get("amplitude_score"),
+            volume_score=s.get("volume_score"),
+            change_score=s.get("change_score"),
+            trend_score=s.get("trend_score"),
+            activity_score=s.get("activity_score"),
+            composite_score=s.get("composite_score"),
+            amplitude_pct=s.get("amplitude_pct"),
+            change_pct=s.get("change_pct"),
+            volume_ratio=s.get("volume_ratio"),
+            trend_60m=s.get("trend_60m"),
+            trend_15m=s.get("trend_15m"),
+            trend_5m=s.get("trend_5m"),
+            direction=s.get("direction"),
+            direction_tag=s.get("direction_tag"),
+            category=s.get("category"),
+            pivot=pivots.get("pivot"),
+            r1=pivots.get("r1"),
+            r2=pivots.get("r2"),
+            s1=pivots.get("s1"),
+            s2=pivots.get("s2"),
+            rank=s.get("rank"),
+            data_date=s.get("data_date"),
+        )
+        db.add(score_record)
+
+    # 保存交易计划
+    for p in plan_data.get("plans", []):
+        plan_record = TradingPlanV2(
+            review_date_id=review_plan_id,
+            symbol=p["symbol"],
+            name=p["name"],
+            direction=p["direction"],
+            composite_score=p.get("composite_score"),
+            entry_low=p.get("entry_low"),
+            entry_high=p.get("entry_high"),
+            stop_loss=p.get("stop_loss"),
+            target1=p.get("target1"),
+            target2=p.get("target2"),
+            trigger=p.get("trigger"),
+            amplitude_score=p.get("amplitude_score"),
+            volume_score=p.get("volume_score"),
+            trend_score=p.get("trend_score"),
+            activity_score=p.get("activity_score"),
+            category=p.get("category"),
+        )
+        db.add(plan_record)
+
+    # 保存板块热度
+    for sec in plan_data.get("sectors", []):
+        sector_record = SectorHeat(
+            review_date_id=review_plan_id,
+            sector_name=sec["sector_name"],
+            avg_score=sec.get("avg_score"),
+            avg_trend=sec.get("avg_trend"),
+            direction=sec.get("direction"),
+            heat_level=sec.get("heat_level"),
+            leader_symbol=sec.get("leader_symbol"),
+            leader_score=sec.get("leader_score"),
+            members=sec.get("members"),
+        )
+        db.add(sector_record)
+
+    db.commit()
+    logger.info(f"交易计划已保存: {review_date_str}, ID={review_plan_id}")
+    return review_plan_id
 
 
 def get_plan_data(db: Session, review_plan_id: int) -> Optional[dict]:

app/services/trade_parser.py

@@ -23,17 +23,19 @@ _VARIETY_NAME_MAP = {}
 
 
 def _load_variety_name_map():
-    """从配置加载品种名称映射"""
+    """从 symbols_config.json 加载品种名称映射"""
     global _VARIETY_NAME_MAP
     if _VARIETY_NAME_MAP:
         return
-    from app.config_store import get_config_store
-    config = get_config_store().get_config("symbols", {"futures": {}, "stock": {}})
-    # 正向: {"沪银": "AG2608"} -> 反向: {"AG": "沪银"}
-    for name, contract in config.get("futures", {}).items():
-        variety = extract_variety(contract)
-        if variety and variety not in _VARIETY_NAME_MAP:
-            _VARIETY_NAME_MAP[variety] = name
+    config_path = Path(__file__).resolve().parent.parent.parent / "config" / "symbols_config.json"
+    if config_path.exists():
+        with open(config_path, "r", encoding="utf-8") as f:
+            config = json.load(f)
+        # 正向: {"沪银": "AG2608"} -> 反向: {"AG": "沪银"}
+        for name, contract in config.get("futures", {}).items():
+            variety = extract_variety(contract)
+            if variety and variety not in _VARIETY_NAME_MAP:
+                _VARIETY_NAME_MAP[variety] = name
 
 
 def extract_variety(contract):

app/storage_manager.py

@@ -1,774 +0,0 @@
-import datetime as _datetime
-import json
-import logging
-import time
-from datetime import datetime
-
-from sqlalchemy import text
-from sqlalchemy.orm import sessionmaker
-
-from app.config import CACHE_TTL_SECONDS, REDIS_TTL_SECONDS
-from app.models import MarketData, SymbolTimestamp
-
-logger = logging.getLogger(__name__)
-
-# Redis 缓存 TTL：读取自 app.config.REDIS_TTL_SECONDS（默认 30 天）
-# 业务缓存有效期：读取自 app.config.CACHE_TTL_SECONDS（默认 300 秒）
-
-
-class StorageManager:
-    """存储管理器骨架，封装 Redis / MySQL 可用性检测与三级降级状态。"""
-
-    def __init__(self, redis_client=None, mysql_engine=None, check_interval=30):
-        self.redis_client = redis_client
-        self.mysql_engine = mysql_engine
-        self.check_interval = check_interval
-
-        self.redis_available = False
-        self.mysql_available = False
-        self.last_redis_check = 0
-        self.last_mysql_check = 0
-
-    def check_redis(self):
-        """惰性检测 Redis 可用性，30 秒间隔内返回缓存结果。"""
-        now = time.time()
-        if now - self.last_redis_check < self.check_interval:
-            return self.redis_available
-
-        if self.redis_client is None:
-            self.redis_available = False
-        else:
-            try:
-                self.redis_client.ping()
-                self.redis_available = True
-            except Exception as e:
-                self.redis_available = False
-
-        self.last_redis_check = now
-        return self.redis_available
-
-    def check_mysql(self):
-        """惰性检测 MySQL 可用性，30 秒间隔内返回缓存结果。"""
-        now = time.time()
-        if now - self.last_mysql_check < self.check_interval:
-            return self.mysql_available
-
-        if self.mysql_engine is None:
-            self.mysql_available = False
-        else:
-            try:
-                with self.mysql_engine.connect() as conn:
-                    conn.execute(text("SELECT 1"))
-                self.mysql_available = True
-            except Exception as e:
-                self.mysql_available = False
-
-        self.last_mysql_check = now
-        return self.mysql_available
-
-    def _parse_fetched_at(self, timestamp_raw):
-        """优先使用输入 timestamp，解析失败时回退到当前时间。"""
-        if not timestamp_raw:
-            return _datetime.datetime.now()
-
-        if isinstance(timestamp_raw, str):
-            try:
-                return _datetime.datetime.fromisoformat(timestamp_raw)
-            except Exception:
-                return _datetime.datetime.now()
-
-        if hasattr(timestamp_raw, "isoformat"):
-            return timestamp_raw
-
-        return _datetime.datetime.now()
-
-    def is_available(self):
-        """判断 Redis 或 MySQL 至少一个可用。"""
-        return self.check_redis() or self.check_mysql()
-
-    def initialize(self, redis_client=None, mysql_engine=None):
-        """启动时调用，可选注入 Redis/MySQL 客户端并检测各后端可用性。"""
-        if redis_client is not None:
-            self.redis_client = redis_client
-        if mysql_engine is not None:
-            self.mysql_engine = mysql_engine
-
-        # 重置检测缓存，确保注入新客户端后重新探测后端可用性
-        self.last_redis_check = 0
-        self.last_mysql_check = 0
-
-        redis_ok = self.check_redis()
-        mysql_ok = self.check_mysql()
-
-        if redis_ok:
-            logger.info("Redis 可用")
-        else:
-            logger.warning("Redis 不可用")
-
-        if mysql_ok:
-            logger.info("MySQL 可用")
-        else:
-            logger.warning("MySQL 不可用")
-
-    def _discover_periods(self, symbol, data_type):
-        """从 Redis 或 MySQL 发现该品种已缓存的所有周期。"""
-        if self.check_redis():
-            try:
-                pattern = f"market_data:{symbol}:*"
-                keys = self.redis_client.keys(pattern)
-                periods = set()
-                for key in keys:
-                    key_str = key.decode("utf-8") if isinstance(key, bytes) else key
-                    parts = key_str.split(":")
-                    if len(parts) == 3:
-                        periods.add(parts[2])
-                if periods:
-                    return sorted(periods)
-            except Exception as e:
-                logger.warning(f"Redis 发现周期失败 [{symbol}]: {e}")
-
-        if not self.check_mysql():
-            return []
-
-        try:
-            SessionLocal = sessionmaker(bind=self.mysql_engine)
-            with SessionLocal() as db:
-                rows = (
-                    db.query(MarketData.period)
-                    .filter_by(symbol=symbol, data_type=data_type)
-                    .distinct()
-                    .all()
-                )
-                return sorted([r.period for r in rows if r.period])
-        except Exception as e:
-            logger.warning(f"MySQL 发现周期失败 [{symbol}]: {e}")
-            return []
-
-    def _get_market_data_single_period(self, symbol, data_type, period):
-        """读取单个周期的行情数据：Redis → MySQL → None。"""
-        cache_key = f"market_data:{symbol}:{period}"
-
-        # 1. 检查 Redis 缓存
-        if self.check_redis():
-            try:
-                raw = self.redis_client.get(cache_key)
-                if raw:
-                    return json.loads(raw)
-            except Exception as e:
-                logger.warning(f"Redis 读取失败 [{cache_key}]: {e}")
-
-        # 2. Redis 未命中，检查 MySQL 可用性
-        if not self.check_mysql():
-            return None
-
-        # 3. 从 MySQL 读取
-        try:
-            SessionLocal = sessionmaker(bind=self.mysql_engine)
-            with SessionLocal() as db:
-                record = (
-                    db.query(MarketData)
-                    .filter_by(symbol=symbol, data_type=data_type, period=period)
-                    .first()
-                )
-                if not record:
-                    return None
-
-                result = {
-                    "current_price": record.current_price,
-                    "timestamp": (
-                        record.fetched_at.isoformat() if record.fetched_at else None
-                    ),
-                    "candles": (
-                        json.loads(record.candles_json) if record.candles_json else []
-                    ),
-                }
-
-                # 4. 回填 Redis（TTL 30 天）
-                if self.check_redis():
-                    try:
-                        self.redis_client.setex(
-                            cache_key,
-                            REDIS_TTL_SECONDS,
-                            json.dumps(result, ensure_ascii=False),
-                        )
-                    except Exception as e:
-                        logger.warning(f"Redis 回填失败 [{cache_key}]: {e}")
-
-                return result
-        except Exception as e:
-            logger.warning(f"MySQL 读取失败 [{cache_key}]: {e}")
-            return None
-
-    @staticmethod
-    def _parse_candle_time(candle):
-        """解析单根 K 线的时间字段，返回 naive datetime 或 None。"""
-        candle_time = candle.get("datetime") or candle.get("time")
-        if not candle_time:
-            return None
-
-        if isinstance(candle_time, str):
-            try:
-                dt = datetime.fromisoformat(candle_time.replace("Z", "+00:00"))
-                if dt.tzinfo is not None:
-                    dt = dt.replace(tzinfo=None)
-                return dt
-            except Exception:
-                return None
-
-        if hasattr(candle_time, "tzinfo") and candle_time.tzinfo is not None:
-            return candle_time.replace(tzinfo=None)
-        return candle_time
-
-    def _filter_and_truncate(self, merged, end_time, max_candles):
-        """在合并结果上按 end_time 与 max_candles 过滤/截断每个周期。"""
-        if merged is None:
-            return None
-
-        filter_end_time = end_time if end_time else datetime.now()
-        if filter_end_time.tzinfo is not None:
-            filter_end_time = filter_end_time.replace(tzinfo=None)
-
-        timeframes = {}
-        for period, candles in merged.get("timeframes", {}).items():
-            filtered = []
-            for candle in candles:
-                candle_dt = self._parse_candle_time(candle)
-                if candle_dt is None or candle_dt <= filter_end_time:
-                    filtered.append(candle)
-
-            if len(filtered) > max_candles:
-                filtered = filtered[-max_candles:]
-
-            timeframes[period] = filtered
-
-        merged["timeframes"] = timeframes
-        return merged
-
-    def _merge_period_results(self, symbol, data_type, period_results):
-        """将按周期返回的结果合并为统一格式。"""
-        timeframes = {}
-        current_price = None
-        newest = None
-
-        for period, result in period_results.items():
-            if not result:
-                continue
-            candles = result.get("candles", [])
-            timeframes[period] = candles
-            if current_price is None:
-                current_price = result.get("current_price")
-            timestamp_raw = result.get("timestamp")
-            if timestamp_raw:
-                try:
-                    timestamp_dt = datetime.fromisoformat(timestamp_raw)
-                    # 去掉时区信息，统一使用 naive datetime
-                    if timestamp_dt.tzinfo is not None:
-                        timestamp_dt = timestamp_dt.replace(tzinfo=None)
-                    if newest is None or timestamp_dt > newest:
-                        newest = timestamp_dt
-                except Exception:
-                    pass
-
-        if not timeframes:
-            return None
-
-        if newest is None:
-            newest = datetime.now()
-
-        now = datetime.now()
-        is_fresh = (now - newest).total_seconds() < CACHE_TTL_SECONDS
-
-        return {
-            "symbol": symbol,
-            "type": data_type,
-            "current_price": current_price,
-            "timestamp": newest.isoformat(),
-            "timeframes": timeframes,
-            "is_fresh": is_fresh,
-            "fetched_at": newest.isoformat(),
-        }
-
-    def get_market_data(self, symbol, data_type, periods=None, end_time=None, max_candles=100):
-        """
-        读取行情数据：Redis → MySQL → None（由调用方降级到 SQLite）。
-
-        Args:
-            symbol: 品种合约代码
-            data_type: 数据类型，如 futures
-            periods: 周期或周期列表，如 "5min" 或 ["5min", "15min"];
-                     为 None 时自动发现全部周期
-            end_time: 结束时间（可选），过滤该时间之前的 K 线
-            max_candles: 每个周期最大 K 线数量，默认 100
-
-        Returns:
-            periods 为字符串时返回旧版单周期 dict;
-            periods 为列表/None 时返回合并后的 dict（包含 timeframes）或 None
-        """
-        single_period = isinstance(periods, str)
-        query_periods = [periods] if single_period else periods
-
-        if query_periods is None:
-            query_periods = self._discover_periods(symbol, data_type)
-            if not query_periods:
-                return None
-
-        period_results = {}
-        for period in query_periods:
-            period_results[period] = self._get_market_data_single_period(
-                symbol, data_type, period
-            )
-
-        merged = self._merge_period_results(symbol, data_type, period_results)
-        if merged is None:
-            return None
-
-        merged = self._filter_and_truncate(merged, end_time, max_candles)
-
-        if single_period:
-            period = query_periods[0]
-            return {
-                "current_price": merged.get("current_price"),
-                "timestamp": merged.get("timestamp"),
-                "candles": merged["timeframes"].get(period, []),
-            }
-
-        return merged
-
-    def get_symbol_timestamp(self, symbol, data_type):
-        """
-        读取合约时间戳：Redis → MySQL → None（由调用方降级到 SQLite）。
-
-        Args:
-            symbol: 品种合约代码
-            data_type: 数据类型，如 futures
-
-        Returns:
-            dict 或 None
-        """
-        cache_key = f"symbol_timestamps:{symbol}"
-
-        # 1. 检查 Redis 缓存
-        if self.check_redis():
-            try:
-                raw = self.redis_client.get(cache_key)
-                if raw:
-                    return json.loads(raw)
-            except Exception as e:
-                logger.warning(f"Redis 读取失败 [{cache_key}]: {e}")
-
-        # 2. Redis 未命中，检查 MySQL 可用性
-        if not self.check_mysql():
-            return None
-
-        # 3. 从 MySQL 读取
-        try:
-            SessionLocal = sessionmaker(bind=self.mysql_engine)
-            with SessionLocal() as db:
-                record = (
-                    db.query(SymbolTimestamp)
-                    .filter_by(symbol=symbol, data_type=data_type)
-                    .first()
-                )
-                if not record:
-                    return None
-
-                result = {
-                    "last_refresh_at": (
-                        record.last_refresh_at.isoformat()
-                        if record.last_refresh_at
-                        else None
-                    ),
-                    "refresh_count": record.refresh_count,
-                }
-
-                # 4. 回填 Redis（TTL 30 天）
-                if self.check_redis():
-                    try:
-                        self.redis_client.setex(
-                            cache_key,
-                            REDIS_TTL_SECONDS,
-                            json.dumps(result, ensure_ascii=False),
-                        )
-                    except Exception as e:
-                        logger.warning(f"Redis 回填失败 [{cache_key}]: {e}")
-
-                return result
-        except Exception as e:
-            logger.warning(f"MySQL 读取失败 [{cache_key}]: {e}")
-            return None
-
-    def save_market_data(self, symbol, data):
-        """
-        保存行情数据：先删 Redis 缓存，再写 MySQL，MySQL 成功后回填 Redis。
-
-        Args:
-            symbol: 品种合约代码
-            data: 采集脚本返回的数据，包含 timeframes, current_price, timestamp, type
-
-        Returns:
-            bool: MySQL 写入是否成功
-        """
-        data_type = data.get("type", "futures")
-        timeframes = data.get("timeframes", {})
-        current_price = data.get("current_price")
-        fetched_at = self._parse_fetched_at(data.get("timestamp"))
-
-        cache_keys = [f"market_data:{symbol}:{period}" for period in timeframes.keys()]
-
-        # 1. 删除 Redis 缓存
-        if self.check_redis() and cache_keys:
-            try:
-                self.redis_client.delete(*cache_keys)
-            except Exception as e:
-                logger.warning(f"Redis 删除缓存失败 [{symbol}]: {e}")
-
-        # 2. 写入 MySQL（事务）
-        if not self.check_mysql():
-            logger.warning(f"MySQL 不可用，无法写入行情数据 [{symbol}]")
-            return False
-
-        try:
-            SessionLocal = sessionmaker(bind=self.mysql_engine)
-            with SessionLocal() as db:
-                try:
-                    for period, candles in timeframes.items():
-                        candles_json = json.dumps(candles, ensure_ascii=False)
-                        record = (
-                            db.query(MarketData)
-                            .filter_by(symbol=symbol, data_type=data_type, period=period)
-                            .first()
-                        )
-                        if record:
-                            record.candles_json = candles_json
-                            record.current_price = current_price
-                            record.fetched_at = fetched_at
-                            record.candle_count = len(candles)
-                        else:
-                            record = MarketData(
-                                symbol=symbol,
-                                data_type=data_type,
-                                period=period,
-                                candles_json=candles_json,
-                                current_price=current_price,
-                                fetched_at=fetched_at,
-                                candle_count=len(candles),
-                            )
-                            db.add(record)
-                    db.commit()
-                except Exception:
-                    db.rollback()
-                    raise
-        except Exception as e:
-            logger.error(f"MySQL 写入行情数据失败 [{symbol}]: {e}")
-            return False
-
-        # 3. MySQL 成功，回填 Redis（失败仅记录日志）
-        if self.check_redis():
-            for period, candles in timeframes.items():
-                cache_key = f"market_data:{symbol}:{period}"
-                cache_value = {
-                    "current_price": current_price,
-                    "timestamp": fetched_at.isoformat(),
-                    "candles": candles,
-                }
-                try:
-                    self.redis_client.setex(
-                        cache_key,
-                        REDIS_TTL_SECONDS,
-                        json.dumps(cache_value, ensure_ascii=False),
-                    )
-                except Exception as e:
-                    logger.warning(f"Redis 更新失败 [{cache_key}]: {e}")
-
-        return True
-
-    def save_symbol_timestamp(self, symbol, data_type, refresh_time):
-        """
-        保存合约时间戳：先删 Redis 缓存，再写 MySQL，MySQL 成功后回填 Redis。
-
-        Args:
-            symbol: 品种合约代码
-            data_type: 数据类型，如 futures
-            refresh_time: 刷新时间（datetime）
-
-        Returns:
-            bool: MySQL 写入是否成功
-        """
-        cache_key = f"symbol_timestamps:{symbol}"
-
-        # 1. 删除 Redis 缓存
-        if self.check_redis():
-            try:
-                self.redis_client.delete(cache_key)
-            except Exception as e:
-                logger.warning(f"Redis 删除缓存失败 [{cache_key}]: {e}")
-
-        # 2. 写入 MySQL（事务）
-        if not self.check_mysql():
-            logger.warning(f"MySQL 不可用，无法写入合约时间戳 [{symbol}]")
-            return False
-
-        try:
-            SessionLocal = sessionmaker(bind=self.mysql_engine)
-            with SessionLocal() as db:
-                try:
-                    record = (
-                        db.query(SymbolTimestamp)
-                        .filter_by(symbol=symbol, data_type=data_type)
-                        .first()
-                    )
-                    if record:
-                        record.last_refresh_at = refresh_time
-                        record.refresh_count += 1
-                    else:
-                        record = SymbolTimestamp(
-                            symbol=symbol,
-                            data_type=data_type,
-                            last_refresh_at=refresh_time,
-                            refresh_count=1,
-                        )
-                        db.add(record)
-                    db.commit()
-                except Exception:
-                    db.rollback()
-                    raise
-        except Exception as e:
-            logger.error(f"MySQL 写入合约时间戳失败 [{symbol}]: {e}")
-            return False
-
-        # 3. MySQL 成功，回填 Redis（失败仅记录日志）
-        if self.check_redis():
-            cache_value = {
-                "last_refresh_at": refresh_time.isoformat(),
-                "refresh_count": record.refresh_count,
-            }
-            try:
-                self.redis_client.setex(
-                    cache_key,
-                    REDIS_TTL_SECONDS,
-                    json.dumps(cache_value, ensure_ascii=False),
-                )
-            except Exception as e:
-                logger.warning(f"Redis 更新失败 [{cache_key}]: {e}")
-
-        return True
-
-    def save_market_data_with_timestamp(self, symbol, data, refresh_time):
-        """
-        在同一 MySQL 事务中原子写入行情数据与合约时间戳。
-
-        Redis 缓存的删除/回填在事务外进行，失败仅记录日志，不影响 MySQL 写入。
-
-        Args:
-            symbol: 品种合约代码
-            data: 采集脚本返回的数据，包含 timeframes, current_price, timestamp, type
-            refresh_time: 刷新时间（datetime）
-
-        Returns:
-            bool: MySQL 写入是否成功
-        """
-        data_type = data.get("type", "futures")
-        timeframes = data.get("timeframes", {})
-        current_price = data.get("current_price")
-        fetched_at = self._parse_fetched_at(data.get("timestamp"))
-
-        market_cache_keys = [
-            f"market_data:{symbol}:{period}" for period in timeframes.keys()
-        ]
-        timestamp_cache_key = f"symbol_timestamps:{symbol}"
-        cache_keys = market_cache_keys + [timestamp_cache_key]
-
-        # 1. 删除 Redis 缓存
-        if self.check_redis() and cache_keys:
-            try:
-                self.redis_client.delete(*cache_keys)
-            except Exception as e:
-                logger.warning(f"Redis 删除缓存失败 [{symbol}]: {e}")
-
-        # 2. 写入 MySQL（同一事务）
-        if not self.check_mysql():
-            logger.warning(f"MySQL 不可用，无法写入行情数据与时间戳 [{symbol}]")
-            return False
-
-        try:
-            SessionLocal = sessionmaker(bind=self.mysql_engine)
-            with SessionLocal() as db:
-                try:
-                    for period, candles in timeframes.items():
-                        candles_json = json.dumps(candles, ensure_ascii=False)
-                        record = (
-                            db.query(MarketData)
-                            .filter_by(symbol=symbol, data_type=data_type, period=period)
-                            .first()
-                        )
-                        if record:
-                            record.candles_json = candles_json
-                            record.current_price = current_price
-                            record.fetched_at = fetched_at
-                            record.candle_count = len(candles)
-                        else:
-                            record = MarketData(
-                                symbol=symbol,
-                                data_type=data_type,
-                                period=period,
-                                candles_json=candles_json,
-                                current_price=current_price,
-                                fetched_at=fetched_at,
-                                candle_count=len(candles),
-                            )
-                            db.add(record)
-
-                    timestamp_record = (
-                        db.query(SymbolTimestamp)
-                        .filter_by(symbol=symbol, data_type=data_type)
-                        .first()
-                    )
-                    if timestamp_record:
-                        timestamp_record.last_refresh_at = refresh_time
-                        timestamp_record.refresh_count += 1
-                        refresh_count = timestamp_record.refresh_count
-                    else:
-                        timestamp_record = SymbolTimestamp(
-                            symbol=symbol,
-                            data_type=data_type,
-                            last_refresh_at=refresh_time,
-                            refresh_count=1,
-                        )
-                        db.add(timestamp_record)
-                        refresh_count = 1
-
-                    db.commit()
-                except Exception:
-                    db.rollback()
-                    raise
-        except Exception as e:
-            logger.error(f"MySQL 写入行情数据与时间戳失败 [{symbol}]: {e}")
-            return False
-
-        # 3. MySQL 成功，回填 Redis（失败仅记录日志）
-        if self.check_redis():
-            for period, candles in timeframes.items():
-                cache_key = f"market_data:{symbol}:{period}"
-                cache_value = {
-                    "current_price": current_price,
-                    "timestamp": fetched_at.isoformat(),
-                    "candles": candles,
-                }
-                try:
-                    self.redis_client.setex(
-                        cache_key,
-                        REDIS_TTL_SECONDS,
-                        json.dumps(cache_value, ensure_ascii=False),
-                    )
-                except Exception as e:
-                    logger.warning(f"Redis 更新失败 [{cache_key}]: {e}")
-
-            timestamp_cache_value = {
-                "last_refresh_at": refresh_time.isoformat(),
-                "refresh_count": refresh_count,
-            }
-            try:
-                self.redis_client.setex(
-                    timestamp_cache_key,
-                    REDIS_TTL_SECONDS,
-                    json.dumps(timestamp_cache_value, ensure_ascii=False),
-                )
-            except Exception as e:
-                logger.warning(f"Redis 更新失败 [{timestamp_cache_key}]: {e}")
-
-        return True
-
-    def delete_cache(self, symbol, periods):
-        """
-        批量删除 Redis 行情数据缓存键。
-
-        Args:
-            symbol: 品种合约代码
-            periods: 周期列表，如 ["5min", "15min"]
-        """
-        if not self.check_redis():
-            return
-
-        cache_keys = [f"market_data:{symbol}:{period}" for period in periods]
-        if not cache_keys:
-            return
-
-        try:
-            self.redis_client.delete(*cache_keys)
-        except Exception as e:
-            logger.warning(f"Redis 批量删除缓存失败 [{symbol}]: {e}")
-
-    def cache_get(self, key):
-        """
-        通用 Redis 缓存读取。
-
-        Args:
-            key: 缓存键
-
-        Returns:
-            反序列化后的值，或 None
-        """
-        if not self.check_redis():
-            return None
-
-        try:
-            raw = self.redis_client.get(key)
-            if raw:
-                return json.loads(raw)
-        except Exception as e:
-            logger.warning(f"Redis 读取失败 [{key}]: {e}")
-
-        return None
-
-    def cache_set(self, key, value, ttl=None):
-        """
-        通用 Redis 缓存写入。
-
-        Args:
-            key: 缓存键
-            value: 缓存值（可 JSON 序列化）
-            ttl: 过期时间（秒），默认 REDIS_TTL_SECONDS
-
-        Returns:
-            bool: 是否成功
-        """
-        if not self.check_redis():
-            return False
-
-        if ttl is None:
-            ttl = REDIS_TTL_SECONDS
-
-        try:
-            self.redis_client.setex(
-                key, ttl, json.dumps(value, ensure_ascii=False, default=str)
-            )
-            return True
-        except Exception as e:
-            logger.warning(f"Redis 写入失败 [{key}]: {e}")
-            return False
-
-    def cache_delete(self, key):
-        """
-        通用 Redis 缓存删除。
-
-        Args:
-            key: 缓存键
-        """
-        if not self.check_redis():
-            return
-
-        try:
-            self.redis_client.delete(key)
-        except Exception as e:
-            logger.warning(f"Redis 删除失败 [{key}]: {e}")
-
-
-_storage_manager = None
-
-
-def get_storage_manager():
-    """获取全局 StorageManager 单例。"""
-    global _storage_manager
-    if _storage_manager is None:
-        _storage_manager = StorageManager()
-    return _storage_manager

docker-compose.yml

@@ -15,19 +15,6 @@ services:
       - BUFFER_LOG_LEVEL=INFO
       - MAX_WORKERS=2
       - TZ=Asia/Shanghai
-      - REDIS_HOST=redis
-      - REDIS_PORT=6379
-      - REDIS_DB=0
-      - REDIS_PASSWORD=${REDIS_PASSWORD:-}
-      - REDIS_TTL_SECONDS=${REDIS_TTL_SECONDS:-2592000}
-      - MYSQL_HOST=mysql
-      - MYSQL_PORT=3306
-      - MYSQL_USER=root
-      - MYSQL_PASSWORD=${MYSQL_PASSWORD:-buffer123}
-      - MYSQL_DATABASE=${MYSQL_DATABASE:-buffer_platform}
-    depends_on:
-      - redis
-      - mysql
     volumes:
       # 数据持久化 - SQLite数据库
       - ./data:/app/data
@@ -44,35 +31,6 @@ services:
     networks:
       - futures-network
 
-  redis:
-    image: redis:7-alpine
-    container_name: futures-redis
-    restart: unless-stopped
-    ports:
-      - "6379:6379"
-    volumes:
-      - redis-data:/data
-    networks:
-      - futures-network
-
-  mysql:
-    image: mysql:8.0
-    container_name: futures-mysql
-    restart: unless-stopped
-    environment:
-      MYSQL_ROOT_PASSWORD: ${MYSQL_PASSWORD:-buffer123}
-      MYSQL_DATABASE: ${MYSQL_DATABASE:-buffer_platform}
-    ports:
-      - "3306:3306"
-    volumes:
-      - mysql-data:/var/lib/mysql
-    networks:
-      - futures-network
-
 networks:
   futures-network:
     driver: bridge
-
-volumes:
-  redis-data:
-  mysql-data:

docs/superpowers/plans/2026-07-04-analysis-storage-refactor.md

@@ -1,102 +0,0 @@
----
-change: analysis-storage-refactor
-design-doc: docs/superpowers/specs/2026-07-04-analysis-storage-refactor-design.md
-base-ref: 82de2f9
-archived-with: 2026-07-04-analysis-storage-refactor
----
-
-# Analysis Storage Refactor - 实施计划
-
-> 基于 [Design Doc](docs/superpowers/specs/2026-07-04-analysis-storage-refactor-design.md) 拆分的可执行任务。
-> 目标：将 `futures_analysis.db`（14 张表）迁移到 MySQL，并引入 Redis 缓存层，与行情数据存储策略保持一致。
-
----
-
-## 任务总览
-
-| # | 任务 | 依赖 |
-|---|------|------|
-| T1 | 扩展 StorageManager 通用缓存方法 | - |
-| T2 | 创建 analysis_migration.py 迁移脚本 | T1 |
-| T3 | 修改 analysis_db.py 支持 MySQL/SQLite 动态切换 | T1 |
-| T4 | 在 main.py lifespan 中集成迁移和表初始化 | T2, T3 |
-| T5 | 编写测试用例 | T1-T4 |
-
----
-
-## T1: 扩展 StorageManager 通用缓存方法
-
-**文件**: `app/storage_manager.py`
-
-**任务**:
-1. 新增 `cache_get(key)` 方法
-2. 新增 `cache_set(key, value, ttl)` 方法
-3. 新增 `cache_delete(key)` 方法
-
-**验收**:
-- 方法支持 Redis 命中/未命中
-- 缓存 TTL 可配置
-- 通用方法不依赖具体业务
-
----
-
-## T2: 创建 analysis_migration.py 迁移脚本
-
-**文件**: `app/analysis_migration.py`
-
-**任务**:
-1. 实现 `migrate_analysis_sqlite_to_mysql()` 函数
-2. 检测 MySQL analysis 表是否已有数据
-3. 从 SQLite 读取全部数据
-4. 批量写入 MySQL
-5. 记录迁移日志
-
-**验收**:
-- 幂等性：MySQL 有数据时跳过迁移
-- 迁移失败不影响应用启动
-
----
-
-## T3: 修改 analysis_db.py 使用 StorageManager
-
-**文件**: `app/analysis_db.py`
-
-**任务**:
-1. 修改 `get_analysis_db()` 使用 StorageManager
-2. 实现 MySQL 不可用时降级到 SQLite
-3. 保持 API 接口不变
-
-**验收**:
-- API 调用透明切换存储后端
-- 降级时功能正常
-
----
-
-## T4: 在 main.py lifespan 中集成
-
-**文件**: `app/main.py`
-
-**任务**:
-1. 在 lifespan 中创建 analysis 表（MySQL）
-2. 调用迁移函数
-3. 记录启动日志
-
-**验收**:
-- 启动时自动创建 14 张表
-- 自动迁移 SQLite 数据
-
----
-
-## T5: 编写测试用例
-
-**文件**: `tests/test_analysis_storage.py`
-
-**任务**:
-1. 测试 Redis 缓存命中场景
-2. 测试 Redis 缓存未命中回源 MySQL
-3. 测试 MySQL 不可用降级到 SQLite
-4. 测试数据迁移完整性
-
-**验收**:
-- 所有测试通过
-- 覆盖三级降级场景

docs/superpowers/plans/2026-07-04-config-to-mysql.md

@@ -1,129 +0,0 @@
----
-change: config-to-mysql
-design-doc: docs/superpowers/specs/2026-07-04-config-to-mysql-design.md
-base-ref: 4956086
-archived-with: config-to-mysql
----
-
-# Config to MySQL - 实施计划
-
-> 基于 [Design Doc](docs/superpowers/specs/2026-07-04-config-to-mysql-design.md) 拆分的可执行任务。
-> 目标：将 `symbols_config.json` 和 `ai_config.json` 迁移到 MySQL，保留 JSON 文件作为 fallback。
-
----
-
-## 任务总览
-
-| # | 任务 | 依赖 |
-|---|------|------|
-| T1 | 新增 AppConfig 模型和 ConfigStore | - |
-| T2 | 创建 config_migration.py 迁移脚本 | T1 |
-| T3 | 在 main.py lifespan 中集成 | T1, T2 |
-| T4 | 修改配置 API | T1 |
-| T5 | 修改业务使用方 | T1 |
-| T6 | 编写测试用例 | T1-T5 |
-
----
-
-## T1: 新增 AppConfig 模型和 ConfigStore
-
-**文件**:
-- `app/models.py`
-- `app/config_store.py`
-
-**任务**:
-1. 在 `app/models.py` 中新增 `AppConfig` 模型
-2. 创建 `app/config_store.py` 和 `ConfigStore` 类
-3. 实现 `get_config(key, fallback)`
-4. 实现 `set_config(key, value)`
-5. 实现 `load_from_json(key, fallback)` 和 `save_to_json(key, value)`
-6. 实现 `get_config_store()` 单例函数
-
-**验收**:
-- `ConfigStore` 支持 MySQL 命中、未命中回填、JSON fallback
-- `set_config` 始终写入 JSON，MySQL 可用时同时写入数据库
-
----
-
-## T2: 创建 config_migration.py 迁移脚本
-
-**文件**: `app/config_migration.py`
-
-**任务**:
-1. 定义配置映射（key → file path → default）
-2. 实现 `migrate_configs_to_mysql()`
-3. 检测数据库是否已有配置
-4. 从 JSON 读取并写入 MySQL
-
-**验收**:
-- 幂等性：数据库已有数据时跳过
-- 缺失配置时从 JSON 迁移
-
----
-
-## T3: 在 main.py lifespan 中集成
-
-**文件**: `app/main.py`
-
-**任务**:
-1. 在 MySQL 初始化后创建 `app_config` 表
-2. 调用 `migrate_configs_to_mysql()`
-3. 记录迁移日志
-
-**验收**:
-- 启动时自动创建配置表
-- 自动迁移 JSON 配置
-
----
-
-## T4: 修改配置 API
-
-**文件**:
-- `app/api/config.py`
-- `app/api/ai_config.py`
-
-**任务**:
-1. `config.py` 的 `get_config` 和 `upload_config` 使用 `ConfigStore`
-2. `ai_config.py` 的 `_load_ai_config` 和 `_save_ai_config` 使用 `ConfigStore`
-3. 保持 API 接口签名不变
-
-**验收**:
-- 上传配置同时写入数据库和 JSON 文件
-- 读取配置优先从数据库
-
----
-
-## T5: 修改业务使用方
-
-**文件**:
-- `app/api/futures_analysis.py`
-- `app/api/trade_review.py`
-- `app/services/trade_parser.py`
-- `app/services/plan_generator.py`
-- `app/services/ai_analysis.py`
-
-**任务**:
-1. 替换所有 `_load_symbols_config()` / `load_symbols_config()` 为 `ConfigStore.get_config("symbols")`
-2. 替换 `_load_ai_config()` 为 `ConfigStore.get_config("ai")`
-
-**验收**:
-- 所有读取点统一使用 `ConfigStore`
-- 不修改业务逻辑
-
----
-
-## T6: 编写测试用例
-
-**文件**: `tests/test_config_store.py`
-
-**任务**:
-1. 测试 MySQL 命中场景
-2. 测试 MySQL 未命中时读取 JSON 并回填
-3. 测试 MySQL 不可用时读取 JSON
-4. 测试 `set_config` 双写
-5. 测试迁移幂等性
-6. 运行全部测试套件确保无回归
-
-**验收**:
-- 所有测试通过
-- 测试覆盖核心降级场景

docs/superpowers/plans/2026-07-04-storage-cache-refactor.md

@@ -1,448 +0,0 @@
----
-change: storage-cache-refactor
-design-doc: docs/superpowers/specs/2026-07-04-storage-cache-refactor-design.md
-base-ref: 8b5e43f4915cef786208a8132460f87b8b191765
-archived-with: 2026-07-04-storage-cache-refactor
----
-
-# Storage Cache Refactor - 实施计划
-
-> 基于 [Design Doc](docs/superpowers/specs/2026-07-04-storage-cache-refactor-design.md) 拆分的可执行任务。
-> 目标：引入 Redis（缓存）+ MySQL（持久化）+ SQLite（兜底）三级存储架构，改造现有 cache.py 内部封装 StorageManager，API 层零改动。
-
----
-
-## 任务总览
-
-| # | 任务 | 预估 | 依赖 |
-|---|------|------|------|
-| T1 | 添加 redis/pymysql 依赖 | 5min | - |
-| T2 | config.py 新增 Redis/MySQL 配置项 | 10min | - |
-| T3 | docker-compose.yml 新增 Redis/MySQL 服务 | 10min | T2 |
-| T4 | 创建 app/mysql_database.py | 20min | T2 |
-| T5 | 创建 app/redis_client.py | 20min | T2 |
-| T6 | lifespan 中初始化 Redis/MySQL 连接 | 15min | T4, T5 |
-| T7 | MySQL 表结构初始化（复用 ORM 模型） | 15min | T4, T6 |
-| T8 | 创建 app/storage_manager.py 骨架 + 降级检测 | 30min | T4, T5, T6 |
-| T9 | StorageManager 读取逻辑（Redis → MySQL → SQLite） | 30min | T8 |
-| T10 | StorageManager 写入逻辑 + 双写一致性 | 30min | T8 |
-| T11 | 创建数据迁移脚本 app/migration.py | 25min | T4, T7 |
-| T12 | 启动时自动触发迁移 | 10min | T11 |
-| T13 | 改造 cache.py 内部封装 StorageManager | 30min | T9, T10 |
-| T14 | 验证：Redis 缓存命中/未命中场景 | 15min | T13 |
-| T15 | 验证：降级到 MySQL / SQLite 场景 | 15min | T13 |
-| T16 | 验证：双写一致性 + 数据迁移完整性 | 15min | T13 |
-
----
-
-## 详细任务
-
-### T1: 添加 redis/pymysql 依赖
-
-**文件**: `requirements.txt`
-
-**操作**:
-- 在 `requirements.txt` 末尾追加：
-  ```
-  redis>=5.0.0
-  pymysql>=1.1.0
-  cryptography>=42.0.0
-  ```
-- `cryptography` 是 PyMySQL 启用加密连接所需的可选依赖
-
-**验证**: `pip install -r requirements.txt` 成功安装无报错
-
----
-
-### T2: config.py 新增 Redis/MySQL 配置项
-
-**文件**: `app/config.py`
-
-**操作**:
-- 在现有配置末尾新增以下配置块（参考 Design Doc §7.1）：
-  ```python
-  # Redis 配置
-  REDIS_HOST = os.getenv("REDIS_HOST", "localhost")
-  REDIS_PORT = int(os.getenv("REDIS_PORT", "6379"))
-  REDIS_DB = int(os.getenv("REDIS_DB", "0"))
-  REDIS_PASSWORD = os.getenv("REDIS_PASSWORD", "")
-  REDIS_TTL_SECONDS = int(os.getenv("REDIS_TTL_SECONDS", "2592000"))  # 30 天
-
-  # MySQL 配置
-  MYSQL_HOST = os.getenv("MYSQL_HOST", "localhost")
-  MYSQL_PORT = int(os.getenv("MYSQL_PORT", "3306"))
-  MYSQL_USER = os.getenv("MYSQL_USER", "root")
-  MYSQL_PASSWORD = os.getenv("MYSQL_PASSWORD", "")
-  MYSQL_DATABASE = os.getenv("MYSQL_DATABASE", "buffer_platform")
-  ```
-
-**验证**: `from app.config import REDIS_HOST, MYSQL_HOST` 无报错，默认值正确
-
----
-
-### T3: docker-compose.yml 新增 Redis/MySQL 服务
-
-**文件**: `docker-compose.yml`
-
-**操作**:
-- 在 `services` 下新增 `redis` 和 `mysql` 服务（参考 Design Doc §7.2）：
-  ```yaml
-  redis:
-    image: redis:7-alpine
-    container_name: futures-redis
-    restart: unless-stopped
-    ports:
-      - "6379:6379"
-    volumes:
-      - redis-data:/data
-    networks:
-      - futures-network
-
-  mysql:
-    image: mysql:8.0
-    container_name: futures-mysql
-    restart: unless-stopped
-    environment:
-      MYSQL_ROOT_PASSWORD: ${MYSQL_PASSWORD:-buffer123}
-      MYSQL_DATABASE: ${MYSQL_DATABASE:-buffer_platform}
-    ports:
-      - "3306:3306"
-    volumes:
-      - mysql-data:/var/lib/mysql
-    networks:
-      - futures-network
-  ```
-- 在顶层新增 `volumes` 声明：
-  ```yaml
-  volumes:
-    redis-data:
-    mysql-data:
-  ```
-- 在 `buffer-platform` 的 `environment` 中新增 Redis/MySQL 环境变量传递
-
-**验证**: `docker-compose config` 解析无语法错误
-
----
-
-### T4: 创建 app/mysql_database.py
-
-**文件**: `app/mysql_database.py`（新建）
-
-**操作**:
-- 创建 MySQL 连接引擎和 SessionLocal，参考现有 `app/database.py` 的结构：
-  ```python
-  from sqlalchemy import create_engine, text
-  from sqlalchemy.orm import sessionmaker
-  from app.config import MYSQL_HOST, MYSQL_PORT, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DATABASE
-
-  mysql_engine = None
-  MySQLSessionLocal = None
-
-  def init_mysql():
-      """初始化 MySQL 连接引擎，失败时返回 None"""
-      global mysql_engine, MySQLSessionLocal
-      try:
-          url = f"mysql+pymysql://{MYSQL_USER}:{MYSQL_PASSWORD}@{MYSQL_HOST}:{MYSQL_PORT}/{MYSQL_DATABASE}?charset=utf8mb4"
-          mysql_engine = create_engine(url, pool_pre_ping=True, pool_recycle=3600)
-          with mysql_engine.connect() as conn:
-              conn.execute(text("SELECT 1"))
-          MySQLSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=mysql_engine)
-          return mysql_engine
-      except Exception as e:
-          logger.warning(f"MySQL 初始化失败: {e}")
-          mysql_engine = None
-          MySQLSessionLocal = None
-          return None
-
-  def get_mysql_session():
-      """获取 MySQL 会话"""
-      if MySQLSessionLocal is None:
-          raise RuntimeError("MySQL 未初始化")
-      return MySQLSessionLocal()
-  ```
-
-**验证**: 手动调用 `init_mysql()`，在无 MySQL 环境下返回 `None` 不抛异常
-
----
-
-### T5: 创建 app/redis_client.py
-
-**文件**: `app/redis_client.py`（新建）
-
-**操作**:
-- 封装 Redis 连接池和客户端：
-  ```python
-  import redis
-  from app.config import REDIS_HOST, REDIS_PORT, REDIS_DB, REDIS_PASSWORD
-
-  redis_client = None
-
-  def init_redis():
-      """初始化 Redis 客户端，失败时返回 None"""
-      global redis_client
-      try:
-          redis_client = redis.Redis(
-              host=REDIS_HOST, port=REDIS_PORT, db=REDIS_DB,
-              password=REDIS_PASSWORD or None,
-              decode_responses=True,
-              socket_connect_timeout=5,
-          )
-          redis_client.ping()
-          return redis_client
-      except Exception as e:
-          logger.warning(f"Redis 初始化失败: {e}")
-          redis_client = None
-          return None
-
-  def get_redis():
-      """获取 Redis 客户端实例"""
-      return redis_client
-  ```
-
-**验证**: 手动调用 `init_redis()`，在无 Redis 环境下返回 `None` 不抛异常
-
----
-
-### T6: lifespan 中初始化 Redis/MySQL 连接
-
-**文件**: `app/main.py`
-
-**操作**:
-- 在 `lifespan` 函数中，`Base.metadata.create_all` 之后新增：
-  ```python
-  # 初始化 Redis 和 MySQL
-  from app.redis_client import init_redis
-  from app.mysql_database import init_mysql
-
-  redis_ok = init_redis() is not None
-  mysql_ok = init_mysql() is not None
-
-  if redis_ok and mysql_ok:
-      logger.info("存储模式: Redis + MySQL")
-  elif mysql_ok:
-      logger.warning("存储模式: MySQL (Redis 不可用)")
-  else:
-      logger.error("存储模式: SQLite (Redis 和 MySQL 均不可用)")
-  ```
-
-**验证**: 应用启动日志中输出存储模式信息，无 Redis/MySQL 时降级提示正常
-
----
-
-### T7: MySQL 表结构初始化（复用 ORM 模型）
-
-**文件**: `app/main.py`（修改 lifespan）
-
-**操作**:
-- 在 T6 初始化代码之后，如果 MySQL 可用，使用现有 ORM 模型创建表：
-  ```python
-  if mysql_ok:
-      from app.mysql_database import mysql_engine
-      from app.models import Base as MarketBase
-      # 在 MySQL 中创建行情相关表
-      MarketBase.metadata.create_all(bind=mysql_engine)
-      logger.info("MySQL 表结构初始化完成")
-  ```
-- 注意：只需创建 `market_data` 和 `symbol_timestamps` 两张表，`scheduled_tasks` 等低频表仍留在 SQLite
-
-**验证**: MySQL 中可查到 `market_data` 和 `symbol_timestamps` 表结构
-
----
-
-### T8: 创建 app/storage_manager.py 骨架 + 降级检测
-
-**文件**: `app/storage_manager.py`（新建）
-
-**操作**:
-- 实现 `StorageManager` 类骨架，包含：
-  - `__init__`: 持有 redis_client / mysql_engine 引用，初始化降级状态标志
-  - `check_redis()` / `check_mysql()`: 惰性恢复检测（30 秒间隔，参考 Design Doc §4.1）
-  - `is_available()`: 判断 Redis 或 MySQL 至少一个可用
-  - `initialize()`: 启动时调用，检测各后端可用性并输出日志
-  - 全局单例 `get_storage_manager()` 工厂函数
-- 本任务只实现骨架和降级检测，不包含具体读写逻辑
-
-**验证**: 实例化 `StorageManager` 后，`check_redis()` / `check_mysql()` 在无服务环境下返回 `False`
-
----
-
-### T9: StorageManager 读取逻辑（Redis → MySQL → SQLite）
-
-**文件**: `app/storage_manager.py`（续写）
-
-**操作**:
-- 实现 `get_market_data(symbol, data_type, periods)` 方法：
-  1. 检查 Redis 缓存（key 格式：`market_data:{symbol}:{period}`，参考 Design Doc §2.1）
-  2. Redis 命中 → 反序列化 JSON 返回
-  3. Redis 未命中 → 检查 MySQL 可用性
-  4. MySQL 可用 → 从 MySQL 读取 → 回填 Redis（TTL 30 天）→ 返回
-  5. MySQL 不可用 → 返回 `None`（由调用方降级到 SQLite）
-- 实现 `get_symbol_timestamp(symbol, data_type)` 方法：
-  - 类似逻辑，key 格式：`symbol_timestamps:{symbol}`
-
-**验证**: 单元测试或手动测试：
-- 无 Redis/MySQL 时返回 `None`
-- 有 MySQL 时从 MySQL 读取并回填 Redis
-
----
-
-### T10: StorageManager 写入逻辑 + 双写一致性
-
-**文件**: `app/storage_manager.py`（续写）
-
-**操作**:
-- 实现 `save_market_data(symbol, data)` 方法（参考 Design Doc §3.2）：
-  1. 删除 Redis 缓存（`market_data:{symbol}:{period}`）
-  2. 写入 MySQL（事务）
-  3. MySQL 成功 → 更新 Redis 缓存
-  4. MySQL 失败 → 记录日志，返回 False（不更新 Redis）
-  5. Redis 更新失败 → 仅记录日志，不影响返回
-- 实现 `save_symbol_timestamp(symbol, data_type, refresh_time)` 方法：
-  - 类似双写逻辑
-- 实现 `delete_cache(symbol, periods)` 方法：
-  - 批量删除 Redis 缓存键
-
-**验证**: 
-- MySQL 写入成功 → Redis 缓存同步更新
-- MySQL 写入失败 → Redis 不更新，返回 False
-- Redis 更新失败 → 不影响 MySQL 写入结果
-
----
-
-### T11: 创建数据迁移脚本 app/migration.py
-
-**文件**: `app/migration.py`（新建）
-
-**操作**:
-- 实现 `migrate_sqlite_to_mysql()` 函数（参考 Design Doc §6.1）：
-  1. 创建 SQLite 引擎（复用 `DB_PATH`）
-  2. 检查 MySQL `market_data` 表是否为空
-  3. 为空时从 SQLite 读取全部 `market_data` 记录
-  4. 批量写入 MySQL
-  5. 同样迁移 `symbol_timestamps` 表
-  6. 输出迁移记录数日志
-- 幂等设计：MySQL 已有数据时跳过
-
-**验证**: 
-- MySQL 表为空时，迁移成功，数据条数一致
-- MySQL 表非空时，跳过迁移，日志提示
-
----
-
-### T12: 启动时自动触发迁移
-
-**文件**: `app/main.py`（修改 lifespan）
-
-**操作**:
-- 在 T7 表结构初始化之后新增：
-  ```python
-  if mysql_ok:
-      from app.migration import migrate_sqlite_to_mysql
-      migrate_sqlite_to_mysql()
-  ```
-
-**验证**: 首次启动时日志输出迁移信息，再次启动时跳过迁移
-
----
-
-### T13: 改造 cache.py 内部封装 StorageManager
-
-**文件**: `app/services/cache.py`（修改）
-
-**操作**:
-- 改造 `save_market_data()` 函数（参考 Design Doc §5.1）：
-  - 优先调用 `storage.save_market_data(symbol, data)` 双写
-  - 失败时降级到现有 SQLite 写入逻辑 `_save_to_sqlite()`
-- 改造 `get_cached_data()` 函数：
-  - 优先调用 `storage.get_market_data(symbol, data_type, periods)` 读取
-  - 返回 `None` 时降级到现有 SQLite 读取逻辑 `_get_from_sqlite()`
-- 改造 `update_symbol_timestamp()` 和 `get_symbol_timestamp()`：
-  - 类似封装，优先走 StorageManager
-- 保持所有函数的外部签名不变，API 层零改动
-- 现有 SQLite 逻辑提取为内部 `_save_to_sqlite()` / `_get_from_sqlite()` 私有函数
-
-**验证**:
-- 现有 API 接口 `/api/v1/data/latest/{symbol}` 返回数据格式不变
-- 现有 API 接口 `/api/v1/data/batch-fetch` 行为不变
-- 无 Redis/MySQL 时完全降级到 SQLite，行为与改造前一致
-
----
-
-### T14: 验证 - Redis 缓存命中/未命中场景
-
-**操作**:
-- 启动 Redis + MySQL 服务
-- 调用刷新接口写入数据
-- 调用读取接口，验证首次从 MySQL 读取并回填 Redis
-- 再次调用读取接口，验证从 Redis 缓存命中（检查日志）
-- 等待 TTL 过期或手动删除 Redis key，验证回源 MySQL
-
-**验证标准**:
-- 日志中可见 "Redis 缓存命中" / "Redis 未命中，从 MySQL 读取" 信息
-- 返回数据格式正确
-
----
-
-### T15: 验证 - 降级到 MySQL / SQLite 场景
-
-**操作**:
-- 停止 Redis 服务，调用读取接口
-- 验证自动降级到 MySQL，日志输出 "Redis 不可用"
-- 停止 Redis + MySQL 服务，调用读取接口
-- 验证降级到 SQLite，日志输出 "存储模式: SQLite"
-- 恢复 Redis 服务，等待 30 秒后验证自动恢复
-
-**验证标准**:
-- 各降级场景下接口正常返回，无 500 错误
-- 日志清晰标识当前存储模式
-
----
-
-### T16: 验证 - 双写一致性 + 数据迁移完整性
-
-**操作**:
-- 双写一致性：
-  1. 调用刷新接口写入数据
-  2. 分别查询 MySQL 和 Redis，验证数据一致
-  3. 模拟 Redis 写入失败（停止 Redis），验证 MySQL 数据不受影响
-- 数据迁移完整性：
-  1. 清空 MySQL 表
-  2. 重启应用触发迁移
-  3. 对比 SQLite 和 MySQL 数据条数一致
-
-**验证标准**:
-- MySQL 和 Redis 中数据内容一致
-- Redis 故障不影响 MySQL 持久化
-- 迁移前后数据条数一致
-
----
-
-## 依赖关系图
-
-```
-T1 (依赖)  ──┐
-T2 (配置)  ──┼── T3 (docker-compose)
-             ├── T4 (mysql_database.py)
-             └── T5 (redis_client.py)
-                    │
-T4 + T5 ─────── T6 (lifespan 初始化)
-                    │
-                 T7 (MySQL 建表)
-                    │
-                 T8 (StorageManager 骨架)
-                   ╱ ╲
-              T9      T10 (读/写逻辑)
-                 ╲   ╱
-                 T13 (cache.py 改造)
-                   ╱ │ ╲
-              T14  T15  T16 (验证)
-
-T4 + T7 ──── T11 (迁移脚本) ──── T12 (启动迁移)
-```
-
-## 关键约束
-
-1. **API 层零改动**: `app/api/data.py` 不修改，所有变更封装在 `cache.py` 和 `storage_manager.py` 内部
-2. **SQLite 保留**: 不删除 SQLite 相关代码，作为最终兜底
-3. **幂等迁移**: 数据迁移脚本可重复执行，MySQL 有数据时跳过
-4. **渐进式降级**: 无 Redis/MySQL 时系统行为与改造前完全一致

docs/superpowers/reports/2026-07-04-analysis-storage-refactor-verify.md

@@ -1,20 +0,0 @@
-# 验证报告: analysis-storage-refactor
-
-## 代码审查
-
-| 级别 | 问题 | 状态 |
-|------|------|------|
-| CRITICAL | 迁移写入使用 `db.expunge(record)` 会导致 `InvalidRequestError` | 已修复，改用 `make_transient` |
-| CRITICAL | `get_analysis_db()` 在 MySQL Session 创建失败时抛出 `UnboundLocalError` | 已修复，增加异常降级 |
-| IMPORTANT | 启动流程中 MySQL 初始化/迁移未做错误隔离 | 部分接受：`get_analysis_db` 已增加降级；lifespan 中 `init_analysis_mysql` 依赖 MySQL 可用性判断，异常会被顶层捕获 |
-| IMPORTANT | 测试覆盖补充 | 已补充 MySQL Session 创建失败降级测试 |
-
-## 分支处理
-
-- 分支：`feature/20260704/analysis-storage-refactor`
-- 处理方式：合并到当前分支（refactor3.0）
-- 合并后提交：`2797447`
-
-## 结论
-
-验证通过，可以归档。

docs/superpowers/reports/2026-07-04-config-to-mysql-verify.md

@@ -1,66 +0,0 @@
-# Config to MySQL - 验证报告
-
-- **Change**: config-to-mysql
-- **日期**: 2026-07-04
-- **验证人**: AI Agent
-- **分支**: feature/20260704/config-to-mysql
-
-## 验证项
-
-| # | 检查项 | 结果 | 证据 |
-|---|--------|------|------|
-| 1 | tasks.md 全部完成 | ✅ | 所有 18 个子任务已勾选 |
-| 2 | 实现符合 Design Doc | ✅ | 单表 `app_config`、统一 `ConfigStore`、JSON fallback |
-| 3 | 实现符合 proposal | ✅ | symbols + ai 配置迁移到 MySQL，保留 JSON fallback |
-| 4 | 测试通过 | ✅ | `python -m pytest tests/` 110 passed, 2 xfailed |
-| 5 | 新增测试覆盖核心场景 | ✅ | `tests/test_config_store.py` 8 个用例覆盖命中/未命中/降级/迁移 |
-| 6 | 无硬编码密钥 | ✅ | 代码审查未发现 |
-| 7 | 无 SQL 注入风险 | ✅ | 使用 SQLAlchemy ORM 参数化查询 |
-
-## 代码审查
-
-**审查方式**: general_purpose_task 子代理审查
-
-### 已修复问题
-
-| 级别 | 问题 | 修复方式 |
-|------|------|----------|
-| CRITICAL | MySQL 写入失败时 JSON 已更新但 MySQL 仍为旧值 | `set_config` 改为先写 MySQL，成功后再写 JSON；失败返回 False 并保留 JSON 旧值 |
-| IMPORTANT | JSON 文件直接覆盖写入 | 使用临时文件 + `replace` 原子写入 |
-| IMPORTANT | JSON 损坏时回填 MySQL 默认值 | 新增 `_load_json_from_file`，损坏时返回 None，get_config 使用 fallback 但不回填 |
-| IMPORTANT | `_save_to_mysql` 返回 False 时未处理 | `set_config` 检查 `_save_to_mysql` 返回值 |
-| MINOR | 多处未使用导入/变量 | 已清理 |
-
-### 接受的风险
-
-| 级别 | 问题 | 接受原因 |
-|------|------|----------|
-| IMPORTANT | AI 配置中的 `api_key` 以明文存入 MySQL JSON 字段 | 超出本次 change 范围；JSON 文件原本也是明文存储，风险未扩大；建议后续单独 change 增加加密或敏感字段隔离 |
-
-## 分支处理
-
-- [ ] 本地合并到主分支
-- [ ] 推送并创建 PR
-- [ ] 保持分支
-- [ ] 丢弃工作
-
-## 结论
-
-### 重新验证发现的问题
-
-**问题**: 应用启动时配置迁移被跳过，MySQL app_config 表为空。
-
-**根因**: `app.mysql_database.MySQLSessionLocal` 在 `init_mysql()` 执行前被 `app.config_store` 模块通过 `from app.mysql_database import MySQLSessionLocal` 导入，捕获了初始值 `None`。后续 `init_mysql()` 重新赋值模块变量后，`app.config_store` 中的名称仍指向 `None`，导致 `ConfigStore` 无法获取有效的 MySQL session，迁移被跳过。
-
-**修复**:
-- `app/config_store.py`: 改为通过 `sys.modules` 动态读取 `app.mysql_database.MySQLSessionLocal`，始终获取最新值
-- `app/config_migration.py`: 使用 `store.session_maker` 检查 MySQL session 是否初始化
-
-**修复验证**:
-- 清理 app_config 表后启动应用，日志显示成功迁移 symbols 和 ai 配置
-- 数据库查询确认 `symbols` 配置包含 38 个品种（与 JSON 文件一致）
-- 全部测试套件 110 passed, 2 xfailed
-
-## 结论
-
-验证通过。实现符合设计，测试覆盖核心场景，代码审查和手动验证发现的问题均已修复。

docs/superpowers/reports/2026-07-04-storage-cache-refactor-verify.md

@@ -1,197 +0,0 @@
-# Verification Report: storage-cache-refactor
-
-## Summary
-
-| 维度         | 状态                                          |
-|--------------|-----------------------------------------------|
-| 完整性 (Completeness) | 20/20 任务已勾选，14/14 需求已实现 |
-| 正确性 (Correctness)  | 14/14 需求有测试覆盖，8 个测试文件   |
-| 一致性 (Coherence)    | 遵循设计决策，双写顺序正确，API 层零改动 |
-
----
-
-## 1. 完整性验证 (Completeness)
-
-### 1.1 tasks.md 任务勾选状态
-
-全部 20 个任务均已勾选 `[x]`，覆盖 7 个分组：
-
-| 分组               | 任务数 | 状态 |
-|--------------------|--------|------|
-| 1. 依赖与配置      | 3      | 全部完成 |
-| 2. 数据库模型与初始化 | 4    | 全部完成 |
-| 3. 数据迁移         | 2    | 全部完成 |
-| 4. 存储管理层       | 5    | 全部完成 |
-| 5. 双写与缓存一致性 | 3    | 全部完成 |
-| 6. 接口改造         | 3    | 全部完成 |
-| 7. 测试与验证       | 6    | 全部完成 |
-
-### 1.2 Delta Spec 需求实现映射
-
-**redis-cache-layer (4 需求)**
-
-| 需求                   | 实现文件                          | 实现状态 |
-|------------------------|-----------------------------------|----------|
-| Redis 缓存连接管理     | `app/redis_client.py`             | ✅ 已实现 |
-| 行情数据缓存读取       | `app/storage_manager.py` L147-200 | ✅ 已实现 |
-| Redis 缓存 TTL 管理    | `app/config.py` L43 (REDIS_TTL_SECONDS=2592000) | ✅ 已实现 |
-| Redis 缓存失效         | `app/storage_manager.py` L413-420 (save_market_data), L578-583 (save_market_data_with_timestamp) | ✅ 已实现 |
-
-**mysql-persistence (4 需求)**
-
-| 需求                   | 实现文件                          | 实现状态 |
-|------------------------|-----------------------------------|----------|
-| MySQL 连接管理         | `app/mysql_database.py`           | ✅ 已实现 |
-| 行情数据持久化存储     | `app/storage_manager.py` L427-460 | ✅ 已实现 |
-| MySQL 表结构迁移       | `app/migration.py`                | ✅ 已实现 |
-| MySQL 事务支持         | `app/storage_manager.py` L430-457 (commit/rollback) | ✅ 已实现 |
-
-**storage-fallback (3 需求)**
-
-| 需求                   | 实现文件                          | 实现状态 |
-|------------------------|-----------------------------------|----------|
-| 三级降级策略           | `app/storage_manager.py` L32-87 + `app/services/cache.py` 各函数 | ✅ 已实现 |
-| 降级状态检测           | `app/storage_manager.py` L32-67 (惰性检测 30s 间隔) | ✅ 已实现 |
-| 降级恢复               | `app/storage_manager.py` L32-67 (超过 check_interval 后重新探测) | ✅ 已实现 |
-
-**dual-write-consistency (3 需求)**
-
-| 需求                   | 实现文件                          | 实现状态 |
-|------------------------|-----------------------------------|----------|
-| 刷新接口双写           | `app/storage_manager.py` L553-676 (save_market_data_with_timestamp) | ✅ 已实现 |
-| 双写顺序保证           | `app/storage_manager.py` L578-661 (先删 Redis → 写 MySQL → 回填 Redis) | ✅ 已实现 |
-| 缓存回填一致性         | `app/storage_manager.py` L186-195 (回填 TTL 30 天) | ✅ 已实现 |
-
----
-
-## 2. 正确性验证 (Correctness)
-
-### 2.1 测试覆盖矩阵
-
-| 场景                       | 测试文件                                       | 覆盖状态 |
-|----------------------------|------------------------------------------------|----------|
-| Redis 缓存命中             | `test_redis_cache_scenarios.py` TestRedisCacheHitMiss | ✅ 已覆盖 |
-| Redis 缓存未命中回源 MySQL | `test_redis_cache_scenarios.py` TestRedisCacheHitMiss | ✅ 已覆盖 |
-| Redis 不可用降级到 MySQL   | `test_fallback_scenarios.py` TestStorageManagerFallback, TestApiFallbackResponses | ✅ 已覆盖 |
-| Redis+MySQL 均不可用降级到 SQLite | `test_fallback_scenarios.py` TestApiFallbackResponses | ✅ 已覆盖 |
-| 双写一致性                 | `test_dual_write_and_migration.py` TestDualWriteConsistency, `test_storage_manager.py` TestStorageManagerWriteLogic | ✅ 已覆盖 |
-| 迁移完整性                 | `test_migration.py` TestMigrateSqliteToMysql, `test_dual_write_and_migration.py` TestMigrationIntegrity | ✅ 已覆盖 |
-| 惰性恢复检测               | `test_storage_manager.py` TestStorageManagerSkeleton, `test_fallback_scenarios.py` TestStorageManagerFallback | ✅ 已覆盖 |
-| MySQL 失败回滚             | `test_storage_manager.py` TestStorageManagerWriteLogic | ✅ 已覆盖 |
-| Redis 失败不影响持久化     | `test_dual_write_and_migration.py` TestDualWriteConsistency | ✅ 已覆盖 |
-| 启动时降级日志             | `test_main_lifespan.py`, `test_fallback_scenarios.py` TestLifespanFallbackLogs | ✅ 已覆盖 |
-| API 层零改动               | `app/api/data.py` 中无 storage_manager/redis/mysql 引用 | ✅ 已确认 |
-
-### 2.2 测试文件清单
-
-| 测试文件                              | 测试类/函数数 | 描述 |
-|---------------------------------------|---------------|------|
-| `test_storage_manager.py`             | 5 类 ~25 测试 | StorageManager 骨架、读取、写入、配置、原子写入 |
-| `test_redis_cache_scenarios.py`       | 4 类 ~8 测试  | Redis 缓存命中/未命中场景（含 FakeRedis 集成测试） |
-| `test_fallback_scenarios.py`          | 3 类 ~6 测试  | 降级场景（含 API 层 TestClient 集成测试） |
-| `test_dual_write_and_migration.py`    | 2 类 ~5 测试  | 双写一致性 + 端到端迁移验证 |
-| `test_migration.py`                   | 1 类 ~3 测试  | SQLite→MySQL 迁移脚本单元测试 |
-| `test_cache_storage_integration.py`   | 5 类 ~20 测试 | cache.py 与 StorageManager 集成降级测试 |
-| `test_mysql_database.py`              | 1 测试         | MySQL 密码 URL 编码验证 |
-| `test_main_lifespan.py`               | ~8 测试        | lifespan 初始化、存储模式、迁移触发 |
-
----
-
-## 3. 一致性验证 (Coherence)
-
-### 3.1 架构决策遵循情况
-
-| 设计决策                    | 实现情况 | 验证详情 |
-|-----------------------------|----------|----------|
-| Redis + MySQL + SQLite 三级架构 | ✅ 遵循 | `StorageManager` 封装三级逻辑，`cache.py` 各函数先尝试 StorageManager 再降级 SQLite |
-| StorageManager 抽象层       | ✅ 遵循 | `app/storage_manager.py` 提供统一接口，`cache.py` 通过 `get_storage_manager()` 调用 |
-| 双写顺序：先删 Redis → 写 MySQL → 回填 Redis | ✅ 遵循 | `save_market_data_with_timestamp` L578-661 实现正确 |
-| TTL 30 天                   | ✅ 遵循 | `REDIS_TTL_SECONDS = 2592000` 在 `config.py` 中配置，所有 `setex` 调用使用该值 |
-| 惰性恢复（30 秒间隔）       | ✅ 遵循 | `check_interval=30` 默认值，`check_redis`/`check_mysql` 实现惰性检测 |
-| 启动时检测可用性            | ✅ 遵循 | `main.py` lifespan 中调用 `init_redis()`/`init_mysql()` 并注入 StorageManager |
-| API 层零改动                | ✅ 遵循 | `app/api/data.py` 仅引用 `app.services.cache` 函数，无任何 storage 相关引用 |
-| 数据迁移幂等                | ✅ 遵循 | `migrate_sqlite_to_mysql()` 检查 MySQL 表是否已有数据，有则跳过 |
-
-### 3.2 双写顺序验证
-
-`save_market_data_with_timestamp` (L553-676) 执行顺序：
-
-1. **L578-583**: 删除 Redis 缓存（`market_data:{symbol}:{period}` + `symbol_timestamps:{symbol}`）
-2. **L590-643**: 写入 MySQL（同一事务写入 MarketData + SymbolTimestamp），失败则 rollback 并返回 False
-3. **L645-674**: MySQL 成功后回填 Redis（失败仅记录 warning 日志，不影响返回值）
-
-此顺序与设计文档 §3.2 写入流程图完全一致，属于标准 Cache-Aside 更新模式。
-
-### 3.3 三级降级路径验证
-
-| 路径 | 触发条件 | 实现位置 | 行为 |
-|------|----------|----------|------|
-| 正常模式 | Redis + MySQL 均可用 | `StorageManager.get_market_data` | Redis → MySQL → 回填 Redis |
-| Redis 降级 | Redis 不可用，MySQL 可用 | `StorageManager.check_redis()` 返回 False | 直接 MySQL 读取/写入 |
-| SQLite 降级 | Redis + MySQL 均不可用 | `cache.py` 各函数 try/except 块 | 降级到 `_get_from_sqlite` / `_save_to_sqlite` |
-
----
-
-## 4. 安全检查
-
-| 检查项                   | 状态 | 详情 |
-|--------------------------|------|------|
-| 无硬编码密钥             | ✅ 通过 | Redis/MySQL 密码均通过 `os.getenv()` 读取，默认值为空字符串 |
-| MySQL 密码 URL 编码      | ✅ 通过 | `mysql_database.py` L20: `urllib.parse.quote_plus(MYSQL_PASSWORD)` |
-| 无 unsafe/eval/exec 操作 | ✅ 通过 | 全项目 grep 无匹配 |
-| 无敏感信息泄露           | ✅ 通过 | 日志中仅记录连接状态，不输出密码/连接串 |
-| docker-compose 密码      | ⚠️ 注意 | 使用 `${MYSQL_PASSWORD:-buffer123}` 作为默认值，仅用于开发环境，可接受 |
-
----
-
-## 5. Issues
-
-### CRITICAL
-
-无。
-
-### WARNING
-
-无。
-
-### SUGGESTION
-
-1. **xfail 测试标记**：`test_redis_cache_scenarios.py` 中有 2 个 `@pytest.mark.xfail(strict=True)` 测试（`test_cache_hit_logs_redis_hit` 和 `test_cache_miss_logs_redis_miss_and_mysql_read`），验证的是"Redis 缓存命中/未命中"日志输出。当前 StorageManager 未输出这些特定日志消息，因此测试被标记为预期失败。这不影响功能正确性，但建议在后续迭代中补充这些日志或移除 xfail 测试。
-
-2. **docker-compose 默认密码**：`MYSQL_PASSWORD` 默认值为 `buffer123`，仅适用于开发环境。生产部署时应通过环境变量或 secrets 管理工具设置强密码。此问题属于部署配置范畴，不影响本次 change 的验证结果。
-
----
-
-## 6. 热修复记录
-
-### 2026-07-04 时区 bug 修复
-
-**问题**: 手动验证时发现，点击"刷新全部"后前端无数据显示。
-
-**根因**: `storage_manager.py` 第 263 行 `datetime.fromisoformat()` 解析时间戳时保留了时区信息（`+08:00`），但第 276 行 `datetime.now()` 返回 naive datetime，两者相减导致 `TypeError: can't subtract offset-naive and offset-aware datetimes`。
-
-**修复**: 在 `_merge_period_results` 中解析时间戳后去掉时区信息：
-```python
-timestamp_dt = datetime.fromisoformat(timestamp_raw)
-if timestamp_dt.tzinfo is not None:
-    timestamp_dt = timestamp_dt.replace(tzinfo=None)
-```
-
-**提交**: `98567a3` - fix: 修复时区不匹配导致行情数据读取失败
-
-**验证**: 修复后手动验证通过，MySQL 190 条记录、Redis 190 个键正常读写。
-
----
-
-## 7. 最终评估
-
-**通过 ✅**
-
-storage-cache-refactor change 的实现完整覆盖了所有 OpenSpec 产物中定义的需求：
-
-- **完整性**：20/20 任务完成，14/14 需求有对应实现代码
-- **正确性**：8 个测试文件覆盖全部 spec scenario，包括 Redis 缓存命中/未命中、三级降级、双写一致性、迁移完整性、惰性恢复检测
-- **一致性**：实现严格遵循 Design Doc 中的架构决策，三级降级策略正确，双写顺序正确（先删 Redis → 写 MySQL → 回填 Redis），API 层零改动已确认
-- **安全性**：无硬编码密钥，MySQL 密码已 URL 编码，无 unsafe 操作
-
-建议归档此 change。

docs/superpowers/specs/2026-07-04-analysis-storage-refactor-design.md

@@ -1,196 +0,0 @@
----
-comet_change: analysis-storage-refactor
-role: technical-design
-canonical_spec: openspec
-archived-with: 2026-07-04-analysis-storage-refactor
-status: final
----
-
-# Analysis Storage Refactor - Technical Design
-
-## 1. 架构概览
-
-### 1.1 目标架构
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│                     应用层                                   │
-│  app/api/futures_analysis.py  ←→  app/services/cache.py     │
-│                                         ↓                   │
-│                                   StorageManager            │
-│                                   (storage_manager.py)      │
-└─────────────────────────────────────────────────────────────┘
-                              ↓
-        ┌─────────────────────┼─────────────────────┐
-        ↓                     ↓                     ↓
-   ┌─────────┐          ┌─────────┐          ┌─────────┐
-   │  Redis  │          │  MySQL  │          │ SQLite  │
-   │ (缓存)  │          │(持久化) │          │ (兜底)  │
-   └─────────┘          └─────────┘          └─────────┘
-```
-
-### 1.2 核心组件
-
-| 组件 | 职责 |
-|------|------|
-| `StorageManager` | 提供通用 Redis 缓存方法（`cache_get`、`cache_set`、`cache_delete`） |
-| `analysis_db.py` | Analysis 数据库连接管理，根据后端可用性返回 MySQL 或 SQLite Session |
-| `analysis_models.py` | ORM 模型定义（不变） |
-| `analysis_migration.py` | SQLite → MySQL 数据迁移 |
-
-### 1.3 表清单
-
-| 表名 | 用途 | 缓存 TTL |
-|------|------|----------|
-| `futures_analysis` | 期货分析报告 | 5 分钟 |
-| `watched_symbols` | 用户关注品种 | 10 分钟 |
-| `ai_model_configs` | AI 模型配置 | 10 分钟 |
-| `analysis_settings` | 分析设置 | 10 分钟 |
-| `ai_analysis_cache` | AI 分析缓存 | 5 分钟 |
-| `review_dates` | 复盘日期 | 1 小时 |
-| `symbol_rankings` | 品种排名 | 1 小时 |
-| `trading_plans` | 交易计划 | 1 小时 |
-| `symbol_scores_v2` | V2 品种评分 | 1 小时 |
-| `trading_plans_v2` | V2 交易计划 | 1 小时 |
-| `sector_heat` | 板块热度 | 1 小时 |
-| `review_plans_v2` | V2 复盘计划 | 1 小时 |
-| `trade_records` | 交易记录 | 不缓存 |
-| `trade_import_batches` | 交易导入批次 | 不缓存 |
-
-## 2. 降级策略
-
-### 2.1 数据库 Session 切换
-
-`analysis_db.py` 中的 `get_analysis_db()` 根据后端可用性返回不同 Session：
-
-```
-业务代码 → get_analysis_db()
-              ↓
-        MySQL 可用？
-        ↓ 是              ↓ 否
-    MySQL Session    SQLite Session
-```
-
-### 2.2 Redis 缓存层（可选）
-
-对于高频读取场景，业务代码可通过 `StorageManager.cache_get/cache_set/cache_delete` 使用 Redis：
-
-```
-读取请求
-    ↓
-StorageManager.cache_get(key)
-    ↓ 命中
-返回数据
-    ↓ 未命中
-ORM 查询 MySQL/SQLite → StorageManager.cache_set(key, value) → 返回
-```
-
-### 2.3 降级状态检测
-
-- 复用 `StorageManager.check_mysql()` 惰性检测 MySQL 可用性
-- MySQL 不可用时，`get_analysis_db()` 返回 SQLite Session
-- 保留 SQLite 文件 `data/futures_analysis.db` 作为兜底
-
-## 3. 数据迁移
-
-### 3.1 迁移时机
-
-应用启动时（`lifespan`），在 MySQL 表结构初始化后执行。
-
-### 3.2 迁移逻辑
-
-```python
-def migrate_analysis_sqlite_to_mysql():
-    """将 SQLite analysis 数据迁移到 MySQL"""
-    # 1. 检测 MySQL 表是否已有数据
-    mysql_count = count_mysql_analysis_tables()
-    if mysql_count > 0:
-        logger.info("MySQL analysis 表已有数据，跳过迁移")
-        return
-    
-    # 2. 从 SQLite 读取数据
-    sqlite_data = read_sqlite_analysis_data()
-    
-    # 3. 批量写入 MySQL
-    write_mysql_analysis_data(sqlite_data)
-    
-    logger.info("Analysis 数据迁移完成")
-```
-
-### 3.3 幂等性
-
-- 检测 MySQL 表是否已有数据
-- 有数据则跳过迁移
-- 迁移失败不影响应用启动
-
-## 4. 缓存策略
-
-### 4.1 通用缓存方法
-
-`StorageManager` 提供三个通用方法：
-
-- `cache_get(key)`: 读取 Redis 缓存
-- `cache_set(key, value, ttl)`: 写入 Redis 缓存
-- `cache_delete(key)`: 删除 Redis 缓存
-
-### 4.2 缓存键设计
-
-由业务代码决定缓存键，推荐格式：
-
-```
-analysis:{table_name}:{id}
-analysis:{table_name}:list:{query_hash}
-```
-
-### 4.3 缓存失效
-
-- 写入时删除相关缓存
-- TTL 过期自动失效
-
-### 4.4 缓存回填
-
-- 读取时未命中，查询 MySQL/SQLite 后回填
-- TTL 与表类型对应
-
-## 5. 兼容性
-
-### 5.1 ORM 模型
-
-- 保持不变
-- 使用 `AnalysisBase` 作为基类
-
-### 5.2 API 接口
-
-- 保持不变
-- 通过 `get_analysis_db()` 依赖注入
-
-### 5.3 SQLite 文件
-
-- 保留 `data/futures_analysis.db`
-- 降级时使用
-
-## 6. 测试策略
-
-### 6.1 单元测试
-
-| 场景 | 测试方法 |
-|------|----------|
-| Redis 缓存命中 | Mock Redis，验证不查询 MySQL |
-| Redis 缓存未命中 | Mock Redis 返回 None，验证查询 MySQL |
-| MySQL 降级到 SQLite | Mock MySQL 不可用，验证查询 SQLite |
-| 数据迁移 | 验证 SQLite 数据完整迁移到 MySQL |
-
-### 6.2 集成测试
-
-- 启动应用，验证 MySQL 表创建
-- 执行迁移，验证数据完整性
-- 调用 API，验证功能正常
-
-## 7. 风险与缓解
-
-| 风险 | 缓解措施 |
-|------|----------|
-| 数据迁移失败 | 保留 SQLite 作为降级方案，迁移失败时自动降级 |
-| Redis 缓存不一致 | 写入时先删缓存，再写 MySQL，最后回填缓存 |
-| 表结构不兼容 | 复用现有 ORM 模型，MySQL 自动创建表结构 |
-| 性能下降 | Redis 缓存减少 MySQL 查询压力 |

docs/superpowers/specs/2026-07-04-config-to-mysql-design.md

@@ -1,189 +0,0 @@
----
-comet_change: config-to-mysql
-role: technical-design
-canonical_spec: openspec
-archived-with: config-to-mysql
-status: final
----
-
-# Config to MySQL - Technical Design
-
-## 1. 架构概览
-
-### 1.1 目标架构
-
-```
-业务代码 / API
-    ↓
-app/config_store.py  (统一入口)
-    ↓
-MySQL 可用？
-    ↓ 是              ↓ 否
-读/写 app_config   读/写 JSON 文件
-```
-
-### 1.2 核心组件
-
-| 组件 | 职责 |
-|------|------|
-| `AppConfig` 模型 | MySQL 配置表 ORM 映射 |
-| `ConfigStore` | 统一配置读写入口，封装降级逻辑 |
-| `config_migration.py` | JSON → MySQL 一次性迁移 |
-| JSON 文件 | MySQL 不可用时降级使用 |
-
-## 2. 数据模型
-
-### 2.1 AppConfig 表
-
-```python
-class AppConfig(Base):
-    __tablename__ = "app_config"
-
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    config_key = Column(String(64), unique=True, nullable=False, index=True)
-    config_value = Column(JSON, nullable=False)
-    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
-    created_at = Column(DateTime, default=datetime.utcnow)
-```
-
-### 2.2 配置键
-
-| config_key | 对应文件 | 默认值 |
-|------------|----------|--------|
-| `symbols` | `config/symbols_config.json` | `{"futures": {}, "stock": {}}` |
-| `ai` | `config/ai_config.json` | `{"models": [], "active_model": None, "analysis_settings": {...}}` |
-
-## 3. 降级策略
-
-### 3.1 读取流程
-
-1. 检查 MySQL 可用性（复用 `StorageManager.check_mysql()`）
-2. MySQL 可用：
-   - 查询 `app_config`
-   - 命中则返回
-   - 未命中则读取 JSON 文件并回填数据库
-3. MySQL 不可用：
-   - 直接读取 JSON 文件
-
-### 3.2 写入流程
-
-1. 检查 MySQL 可用性
-2. MySQL 可用时先写入 `app_config`；失败时保留 JSON 旧值并返回 False
-3. MySQL 写入成功后，再原子写入 JSON 文件
-4. MySQL 不可用时只写入 JSON 文件
-
-### 3.3 降级检测
-
-复用 `StorageManager.check_mysql()` 惰性检测，避免每次配置读写都尝试连接数据库。
-
-## 4. ConfigStore 接口
-
-```python
-class ConfigStore:
-    def get_config(self, key: str, fallback: Optional[dict] = None) -> dict: ...
-    def set_config(self, key: str, value: dict) -> bool: ...
-    def load_from_json(self, key: str, fallback: Optional[dict] = None) -> dict: ...
-    def save_to_json(self, key: str, value: dict) -> None: ...
-```
-
-### 4.1 单例获取
-
-```python
-_config_store = None
-
-def get_config_store() -> ConfigStore:
-    global _config_store
-    if _config_store is None:
-        _config_store = ConfigStore()
-    return _config_store
-```
-
-## 5. 数据迁移
-
-### 5.1 迁移时机
-
-应用启动时（`lifespan`），在 MySQL 表结构初始化后执行。
-
-### 5.2 迁移逻辑
-
-```python
-def migrate_configs_to_mysql():
-    for key, file_path, default in CONFIGS:
-        if _config_exists_in_mysql(key):
-            continue
-        value = _load_json(file_path, default)
-        _save_to_mysql(key, value)
-```
-
-### 5.3 幂等性
-
-- 检测 `app_config` 是否已有对应 key
-- 有则跳过
-
-## 6. 使用方修改
-
-### 6.1 品种配置读取
-
-替换以下文件中的 `_load_symbols_config()` / `load_symbols_config()`：
-
-- `app/api/config.py`
-- `app/api/futures_analysis.py`
-- `app/api/trade_review.py`
-- `app/services/trade_parser.py`
-- `app/services/plan_generator.py`
-
-统一使用：
-
-```python
-from app.config_store import get_config_store
-
-symbols = get_config_store().get_config("symbols", {"futures": {}, "stock": {}})
-```
-
-### 6.2 AI 配置读取
-
-替换 `app/api/ai_config.py` 和 `app/services/ai_analysis.py` 中的 `_load_ai_config()`：
-
-```python
-ai_config = get_config_store().get_config("ai", {...default...})
-```
-
-### 6.3 写入接口
-
-`app/api/config.py` 和 `app/api/ai_config.py` 的保存接口改为：
-
-```python
-get_config_store().set_config("symbols", data)
-```
-
-## 7. 兼容性
-
-- 保持 JSON 文件路径和 schema 不变
-- API 接口签名不变
-- 默认值与现有 JSON 默认值一致
-
-## 8. 测试策略
-
-### 8.1 单元测试
-
-| 场景 | 测试 |
-|------|------|
-| MySQL 命中 | `get_config` 从数据库返回值 |
-| MySQL 未命中 | `get_config` 读取 JSON 并回填 |
-| MySQL 不可用 | `get_config` 读取 JSON |
-| 写入 | `set_config` 双写数据库和文件 |
-| 迁移幂等 | 数据库已有数据时跳过 |
-
-### 8.2 集成测试
-
-- 启动应用验证配置表创建
-- 验证 API 读写正常
-- 运行全部测试套件确保无回归
-
-## 9. 风险与缓解
-
-| 风险 | 缓解措施 |
-|------|----------|
-| MySQL 不可用时配置无法写入数据库 | 始终同步写入 JSON 文件 |
-| 多处修改引入回归 | 统一 `ConfigStore` 接口 + 全面测试 |
-| JSON 文件与数据库不一致 | 写入时双写；读取时优先数据库 |

docs/superpowers/specs/2026-07-04-storage-cache-refactor-design.md

@@ -1,369 +0,0 @@
----
-comet_change: storage-cache-refactor
-role: technical-design
-canonical_spec: openspec
-archived-with: 2026-07-04-storage-cache-refactor
-status: final
----
-
-# Storage Cache Refactor - Technical Design
-
-## 1. 架构概览
-
-### 1.1 目标架构
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│                     应用层                                   │
-│  app/api/data.py  ←→  app/services/cache.py                │
-│                              ↓                              │
-│                    StorageManager                            │
-│                    (storage_manager.py)                      │
-└─────────────────────────────────────────────────────────────┘
-                              ↓
-        ┌─────────────────────┼─────────────────────┐
-        ↓                     ↓                     ↓
-   ┌─────────┐          ┌─────────┐          ┌─────────┐
-   │  Redis  │          │  MySQL  │          │ SQLite  │
-   │ (缓存)  │          │(持久化) │          │ (兜底)  │
-   └─────────┘          └─────────┘          └─────────┘
-```
-
-### 1.2 核心组件
-
-| 组件 | 文件 | 职责 |
-|------|------|------|
-| StorageManager | `app/storage_manager.py` | 封装三级存储逻辑，提供统一接口 |
-| RedisClient | `app/redis_client.py` | Redis 连接池和客户端封装 |
-| MySQLDatabase | `app/mysql_database.py` | MySQL 引擎和 SessionLocal |
-| cache.py | `app/services/cache.py` | 保持现有函数签名，内部调用 StorageManager |
-
-## 2. Redis 数据结构
-
-### 2.1 行情数据缓存
-
-```
-Key: market_data:{symbol}:{period}
-Value: JSON {
-  "current_price": 123.45,
-  "timestamp": "2026-07-04T10:00:00",
-  "candles": [
-    {"datetime": "...", "open": ..., "high": ..., "low": ..., "close": ...}
-  ]
-}
-TTL: 30 天 (2592000 秒)
-```
-
-### 2.2 合约时间戳缓存
-
-```
-Key: symbol_timestamps:{symbol}
-Value: JSON {
-  "last_refresh_at": "2026-07-04T10:00:00",
-  "refresh_count": 42
-}
-TTL: 30 天 (2592000 秒)
-```
-
-### 2.3 设计理由
-
-- 结构化键值存储，便于按品种和周期精确查询
-- JSON 格式与当前 SQLite 存储格式兼容，迁移成本低
-- TTL 自动清理，避免内存无限增长
-
-## 3. 数据流设计
-
-### 3.1 读取流程
-
-```
-请求行情数据
-    ↓
-检查 Redis 缓存
-    ├─ 命中 → 返回数据
-    └─ 未命中 → 检查 MySQL 可用性
-                ├─ 可用 → 读取 MySQL → 回填 Redis (TTL 30天) → 返回
-                └─ 不可用 → 读取 SQLite → 返回
-```
-
-### 3.2 写入流程（刷新接口）
-
-```
-刷新行情数据
-    ↓
-删除 Redis 缓存 (market_data:{symbol}:{period})
-    ↓
-写入 MySQL（事务）
-    ├─ 成功 → 更新 Redis 缓存 → 返回成功
-    └─ 失败 → 返回错误（不更新 Redis）
-```
-
-### 3.3 降级流程
-
-```
-StorageManager 检查存储后端可用性
-    ↓
-Redis 可用？
-    ├─ 是 → 使用 Redis 缓存
-    └─ 否 → MySQL 可用？
-            ├─ 是 → 使用 MySQL 持久化
-            └─ 否 → 使用 SQLite 兜底
-```
-
-## 4. 降级检测机制
-
-### 4.1 惰性恢复策略
-
-```python
-class StorageManager:
-    def __init__(self):
-        self.redis_available = False
-        self.mysql_available = False
-        self.last_redis_check = 0
-        self.last_mysql_check = 0
-        self.check_interval = 30  # 秒
-    
-    def check_redis(self):
-        """检查 Redis 可用性，30秒内不重复检测"""
-        now = time.time()
-        if now - self.last_redis_check < self.check_interval:
-            return self.redis_available
-        
-        try:
-            self.redis_client.ping()
-            self.redis_available = True
-            logger.info("Redis 连接恢复")
-        except Exception as e:
-            self.redis_available = False
-            logger.warning(f"Redis 不可用: {e}")
-        
-        self.last_redis_check = now
-        return self.redis_available
-    
-    def check_mysql(self):
-        """检查 MySQL 可用性，30秒内不重复检测"""
-        now = time.time()
-        if now - self.last_mysql_check < self.check_interval:
-            return self.mysql_available
-        
-        try:
-            with self.mysql_engine.connect() as conn:
-                conn.execute(text("SELECT 1"))
-            self.mysql_available = True
-            logger.info("MySQL 连接恢复")
-        except Exception as e:
-            self.mysql_available = False
-            logger.warning(f"MySQL 不可用: {e}")
-        
-        self.last_mysql_check = now
-        return self.mysql_available
-```
-
-### 4.2 启动时初始化
-
-```python
-# app/main.py lifespan
-storage_manager = StorageManager()
-storage_manager.initialize()
-
-# 检测可用性
-redis_ok = storage_manager.check_redis()
-mysql_ok = storage_manager.check_mysql()
-
-if redis_ok and mysql_ok:
-    logger.info("存储模式: Redis + MySQL")
-elif mysql_ok:
-    logger.warning("存储模式: MySQL (Redis 不可用)")
-else:
-    logger.error("存储模式: SQLite (Redis 和 MySQL 均不可用)")
-```
-
-## 5. 集成方式
-
-### 5.1 cache.py 内部封装
-
-```python
-# app/services/cache.py
-
-def get_cached_data(db, symbol, data_type, periods, end_time=None, max_candles=100):
-    """从缓存中获取完整的多周期数据"""
-    storage = get_storage_manager()
-    
-    # 优先从 Redis/MySQL 读取
-    if storage.is_available():
-        try:
-            result = storage.get_market_data(symbol, data_type, periods)
-            if result:
-                return result
-        except Exception as e:
-            logger.warning(f"StorageManager 读取失败，降级到 SQLite: {e}")
-    
-    # 降级到 SQLite
-    return _get_from_sqlite(db, symbol, data_type, periods, end_time, max_candles)
-
-
-def save_market_data(db, symbol, data):
-    """保存采集结果到缓存"""
-    storage = get_storage_manager()
-    
-    # 优先写入 Redis/MySQL
-    if storage.is_available():
-        try:
-            storage.save_market_data(symbol, data)
-            return
-        except Exception as e:
-            logger.warning(f"StorageManager 写入失败，降级到 SQLite: {e}")
-    
-    # 降级到 SQLite
-    _save_to_sqlite(db, symbol, data)
-```
-
-### 5.2 API 层零改动
-
-- `app/api/data.py` 保持不变
-- 所有接口仍使用 `db: Session = Depends(get_db)`
-- cache.py 内部自动选择存储后端
-
-## 6. 数据迁移
-
-### 6.1 迁移策略
-
-```python
-# app/migration.py
-
-def migrate_sqlite_to_mysql():
-    """从 SQLite 迁移历史数据到 MySQL"""
-    sqlite_engine = create_engine(f"sqlite:///{DB_PATH}")
-    mysql_engine = create_mysql_engine()
-    
-    # 检查 MySQL 表是否为空
-    with mysql_engine.connect() as conn:
-        result = conn.execute(text("SELECT COUNT(*) FROM market_data"))
-        count = result.scalar()
-        
-        if count > 0:
-            logger.info("MySQL 已有数据，跳过迁移")
-            return
-    
-    # 从 SQLite 读取数据
-    with sqlite_engine.connect() as conn:
-        result = conn.execute(text("SELECT * FROM market_data"))
-        rows = result.fetchall()
-    
-    # 写入 MySQL
-    with mysql_engine.begin() as conn:
-        for row in rows:
-            conn.execute(
-                text("INSERT INTO market_data ..."),
-                {...}
-            )
-    
-    logger.info(f"数据迁移完成，共迁移 {len(rows)} 条记录")
-```
-
-### 6.2 迁移触发时机
-
-- 应用启动时自动检测
-- MySQL 表为空时触发迁移
-- 迁移完成后输出日志
-
-## 7. 配置项
-
-### 7.1 新增配置
-
-```python
-# app/config.py
-
-# Redis 配置
-REDIS_HOST = os.getenv("REDIS_HOST", "localhost")
-REDIS_PORT = int(os.getenv("REDIS_PORT", "6379"))
-REDIS_DB = int(os.getenv("REDIS_DB", "0"))
-REDIS_PASSWORD = os.getenv("REDIS_PASSWORD", "")
-REDIS_TTL_SECONDS = int(os.getenv("REDIS_TTL_SECONDS", "2592000"))  # 30 天
-
-# MySQL 配置
-MYSQL_HOST = os.getenv("MYSQL_HOST", "localhost")
-MYSQL_PORT = int(os.getenv("MYSQL_PORT", "3306"))
-MYSQL_USER = os.getenv("MYSQL_USER", "root")
-MYSQL_PASSWORD = os.getenv("MYSQL_PASSWORD", "")
-MYSQL_DATABASE = os.getenv("MYSQL_DATABASE", "buffer_platform")
-```
-
-### 7.2 docker-compose.yml 新增服务
-
-```yaml
-services:
-  redis:
-    image: redis:7-alpine
-    ports:
-      - "6379:6379"
-    volumes:
-      - redis-data:/data
-  
-  mysql:
-    image: mysql:8.0
-    environment:
-      MYSQL_ROOT_PASSWORD: ${MYSQL_PASSWORD}
-      MYSQL_DATABASE: ${MYSQL_DATABASE}
-    ports:
-      - "3306:3306"
-    volumes:
-      - mysql-data:/var/lib/mysql
-```
-
-## 8. 测试策略
-
-### 8.1 单元测试
-
-- StorageManager 各方法独立测试
-- Redis 缓存命中/未命中场景
-- MySQL 读写场景
-- 降级逻辑场景
-
-### 8.2 集成测试
-
-- Redis + MySQL 正常模式
-- Redis 不可用降级到 MySQL
-- Redis + MySQL 均不可用降级到 SQLite
-- 刷新接口双写一致性
-
-### 8.3 故障注入
-
-- 模拟 Redis 服务停止
-- 模拟 MySQL 服务停止
-- 验证降级和恢复逻辑
-
-### 8.4 性能测试
-
-- 对比改造前后读取延迟
-- 验证 Redis 缓存命中率
-- 监控 MySQL 查询性能
-
-## 9. 风险与缓解
-
-| 风险 | 影响 | 缓解措施 |
-|------|------|---------|
-| Redis 内存占用过高 | 系统内存不足 | TTL 30 天自动清理，监控内存使用 |
-| 双写一致性 | MySQL 成功但 Redis 失败 | Redis 失败仅记录日志，不影响持久化 |
-| 降级检测延迟 | 恢复不及时 | 30 秒惰性恢复阈值，平衡性能和实时性 |
-| 数据迁移失败 | 历史数据丢失 | 保留 SQLite 兜底，可手动回滚 |
-| MySQL 部署复杂度 | 运维成本增加 | docker-compose 一键部署 |
-
-## 10. 实施计划
-
-### 10.1 阶段划分
-
-1. **依赖与配置**: 添加 redis、pymysql 依赖，新增配置项
-2. **数据库模型**: 创建 Redis/MySQL 连接模块
-3. **StorageManager**: 实现三级存储逻辑
-4. **集成改造**: 改造 cache.py，集成 StorageManager
-5. **数据迁移**: 实现 SQLite → MySQL 迁移
-6. **测试验证**: 单元测试、集成测试、故障注入
-
-### 10.2 验收标准
-
-- Redis 缓存命中时，读取延迟 < 10ms
-- Redis 未命中时，从 MySQL 读取并回填
-- Redis 不可用时，自动降级到 MySQL
-- Redis + MySQL 均不可用时，降级到 SQLite
-- 刷新接口双写成功，数据一致性保证
-- 数据迁移完整，历史数据不丢失

openspec/changes/archive/2026-07-04-analysis-storage-refactor/.comet.yaml

@@ -1,24 +0,0 @@
-workflow: full
-phase: archive
-context_compression: off
-build_mode: executing-plans
-build_pause: null
-subagent_dispatch: null
-tdd_mode: tdd
-review_mode: thorough
-isolation: branch
-verify_mode: full
-auto_transition: true
-base_ref: 82de2f9
-design_doc: docs/superpowers/specs/2026-07-04-analysis-storage-refactor-design.md
-plan: docs/superpowers/plans/2026-07-04-analysis-storage-refactor.md
-verify_result: pass
-verification_report: docs/superpowers/reports/2026-07-04-analysis-storage-refactor-verify.md
-branch_status: handled
-created_at: 2026-07-04
-verified_at: 2026-07-04
-archived: true
-handoff_context: null
-handoff_hash: null
-build_command: python -m pytest tests/ -v
-verify_command: python -m pytest tests/ -v

openspec/changes/archive/2026-07-04-analysis-storage-refactor/.comet/handoff/brainstorm-summary.md

@@ -1,42 +0,0 @@
-# Brainstorm Summary
-
-- Change: analysis-storage-refactor
-- Date: 2026-07-04
-
-## 确认的技术方案
-
-将 `futures_analysis.db`（14 张表）迁移到 MySQL `buffer_platform` 数据库，并引入 Redis 缓存层，与行情数据存储策略保持一致（Redis→MySQL→SQLite 三级降级）。
-
-### 核心设计
-
-1. **复用现有连接**：使用 `storage_manager.py` 中的 `mysql_engine` 和 `redis_client`
-2. **扩展 StorageManager**：新增 analysis 表读写方法
-3. **降级策略**：Redis 缓存 → MySQL 持久化 → SQLite 兜底
-4. **数据迁移**：启动时自动迁移现有 SQLite 数据到 MySQL
-
-### 缓存策略
-
-| 表类型 | 缓存 TTL | 说明 |
-|--------|----------|------|
-| AI 分析结果 | 5 分钟 | 频繁读取，短期缓存 |
-| 复盘计划 | 1 小时 | 每日更新，中期缓存 |
-| 交易记录 | 不缓存 | 写入后不再修改 |
-| 配置表 | 10 分钟 | 低频读取 |
-
-## 关键取舍与风险
-
-| 取舍/风险 | 决策/缓解 |
-|-----------|-----------|
-| 表名前缀 | 保持原名，通过 ORM 模型区分 |
-| 数据迁移失败 | 保留 SQLite 作为降级方案 |
-| Redis 缓存一致性 | 写入时先删缓存，再写 MySQL，最后回填 |
-
-## 测试策略
-
-1. 单元测试：三级降级场景
-2. 集成测试：数据迁移完整性
-3. 功能测试：现有功能（AI 分析、复盘计划、交易记录）正常工作
-
-## Spec Patch
-
-无（复用已有 delta spec 结构）

openspec/changes/archive/2026-07-04-analysis-storage-refactor/.openspec.yaml

@@ -1,3 +0,0 @@
-name: analysis-storage-refactor
-created: 2026-07-04
-status: active

openspec/changes/archive/2026-07-04-analysis-storage-refactor/design.md

@@ -1,88 +0,0 @@
-# Design: Analysis Storage Refactor
-
-## 架构决策
-
-### 决策 1：复用现有连接
-
-**决策**：复用 `storage_manager.py` 中的 `mysql_engine` 和 `redis_client`，不创建新的连接。
-
-**理由**：
-- 避免重复创建连接池
-- 保持配置一致性
-- 简化降级逻辑
-
-### 决策 2：扩展 StorageManager
-
-**决策**：在 `StorageManager` 中新增 analysis 表读写方法，与行情数据共用同一套降级逻辑。
-
-**理由**：
-- 统一降级策略
-- 减少代码重复
-- 便于维护
-
-### 决策 3：表名前缀
-
-**决策**：analysis 表在 MySQL 中保持原名，不添加前缀。
-
-**理由**：
-- 表名已通过 ORM 模型定义
-- 避免与行情数据表冲突（行情表：`market_data`, `symbol_timestamps`, `scheduled_tasks`）
-
-## 数据流
-
-```
-┌─────────────────────────────────────────────────────────────┐
-│                     应用层                                   │
-│  app/api/futures_analysis.py  ←→  app/services/cache.py     │
-│                                         ↓                   │
-│                                   StorageManager            │
-│                                   (storage_manager.py)      │
-└─────────────────────────────────────────────────────────────┘
-                              ↓
-        ┌─────────────────────┼─────────────────────┐
-        ↓                     ↓                     ↓
-   ┌─────────┐          ┌─────────┐          ┌─────────┐
-   │  Redis  │          │  MySQL  │          │ SQLite  │
-   │ (缓存)  │          │(持久化) │          │ (兜底)  │
-   └─────────┘          └─────────┘          └─────────┘
-```
-
-## 降级策略
-
-### 读取流程
-
-1. 检查 Redis 缓存，命中则返回
-2. Redis 未命中，检查 MySQL 可用性
-3. MySQL 可用则查询，结果回填 Redis
-4. MySQL 不可用，降级到 SQLite
-
-### 写入流程
-
-1. 删除 Redis 缓存
-2. 写入 MySQL（事务）
-3. MySQL 成功后回填 Redis
-4. MySQL 失败则写入 SQLite
-
-## 数据迁移
-
-启动时执行一次性迁移：
-
-1. 检测 MySQL analysis 表是否为空
-2. 为空则从 SQLite 读取全部数据
-3. 批量写入 MySQL
-4. 迁移完成后记录日志
-
-## 缓存策略
-
-| 表类型 | 缓存 TTL | 说明 |
-|--------|----------|------|
-| AI 分析结果 | 5 分钟 | 频繁读取，短期缓存 |
-| 复盘计划 | 1 小时 | 每日更新，中期缓存 |
-| 交易记录 | 不缓存 | 写入后不再修改 |
-| 配置表 | 10 分钟 | 低频读取 |
-
-## 兼容性
-
-- ORM 模型定义不变
-- API 接口签名不变
-- SQLite 文件保留，降级时使用

openspec/changes/archive/2026-07-04-analysis-storage-refactor/proposal.md

@@ -1,51 +0,0 @@
-# Proposal: Analysis Storage Refactor
-
-## 问题背景
-
-当前 `futures_analysis.db` 是独立的 SQLite 数据库，存储 14 张表（AI 分析、复盘计划、交易记录等）。与行情数据（已迁移到 MySQL/Redis）分离存储，存在以下问题：
-
-1. **数据孤岛**：分析数据与行情数据分离，无法统一管理和备份
-2. **扩展性差**：SQLite 不适合高并发读写场景
-3. **架构不一致**：行情数据已采用 Redis→MySQL→SQLite 三级降级策略，分析数据仍使用单一 SQLite
-
-## 目标
-
-将 `futures_analysis.db` 的 14 张表迁移到 MySQL `buffer_platform` 数据库，并引入 Redis 缓存层，与行情数据存储策略保持一致。
-
-## 范围
-
-### 包含
-
-- 复用现有 MySQL 连接（`mysql_engine`）和 Redis 连接（`redis_client`）
-- 实现三级降级：Redis 缓存 → MySQL 持久化 → SQLite 兜底
-- 启动时自动迁移现有 SQLite 数据到 MySQL
-- 保持 ORM 模型定义不变
-- 保持 API 接口不变
-
-### 不包含
-
-- 行情数据存储（已完成）
-- 前端代码修改
-- 新增业务功能
-
-## 非目标
-
-- 不改变现有 ORM 模型定义
-- 不改变 API 接口签名
-- 不引入新的业务逻辑
-
-## 验收标准
-
-1. 启动时检测 MySQL/Redis 可用，自动创建 analysis 表并迁移数据
-2. API 读写 analysis 表时优先使用 Redis 缓存，未命中回源 MySQL
-3. MySQL 不可用时降级到 SQLite
-4. 现有功能（AI 分析、复盘计划、交易记录）正常工作
-5. 单元测试覆盖三级降级场景
-
-## 风险
-
-| 风险 | 缓解措施 |
-|------|----------|
-| 数据迁移失败 | 保留 SQLite 作为降级方案，迁移失败时自动降级 |
-| Redis 缓存一致性 | 写入时先删缓存，再写 MySQL，最后回填缓存 |
-| 表结构不兼容 | 复用现有 ORM 模型，MySQL 自动创建表结构 |

openspec/changes/archive/2026-07-04-analysis-storage-refactor/tasks.md

@@ -1,32 +0,0 @@
-# Tasks: Analysis Storage Refactor
-
-## 1. StorageManager 扩展
-
-- [x] 1.1 在 `StorageManager` 中新增 `cache_get()` 通用缓存读取方法
-- [x] 1.2 在 `StorageManager` 中新增 `cache_set()` 通用缓存写入方法
-- [x] 1.3 在 `StorageManager` 中新增 `cache_delete()` 通用缓存删除方法
-
-## 2. 数据迁移
-
-- [x] 2.1 创建 `app/analysis_migration.py`，实现 SQLite → MySQL 迁移逻辑
-- [x] 2.2 在 `app/main.py` 的 `lifespan` 中调用迁移函数，启动时自动迁移
-- [x] 2.3 迁移幂等性：检测 MySQL 表是否已有数据，有则跳过
-
-## 3. 降级逻辑集成
-
-- [x] 3.1 修改 `app/analysis_db.py`，`get_analysis_db()` 根据 MySQL 可用性返回 Session
-- [x] 3.2 实现 MySQL 不可用时降级到 SQLite 的逻辑
-- [x] 3.3 保留 Redis 缓存能力（通过 StorageManager 通用缓存方法）
-
-## 4. 表结构初始化
-
-- [x] 4.1 在 `app/main.py` 的 `lifespan` 中创建 analysis 表（MySQL）
-- [x] 4.2 验证 14 张表在 MySQL 中正确创建
-
-## 5. 测试与验证
-
-- [x] 5.1 验证 Redis 缓存命中场景
-- [x] 5.2 验证 Redis 缓存未命中回源 MySQL 场景
-- [x] 5.3 验证 MySQL 不可用降级到 SQLite 场景
-- [x] 5.4 验证数据迁移完整性
-- [x] 5.5 验证现有测试套件全部通过（101 passed, 2 xfailed）

openspec/changes/archive/2026-07-04-storage-cache-refactor/.comet.yaml

@@ -1,24 +0,0 @@
-workflow: full
-phase: archive
-context_compression: off
-build_mode: subagent-driven-development
-build_pause: null
-subagent_dispatch: confirmed
-tdd_mode: tdd
-review_mode: thorough
-isolation: worktree
-verify_mode: full
-auto_transition: true
-base_ref: 8b5e43f4915cef786208a8132460f87b8b191765
-design_doc: docs/superpowers/specs/2026-07-04-storage-cache-refactor-design.md
-plan: docs/superpowers/plans/2026-07-04-storage-cache-refactor.md
-verify_result: pass
-verification_report: docs/superpowers/reports/2026-07-04-storage-cache-refactor-verify.md
-branch_status: handled
-created_at: 2026-07-04
-verified_at: 2026-07-04T15:00:00
-archived: true
-handoff_context: openspec/changes/storage-cache-refactor/.comet/handoff/design-context.json
-handoff_hash: 1064fdf5186e511848878541bdad663ac6b521ee5721807d01eaf3481bb0cd5a
-build_command: python -m pytest tests/ -v
-verify_command: python -m pytest tests/ -v

openspec/changes/archive/2026-07-04-storage-cache-refactor/.comet/handoff/brainstorm-summary.md

@@ -1,46 +0,0 @@
-# Brainstorm Summary
-
-- Change: storage-cache-refactor
-- Date: 2026-07-04
-
-## 确认的技术方案
-
-1. **Redis 数据结构**: 方案 C — 结构化键值存储
-   - `market_data:{symbol}:{period}` → JSON（含 current_price, timestamp, candles）
-   - `symbol_timestamps:{symbol}` → JSON（含 last_refresh_at, refresh_count）
-   - TTL: 30 天
-
-2. **集成方式**: 方案 B — cache.py 内部封装
-   - cache.py 函数签名不变（仍接收 `db: Session`）
-   - 函数内部判断：优先走 Redis/MySQL，降级时走原有 SQLite 逻辑
-   - API 层零改动，渐进式迁移
-
-3. **降级检测**: 方案 C — 惰性恢复
-   - 启动时检测 Redis/MySQL 可用性
-   - 运行时捕获异常标记不可用
-   - 下次请求时距上次检测超 30 秒则尝试重连
-   - 重连成功恢复，失败继续降级
-
-4. **MySQL 驱动**: pymysql（纯 Python，Windows 零障碍部署）
-
-5. **双写策略**: 同步双写，先写 MySQL 再更新 Redis
-   - 写入流程：删 Redis 缓存 → 写 MySQL → 更新 Redis
-   - MySQL 失败回滚，Redis 失败仅记录日志
-
-## 关键取舍与风险
-
-- Redis 内存占用 → TTL 30 天自动清理
-- 双写一致性 → MySQL 优先，Redis 失败不影响持久化
-- 降级检测延迟 → 30 秒惰性恢复阈值
-- 数据迁移 → 启动时自动从 SQLite 迁移到 MySQL，保留 SQLite 兜底
-
-## 测试策略
-
-- 单元测试：StorageManager 各方法
-- 集成测试：三级降级场景
-- 故障注入：模拟 Redis/MySQL 不可用
-- 性能对比：改造前后读取延迟
-
-## Spec Patch
-
-无（现有 delta spec 已覆盖所有验收场景）

openspec/changes/archive/2026-07-04-storage-cache-refactor/.comet/handoff/design-context.json

@@ -1,17 +0,0 @@
-{
-  "change": "storage-cache-refactor",
-  "phase": "design",
-  "mode": "compact",
-  "canonical_spec": "openspec",
-  "generated_by": "comet-handoff.sh",
-  "context_hash": "1064fdf5186e511848878541bdad663ac6b521ee5721807d01eaf3481bb0cd5a",
-  "files": [
-    { "path": "openspec/changes/storage-cache-refactor/proposal.md", "sha256": "759de20d4e94b3228ee94d8607740de2949c24935933884584b85d3d855569ad" },
-    { "path": "openspec/changes/storage-cache-refactor/design.md", "sha256": "293fba52d3bef2adc55fa3d8667879fc7806918922f2f273d05efbc870c862ac" },
-    { "path": "openspec/changes/storage-cache-refactor/tasks.md", "sha256": "295733c66c5b2599cac51356e7344d17c579e674e667ec24c6b77d62ee519fcd" },
-    { "path": "openspec/changes/storage-cache-refactor/specs/dual-write-consistency/spec.md", "sha256": "6fd0c00433c73329adc93f97ea5a8b744d9a74148d7db40f30c843e92480b91e" },
-    { "path": "openspec/changes/storage-cache-refactor/specs/mysql-persistence/spec.md", "sha256": "f23680f51345a871dddbf3d18eacf6a53de1a20945d02516ffc55a2eb500af75" },
-    { "path": "openspec/changes/storage-cache-refactor/specs/redis-cache-layer/spec.md", "sha256": "a0b5c7023c88339957ce5576ad326474fd0ab913756c223573766cbc9e23f761" },
-    { "path": "openspec/changes/storage-cache-refactor/specs/storage-fallback/spec.md", "sha256": "feaf531250861c109bc48d06d684ff2520cb48269397211bdcefe7cda9013714" }
-  ]
-}

openspec/changes/archive/2026-07-04-storage-cache-refactor/.comet/handoff/design-context.md

@@ -1,387 +0,0 @@
-# Comet Design Handoff
-
-- Change: storage-cache-refactor
-- Phase: design
-- Mode: compact
-- Context hash: 1064fdf5186e511848878541bdad663ac6b521ee5721807d01eaf3481bb0cd5a
-
-Generated-by: comet-handoff.sh
-
-OpenSpec remains the canonical capability spec. This handoff is a deterministic, source-traceable context pack, not an agent-authored summary.
-
-## openspec/changes/storage-cache-refactor/proposal.md
-
-- Source: openspec/changes/storage-cache-refactor/proposal.md
-- Lines: 1-33
-- SHA256: 759de20d4e94b3228ee94d8607740de2949c24935933884584b85d3d855569ad
-
-```md
-## Why
-
-当前系统使用 SQLite 作为唯一存储后端，无法满足行情数据高频读写的性能需求。每次刷新行情数据都需要直接读写磁盘文件，导致响应延迟高、并发能力受限。需要引入更高效的存储方案以提升系统吞吐量和用户体验。
-
-## What Changes
-
-- 引入 Redis 作为热数据缓存层，行情数据优先从 Redis 读取（TTL 30 天）
-- 引入 MySQL 作为持久化存储层，替代 SQLite 承担主要持久化职责
-- 保留 SQLite 作为最终兜底方案，当 Redis 和 MySQL 均不可用时启用
-- 新增数据访问层：实现 Redis → MySQL → SQLite 的三级降级读取策略
-- 刷新接口改造：数据同步写入 Redis 和 MySQL，保证双写一致性
-- 启动流程改造：初始化 Redis/MySQL/SQLite 连接，检测可用性
-
-## Capabilities
-
-### New Capabilities
-
-- `redis-cache-layer`: Redis 缓存读写能力，包括热数据缓存、TTL 管理、缓存失效策略
-- `mysql-persistence`: MySQL 持久化存储能力，替代 SQLite 承担主要持久化职责
-- `storage-fallback`: 三级降级策略（Redis → MySQL → SQLite），保证系统可用性
-- `dual-write-consistency`: 刷新接口双写能力，保证 Redis 和 MySQL 数据一致性
-
-### Modified Capabilities
-
-（无既有 spec 需要修改）
-
-## Impact
-
-- **代码**: `app/database.py`、`app/models.py`、`app/api/data.py`、`app/services/collector.py`、`app/main.py`
-- **依赖**: 新增 `redis`、`pymysql`（或 `aiomysql`）Python 包
-- **配置**: `app/config.py` 新增 Redis/MySQL 连接配置
-- **部署**: `docker-compose.yml` 新增 Redis 和 MySQL 服务
-- **数据库**: 新增 MySQL 数据库初始化脚本，保留 SQLite 作为兜底
-```
-
-## openspec/changes/storage-cache-refactor/design.md
-
-- Source: openspec/changes/storage-cache-refactor/design.md
-- Lines: 1-121
-- SHA256: 293fba52d3bef2adc55fa3d8667879fc7806918922f2f273d05efbc870c862ac
-
-[TRUNCATED]
-
-```md
-## Context
-
-当前系统使用 SQLite 作为唯一存储后端，所有行情数据（`MarketData`）以 JSON 字符串形式存储在磁盘文件中。每次刷新行情时，系统需要从数据源采集数据、写入 SQLite，读取时再反序列化。这种架构在高频读写场景下存在性能瓶颈。
-
-系统包含以下核心实体：
-- `MarketData`: 行情 K 线数据（高频读写，数据量大）
-- `SymbolTimestamp`: 合约数据时间戳（中频读写）
-- `ScheduledTask`: 定时任务配置（低频读写）
-- 用户认证、交易复盘等低频业务表
-
-约束条件：
-- 单机部署，需要本地运行 Redis
-- 需要保证系统可用性，即使部分存储组件故障
-- 现有 SQLite 数据需要迁移或兼容
-
-## Goals / Non-Goals
-
-**Goals:**
-- 引入 Redis 作为热数据缓存层，提升行情数据读取性能（TTL 30 天）
-- 引入 MySQL 作为主要持久化存储，替代 SQLite 承担日常读写
-- 保留 SQLite 作为最终兜底方案，保证系统可用性
-- 实现三级降级策略：Redis → MySQL → SQLite
-- 刷新接口双写：数据同步写入 Redis 和 MySQL
-- 启动时初始化多存储后端，检测可用性
-
-**Non-Goals:**
-- 不迁移用户认证、交易复盘等低频业务表（保持 SQLite）
-- 不改造前端页面
-- 不统一 API 接口规范（留给后续 change）
-- 不实现分布式部署或集群方案
-
-## Decisions
-
-### 1. 存储分层策略
-
-**决策**: 采用 Redis（缓存）+ MySQL（持久化）+ SQLite（兜底）三级架构。
-
-**理由**:
-- Redis 提供亚毫秒级读取性能，适合行情数据高频访问
-- MySQL 提供可靠的持久化能力和事务支持，替代 SQLite 成为主存储
-- SQLite 保留作为最终兜底，保证极端情况下系统仍可运行
-- 三级降级保证系统可用性，避免单点故障
-
-**备选方案**:
-- Redis + PostgreSQL: PostgreSQL 功能更强大，但部署复杂度更高，MySQL 更轻量
-- 纯 Redis: 无法满足持久化需求，数据丢失风险高
-- 纯 MySQL: 缺少缓存层，读取性能提升有限
-
-### 2. 数据访问层设计
-
-**决策**: 新增 `StorageManager` 抽象层，封装三级降级逻辑。
-
-**理由**:
-- 业务代码无需关心底层存储实现
-- 降级策略集中管理，便于维护和测试
-- 可通过配置切换存储后端，支持渐进式迁移
-
-**备选方案**:
-- 直接在业务代码中实现降级逻辑: 代码重复，难以维护
-- 使用 ORM 插件: 灵活性不足，难以实现复杂的降级策略
-
-### 3. 双写一致性策略
-
-**决策**: 刷新接口采用同步双写，先写 MySQL 再更新 Redis。
-
-**理由**:
-- MySQL 作为持久化主存储，必须先保证数据落盘
-- Redis 作为缓存，写入失败不影响数据持久化
-- 同步双写保证数据一致性，避免异步延迟导致的数据不一致
-
-**备选方案**:
-- 异步双写: 性能更好，但可能出现数据不一致
-- 仅写 MySQL，Redis 通过缓存未命中回填: 首次读取性能差
-
-### 4. Redis 缓存策略
-
-**决策**: 行情数据 TTL 30 天，缓存未命中时从 MySQL 读取并回填。
-
-**理由**:
-- 30 天覆盖大部分行情数据的活跃访问周期
-```
-
-Full source: openspec/changes/storage-cache-refactor/design.md
-
-## openspec/changes/storage-cache-refactor/tasks.md
-
-- Source: openspec/changes/storage-cache-refactor/tasks.md
-- Lines: 1-46
-- SHA256: 295733c66c5b2599cac51356e7344d17c579e674e667ec24c6b77d62ee519fcd
-
-```md
-## 1. 依赖与配置
-
-- [ ] 1.1 添加 `redis`、`pymysql` 依赖到 `requirements.txt`
-- [ ] 1.2 在 `app/config.py` 中新增 Redis 和 MySQL 连接配置项（host、port、user、password、database）
-- [ ] 1.3 在 `docker-compose.yml` 中新增 Redis 和 MySQL 服务定义
-
-## 2. 数据库模型与初始化
-
-- [ ] 2.1 创建 `app/mysql_database.py`，实现 MySQL 连接引擎和 SessionLocal
-- [ ] 2.2 创建 `app/redis_client.py`，实现 Redis 连接池和客户端封装
-- [ ] 2.3 在 `app/main.py` 的 `lifespan` 中初始化 Redis 和 MySQL 连接，检测可用性
-- [ ] 2.4 创建 MySQL 表结构初始化脚本（复用现有 ORM 模型）
-
-## 3. 数据迁移
-
-- [ ] 3.1 创建数据迁移脚本，从 SQLite 读取历史数据并写入 MySQL
-- [ ] 3.2 在应用启动时检测 MySQL 表是否为空，自动触发迁移
-
-## 4. 存储管理层
-
-- [ ] 4.1 创建 `app/storage_manager.py`，实现 `StorageManager` 抽象层
-- [ ] 4.2 实现 Redis 缓存读取逻辑（命中返回，未命中回源 MySQL 并回填）
-- [ ] 4.3 实现 MySQL 持久化读写逻辑
-- [ ] 4.4 实现三级降级策略（Redis → MySQL → SQLite）
-- [ ] 4.5 实现降级状态检测和恢复机制
-
-## 5. 双写与缓存一致性
-
-- [ ] 5.1 实现刷新接口双写逻辑：先删 Redis 缓存，再写 MySQL，最后更新 Redis
-- [ ] 5.2 实现双写顺序保证和错误处理（MySQL 失败回滚，Redis 失败记录日志）
-- [ ] 5.3 实现缓存未命中回填逻辑（TTL 30 天）
-
-## 6. 接口改造
-
-- [ ] 6.1 改造 `app/api/data.py` 中的行情数据读取接口，使用 `StorageManager`
-- [ ] 6.2 改造 `app/api/data.py` 中的刷新接口，使用双写逻辑
-- [ ] 6.3 改造 `app/services/collector.py`，使用 `StorageManager` 写入数据
-
-## 7. 测试与验证
-
-- [ ] 7.1 验证 Redis 缓存命中场景
-- [ ] 7.2 验证 Redis 缓存未命中回源 MySQL 场景
-- [ ] 7.3 验证 Redis 不可用降级到 MySQL 场景
-- [ ] 7.4 验证 Redis 和 MySQL 均不可用降级到 SQLite 场景
-- [ ] 7.5 验证刷新接口双写一致性
-- [ ] 7.6 验证数据迁移完整性
-```
-
-## openspec/changes/storage-cache-refactor/specs/dual-write-consistency/spec.md
-
-- Source: openspec/changes/storage-cache-refactor/specs/dual-write-consistency/spec.md
-- Lines: 1-30
-- SHA256: 6fd0c00433c73329adc93f97ea5a8b744d9a74148d7db40f30c843e92480b91e
-
-```md
-## ADDED Requirements
-
-### Requirement: 刷新接口双写
-系统应当在刷新接口中实现 Redis 和 MySQL 的同步双写，保证数据一致性。
-
-#### Scenario: 刷新接口双写成功
-- **WHEN** 用户调用刷新接口更新行情数据
-- **THEN** 系统先删除 Redis 缓存，再写入 MySQL，最后更新 Redis 缓存
-
-#### Scenario: MySQL 写入失败
-- **WHEN** 刷新接口写入 MySQL 失败
-- **THEN** 系统返回错误响应，不更新 Redis 缓存，保证数据一致性
-
-#### Scenario: Redis 写入失败
-- **WHEN** 刷新接口写入 MySQL 成功但 Redis 写入失败
-- **THEN** 系统返回成功响应（MySQL 数据已持久化），输出 Redis 写入失败警告日志
-
-### Requirement: 双写顺序保证
-系统应当保证双写的顺序：先写 MySQL，再更新 Redis。
-
-#### Scenario: 双写顺序
-- **WHEN** 刷新接口执行双写
-- **THEN** 系统先写入 MySQL 并确认成功，再更新 Redis 缓存
-
-### Requirement: 缓存回填一致性
-系统应当在缓存未命中回填时保证回填数据与 MySQL 数据一致。
-
-#### Scenario: 缓存未命中回填
-- **WHEN** Redis 缓存未命中且从 MySQL 读取数据
-- **THEN** 系统将 MySQL 数据回填到 Redis，TTL 设置为 30 天
-```
-
-## openspec/changes/storage-cache-refactor/specs/mysql-persistence/spec.md
-
-- Source: openspec/changes/storage-cache-refactor/specs/mysql-persistence/spec.md
-- Lines: 1-41
-- SHA256: f23680f51345a871dddbf3d18eacf6a53de1a20945d02516ffc55a2eb500af75
-
-```md
-## ADDED Requirements
-
-### Requirement: MySQL 连接管理
-系统应当提供 MySQL 连接管理能力，包括连接初始化、连接池管理和表结构初始化。
-
-#### Scenario: MySQL 连接初始化成功
-- **WHEN** 应用启动且 MySQL 配置有效
-- **THEN** 系统成功建立 MySQL 连接并创建必要的表结构
-
-#### Scenario: MySQL 连接初始化失败
-- **WHEN** 应用启动但 MySQL 服务不可用
-- **THEN** 系统输出错误日志并标记 MySQL 为不可用状态，但不阻止应用启动
-
-### Requirement: 行情数据持久化存储
-系统应当使用 MySQL 作为行情数据的主要持久化存储，替代 SQLite。
-
-#### Scenario: 行情数据写入 MySQL
-- **WHEN** 刷新接口接收到行情数据更新请求
-- **THEN** 系统将数据写入 MySQL 的 `market_data` 表
-
-#### Scenario: 行情数据从 MySQL 读取
-- **WHEN** Redis 缓存未命中且 MySQL 可用
-- **THEN** 系统从 MySQL 读取行情数据并返回
-
-### Requirement: MySQL 表结构迁移
-系统应当提供从 SQLite 到 MySQL 的数据迁移能力，保证历史数据不丢失。
-
-#### Scenario: 首次启动数据迁移
-- **WHEN** 应用首次启动且 MySQL 可用但表为空
-- **THEN** 系统从 SQLite 读取历史数据并迁移到 MySQL
-
-#### Scenario: 迁移完成
-- **WHEN** 数据迁移完成
-- **THEN** 系统输出迁移成功日志，后续读写直接操作 MySQL
-
-### Requirement: MySQL 事务支持
-系统应当使用 MySQL 事务保证数据写入的原子性和一致性。
-
-#### Scenario: 批量写入事务
-- **WHEN** 刷新接口需要写入多个品种的行情数据
-- **THEN** 系统使用事务保证所有数据要么全部写入成功，要么全部回滚
-```
-
-## openspec/changes/storage-cache-refactor/specs/redis-cache-layer/spec.md
-
-- Source: openspec/changes/storage-cache-refactor/specs/redis-cache-layer/spec.md
-- Lines: 1-41
-- SHA256: a0b5c7023c88339957ce5576ad326474fd0ab913756c223573766cbc9e23f761
-
-```md
-## ADDED Requirements
-
-### Requirement: Redis 缓存连接管理
-系统应当提供 Redis 连接管理能力，包括连接初始化、健康检查和连接池管理。
-
-#### Scenario: Redis 连接初始化成功
-- **WHEN** 应用启动且 Redis 配置有效
-- **THEN** 系统成功建立 Redis 连接并输出初始化成功日志
-
-#### Scenario: Redis 连接初始化失败
-- **WHEN** 应用启动但 Redis 服务不可用
-- **THEN** 系统输出警告日志并标记 Redis 为不可用状态，但不阻止应用启动
-
-### Requirement: 行情数据缓存读取
-系统应当优先从 Redis 读取行情数据，缓存未命中时回源 MySQL。
-
-#### Scenario: Redis 缓存命中
-- **WHEN** 用户请求行情数据且 Redis 中存在该数据
-- **THEN** 系统直接从 Redis 返回数据，不访问 MySQL
-
-#### Scenario: Redis 缓存未命中
-- **WHEN** 用户请求行情数据但 Redis 中不存在该数据
-- **THEN** 系统从 MySQL 读取数据，回填到 Redis（TTL 30 天），并返回数据
-
-### Requirement: Redis 缓存 TTL 管理
-系统应当为缓存数据设置 30 天过期时间，过期后自动清理。
-
-#### Scenario: 缓存数据过期
-- **WHEN** 缓存数据超过 30 天未访问
-- **THEN** Redis 自动清理该数据，下次访问时从 MySQL 重新加载
-
-#### Scenario: 缓存数据续期
-- **WHEN** 用户访问已缓存的行情数据
-- **THEN** 系统返回缓存数据，TTL 保持为 30 天（不续期）
-
-### Requirement: Redis 缓存失效
-系统应当在数据更新时主动失效相关缓存，保证数据一致性。
-
-#### Scenario: 刷新接口触发缓存失效
-- **WHEN** 用户调用刷新接口更新行情数据
-- **THEN** 系统先删除 Redis 中对应的缓存数据，再执行双写流程
-```
-
-## openspec/changes/storage-cache-refactor/specs/storage-fallback/spec.md
-
-- Source: openspec/changes/storage-cache-refactor/specs/storage-fallback/spec.md
-- Lines: 1-38
-- SHA256: feaf531250861c109bc48d06d684ff2520cb48269397211bdcefe7cda9013714
-
-```md
-## ADDED Requirements
-
-### Requirement: 三级降级策略
-系统应当实现 Redis → MySQL → SQLite 的三级降级读取策略，保证系统可用性。
-
-#### Scenario: 正常模式（Redis + MySQL 可用）
-- **WHEN** Redis 和 MySQL 均可用
-- **THEN** 系统优先从 Redis 读取，未命中时回源 MySQL
-
-#### Scenario: Redis 不可用降级
-- **WHEN** Redis 服务不可用但 MySQL 可用
-- **THEN** 系统直接从 MySQL 读取数据，跳过 Redis 缓存层
-
-#### Scenario: Redis 和 MySQL 均不可用降级
-- **WHEN** Redis 和 MySQL 均不可用
-- **THEN** 系统降级到 SQLite，从 SQLite 读取数据并保证基础服务可用
-
-### Requirement: 降级状态检测
-系统应当能够检测存储后端的可用性状态，并在降级时输出明确的日志。
-
-#### Scenario: 启动时降级检测
-- **WHEN** 应用启动时检测到 Redis 或 MySQL 不可用
-- **THEN** 系统输出降级警告日志，说明当前使用的存储模式
-
-#### Scenario: 运行时降级触发
-- **WHEN** 运行中 Redis 或 MySQL 连接异常
-- **THEN** 系统自动切换到降级模式，输出降级日志，并继续提供服务
-
-### Requirement: 降级恢复
-系统应当能够在存储后端恢复后自动恢复到正常模式。
-
-#### Scenario: Redis 恢复
-- **WHEN** Redis 从不可用状态恢复
-- **THEN** 系统自动恢复到 Redis + MySQL 模式，后续读取优先使用 Redis
-
-#### Scenario: MySQL 恢复
-- **WHEN** MySQL 从不可用状态恢复
-- **THEN** 系统自动恢复到 Redis + MySQL 模式，SQLite 降级结束
-```
-

openspec/changes/archive/2026-07-04-storage-cache-refactor/.comet/subagent-progress.md

@@ -1,43 +0,0 @@
-# Subagent Progress
-
-- Change: storage-cache-refactor
-- Review Mode: thorough
-- TDD Mode: tdd
-
-## Task Ledger
-
-| # | Task | Status | Stage | Commit | Notes |
-|---|------|--------|-------|--------|-------|
-| T1 | 添加 redis/pymysql 依赖 | done | done | f86b096 | - |
-| T2 | config.py 新增 Redis/MySQL 配置项 | done | done | 4c0bbbb | 环境变量名已统一 |
-| T3 | docker-compose.yml 新增 Redis/MySQL 服务 | done | done | d6e17f5 | - |
-| T4 | 创建 app/mysql_database.py | done | done | 7c46ffc | - |
-| T5 | 创建 app/redis_client.py | done | done | b7ae897 | - |
-| T6 | lifespan 中初始化 Redis/MySQL 连接 | done | done | a4c3af6 | - |
-| T7 | MySQL 表结构初始化（复用 ORM 模型） | done | done | 72d81ce | - |
-| T8 | 创建 app/storage_manager.py 骨架 + 降级检测 | done | done | 48f9765 | - |
-| T9 | StorageManager 读取逻辑（Redis → MySQL → SQLite） | done | done | beba383 | - |
-| T10 | StorageManager 写入逻辑 + 双写一致性 | done | done | 8f3c2b6 | fix: 59e461a |
-| T11 | 创建数据迁移脚本 app/migration.py | done | done | a26a44e | - |
-| T12 | 启动时自动触发迁移 | done | done | 5db0546 | - |
-| T13 | 改造 cache.py 内部封装 StorageManager | done | done | 7ee6794 | fixes: 2720ddb, bf4f571 |
-| T14 | 验证：Redis 缓存命中/未命中场景 | done | done | ad9d7f8 | 2 xfail: 日志断言 |
-| T15 | 验证：降级到 MySQL / SQLite 场景 | done | done | 7cea089 | fix: 177a10f 单例注入 |
-| T16 | 验证：双写一致性 + 数据迁移完整性 | done | done | 4d7b3e6 | fix: 46f5846 迁移落盘 |
-
-## Final Review
-
-- Status: APPROVED (4 rounds)
-- Final fix: e17a183 (atomic writes, migration, config, URL encoding)
-- Final fix: d9bda2c (is_fresh TTL semantics)
-- Final fix: 0a519d5 (timestamp write fallback)
-
-## Batch Reviews
-
-- Batch 1 (T1-T3): APPROVED
-- Batch 2 (T4-T6): APPROVED
-- Batch 3 (T7-T10): APPROVED (after fix)
-- Batch 4 (T11-T12): APPROVED
-- Task 13 Review: APPROVED (after 2 fixes)
-- Batch 5 (T14-T16 + fixes): APPROVED
-- Final Review v4: APPROVED

openspec/changes/archive/2026-07-04-storage-cache-refactor/.openspec.yaml

@@ -1,2 +0,0 @@
-schema: spec-driven
-created: 2026-07-04

openspec/changes/archive/2026-07-04-storage-cache-refactor/design.md

@@ -1,121 +0,0 @@
-## Context
-
-当前系统使用 SQLite 作为唯一存储后端，所有行情数据（`MarketData`）以 JSON 字符串形式存储在磁盘文件中。每次刷新行情时，系统需要从数据源采集数据、写入 SQLite，读取时再反序列化。这种架构在高频读写场景下存在性能瓶颈。
-
-系统包含以下核心实体：
-- `MarketData`: 行情 K 线数据（高频读写，数据量大）
-- `SymbolTimestamp`: 合约数据时间戳（中频读写）
-- `ScheduledTask`: 定时任务配置（低频读写）
-- 用户认证、交易复盘等低频业务表
-
-约束条件：
-- 单机部署，需要本地运行 Redis
-- 需要保证系统可用性，即使部分存储组件故障
-- 现有 SQLite 数据需要迁移或兼容
-
-## Goals / Non-Goals
-
-**Goals:**
-- 引入 Redis 作为热数据缓存层，提升行情数据读取性能（TTL 30 天）
-- 引入 MySQL 作为主要持久化存储，替代 SQLite 承担日常读写
-- 保留 SQLite 作为最终兜底方案，保证系统可用性
-- 实现三级降级策略：Redis → MySQL → SQLite
-- 刷新接口双写：数据同步写入 Redis 和 MySQL
-- 启动时初始化多存储后端，检测可用性
-
-**Non-Goals:**
-- 不迁移用户认证、交易复盘等低频业务表（保持 SQLite）
-- 不改造前端页面
-- 不统一 API 接口规范（留给后续 change）
-- 不实现分布式部署或集群方案
-
-## Decisions
-
-### 1. 存储分层策略
-
-**决策**: 采用 Redis（缓存）+ MySQL（持久化）+ SQLite（兜底）三级架构。
-
-**理由**:
-- Redis 提供亚毫秒级读取性能，适合行情数据高频访问
-- MySQL 提供可靠的持久化能力和事务支持，替代 SQLite 成为主存储
-- SQLite 保留作为最终兜底，保证极端情况下系统仍可运行
-- 三级降级保证系统可用性，避免单点故障
-
-**备选方案**:
-- Redis + PostgreSQL: PostgreSQL 功能更强大，但部署复杂度更高，MySQL 更轻量
-- 纯 Redis: 无法满足持久化需求，数据丢失风险高
-- 纯 MySQL: 缺少缓存层，读取性能提升有限
-
-### 2. 数据访问层设计
-
-**决策**: 新增 `StorageManager` 抽象层，封装三级降级逻辑。
-
-**理由**:
-- 业务代码无需关心底层存储实现
-- 降级策略集中管理，便于维护和测试
-- 可通过配置切换存储后端，支持渐进式迁移
-
-**备选方案**:
-- 直接在业务代码中实现降级逻辑: 代码重复，难以维护
-- 使用 ORM 插件: 灵活性不足，难以实现复杂的降级策略
-
-### 3. 双写一致性策略
-
-**决策**: 刷新接口采用同步双写，先写 MySQL 再更新 Redis。
-
-**理由**:
-- MySQL 作为持久化主存储，必须先保证数据落盘
-- Redis 作为缓存，写入失败不影响数据持久化
-- 同步双写保证数据一致性，避免异步延迟导致的数据不一致
-
-**备选方案**:
-- 异步双写: 性能更好，但可能出现数据不一致
-- 仅写 MySQL，Redis 通过缓存未命中回填: 首次读取性能差
-
-### 4. Redis 缓存策略
-
-**决策**: 行情数据 TTL 30 天，缓存未命中时从 MySQL 读取并回填。
-
-**理由**:
-- 30 天覆盖大部分行情数据的活跃访问周期
-- 缓存未命中回填保证读取性能
-- TTL 过期后自动清理，避免内存无限增长
-
-**备选方案**:
-- 永不过期: 内存占用不可控
-- 更短 TTL（如 1 天）: 缓存命中率低，频繁回源 MySQL
-
-### 5. 降级检测机制
-
-**决策**: 启动时检测 Redis/MySQL 可用性，运行时捕获连接异常触发降级。
-
-**理由**:
-- 启动时检测可提前发现问题，输出明确的错误日志
-- 运行时降级保证系统可用性，避免服务中断
-- 降级状态可通过日志监控，便于运维排查
-
-**备选方案**:
-- 仅启动时检测: 无法处理运行中服务故障
-- 健康检查接口: 增加复杂度，当前场景不需要
-
-### 6. 数据迁移策略
-
-**决策**: 新增 MySQL 表结构，启动时从 SQLite 迁移历史数据到 MySQL。
-
-**理由**:
-- 保证历史数据不丢失
-- 一次性迁移，后续直接读写 MySQL
-- SQLite 保留作为兜底，不删除
-
-**备选方案**:
-- 手动迁移: 容易遗漏，风险高
-- 双写过渡期: 复杂度高，当前场景不需要
-
-## Risks / Trade-offs
-
-- **[风险]** Redis 和 MySQL 同时故障 → **[缓解]** SQLite 兜底，系统仍可运行
-- **[风险]** 双写一致性：MySQL 写入成功但 Redis 写入失败 → **[缓解]** Redis 写入失败不影响持久化，下次读取时从 MySQL 回填
-- **[风险]** Redis 内存占用过高 → **[缓解]** TTL 30 天自动清理，监控内存使用
-- **[风险]** MySQL 部署复杂度增加 → **[缓解]** 使用 docker-compose 一键部署
-- **[取舍]** 同步双写性能略低于异步双写 → 换取数据一致性保证
-- **[取舍]** 三级降级增加代码复杂度 → 换取系统高可用性

openspec/changes/archive/2026-07-04-storage-cache-refactor/proposal.md

@@ -1,33 +0,0 @@
-## Why
-
-当前系统使用 SQLite 作为唯一存储后端，无法满足行情数据高频读写的性能需求。每次刷新行情数据都需要直接读写磁盘文件，导致响应延迟高、并发能力受限。需要引入更高效的存储方案以提升系统吞吐量和用户体验。
-
-## What Changes
-
-- 引入 Redis 作为热数据缓存层，行情数据优先从 Redis 读取（TTL 30 天）
-- 引入 MySQL 作为持久化存储层，替代 SQLite 承担主要持久化职责
-- 保留 SQLite 作为最终兜底方案，当 Redis 和 MySQL 均不可用时启用
-- 新增数据访问层：实现 Redis → MySQL → SQLite 的三级降级读取策略
-- 刷新接口改造：数据同步写入 Redis 和 MySQL，保证双写一致性
-- 启动流程改造：初始化 Redis/MySQL/SQLite 连接，检测可用性
-
-## Capabilities
-
-### New Capabilities
-
-- `redis-cache-layer`: Redis 缓存读写能力，包括热数据缓存、TTL 管理、缓存失效策略
-- `mysql-persistence`: MySQL 持久化存储能力，替代 SQLite 承担主要持久化职责
-- `storage-fallback`: 三级降级策略（Redis → MySQL → SQLite），保证系统可用性
-- `dual-write-consistency`: 刷新接口双写能力，保证 Redis 和 MySQL 数据一致性
-
-### Modified Capabilities
-
-（无既有 spec 需要修改）
-
-## Impact
-
-- **代码**: `app/database.py`、`app/models.py`、`app/api/data.py`、`app/services/collector.py`、`app/main.py`
-- **依赖**: 新增 `redis`、`pymysql`（或 `aiomysql`）Python 包
-- **配置**: `app/config.py` 新增 Redis/MySQL 连接配置
-- **部署**: `docker-compose.yml` 新增 Redis 和 MySQL 服务
-- **数据库**: 新增 MySQL 数据库初始化脚本，保留 SQLite 作为兜底

openspec/changes/archive/2026-07-04-storage-cache-refactor/specs/dual-write-consistency/spec.md

@@ -1,30 +0,0 @@
-## ADDED Requirements
-
-### Requirement: 刷新接口双写
-系统应当在刷新接口中实现 Redis 和 MySQL 的同步双写，保证数据一致性。
-
-#### Scenario: 刷新接口双写成功
-- **WHEN** 用户调用刷新接口更新行情数据
-- **THEN** 系统先删除 Redis 缓存，再写入 MySQL，最后更新 Redis 缓存
-
-#### Scenario: MySQL 写入失败
-- **WHEN** 刷新接口写入 MySQL 失败
-- **THEN** 系统返回错误响应，不更新 Redis 缓存，保证数据一致性
-
-#### Scenario: Redis 写入失败
-- **WHEN** 刷新接口写入 MySQL 成功但 Redis 写入失败
-- **THEN** 系统返回成功响应（MySQL 数据已持久化），输出 Redis 写入失败警告日志
-
-### Requirement: 双写顺序保证
-系统应当保证双写的顺序：先写 MySQL，再更新 Redis。
-
-#### Scenario: 双写顺序
-- **WHEN** 刷新接口执行双写
-- **THEN** 系统先写入 MySQL 并确认成功，再更新 Redis 缓存
-
-### Requirement: 缓存回填一致性
-系统应当在缓存未命中回填时保证回填数据与 MySQL 数据一致。
-
-#### Scenario: 缓存未命中回填
-- **WHEN** Redis 缓存未命中且从 MySQL 读取数据
-- **THEN** 系统将 MySQL 数据回填到 Redis，TTL 设置为 30 天

openspec/changes/archive/2026-07-04-storage-cache-refactor/specs/mysql-persistence/spec.md

@@ -1,41 +0,0 @@
-## ADDED Requirements
-
-### Requirement: MySQL 连接管理
-系统应当提供 MySQL 连接管理能力，包括连接初始化、连接池管理和表结构初始化。
-
-#### Scenario: MySQL 连接初始化成功
-- **WHEN** 应用启动且 MySQL 配置有效
-- **THEN** 系统成功建立 MySQL 连接并创建必要的表结构
-
-#### Scenario: MySQL 连接初始化失败
-- **WHEN** 应用启动但 MySQL 服务不可用
-- **THEN** 系统输出错误日志并标记 MySQL 为不可用状态，但不阻止应用启动
-
-### Requirement: 行情数据持久化存储
-系统应当使用 MySQL 作为行情数据的主要持久化存储，替代 SQLite。
-
-#### Scenario: 行情数据写入 MySQL
-- **WHEN** 刷新接口接收到行情数据更新请求
-- **THEN** 系统将数据写入 MySQL 的 `market_data` 表
-
-#### Scenario: 行情数据从 MySQL 读取
-- **WHEN** Redis 缓存未命中且 MySQL 可用
-- **THEN** 系统从 MySQL 读取行情数据并返回
-
-### Requirement: MySQL 表结构迁移
-系统应当提供从 SQLite 到 MySQL 的数据迁移能力，保证历史数据不丢失。
-
-#### Scenario: 首次启动数据迁移
-- **WHEN** 应用首次启动且 MySQL 可用但表为空
-- **THEN** 系统从 SQLite 读取历史数据并迁移到 MySQL
-
-#### Scenario: 迁移完成
-- **WHEN** 数据迁移完成
-- **THEN** 系统输出迁移成功日志，后续读写直接操作 MySQL
-
-### Requirement: MySQL 事务支持
-系统应当使用 MySQL 事务保证数据写入的原子性和一致性。
-
-#### Scenario: 批量写入事务
-- **WHEN** 刷新接口需要写入多个品种的行情数据
-- **THEN** 系统使用事务保证所有数据要么全部写入成功，要么全部回滚

openspec/changes/archive/2026-07-04-storage-cache-refactor/specs/redis-cache-layer/spec.md

@@ -1,41 +0,0 @@
-## ADDED Requirements
-
-### Requirement: Redis 缓存连接管理
-系统应当提供 Redis 连接管理能力，包括连接初始化、健康检查和连接池管理。
-
-#### Scenario: Redis 连接初始化成功
-- **WHEN** 应用启动且 Redis 配置有效
-- **THEN** 系统成功建立 Redis 连接并输出初始化成功日志
-
-#### Scenario: Redis 连接初始化失败
-- **WHEN** 应用启动但 Redis 服务不可用
-- **THEN** 系统输出警告日志并标记 Redis 为不可用状态，但不阻止应用启动
-
-### Requirement: 行情数据缓存读取
-系统应当优先从 Redis 读取行情数据，缓存未命中时回源 MySQL。
-
-#### Scenario: Redis 缓存命中
-- **WHEN** 用户请求行情数据且 Redis 中存在该数据
-- **THEN** 系统直接从 Redis 返回数据，不访问 MySQL
-
-#### Scenario: Redis 缓存未命中
-- **WHEN** 用户请求行情数据但 Redis 中不存在该数据
-- **THEN** 系统从 MySQL 读取数据，回填到 Redis（TTL 30 天），并返回数据
-
-### Requirement: Redis 缓存 TTL 管理
-系统应当为缓存数据设置 30 天过期时间，过期后自动清理。
-
-#### Scenario: 缓存数据过期
-- **WHEN** 缓存数据超过 30 天未访问
-- **THEN** Redis 自动清理该数据，下次访问时从 MySQL 重新加载
-
-#### Scenario: 缓存数据续期
-- **WHEN** 用户访问已缓存的行情数据
-- **THEN** 系统返回缓存数据，TTL 保持为 30 天（不续期）
-
-### Requirement: Redis 缓存失效
-系统应当在数据更新时主动失效相关缓存，保证数据一致性。
-
-#### Scenario: 刷新接口触发缓存失效
-- **WHEN** 用户调用刷新接口更新行情数据
-- **THEN** 系统先删除 Redis 中对应的缓存数据，再执行双写流程

openspec/changes/archive/2026-07-04-storage-cache-refactor/specs/storage-fallback/spec.md

@@ -1,38 +0,0 @@
-## ADDED Requirements
-
-### Requirement: 三级降级策略
-系统应当实现 Redis → MySQL → SQLite 的三级降级读取策略，保证系统可用性。
-
-#### Scenario: 正常模式（Redis + MySQL 可用）
-- **WHEN** Redis 和 MySQL 均可用
-- **THEN** 系统优先从 Redis 读取，未命中时回源 MySQL
-
-#### Scenario: Redis 不可用降级
-- **WHEN** Redis 服务不可用但 MySQL 可用
-- **THEN** 系统直接从 MySQL 读取数据，跳过 Redis 缓存层
-
-#### Scenario: Redis 和 MySQL 均不可用降级
-- **WHEN** Redis 和 MySQL 均不可用
-- **THEN** 系统降级到 SQLite，从 SQLite 读取数据并保证基础服务可用
-
-### Requirement: 降级状态检测
-系统应当能够检测存储后端的可用性状态，并在降级时输出明确的日志。
-
-#### Scenario: 启动时降级检测
-- **WHEN** 应用启动时检测到 Redis 或 MySQL 不可用
-- **THEN** 系统输出降级警告日志，说明当前使用的存储模式
-
-#### Scenario: 运行时降级触发
-- **WHEN** 运行中 Redis 或 MySQL 连接异常
-- **THEN** 系统自动切换到降级模式，输出降级日志，并继续提供服务
-
-### Requirement: 降级恢复
-系统应当能够在存储后端恢复后自动恢复到正常模式。
-
-#### Scenario: Redis 恢复
-- **WHEN** Redis 从不可用状态恢复
-- **THEN** 系统自动恢复到 Redis + MySQL 模式，后续读取优先使用 Redis
-
-#### Scenario: MySQL 恢复
-- **WHEN** MySQL 从不可用状态恢复
-- **THEN** 系统自动恢复到 Redis + MySQL 模式，SQLite 降级结束

openspec/changes/archive/2026-07-04-storage-cache-refactor/tasks.md

@@ -1,46 +0,0 @@
-## 1. 依赖与配置
-
-- [x] 1.1 添加 `redis`、`pymysql` 依赖到 `requirements.txt`
-- [x] 1.2 在 `app/config.py` 中新增 Redis 和 MySQL 连接配置项（host、port、user、password、database）
-- [x] 1.3 在 `docker-compose.yml` 中新增 Redis 和 MySQL 服务定义
-
-## 2. 数据库模型与初始化
-
-- [x] 2.1 创建 `app/mysql_database.py`，实现 MySQL 连接引擎和 SessionLocal
-- [x] 2.2 创建 `app/redis_client.py`，实现 Redis 连接池和客户端封装
-- [x] 2.3 在 `app/main.py` 的 `lifespan` 中初始化 Redis 和 MySQL 连接，检测可用性
-- [x] 2.4 创建 MySQL 表结构初始化脚本（复用现有 ORM 模型）
-
-## 3. 数据迁移
-
-- [x] 3.1 创建数据迁移脚本，从 SQLite 读取历史数据并写入 MySQL
-- [x] 3.2 在应用启动时检测 MySQL 表是否为空，自动触发迁移
-
-## 4. 存储管理层
-
-- [x] 4.1 创建 `app/storage_manager.py`，实现 `StorageManager` 抽象层
-- [x] 4.2 实现 Redis 缓存读取逻辑（命中返回，未命中回源 MySQL 并回填）
-- [x] 4.3 实现 MySQL 持久化读写逻辑
-- [x] 4.4 实现三级降级策略（Redis → MySQL → SQLite）
-- [x] 4.5 实现降级状态检测和恢复机制
-
-## 5. 双写与缓存一致性
-
-- [x] 5.1 实现刷新接口双写逻辑：先删 Redis 缓存，再写 MySQL，最后更新 Redis
-- [x] 5.2 实现双写顺序保证和错误处理（MySQL 失败回滚，Redis 失败记录日志）
-- [x] 5.3 实现缓存未命中回填逻辑（TTL 30 天）
-
-## 6. 接口改造
-
-- [x] 6.1 改造 `app/services/cache.py` 中的行情数据读取接口，使用 `StorageManager`
-- [x] 6.2 改造 `app/services/cache.py` 中的刷新接口，使用双写逻辑
-- [x] 6.3 改造 `app/services/cache.py`，使用 `StorageManager` 写入数据（API 层零改动）
-
-## 7. 测试与验证
-
-- [x] 7.1 验证 Redis 缓存命中场景
-- [x] 7.2 验证 Redis 缓存未命中回源 MySQL 场景
-- [x] 7.3 验证 Redis 不可用降级到 MySQL 场景
-- [x] 7.4 验证 Redis 和 MySQL 均不可用降级到 SQLite 场景
-- [x] 7.5 验证刷新接口双写一致性
-- [x] 7.6 验证数据迁移完整性

openspec/changes/archive/2026-07-05-config-to-mysql/.comet.yaml

@@ -1,24 +0,0 @@
-workflow: full
-phase: archive
-context_compression: off
-build_mode: executing-plans
-build_pause: null
-subagent_dispatch: null
-tdd_mode: tdd
-review_mode: thorough
-isolation: branch
-verify_mode: full
-auto_transition: true
-base_ref: f8d5ecd
-design_doc: docs/superpowers/specs/2026-07-04-config-to-mysql-design.md
-plan: docs/superpowers/plans/2026-07-04-config-to-mysql.md
-verify_result: pass
-verification_report: docs/superpowers/reports/2026-07-04-config-to-mysql-verify.md
-branch_status: handled
-created_at: 2026-07-04
-verified_at: 2026-07-05
-archived: true
-handoff_context: null
-handoff_hash: null
-build_command: python -m pytest tests/ -v
-verify_command: python -m pytest tests/ -v

openspec/changes/archive/2026-07-05-config-to-mysql/.comet/handoff/brainstorm-summary.md

@@ -1,31 +0,0 @@
-# Brainstorm Summary
-
-## 确认的技术方案
-
-**采用方案：单表键值对 + 统一配置模块 + JSON fallback**
-
-| 组件 | 说明 |
-|------|------|
-| `app/models.py` | 新增 `AppConfig` 模型 |
-| `app/config_store.py` | 统一配置读写入口 |
-| `app/config_migration.py` | JSON → MySQL 迁移脚本 |
-| JSON 文件 | 降级方案，保留原路径 |
-
-## 关键取舍与风险
-
-| 取舍 | 决策 |
-|------|------|
-| 单表 vs 多表 | 单表，通过 `config_key` 区分，未来扩展无需改表 |
-| 是否使用 Redis | 不使用，按用户要求仅 MySQL |
-| 是否保留文件 | 保留，作为 MySQL 不可用时的降级 |
-| 写入策略 | 双写：MySQL 可用时写数据库 + 写文件；MySQL 不可用时只写文件 |
-
-## 测试策略
-
-- 单元测试：`tests/test_config_store.py` 覆盖读取、写入、降级
-- 迁移测试：验证幂等性
-- 回归测试：全部测试套件
-
-## Spec Patch
-
-无

openspec/changes/archive/2026-07-05-config-to-mysql/.openspec.yaml

@@ -1,3 +0,0 @@
-name: config-to-mysql
-created: 2026-07-04
-status: active

openspec/changes/archive/2026-07-05-config-to-mysql/design.md

@@ -1,101 +0,0 @@
-# Design: Config to MySQL
-
-## 架构决策
-
-### 决策 1：统一配置管理模块
-
-**决策**：创建 `app/config_store.py` 作为所有配置读写的唯一入口。
-
-**理由**：
-- 消除多处重复的文件读取逻辑
-- 集中管理降级策略
-- 便于后续扩展（如缓存、审计）
-
-### 决策 2：单表存储键值对
-
-**决策**：使用单表 `app_config` 存储所有配置，以 `config_key` 区分 `symbols` 和 `ai`。
-
-**表结构**：
-```sql
-CREATE TABLE app_config (
-    id INT PRIMARY KEY AUTO_INCREMENT,
-    config_key VARCHAR(64) UNIQUE NOT NULL,  -- 'symbols' 或 'ai'
-    config_value JSON NOT NULL,
-    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
-    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-)
-```
-
-**理由**：
-- 与现有 JSON schema 兼容
-- 减少表数量
-- 未来新增配置无需改表结构
-
-### 决策 3：MySQL + JSON 文件降级
-
-**决策**：MySQL 可用时优先读写数据库；MySQL 不可用时回退到 JSON 文件。
-
-**理由**：
-- 用户明确要求无需 Redis
-- JSON 文件作为 fallback 简单可靠
-- 与现有配置读取方式兼容
-
-## 数据流
-
-```
-业务代码
-    ↓
-app/config_store.py
-    ↓
-MySQL 可用？
-    ↓ 是              ↓ 否
-读/写 app_config   读/写 JSON 文件
-```
-
-## 配置键设计
-
-| config_key | 对应文件 | 用途 |
-|------------|----------|------|
-| `symbols` | `config/symbols_config.json` | 品种合约映射 |
-| `ai` | `config/ai_config.json` | AI 模型配置 |
-
-## 降级策略
-
-### 读取流程
-
-1. 检查 MySQL 可用性
-2. MySQL 可用则查询 `app_config`
-3. 数据库无数据则读取 JSON 文件并回填数据库
-4. MySQL 不可用则直接读取 JSON 文件
-
-### 写入流程
-
-1. 检查 MySQL 可用性
-2. MySQL 可用则写入 `app_config`
-3. 无论数据库是否成功，同步写入 JSON 文件（保持一致性）
-4. MySQL 不可用则只写入 JSON 文件
-
-## 兼容性
-
-- 保持 `symbols_config.json` 和 `ai_config.json` 的 schema 不变
-- API 接口签名不变
-- 文件路径不变，作为 fallback 使用
-
-## 数据迁移
-
-启动时执行一次性迁移：
-
-1. 检测 `app_config` 表是否已有 `symbols` 和 `ai` 配置
-2. 缺失则从 JSON 文件读取并写入数据库
-3. 迁移幂等：已存在则跳过
-
-## 测试策略
-
-1. 单元测试：
-   - `ConfigStore.get_config` 从 MySQL 读取
-   - `ConfigStore.get_config` 在 MySQL 不可用时读取 JSON
-   - `ConfigStore.set_config` 写入 MySQL 和 JSON
-   - 迁移幂等性
-2. 集成测试：
-   - 启动时自动创建表并迁移
-   - API 接口正常工作

openspec/changes/archive/2026-07-05-config-to-mysql/proposal.md

@@ -1,59 +0,0 @@
-# Proposal: Config to MySQL
-
-## 问题背景
-
-当前配置信息（`symbols_config.json` 品种合约映射、`ai_config.json` AI 模型配置）以 JSON 文件形式存储在 `config/` 目录下。存在以下问题：
-
-1. **配置与应用状态分离**：文件配置难以统一备份、迁移和多实例共享
-2. **读写分散**：多个模块直接读取 JSON 文件，重复解析逻辑
-3. **无版本/审计**：文件修改无历史记录，难以追踪配置变更
-4. **与架构不一致**：行情数据和分析数据已迁移到 MySQL，配置仍停留在文件系统
-
-## 目标
-
-将 `symbols_config.json` 和 `ai_config.json` 迁移到 MySQL `buffer_platform` 数据库，提供统一的配置读取/写入接口，并保留 JSON 文件作为降级方案。
-
-## 范围
-
-### 包含
-
-- 新增 MySQL 配置表：`symbol_config`、`ai_config`
-- 创建统一配置管理模块 `app/config_store.py`
-- 启动时自动迁移现有 JSON 配置到 MySQL
-- 修改以下模块从数据库读取配置：
-  - `app/api/config.py`
-  - `app/api/ai_config.py`
-  - `app/api/futures_analysis.py`
-  - `app/api/trade_review.py`
-  - `app/services/trade_parser.py`
-  - `app/services/plan_generator.py`
-  - `app/services/ai_analysis.py`
-- MySQL 不可用时降级到 JSON 文件
-
-### 不包含
-
-- 新增业务功能
-- 修改配置结构（保持现有 JSON schema）
-- Redis 缓存层
-
-## 非目标
-
-- 不改变配置 schema
-- 不改变 API 接口签名
-- 不引入配置版本控制或审计日志
-
-## 验收标准
-
-1. 启动时自动创建配置表并迁移 JSON 数据到 MySQL
-2. 所有配置读写通过 `app/config_store.py` 接口
-3. MySQL 不可用时自动降级到 JSON 文件
-4. 现有功能（品种列表、AI 配置、交易复盘、计划生成）正常工作
-5. 单元测试覆盖数据库命中、数据库未命中降级、迁移幂等性
-
-## 风险
-
-| 风险 | 缓解措施 |
-|------|----------|
-| 数据迁移失败 | 保留 JSON 文件作为降级方案 |
-| 配置读取性能下降 | 配置数据量小，数据库查询足够快；无 Redis 需求 |
-| 多处修改引入回归 | 统一封装 + 全面测试 |

openspec/changes/archive/2026-07-05-config-to-mysql/tasks.md

@@ -1,37 +0,0 @@
-# Tasks: Config to MySQL
-
-## 1. 数据模型与配置存储模块
-
-- [x] 1.1 在 `app/models.py` 中新增 `AppConfig` 模型
-- [x] 1.2 创建 `app/config_store.py`，实现 `ConfigStore` 类
-- [x] 1.3 实现 `get_config(key)` 方法，支持 MySQL → JSON 降级
-- [x] 1.4 实现 `set_config(key, value)` 方法，支持 MySQL + JSON 双写
-- [x] 1.5 实现 `_load_json(key, fallback)` 和 `_save_to_json(key, value)` 辅助方法
-
-## 2. 数据迁移
-
-- [x] 2.1 创建 `app/config_migration.py`，实现 `migrate_configs_to_mysql()`
-- [x] 2.2 在 `app/main.py` lifespan 中创建 `app_config` 表
-- [x] 2.3 在 `app/main.py` lifespan 中调用迁移函数
-- [x] 2.4 迁移幂等性：数据库已有配置时跳过
-
-## 3. 修改配置 API
-
-- [x] 3.1 修改 `app/api/config.py` 使用 `ConfigStore` 读写 `symbols` 配置
-- [x] 3.2 修改 `app/api/ai_config.py` 使用 `ConfigStore` 读写 `ai` 配置
-- [x] 3.3 保持 API 接口签名不变
-
-## 4. 修改业务使用方
-
-- [x] 4.1 修改 `app/api/futures_analysis.py` 从 `ConfigStore` 读取品种配置
-- [x] 4.2 修改 `app/api/trade_review.py` 从 `ConfigStore` 读取品种配置
-- [x] 4.3 修改 `app/services/trade_parser.py` 从 `ConfigStore` 读取品种配置
-- [x] 4.4 修改 `app/services/plan_generator.py` 从 `ConfigStore` 读取品种配置
-- [x] 4.5 修改 `app/services/ai_analysis.py` 从 `ConfigStore` 读取 AI 配置
-
-## 5. 测试与验证
-
-- [x] 5.1 编写 `tests/test_config_store.py`，覆盖 MySQL 命中/未命中/降级场景
-- [x] 5.2 编写迁移测试，验证幂等性
-- [x] 5.3 运行全部测试套件，确保无回归（110 passed, 2 xfailed）
-- [x] 5.4 启动应用验证配置读取正常

openspec/specs/dual-write-consistency/spec.md

@@ -1,30 +0,0 @@
-## ADDED Requirements
-
-### Requirement: 刷新接口双写
-系统应当在刷新接口中实现 Redis 和 MySQL 的同步双写，保证数据一致性。
-
-#### Scenario: 刷新接口双写成功
-- **WHEN** 用户调用刷新接口更新行情数据
-- **THEN** 系统先删除 Redis 缓存，再写入 MySQL，最后更新 Redis 缓存
-
-#### Scenario: MySQL 写入失败
-- **WHEN** 刷新接口写入 MySQL 失败
-- **THEN** 系统返回错误响应，不更新 Redis 缓存，保证数据一致性
-
-#### Scenario: Redis 写入失败
-- **WHEN** 刷新接口写入 MySQL 成功但 Redis 写入失败
-- **THEN** 系统返回成功响应（MySQL 数据已持久化），输出 Redis 写入失败警告日志
-
-### Requirement: 双写顺序保证
-系统应当保证双写的顺序：先写 MySQL，再更新 Redis。
-
-#### Scenario: 双写顺序
-- **WHEN** 刷新接口执行双写
-- **THEN** 系统先写入 MySQL 并确认成功，再更新 Redis 缓存
-
-### Requirement: 缓存回填一致性
-系统应当在缓存未命中回填时保证回填数据与 MySQL 数据一致。
-
-#### Scenario: 缓存未命中回填
-- **WHEN** Redis 缓存未命中且从 MySQL 读取数据
-- **THEN** 系统将 MySQL 数据回填到 Redis，TTL 设置为 30 天

openspec/specs/mysql-persistence/spec.md

@@ -1,41 +0,0 @@
-## ADDED Requirements
-
-### Requirement: MySQL 连接管理
-系统应当提供 MySQL 连接管理能力，包括连接初始化、连接池管理和表结构初始化。
-
-#### Scenario: MySQL 连接初始化成功
-- **WHEN** 应用启动且 MySQL 配置有效
-- **THEN** 系统成功建立 MySQL 连接并创建必要的表结构
-
-#### Scenario: MySQL 连接初始化失败
-- **WHEN** 应用启动但 MySQL 服务不可用
-- **THEN** 系统输出错误日志并标记 MySQL 为不可用状态，但不阻止应用启动
-
-### Requirement: 行情数据持久化存储
-系统应当使用 MySQL 作为行情数据的主要持久化存储，替代 SQLite。
-
-#### Scenario: 行情数据写入 MySQL
-- **WHEN** 刷新接口接收到行情数据更新请求
-- **THEN** 系统将数据写入 MySQL 的 `market_data` 表
-
-#### Scenario: 行情数据从 MySQL 读取
-- **WHEN** Redis 缓存未命中且 MySQL 可用
-- **THEN** 系统从 MySQL 读取行情数据并返回
-
-### Requirement: MySQL 表结构迁移
-系统应当提供从 SQLite 到 MySQL 的数据迁移能力，保证历史数据不丢失。
-
-#### Scenario: 首次启动数据迁移
-- **WHEN** 应用首次启动且 MySQL 可用但表为空
-- **THEN** 系统从 SQLite 读取历史数据并迁移到 MySQL
-
-#### Scenario: 迁移完成
-- **WHEN** 数据迁移完成
-- **THEN** 系统输出迁移成功日志，后续读写直接操作 MySQL
-
-### Requirement: MySQL 事务支持
-系统应当使用 MySQL 事务保证数据写入的原子性和一致性。
-
-#### Scenario: 批量写入事务
-- **WHEN** 刷新接口需要写入多个品种的行情数据
-- **THEN** 系统使用事务保证所有数据要么全部写入成功，要么全部回滚

openspec/specs/redis-cache-layer/spec.md

@@ -1,41 +0,0 @@
-## ADDED Requirements
-
-### Requirement: Redis 缓存连接管理
-系统应当提供 Redis 连接管理能力，包括连接初始化、健康检查和连接池管理。
-
-#### Scenario: Redis 连接初始化成功
-- **WHEN** 应用启动且 Redis 配置有效
-- **THEN** 系统成功建立 Redis 连接并输出初始化成功日志
-
-#### Scenario: Redis 连接初始化失败
-- **WHEN** 应用启动但 Redis 服务不可用
-- **THEN** 系统输出警告日志并标记 Redis 为不可用状态，但不阻止应用启动
-
-### Requirement: 行情数据缓存读取
-系统应当优先从 Redis 读取行情数据，缓存未命中时回源 MySQL。
-
-#### Scenario: Redis 缓存命中
-- **WHEN** 用户请求行情数据且 Redis 中存在该数据
-- **THEN** 系统直接从 Redis 返回数据，不访问 MySQL
-
-#### Scenario: Redis 缓存未命中
-- **WHEN** 用户请求行情数据但 Redis 中不存在该数据
-- **THEN** 系统从 MySQL 读取数据，回填到 Redis（TTL 30 天），并返回数据
-
-### Requirement: Redis 缓存 TTL 管理
-系统应当为缓存数据设置 30 天过期时间，过期后自动清理。
-
-#### Scenario: 缓存数据过期
-- **WHEN** 缓存数据超过 30 天未访问
-- **THEN** Redis 自动清理该数据，下次访问时从 MySQL 重新加载
-
-#### Scenario: 缓存数据续期
-- **WHEN** 用户访问已缓存的行情数据
-- **THEN** 系统返回缓存数据，TTL 保持为 30 天（不续期）
-
-### Requirement: Redis 缓存失效
-系统应当在数据更新时主动失效相关缓存，保证数据一致性。
-
-#### Scenario: 刷新接口触发缓存失效
-- **WHEN** 用户调用刷新接口更新行情数据
-- **THEN** 系统先删除 Redis 中对应的缓存数据，再执行双写流程

openspec/specs/storage-fallback/spec.md

@@ -1,38 +0,0 @@
-## ADDED Requirements
-
-### Requirement: 三级降级策略
-系统应当实现 Redis → MySQL → SQLite 的三级降级读取策略，保证系统可用性。
-
-#### Scenario: 正常模式（Redis + MySQL 可用）
-- **WHEN** Redis 和 MySQL 均可用
-- **THEN** 系统优先从 Redis 读取，未命中时回源 MySQL
-
-#### Scenario: Redis 不可用降级
-- **WHEN** Redis 服务不可用但 MySQL 可用
-- **THEN** 系统直接从 MySQL 读取数据，跳过 Redis 缓存层
-
-#### Scenario: Redis 和 MySQL 均不可用降级
-- **WHEN** Redis 和 MySQL 均不可用
-- **THEN** 系统降级到 SQLite，从 SQLite 读取数据并保证基础服务可用
-
-### Requirement: 降级状态检测
-系统应当能够检测存储后端的可用性状态，并在降级时输出明确的日志。
-
-#### Scenario: 启动时降级检测
-- **WHEN** 应用启动时检测到 Redis 或 MySQL 不可用
-- **THEN** 系统输出降级警告日志，说明当前使用的存储模式
-
-#### Scenario: 运行时降级触发
-- **WHEN** 运行中 Redis 或 MySQL 连接异常
-- **THEN** 系统自动切换到降级模式，输出降级日志，并继续提供服务
-
-### Requirement: 降级恢复
-系统应当能够在存储后端恢复后自动恢复到正常模式。
-
-#### Scenario: Redis 恢复
-- **WHEN** Redis 从不可用状态恢复
-- **THEN** 系统自动恢复到 Redis + MySQL 模式，后续读取优先使用 Redis
-
-#### Scenario: MySQL 恢复
-- **WHEN** MySQL 从不可用状态恢复
-- **THEN** 系统自动恢复到 Redis + MySQL 模式，SQLite 降级结束

requirements.txt

@@ -1,4 +1,4 @@
-fastapi>=0.110.0
+fastapi>=0.110.0
 uvicorn>=0.29.0
 sqlalchemy>=2.0.0
 aiosqlite>=0.20.0
@@ -10,7 +10,3 @@ tenacity>=8.2.0
 requests>=2.31.0
 httpx>=0.27.0
 python-multipart>=0.0.9
-redis>=5.0.0
-pymysql>=1.1.0
-cryptography>=42.0.0
-python-dotenv>=1.0.0

tests/test_analysis_storage.py

@@ -1,171 +0,0 @@
-"""Analysis 存储迁移测试：Redis 缓存 + MySQL/SQLite 降级。"""
-import json
-from datetime import datetime
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-from app.storage_manager import StorageManager
-
-
-class TestStorageManagerCache:
-    """StorageManager 通用缓存方法测试。"""
-
-    def test_cache_get_returns_redis_value_on_hit(self):
-        """Redis 命中时返回反序列化数据。"""
-        redis_client = MagicMock()
-        redis_client.get.return_value = json.dumps({"symbol": "AG2606", "score": 85})
-        manager = StorageManager(redis_client=redis_client, mysql_engine=MagicMock())
-
-        result = manager.cache_get("analysis:ai_analysis_cache:1")
-
-        assert result == {"symbol": "AG2606", "score": 85}
-        redis_client.get.assert_called_once_with("analysis:ai_analysis_cache:1")
-
-    def test_cache_get_returns_none_when_redis_unavailable(self):
-        """Redis 不可用时返回 None。"""
-        manager = StorageManager(redis_client=None, mysql_engine=MagicMock())
-
-        result = manager.cache_get("analysis:ai_analysis_cache:1")
-
-        assert result is None
-
-    def test_cache_get_returns_none_on_miss(self):
-        """Redis 未命中时返回 None。"""
-        redis_client = MagicMock()
-        redis_client.get.return_value = None
-        manager = StorageManager(redis_client=redis_client, mysql_engine=MagicMock())
-
-        result = manager.cache_get("analysis:ai_analysis_cache:1")
-
-        assert result is None
-
-    def test_cache_set_writes_to_redis_with_ttl(self):
-        """cache_set 使用 TTL 写入 Redis。"""
-        redis_client = MagicMock()
-        manager = StorageManager(redis_client=redis_client, mysql_engine=MagicMock())
-        value = {"symbol": "AG2606", "score": 85}
-
-        manager.cache_set("analysis:ai_analysis_cache:1", value, ttl=300)
-
-        redis_client.setex.assert_called_once_with(
-            "analysis:ai_analysis_cache:1", 300, json.dumps(value, ensure_ascii=False)
-        )
-
-    def test_cache_set_returns_false_when_redis_unavailable(self):
-        """Redis 不可用时 cache_set 返回 False。"""
-        manager = StorageManager(redis_client=None, mysql_engine=MagicMock())
-
-        result = manager.cache_set("analysis:ai_analysis_cache:1", {"score": 85}, ttl=300)
-
-        assert result is False
-
-    def test_cache_delete_removes_redis_key(self):
-        """cache_delete 删除 Redis 键。"""
-        redis_client = MagicMock()
-        manager = StorageManager(redis_client=redis_client, mysql_engine=MagicMock())
-
-        manager.cache_delete("analysis:ai_analysis_cache:1")
-
-        redis_client.delete.assert_called_once_with("analysis:ai_analysis_cache:1")
-
-
-class TestAnalysisDbSwitching:
-    """analysis_db 动态 Session 切换测试。"""
-
-    def test_get_analysis_db_returns_mysql_session_when_mysql_available(self):
-        """MySQL 可用时返回 MySQL Session。"""
-        from app.analysis_db import get_analysis_db
-
-        mysql_engine = MagicMock()
-        mock_session = MagicMock()
-        mock_sessionmaker = MagicMock(return_value=mock_session)
-        mock_session.__enter__ = MagicMock(return_value=mock_session)
-        mock_session.__exit__ = MagicMock(return_value=False)
-
-        with patch("app.analysis_db.MySQLSessionLocal", mock_sessionmaker):
-            with patch("app.analysis_db.get_storage_manager") as mock_sm:
-                sm = MagicMock()
-                sm.check_mysql.return_value = True
-                sm.mysql_engine = mysql_engine
-                mock_sm.return_value = sm
-
-                db = next(get_analysis_db())
-
-                assert db is mock_session
-
-    def test_get_analysis_db_returns_sqlite_session_when_mysql_unavailable(self):
-        """MySQL 不可用时返回 SQLite Session。"""
-        from app.analysis_db import get_analysis_db
-
-        sqlite_engine = MagicMock()
-        mock_session = MagicMock()
-        mock_sessionmaker = MagicMock(return_value=mock_session)
-        mock_session.__enter__ = MagicMock(return_value=mock_session)
-        mock_session.__exit__ = MagicMock(return_value=False)
-
-        with patch("app.analysis_db.AnalysisSessionLocal", mock_sessionmaker):
-            with patch("app.analysis_db.get_storage_manager") as mock_sm:
-                sm = MagicMock()
-                sm.check_mysql.return_value = False
-                mock_sm.return_value = sm
-
-                db = next(get_analysis_db())
-
-                assert db is mock_session
-
-
-class TestAnalysisMigration:
-    """Analysis 数据迁移测试。"""
-
-    def test_migrate_skips_when_mysql_has_data(self):
-        """MySQL 已有数据时跳过迁移。"""
-        from app.analysis_migration import migrate_analysis_sqlite_to_mysql
-
-        with patch("app.analysis_migration.mysql_engine", MagicMock()):
-            with patch("app.analysis_migration._count_mysql_analysis_records") as mock_count:
-                mock_count.return_value = 10
-
-                result = migrate_analysis_sqlite_to_mysql()
-
-                assert result is True
-                mock_count.assert_called_once()
-
-    def test_migrate_moves_data_from_sqlite_to_mysql(self):
-        """SQLite 数据正确迁移到 MySQL。"""
-        from app.analysis_migration import migrate_analysis_sqlite_to_mysql
-
-        with patch("app.analysis_migration.mysql_engine", MagicMock()):
-            with patch("app.analysis_migration._count_mysql_analysis_records") as mock_count:
-                mock_count.return_value = 0
-                with patch("app.analysis_migration._read_sqlite_analysis_data") as mock_read:
-                    mock_read.return_value = {
-                        "ai_analysis_cache": [{"id": 1, "symbol": "AG2606"}]
-                    }
-                    with patch("app.analysis_migration._write_mysql_analysis_data") as mock_write:
-                        mock_write.return_value = True
-
-                        result = migrate_analysis_sqlite_to_mysql()
-
-                        assert result is True
-                        mock_write.assert_called_once_with({"ai_analysis_cache": [{"id": 1, "symbol": "AG2606"}]})
-
-    def test_get_analysis_db_falls_back_to_sqlite_when_mysql_session_fails(self):
-        """MySQL Session 创建失败时降级到 SQLite。"""
-        from app.analysis_db import get_analysis_db
-
-        mysql_session_maker = MagicMock(side_effect=RuntimeError("MySQL 连接失败"))
-        sqlite_session = MagicMock()
-        sqlite_session_maker = MagicMock(return_value=sqlite_session)
-
-        with patch("app.analysis_db.MySQLSessionLocal", mysql_session_maker):
-            with patch("app.analysis_db.AnalysisSessionLocal", sqlite_session_maker):
-                with patch("app.analysis_db.get_storage_manager") as mock_sm:
-                    sm = MagicMock()
-                    sm.check_mysql.return_value = True
-                    mock_sm.return_value = sm
-
-                    db = next(get_analysis_db())
-
-                    assert db is sqlite_session
-                    mysql_session_maker.assert_called_once()

tests/test_cache_storage_integration.py

@@ -1,544 +0,0 @@
-"""
-cache.py StorageManager 集成与 SQLite 降级逻辑测试
-"""
-import json
-import logging
-from datetime import datetime
-from unittest.mock import MagicMock, patch
-
-import pytest
-from sqlalchemy import create_engine
-from sqlalchemy.orm import sessionmaker
-
-from app.models import Base, MarketData, SymbolTimestamp
-
-
-@pytest.fixture
-def db():
-    """提供已创建表结构的内存 SQLite 会话。"""
-    engine = create_engine("sqlite:///:memory:")
-    Base.metadata.create_all(bind=engine)
-    Session = sessionmaker(bind=engine)
-    session = Session()
-    yield session
-    session.close()
-
-
-@pytest.fixture
-def sample_data():
-    """构造与采集脚本格式一致的测试数据。"""
-    return {
-        "type": "futures",
-        "current_price": 123.45,
-        "timestamp": datetime(2026, 7, 4, 10, 0, 0).isoformat(),
-        "timeframes": {
-            "5min": [{"datetime": "2026-07-04T09:55:00", "open": 100, "close": 110}],
-            "15min": [{"datetime": "2026-07-04T09:45:00", "open": 105, "close": 115}],
-        },
-    }
-
-
-@pytest.fixture
-def storage_manager_mock():
-    """构造默认可用的 StorageManager mock。"""
-    manager = MagicMock()
-    manager.is_available.return_value = True
-    manager.save_market_data_with_timestamp.return_value = True
-    manager.save_market_data.return_value = True
-    manager.save_symbol_timestamp.return_value = True
-    manager.get_market_data.return_value = None
-    manager.get_symbol_timestamp.return_value = None
-    return manager
-
-
-def _seed_sqlite_market_data(db, symbol="AG2606", data_type="futures"):
-    """在 SQLite 中写入行情数据（使用当前时间确保缓存未过期）。"""
-    fetched_at = datetime.now()
-    db.add_all(
-        [
-            MarketData(
-                symbol=symbol,
-                data_type=data_type,
-                period="5min",
-                candles_json=json.dumps(
-                    [{"datetime": "2026-07-04T09:55:00", "open": 100, "close": 110}]
-                ),
-                current_price=123.45,
-                fetched_at=fetched_at,
-                candle_count=1,
-            ),
-            MarketData(
-                symbol=symbol,
-                data_type=data_type,
-                period="15min",
-                candles_json=json.dumps(
-                    [{"datetime": "2026-07-04T09:45:00", "open": 105, "close": 115}]
-                ),
-                current_price=123.45,
-                fetched_at=fetched_at,
-                candle_count=1,
-            ),
-        ]
-    )
-    db.commit()
-
-
-def _seed_sqlite_symbol_timestamp(db, symbol="AG2606", data_type="futures"):
-    """在 SQLite 中写入合约时间戳。"""
-    db.add(
-        SymbolTimestamp(
-            symbol=symbol,
-            data_type=data_type,
-            last_refresh_at=datetime(2026, 7, 4, 10, 0, 0),
-            refresh_count=3,
-        )
-    )
-    db.commit()
-
-
-class TestSaveMarketData:
-    """save_market_data 双写与降级测试。"""
-
-    def test_uses_storage_manager_when_available(self, db, sample_data, storage_manager_mock):
-        """StorageManager 可用时通过原子方法写入行情数据与时间戳，并返回代表记录。"""
-        with patch("app.services.cache.get_storage_manager", return_value=storage_manager_mock):
-            from app.services import cache
-
-            result = cache.save_market_data(db, "AG2606", sample_data)
-
-        storage_manager_mock.is_available.assert_called_once()
-        storage_manager_mock.save_market_data_with_timestamp.assert_called_once()
-        call_args = storage_manager_mock.save_market_data_with_timestamp.call_args[0]
-        assert call_args[0] == "AG2606"
-        assert call_args[1] == sample_data
-        assert isinstance(call_args[2], datetime)
-        storage_manager_mock.save_market_data.assert_not_called()
-        storage_manager_mock.save_symbol_timestamp.assert_not_called()
-        assert isinstance(result, MarketData)
-        assert result.symbol == "AG2606"
-        assert result.data_type == "futures"
-        assert result.current_price == 123.45
-
-        sqlite_records = db.query(MarketData).filter_by(symbol="AG2606").all()
-        assert len(sqlite_records) == 0
-
-    def test_falls_back_to_sqlite_when_storage_unavailable(self, db, sample_data, storage_manager_mock):
-        """StorageManager 不可用时降级到 SQLite 写入。"""
-        storage_manager_mock.is_available.return_value = False
-
-        with patch("app.services.cache.get_storage_manager", return_value=storage_manager_mock):
-            from app.services import cache
-
-            result = cache.save_market_data(db, "AG2606", sample_data)
-
-        storage_manager_mock.save_market_data.assert_not_called()
-        storage_manager_mock.save_symbol_timestamp.assert_not_called()
-
-        assert isinstance(result, MarketData)
-        sqlite_records = db.query(MarketData).filter_by(symbol="AG2606").all()
-        assert len(sqlite_records) == 2
-        periods = {r.period for r in sqlite_records}
-        assert periods == {"5min", "15min"}
-
-    def test_falls_back_to_sqlite_when_storage_save_fails(self, db, sample_data, storage_manager_mock):
-        """StorageManager 写入失败时降级到 SQLite 写入。"""
-        storage_manager_mock.save_market_data_with_timestamp.return_value = False
-
-        with patch("app.services.cache.get_storage_manager", return_value=storage_manager_mock):
-            from app.services import cache
-
-            result = cache.save_market_data(db, "AG2606", sample_data)
-
-        storage_manager_mock.save_market_data_with_timestamp.assert_called_once()
-        storage_manager_mock.save_market_data.assert_not_called()
-        storage_manager_mock.save_symbol_timestamp.assert_not_called()
-        assert isinstance(result, MarketData)
-        assert db.query(MarketData).filter_by(symbol="AG2606").count() == 2
-
-    def test_falls_back_to_sqlite_when_storage_raises(self, db, sample_data, storage_manager_mock, caplog):
-        """StorageManager 写入异常时降级到 SQLite 写入并记录警告。"""
-        storage_manager_mock.save_market_data_with_timestamp.side_effect = Exception("storage down")
-
-        with patch("app.services.cache.get_storage_manager", return_value=storage_manager_mock):
-            from app.services import cache
-
-            with caplog.at_level(logging.WARNING, logger="app.services.cache"):
-                result = cache.save_market_data(db, "AG2606", sample_data)
-
-        storage_manager_mock.save_market_data_with_timestamp.assert_called_once()
-        storage_manager_mock.save_market_data.assert_not_called()
-        storage_manager_mock.save_symbol_timestamp.assert_not_called()
-        assert isinstance(result, MarketData)
-        assert db.query(MarketData).filter_by(symbol="AG2606").count() == 2
-        assert "StorageManager 写入失败" in caplog.text
-
-
-class TestGetCachedData:
-    """get_cached_data 读取与降级测试。"""
-
-    def test_uses_storage_manager_and_merges_periods(self, db, storage_manager_mock):
-        """StorageManager 返回合并后的多周期数据。"""
-        fetched_at = datetime.now()
-
-        storage_manager_mock.get_market_data.return_value = {
-            "symbol": "AG2606",
-            "type": "futures",
-            "current_price": 123.45,
-            "timestamp": fetched_at.isoformat(),
-            "fetched_at": fetched_at.isoformat(),
-            "timeframes": {
-                "5min": [{"datetime": "2026-07-04T09:55:00", "open": 100, "close": 110}],
-                "15min": [{"datetime": "2026-07-04T09:45:00", "open": 105, "close": 115}],
-            },
-            "is_fresh": True,
-        }
-
-        with patch("app.services.cache.get_storage_manager", return_value=storage_manager_mock):
-            from app.services import cache
-
-            result = cache.get_cached_data(db, "AG2606", "futures", ["5min", "15min"])
-
-        storage_manager_mock.get_market_data.assert_called_once_with(
-            "AG2606", "futures", ["5min", "15min"], end_time=None, max_candles=100
-        )
-
-        assert result is not None
-        assert result["symbol"] == "AG2606"
-        assert result["type"] == "futures"
-        assert result["current_price"] == 123.45
-        assert result["timestamp"] == fetched_at.isoformat()
-        assert result["fetched_at"] == fetched_at.isoformat()
-        assert "5min" in result["timeframes"]
-        assert "15min" in result["timeframes"]
-        assert len(result["timeframes"]["5min"]) == 1
-        assert result["is_fresh"] is True
-
-    def test_falls_back_to_sqlite_when_storage_returns_none(self, db, storage_manager_mock):
-        """StorageManager 未命中时降级到 SQLite 读取。"""
-        storage_manager_mock.get_market_data.return_value = None
-        _seed_sqlite_market_data(db)
-
-        with patch("app.services.cache.get_storage_manager", return_value=storage_manager_mock):
-            from app.services import cache
-
-            result = cache.get_cached_data(db, "AG2606", "futures", ["5min", "15min"])
-
-        assert result is not None
-        assert result["symbol"] == "AG2606"
-        assert "5min" in result["timeframes"]
-        assert "15min" in result["timeframes"]
-
-    def test_falls_back_to_sqlite_when_storage_raises(self, db, storage_manager_mock, caplog):
-        """StorageManager 读取异常时降级到 SQLite 读取并记录警告。"""
-        storage_manager_mock.get_market_data.side_effect = Exception("storage down")
-        _seed_sqlite_market_data(db)
-
-        with patch("app.services.cache.get_storage_manager", return_value=storage_manager_mock):
-            from app.services import cache
-
-            with caplog.at_level(logging.WARNING, logger="app.services.cache"):
-                result = cache.get_cached_data(db, "AG2606", "futures", ["5min"])
-
-        assert result is not None
-        assert "StorageManager 读取失败" in caplog.text
-
-
-    def test_passes_end_time_and_max_candles_to_storage(self, db, storage_manager_mock):
-        """get_cached_data 将 end_time / max_candles 透传给 StorageManager。"""
-        end_time = datetime(2026, 7, 4, 10, 0, 0)
-
-        with patch("app.services.cache.get_storage_manager", return_value=storage_manager_mock):
-            from app.services import cache
-
-            cache.get_cached_data(db, "AG2606", "futures", ["5min"], end_time=end_time, max_candles=50)
-
-        storage_manager_mock.get_market_data.assert_called_once_with(
-            "AG2606", "futures", ["5min"], end_time=end_time, max_candles=50
-        )
-
-    def test_does_not_refilter_storage_manager_results(self, db, storage_manager_mock):
-        """cache.py 不再对 StorageManager 返回的数据做二次过滤，直接原样返回。"""
-        fetched_at = datetime.now()
-
-        def mock_get_market_data(symbol, data_type, periods, end_time=None, max_candles=100):
-            return {
-                "symbol": symbol,
-                "type": data_type,
-                "current_price": 123.45,
-                "timestamp": fetched_at.isoformat(),
-                "fetched_at": fetched_at.isoformat(),
-                "timeframes": {
-                    "5min": [
-                        {"datetime": "2026-07-04T09:50:00", "open": 100, "close": 101},
-                        {"datetime": "2026-07-04T09:55:00", "open": 101, "close": 102},
-                        {"datetime": "2026-07-04T10:05:00", "open": 102, "close": 103},
-                    ]
-                },
-                "is_fresh": True,
-            }
-
-        storage_manager_mock.get_market_data.side_effect = mock_get_market_data
-
-        with patch("app.services.cache.get_storage_manager", return_value=storage_manager_mock):
-            from app.services import cache
-
-            result = cache.get_cached_data(
-                db, "AG2606", "futures", ["5min"],
-                end_time=datetime(2026, 7, 4, 10, 0, 0),
-                max_candles=1,
-            )
-
-        assert result is not None
-        candles = result["timeframes"]["5min"]
-        # StorageManager 未做过滤，cache.py 也不应再次过滤
-        assert len(candles) == 3
-
-    def test_does_not_mutate_storage_manager_result(self, db, storage_manager_mock):
-        """get_cached_data 返回 StorageManager 结果时不会原地修改原对象。"""
-        fetched_at = datetime.now()
-        original = {
-            "symbol": "AG2606",
-            "type": "futures",
-            "current_price": 123.45,
-            "timestamp": fetched_at.isoformat(),
-            "fetched_at": fetched_at.isoformat(),
-            "timeframes": {
-                "5min": [
-                    {"datetime": "2026-07-04T09:55:00", "open": 100, "close": 110}
-                ]
-            },
-            "is_fresh": True,
-        }
-        storage_manager_mock.get_market_data.return_value = original
-
-        with patch("app.services.cache.get_storage_manager", return_value=storage_manager_mock):
-            from app.services import cache
-
-            result = cache.get_cached_data(db, "AG2606", "futures", ["5min"])
-
-        assert result is not None
-        assert result is not original
-        assert result["timeframes"]["5min"] == original["timeframes"]["5min"]
-        # 修改返回结果不应影响 StorageManager 返回的原对象
-        result["timeframes"]["5min"].append(
-            {"datetime": "2026-07-04T10:00:00", "open": 111, "close": 112}
-        )
-        assert len(original["timeframes"]["5min"]) == 1
-
-    def test_queries_all_periods_when_periods_is_none(self, db, storage_manager_mock):
-        """periods=None 时优先走 StorageManager 查询全部周期。"""
-        fetched_at = datetime.now()
-
-        def mock_get_market_data(symbol, data_type, periods=None, end_time=None, max_candles=100):
-            return {
-                "symbol": symbol,
-                "type": data_type,
-                "current_price": 123.45,
-                "timestamp": fetched_at.isoformat(),
-                "fetched_at": fetched_at.isoformat(),
-                "timeframes": {"5min": [], "15min": []},
-                "is_fresh": True,
-            }
-
-        storage_manager_mock.get_market_data.side_effect = mock_get_market_data
-
-        with patch("app.services.cache.get_storage_manager", return_value=storage_manager_mock):
-            from app.services import cache
-
-            result = cache.get_cached_data(db, "AG2606", "futures", periods=None)
-
-        storage_manager_mock.get_market_data.assert_called_once_with(
-            "AG2606", "futures", None, end_time=None, max_candles=100
-        )
-        assert result is not None
-        assert "5min" in result["timeframes"]
-        assert "15min" in result["timeframes"]
-
-
-class TestCacheStatus:
-    """is_cache_valid / check_cache_status / get_latest_cached 存储层兼容测试。"""
-
-    def _make_merged_result(self, symbol="AG2606", data_type="futures", periods=None, age_seconds=0):
-        fetched_at = datetime.now() - __import__("datetime").timedelta(seconds=age_seconds)
-        timeframes = {}
-        for p in (periods or ["5min", "15min"]):
-            timeframes[p] = [{"datetime": fetched_at.isoformat(), "open": 100, "close": 110}]
-        return {
-            "symbol": symbol,
-            "type": data_type,
-            "current_price": 123.45,
-            "timestamp": fetched_at.isoformat(),
-            "fetched_at": fetched_at.isoformat(),
-            "timeframes": timeframes,
-            "is_fresh": True,
-        }
-
-    def test_is_cache_valid_uses_storage_when_available(self, db, storage_manager_mock):
-        """StorageManager 可用时优先判断缓存有效性。"""
-        storage_manager_mock.get_market_data.return_value = self._make_merged_result(age_seconds=10)
-
-        with patch("app.services.cache.get_storage_manager", return_value=storage_manager_mock):
-            from app.services import cache
-
-            assert cache.is_cache_valid(db, "AG2606", "futures", "5min") is True
-            storage_manager_mock.get_market_data.assert_called_once_with(
-                "AG2606", "futures", ["5min"]
-            )
-
-    def test_is_cache_valid_falls_back_to_sqlite(self, db, storage_manager_mock):
-        """StorageManager 无数据时降级到 SQLite 判断缓存有效性。"""
-        storage_manager_mock.get_market_data.return_value = None
-        _seed_sqlite_market_data(db)
-
-        with patch("app.services.cache.get_storage_manager", return_value=storage_manager_mock):
-            from app.services import cache
-
-            assert cache.is_cache_valid(db, "AG2606", "futures", "5min") is True
-
-    def test_check_cache_status_uses_storage_when_available(self, db, storage_manager_mock):
-        """StorageManager 可用时优先检查多周期缓存状态。"""
-        storage_manager_mock.get_market_data.return_value = self._make_merged_result()
-
-        with patch("app.services.cache.get_storage_manager", return_value=storage_manager_mock):
-            from app.services import cache
-
-            status = cache.check_cache_status(db, "AG2606", "futures", ["5min", "15min"])
-
-        assert status["all_valid"] is True
-        assert set(status["valid_periods"]) == {"5min", "15min"}
-        assert status["missing_periods"] == []
-
-    def test_check_cache_status_falls_back_to_sqlite(self, db, storage_manager_mock):
-        """StorageManager 无数据时降级到 SQLite 检查多周期缓存状态。"""
-        storage_manager_mock.get_market_data.return_value = None
-        _seed_sqlite_market_data(db)
-
-        with patch("app.services.cache.get_storage_manager", return_value=storage_manager_mock):
-            from app.services import cache
-
-            status = cache.check_cache_status(db, "AG2606", "futures", ["5min", "15min"])
-
-        assert status["all_valid"] is True
-        assert set(status["valid_periods"]) == {"5min", "15min"}
-
-    def test_get_latest_cached_uses_storage_when_available(self, db, storage_manager_mock):
-        """StorageManager 可用时优先获取最新缓存记录。"""
-        storage_manager_mock.get_market_data.return_value = self._make_merged_result()
-
-        with patch("app.services.cache.get_storage_manager", return_value=storage_manager_mock):
-            from app.services import cache
-
-            records = cache.get_latest_cached(db, "AG2606", "futures")
-
-        assert len(records) == 2
-        periods = {r.period for r in records}
-        assert periods == {"5min", "15min"}
-        assert all(isinstance(r, MarketData) for r in records)
-
-    def test_get_latest_cached_falls_back_to_sqlite(self, db, storage_manager_mock):
-        """StorageManager 无数据时降级到 SQLite 获取最新缓存记录。"""
-        storage_manager_mock.get_market_data.return_value = None
-        _seed_sqlite_market_data(db)
-
-        with patch("app.services.cache.get_storage_manager", return_value=storage_manager_mock):
-            from app.services import cache
-
-            records = cache.get_latest_cached(db, "AG2606", "futures")
-
-        assert len(records) == 2
-        periods = {r.period for r in records}
-        assert periods == {"5min", "15min"}
-
-
-class TestSymbolTimestamp:
-    """合约时间戳函数封装测试。"""
-
-    def test_update_symbol_timestamp_uses_storage_when_available(self, db, storage_manager_mock):
-        """StorageManager 可用时优先写入合约时间戳。"""
-        refresh_time = datetime(2026, 7, 4, 10, 0, 0)
-
-        with patch("app.services.cache.get_storage_manager", return_value=storage_manager_mock):
-            from app.services import cache
-
-            cache.update_symbol_timestamp(db, "AG2606", "futures", refresh_time)
-
-        storage_manager_mock.save_symbol_timestamp.assert_called_once_with("AG2606", "futures", refresh_time)
-        sqlite_record = db.query(SymbolTimestamp).filter_by(symbol="AG2606").first()
-        assert sqlite_record is None
-
-    def test_update_symbol_timestamp_falls_back_to_sqlite(self, db, storage_manager_mock):
-        """StorageManager 不可用时降级到 SQLite 写入合约时间戳。"""
-        storage_manager_mock.is_available.return_value = False
-        refresh_time = datetime(2026, 7, 4, 10, 0, 0)
-
-        with patch("app.services.cache.get_storage_manager", return_value=storage_manager_mock):
-            from app.services import cache
-
-            cache.update_symbol_timestamp(db, "AG2606", "futures", refresh_time)
-
-        storage_manager_mock.save_symbol_timestamp.assert_not_called()
-        sqlite_record = db.query(SymbolTimestamp).filter_by(symbol="AG2606").first()
-        assert sqlite_record is not None
-        assert sqlite_record.last_refresh_at == refresh_time
-        assert sqlite_record.refresh_count == 1
-
-    def test_update_symbol_timestamp_falls_back_to_sqlite_when_storage_returns_false(self, db, storage_manager_mock):
-        """StorageManager 可用但返回 False 时降级到 SQLite 写入合约时间戳。"""
-        storage_manager_mock.save_symbol_timestamp.return_value = False
-        refresh_time = datetime(2026, 7, 4, 10, 0, 0)
-
-        with patch("app.services.cache.get_storage_manager", return_value=storage_manager_mock):
-            from app.services import cache
-
-            cache.update_symbol_timestamp(db, "AG2606", "futures", refresh_time)
-
-        storage_manager_mock.save_symbol_timestamp.assert_called_once_with("AG2606", "futures", refresh_time)
-        sqlite_record = db.query(SymbolTimestamp).filter_by(symbol="AG2606").first()
-        assert sqlite_record is not None
-        assert sqlite_record.last_refresh_at == refresh_time
-        assert sqlite_record.refresh_count == 1
-
-    def test_update_symbol_timestamp_falls_back_to_sqlite_when_storage_raises(self, db, storage_manager_mock, caplog):
-        """StorageManager 可用但写入异常时降级到 SQLite 写入合约时间戳并记录警告。"""
-        storage_manager_mock.save_symbol_timestamp.side_effect = Exception("mysql down")
-        refresh_time = datetime(2026, 7, 4, 10, 0, 0)
-
-        with patch("app.services.cache.get_storage_manager", return_value=storage_manager_mock):
-            from app.services import cache
-
-            with caplog.at_level(logging.WARNING, logger="app.services.cache"):
-                cache.update_symbol_timestamp(db, "AG2606", "futures", refresh_time)
-
-        storage_manager_mock.save_symbol_timestamp.assert_called_once_with("AG2606", "futures", refresh_time)
-        sqlite_record = db.query(SymbolTimestamp).filter_by(symbol="AG2606").first()
-        assert sqlite_record is not None
-        assert sqlite_record.last_refresh_at == refresh_time
-        assert sqlite_record.refresh_count == 1
-        assert "StorageManager 时间戳写入失败" in caplog.text
-
-    def test_get_symbol_timestamp_uses_storage_when_available(self, db, storage_manager_mock):
-        """StorageManager 可用时优先读取合约时间戳。"""
-        storage_manager_mock.get_symbol_timestamp.return_value = {
-            "last_refresh_at": datetime(2026, 7, 4, 10, 0, 0).isoformat(),
-            "refresh_count": 42,
-        }
-
-        with patch("app.services.cache.get_storage_manager", return_value=storage_manager_mock):
-            from app.services import cache
-
-            result = cache.get_symbol_timestamp(db, "AG2606", "futures")
-
-        storage_manager_mock.get_symbol_timestamp.assert_called_once_with("AG2606", "futures")
-        assert result == datetime(2026, 7, 4, 10, 0, 0)
-
-    def test_get_symbol_timestamp_falls_back_to_sqlite(self, db, storage_manager_mock):
-        """StorageManager 未命中时降级到 SQLite 读取合约时间戳。"""
-        storage_manager_mock.get_symbol_timestamp.return_value = None
-        _seed_sqlite_symbol_timestamp(db)
-
-        with patch("app.services.cache.get_storage_manager", return_value=storage_manager_mock):
-            from app.services import cache
-
-            result = cache.get_symbol_timestamp(db, "AG2606", "futures")
-
-        assert result == datetime(2026, 7, 4, 10, 0, 0)

tests/test_config_store.py

@@ -1,197 +0,0 @@
-"""配置存储测试：MySQL + JSON fallback。"""
-import json
-from pathlib import Path
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-from app.config_store import ConfigStore
-
-
-def _make_session_maker(mock_db):
-    """构造正确的 sessionmaker mock，使 with 语句返回 mock_db。"""
-    session_obj = MagicMock()
-    session_obj.__enter__ = MagicMock(return_value=mock_db)
-    session_obj.__exit__ = MagicMock(return_value=False)
-
-    session_maker = MagicMock(return_value=session_obj)
-    return session_maker
-
-
-class TestConfigStoreGet:
-    """ConfigStore.get_config 测试。"""
-
-    def test_get_config_returns_mysql_value_on_hit(self, tmp_path):
-        """MySQL 命中时返回数据库中的配置。"""
-        mock_config = MagicMock()
-        mock_config.config_value = {"futures": {"沪银": "AG2608"}}
-
-        mock_db = MagicMock()
-        mock_db.query.return_value.filter.return_value.first.return_value = mock_config
-
-        storage = MagicMock()
-        storage.check_mysql.return_value = True
-
-        store = ConfigStore(
-            storage_manager=storage,
-            config_dir=tmp_path,
-            session_maker=_make_session_maker(mock_db),
-        )
-
-        result = store.get_config("symbols", {"futures": {}})
-
-        assert result == {"futures": {"沪银": "AG2608"}}
-
-    def test_get_config_reads_json_and_backfills_when_mysql_miss(self, tmp_path):
-        """MySQL 未命中时读取 JSON 并回填数据库。"""
-        json_path = tmp_path / "symbols_config.json"
-        json_path.write_text(json.dumps({"futures": {"沪银": "AG2608"}}, ensure_ascii=False), encoding="utf-8")
-
-        mock_db = MagicMock()
-        mock_db.query.return_value.filter.return_value.first.return_value = None
-
-        storage = MagicMock()
-        storage.check_mysql.return_value = True
-
-        store = ConfigStore(
-            storage_manager=storage,
-            config_dir=tmp_path,
-            session_maker=_make_session_maker(mock_db),
-        )
-
-        result = store.get_config("symbols", {"futures": {}})
-
-        assert result == {"futures": {"沪银": "AG2608"}}
-        mock_db.add.assert_called_once()
-        mock_db.commit.assert_called_once()
-
-    def test_get_config_falls_back_to_json_when_mysql_unavailable(self, tmp_path):
-        """MySQL 不可用时直接读取 JSON。"""
-        json_path = tmp_path / "symbols_config.json"
-        json_path.write_text(json.dumps({"futures": {"沪银": "AG2608"}}, ensure_ascii=False), encoding="utf-8")
-
-        storage = MagicMock()
-        storage.check_mysql.return_value = False
-
-        store = ConfigStore(
-            storage_manager=storage,
-            config_dir=tmp_path,
-            session_maker=None,
-        )
-
-        result = store.get_config("symbols", {"futures": {}})
-
-        assert result == {"futures": {"沪银": "AG2608"}}
-
-    def test_get_config_returns_fallback_when_no_mysql_and_no_json(self, tmp_path):
-        """MySQL 和 JSON 都不存在时返回 fallback。"""
-        storage = MagicMock()
-        storage.check_mysql.return_value = False
-
-        store = ConfigStore(
-            storage_manager=storage,
-            config_dir=tmp_path,
-            session_maker=None,
-        )
-
-        result = store.get_config("symbols", {"futures": {"默认": "DF2609"}})
-
-        assert result == {"futures": {"默认": "DF2609"}}
-
-
-class TestConfigStoreSet:
-    """ConfigStore.set_config 测试。"""
-
-    def test_set_config_writes_to_mysql_and_json(self, tmp_path):
-        """MySQL 可用时同时写入数据库和 JSON。"""
-        mock_existing = MagicMock()
-
-        mock_db = MagicMock()
-        mock_db.query.return_value.filter.return_value.first.return_value = mock_existing
-
-        storage = MagicMock()
-        storage.check_mysql.return_value = True
-
-        store = ConfigStore(
-            storage_manager=storage,
-            config_dir=tmp_path,
-            session_maker=_make_session_maker(mock_db),
-        )
-
-        result = store.set_config("symbols", {"futures": {"沪银": "AG2608"}})
-
-        assert result is True
-        assert mock_existing.config_value == {"futures": {"沪银": "AG2608"}}
-        mock_db.commit.assert_called_once()
-
-        json_path = tmp_path / "symbols_config.json"
-        assert json_path.exists()
-        assert json.loads(json_path.read_text(encoding="utf-8")) == {"futures": {"沪银": "AG2608"}}
-
-    def test_set_config_writes_only_json_when_mysql_unavailable(self, tmp_path):
-        """MySQL 不可用时只写入 JSON。"""
-        storage = MagicMock()
-        storage.check_mysql.return_value = False
-
-        store = ConfigStore(
-            storage_manager=storage,
-            config_dir=tmp_path,
-            session_maker=None,
-        )
-
-        result = store.set_config("symbols", {"futures": {"沪银": "AG2608"}})
-
-        assert result is True
-
-        json_path = tmp_path / "symbols_config.json"
-        assert json_path.exists()
-        assert json.loads(json_path.read_text(encoding="utf-8")) == {"futures": {"沪银": "AG2608"}}
-
-
-class TestConfigMigration:
-    """配置迁移测试。"""
-
-    def test_migrate_skips_when_config_exists(self, tmp_path):
-        """数据库已有配置时跳过迁移。"""
-        from app.config_migration import migrate_configs_to_mysql
-
-        with patch("app.config_migration.get_config_store") as mock_get_store:
-            store = MagicMock()
-            store._config_exists_in_mysql.return_value = True
-            store.storage_manager.check_mysql.return_value = True
-            store.session_maker = MagicMock()
-            mock_get_store.return_value = store
-
-            result = migrate_configs_to_mysql()
-
-            assert result is True
-            store._load_json.assert_not_called()
-
-    def test_migrate_loads_json_and_saves(self, tmp_path):
-        """从 JSON 读取并保存到数据库。"""
-        from app.config_migration import migrate_configs_to_mysql
-
-        symbols_path = tmp_path / "symbols_config.json"
-        symbols_path.write_text(json.dumps({"futures": {"沪银": "AG2608"}}, ensure_ascii=False), encoding="utf-8")
-
-        ai_path = tmp_path / "ai_config.json"
-        ai_path.write_text(json.dumps({"models": []}, ensure_ascii=False), encoding="utf-8")
-
-        with patch("app.config_migration.get_config_store") as mock_get_store:
-            store = MagicMock()
-            store._config_exists_in_mysql.return_value = False
-            store.storage_manager.check_mysql.return_value = True
-            store.session_maker = MagicMock()
-            store.config_dir = tmp_path
-            store.config_files = {
-                "symbols": symbols_path,
-                "ai": ai_path,
-            }
-            store._load_json.side_effect = lambda key, default: json.loads(store.config_files[key].read_text(encoding="utf-8")) if store.config_files[key].exists() else default
-            store._save_to_mysql.return_value = True
-            mock_get_store.return_value = store
-
-            result = migrate_configs_to_mysql()
-
-            assert result is True
-            assert store._save_to_mysql.call_count == 2

tests/test_dual_write_and_migration.py

@@ -1,279 +0,0 @@
-"""
-数据缓冲平台 - 双写一致性与数据迁移完整性验证测试
-
-本测试通过内存 Fake Redis 与 mock/fake MySQL 验证：
-1. save_market_data 成功后 MySQL 与 Redis 数据内容一致；
-2. Redis 写入失败不影响 MySQL 持久化；
-3. migrate_sqlite_to_mysql 的幂等性与迁移记录数正确性；
-4. 使用真实内存数据库做端到端迁移验证时暴露的生产代码缺陷。
-"""
-import json
-from datetime import datetime
-from unittest.mock import MagicMock, patch
-
-import pytest
-from sqlalchemy import create_engine
-from sqlalchemy.orm import sessionmaker
-
-from app.models import Base, MarketData, SymbolTimestamp
-from app.storage_manager import StorageManager
-
-
-class FakeRedis:
-    """内存模拟 Redis 客户端，支持 setex / get / delete / keys / ping。"""
-
-    def __init__(self, fail_on_write=False):
-        self._store = {}
-        self.fail_on_write = fail_on_write
-
-    def ping(self):
-        return True
-
-    def get(self, key):
-        return self._store.get(key)
-
-    def setex(self, key, seconds, value):
-        if self.fail_on_write:
-            raise Exception("Redis 写入失败")
-        self._store[key] = value
-
-    def delete(self, *keys):
-        if self.fail_on_write:
-            raise Exception("Redis 删除失败")
-        for key in keys:
-            self._store.pop(key, None)
-
-    def keys(self, pattern):
-        prefix = pattern.replace("*", "")
-        return [k for k in self._store.keys() if k.startswith(prefix)]
-
-
-def _make_mysql_memory():
-    """创建内存 MySQL 模拟引擎和会话工厂。"""
-    engine = create_engine("sqlite:///:memory:")
-    Base.metadata.create_all(bind=engine)
-    SessionLocal = sessionmaker(bind=engine)
-    return engine, SessionLocal
-
-
-def _create_sqlite_source(tmp_path, market_count=2, timestamp_count=1):
-    """创建包含测试数据的 SQLite 源数据库，并返回引擎与记录数。"""
-    db_path = tmp_path / "test_source.db"
-    engine = create_engine(f"sqlite:///{db_path}")
-    Base.metadata.create_all(bind=engine)
-    Session = sessionmaker(bind=engine)
-    session = Session()
-    fetched_at = datetime(2026, 7, 4, 10, 0, 0)
-    for i in range(market_count):
-        session.add(
-            MarketData(
-                symbol="AG2606",
-                data_type="futures",
-                period=f"{(i + 1) * 5}min",
-                candles_json='[{"open": 100, "close": 110}]',
-                current_price=123.45,
-                fetched_at=fetched_at,
-                candle_count=1,
-            )
-        )
-    for _ in range(timestamp_count):
-        session.add(
-            SymbolTimestamp(
-                symbol="AG2606",
-                data_type="futures",
-                last_refresh_at=fetched_at,
-                refresh_count=5,
-            )
-        )
-    session.commit()
-    session.close()
-    return engine, market_count, timestamp_count
-
-
-def _make_mysql_session(market_data_count=0, symbol_timestamp_count=0):
-    """构造模拟 MySQL 会话，支持记录写入和计数查询。"""
-    mysql_session = MagicMock()
-    mysql_session.__enter__ = MagicMock(return_value=mysql_session)
-    mysql_session.__exit__ = MagicMock(return_value=False)
-
-    added_market_data = []
-    added_symbol_timestamps = []
-
-    def mock_query(model):
-        query = MagicMock()
-        if model is MarketData:
-            query.count.return_value = market_data_count
-        elif model is SymbolTimestamp:
-            query.count.return_value = symbol_timestamp_count
-        return query
-
-    mysql_session.query.side_effect = mock_query
-    mysql_session.add_all.side_effect = lambda records: (
-        added_market_data.extend(records)
-        if records and isinstance(records[0], MarketData)
-        else added_symbol_timestamps.extend(records)
-    )
-
-    return mysql_session, added_market_data, added_symbol_timestamps
-
-
-@pytest.fixture
-def sample_market_data():
-    """构造与采集脚本格式一致的测试数据。"""
-    return {
-        "type": "futures",
-        "current_price": 123.45,
-        "timestamp": datetime(2026, 7, 4, 10, 0, 0).isoformat(),
-        "timeframes": {
-            "5min": [{"open": 100, "close": 110}],
-            "15min": [{"open": 105, "close": 115}],
-        },
-    }
-
-
-class TestDualWriteConsistency:
-    """双写一致性验证。"""
-
-    def test_save_market_data_writes_consistent_data_to_mysql_and_redis(
-        self, sample_market_data
-    ):
-        """save_market_data 成功后，MySQL 与 Redis 中数据内容一致。"""
-        redis_client = FakeRedis()
-        mysql_engine, MySQLSessionLocal = _make_mysql_memory()
-        manager = StorageManager(redis_client=redis_client, mysql_engine=mysql_engine)
-
-        result = manager.save_market_data("AG2606", sample_market_data)
-
-        assert result is True
-
-        # 验证 MySQL 持久化数据
-        with MySQLSessionLocal() as db:
-            records = db.query(MarketData).filter_by(symbol="AG2606").all()
-            assert len(records) == 2
-            mysql_by_period = {r.period: r for r in records}
-            assert "5min" in mysql_by_period
-            assert "15min" in mysql_by_period
-            assert mysql_by_period["5min"].current_price == 123.45
-            assert mysql_by_period["15min"].current_price == 123.45
-
-        # 验证 Redis 缓存数据
-        redis_5min = json.loads(redis_client.get("market_data:AG2606:5min"))
-        redis_15min = json.loads(redis_client.get("market_data:AG2606:15min"))
-        assert redis_5min["current_price"] == 123.45
-        assert redis_15min["current_price"] == 123.45
-        assert redis_5min["candles"] == [{"open": 100, "close": 110}]
-        assert redis_15min["candles"] == [{"open": 105, "close": 115}]
-
-        # 验证 MySQL 与 Redis 内容一致
-        assert (
-            mysql_by_period["5min"].current_price == redis_5min["current_price"]
-        )
-        assert (
-            mysql_by_period["15min"].current_price == redis_15min["current_price"]
-        )
-        assert (
-            json.loads(mysql_by_period["5min"].candles_json) == redis_5min["candles"]
-        )
-        assert (
-            json.loads(mysql_by_period["15min"].candles_json)
-            == redis_15min["candles"]
-        )
-
-    def test_redis_write_failure_does_not_affect_mysql_persistence(
-        self, sample_market_data
-    ):
-        """Redis 写入失败时，MySQL 数据持久化不受影响，save_market_data 仍返回 True。"""
-        redis_client = FakeRedis(fail_on_write=True)
-        mysql_engine, MySQLSessionLocal = _make_mysql_memory()
-        manager = StorageManager(redis_client=redis_client, mysql_engine=mysql_engine)
-
-        result = manager.save_market_data("AG2606", sample_market_data)
-
-        assert result is True
-
-        # 验证 MySQL 仍有完整数据
-        with MySQLSessionLocal() as db:
-            records = db.query(MarketData).filter_by(symbol="AG2606").all()
-            assert len(records) == 2
-            periods = {r.period for r in records}
-            assert periods == {"5min", "15min"}
-
-        # 验证 Redis 无缓存写入
-        assert redis_client.get("market_data:AG2606:5min") is None
-        assert redis_client.get("market_data:AG2606:15min") is None
-
-
-class TestMigrationIntegrity:
-    """数据迁移完整性验证。"""
-
-    def test_migration_copies_expected_record_counts_from_sqlite_to_mysql(
-        self, tmp_path
-    ):
-        """MySQL 为空时，migrate_sqlite_to_mysql 迁移 SQLite 中全部记录。"""
-        sqlite_engine, sqlite_market_count, sqlite_timestamp_count = (
-            _create_sqlite_source(tmp_path)
-        )
-        mysql_session, added_market_data, added_symbol_timestamps = (
-            _make_mysql_session(market_data_count=0, symbol_timestamp_count=0)
-        )
-
-        with patch("app.migration.create_engine", return_value=sqlite_engine):
-            with patch(
-                "app.migration.MySQLSessionLocal", return_value=mysql_session
-            ):
-                from app.migration import migrate_sqlite_to_mysql
-
-                result = migrate_sqlite_to_mysql()
-
-        assert result is True
-        assert len(added_market_data) == sqlite_market_count
-        assert len(added_symbol_timestamps) == sqlite_timestamp_count
-        assert added_market_data[0].symbol == "AG2606"
-        assert added_market_data[0].period == "5min"
-        assert added_symbol_timestamps[0].symbol == "AG2606"
-        mysql_session.commit.assert_called_once()
-
-    def test_migration_is_idempotent_when_mysql_has_data(self, tmp_path):
-        """MySQL 已有数据时迁移被跳过，保持幂等性，不覆盖已有数据。"""
-        sqlite_engine, _, _ = _create_sqlite_source(tmp_path)
-        mysql_session, added_market_data, added_symbol_timestamps = (
-            _make_mysql_session(market_data_count=1, symbol_timestamp_count=1)
-        )
-
-        with patch("app.migration.create_engine", return_value=sqlite_engine):
-            with patch(
-                "app.migration.MySQLSessionLocal", return_value=mysql_session
-            ):
-                from app.migration import migrate_sqlite_to_mysql
-
-                result = migrate_sqlite_to_mysql()
-
-        assert result is False
-        assert len(added_market_data) == 0
-        assert len(added_symbol_timestamps) == 0
-        mysql_session.commit.assert_not_called()
-
-    def test_migration_end_to_end_with_in_memory_databases(self, tmp_path):
-        """使用真实内存数据库验证迁移前后数据条数一致（当前已知缺陷）。"""
-        sqlite_engine, sqlite_market_count, sqlite_timestamp_count = (
-            _create_sqlite_source(tmp_path)
-        )
-
-        mysql_engine, MySQLSessionLocal = _make_mysql_memory()
-
-        with patch("app.migration.create_engine", return_value=sqlite_engine):
-            with patch("app.migration.MySQLSessionLocal", MySQLSessionLocal):
-                from app.migration import migrate_sqlite_to_mysql
-
-                result = migrate_sqlite_to_mysql()
-
-        assert result is True
-
-        mysql_session = MySQLSessionLocal()
-        try:
-            assert mysql_session.query(MarketData).count() == sqlite_market_count
-            assert (
-                mysql_session.query(SymbolTimestamp).count() == sqlite_timestamp_count
-            )
-        finally:
-            mysql_session.close()

tests/test_fallback_scenarios.py

@@ -1,375 +0,0 @@
-"""
-降级场景验证测试
-
-覆盖：
-1. Redis 不可用但 MySQL 可用时，自动降级到 MySQL
-2. Redis 和 MySQL 均不可用时，自动降级到 SQLite
-3. 各降级场景下接口正常返回，无 500 错误
-4. 恢复 Redis 服务后，等待惰性检测间隔验证自动恢复
-
-实现说明：
-- 使用 FastAPI TestClient 验证接口层行为。
-- 使用内存 SQLite 引擎作为 MySQL 替身（StorageManager 基于 SQLAlchemy 通用接口）。
-- 通过 patch `app.services.cache.get_storage_manager` 注入已配置好的 StorageManager，
-  从而绕过当前 `app/main.py` 启动时尚未将初始化后的 Redis/MySQL 客户端注入 StorageManager
-  全局单例的问题，专注于验证 cache / API 层的降级与恢复逻辑。
-"""
-import json
-import logging
-import time
-from datetime import datetime
-from unittest.mock import MagicMock, patch
-
-import pytest
-from fastapi.testclient import TestClient
-from sqlalchemy import create_engine, text
-from sqlalchemy.orm import sessionmaker
-from sqlalchemy.pool import StaticPool
-
-from app.models import Base, MarketData
-from app.storage_manager import StorageManager
-
-# test_main_lifespan.py 中的 fixture 会 patch app.main.Base.metadata.create_all 且未正确恢复，
-# 导致后续依赖 create_all 的测试失败。这里保留原始方法引用，必要时恢复。
-_original_create_all = Base.metadata.create_all
-
-
-# ===== Fixtures =====
-
-
-@pytest.fixture
-def sqlite_engine():
-    """应用主数据库使用的内存 SQLite 引擎。"""
-    # 防御：修复上游 fixture 对 Base.metadata.create_all 的 patch 泄漏
-    if isinstance(Base.metadata.create_all, MagicMock):
-        Base.metadata.create_all = _original_create_all
-
-    engine = create_engine(
-        "sqlite:///:memory:",
-        connect_args={"check_same_thread": False},
-        poolclass=StaticPool,
-    )
-    Base.metadata.create_all(bind=engine)
-
-    # 确认表已创建
-    with engine.connect() as conn:
-        result = conn.execute(
-            text("SELECT name FROM sqlite_master WHERE type='table' AND name='market_data'")
-        )
-        assert result.fetchone() is not None
-
-    yield engine
-    engine.dispose()
-
-
-@pytest.fixture
-def mysql_engine():
-    """作为 MySQL 替身的内存 SQLite 引擎（StorageManager 使用 SQLAlchemy 通用接口）。"""
-    # 防御：修复上游 fixture 对 Base.metadata.create_all 的 patch 泄漏
-    if isinstance(Base.metadata.create_all, MagicMock):
-        Base.metadata.create_all = _original_create_all
-
-    engine = create_engine(
-        "sqlite:///:memory:",
-        connect_args={"check_same_thread": False},
-        poolclass=StaticPool,
-    )
-    Base.metadata.create_all(bind=engine)
-
-    # 确认表已创建
-    with engine.connect() as conn:
-        result = conn.execute(
-            text("SELECT name FROM sqlite_master WHERE type='table' AND name='market_data'")
-        )
-        assert result.fetchone() is not None
-
-    yield engine
-    engine.dispose()
-
-
-@pytest.fixture
-def app_with_db(sqlite_engine):
-    """返回替换 get_db 依赖为内存 SQLite 的 FastAPI app。"""
-    from app.main import app
-    from app.database import get_db as original_get_db
-
-    SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=sqlite_engine)
-
-    def override_get_db():
-        db = SessionLocal()
-        try:
-            yield db
-        finally:
-            db.close()
-
-    app.dependency_overrides[original_get_db] = override_get_db
-    yield app
-    app.dependency_overrides.clear()
-
-
-@pytest.fixture
-def patch_lifespan_deps():
-    """Patch lifespan 依赖，避免真实连接数据库/Redis/MySQL 和启动调度器。"""
-    mock_db = MagicMock()
-    mock_session_local = MagicMock(return_value=mock_db)
-
-    patches = [
-        patch("app.main.Base.metadata.create_all"),
-        patch("app.main.UserBase.metadata.create_all"),
-        patch("app.analysis_db.init_analysis_db"),
-        patch("app.database.SessionLocal", mock_session_local),
-        patch("app.auth_service.create_default_admin"),
-        patch("app.main.start_scheduler"),
-        patch("app.services.cache.list_tasks", return_value=[]),
-        patch("app.services.scheduler.add_job"),
-        patch("app.main.stop_scheduler"),
-        patch("app.redis_client.init_redis"),
-        patch("app.mysql_database.init_mysql"),
-    ]
-    started = [p.start() for p in patches]
-    yield {
-        "Base_create_all": started[0],
-        "UserBase_create_all": started[1],
-        "init_analysis_db": started[2],
-        "SessionLocal": started[3],
-        "create_default_admin": started[4],
-        "start_scheduler": started[5],
-        "list_tasks": started[6],
-        "add_job": started[7],
-        "stop_scheduler": started[8],
-        "init_redis": started[9],
-        "init_mysql": started[10],
-    }
-    for p in patches:
-        p.stop()
-
-
-class FakeRedis:
-    """可切换可用状态的轻量级 Redis 替身。"""
-
-    def __init__(self, available=True):
-        self._store = {}
-        self._available = available
-
-    def set_available(self, available):
-        self._available = available
-
-    def ping(self):
-        if not self._available:
-            raise Exception("redis down")
-        return True
-
-    def get(self, key):
-        return self._store.get(key)
-
-    def setex(self, key, ttl, value):
-        self._store[key] = value
-
-    def delete(self, *keys):
-        for key in keys:
-            self._store.pop(key, None)
-
-    def keys(self, pattern):
-        prefix = pattern.rstrip("*")
-        return [k for k in self._store if k.startswith(prefix)]
-
-
-# ===== Helpers =====
-
-
-def _seed_market_data(
-    engine,
-    symbol="AG2606",
-    data_type="futures",
-    period="5min",
-    current_price=123.45,
-):
-    """在指定引擎中写入一条行情数据。"""
-    Session = sessionmaker(bind=engine)
-    with Session() as db:
-        db.add(
-            MarketData(
-                symbol=symbol,
-                data_type=data_type,
-                period=period,
-                candles_json=json.dumps(
-                    [
-                        {
-                            "datetime": "2026-07-04T09:55:00",
-                            "open": 100,
-                            "high": 115,
-                            "low": 95,
-                            "close": 110,
-                            "volume": 1000,
-                        }
-                    ]
-                ),
-                current_price=current_price,
-                fetched_at=datetime(2026, 7, 4, 10, 0, 0),
-                candle_count=1,
-            )
-        )
-        db.commit()
-
-
-# ===== Lifespan 日志测试 =====
-
-
-class TestLifespanFallbackLogs:
-    """启动时降级检测日志测试。"""
-
-    @pytest.mark.asyncio
-    async def test_logs_mysql_mode_when_redis_unavailable(
-        self, patch_lifespan_deps, caplog
-    ):
-        """Redis 不可用但 MySQL 可用时，lifespan 应输出 MySQL 降级模式日志。"""
-        from app.main import lifespan, app
-
-        patch_lifespan_deps["init_redis"].return_value = None
-        patch_lifespan_deps["init_mysql"].return_value = MagicMock()
-
-        with caplog.at_level(logging.WARNING, logger="app.main"):
-            async with lifespan(app):
-                pass
-
-        assert "存储模式: MySQL (Redis 不可用)" in caplog.text
-
-    @pytest.mark.asyncio
-    async def test_logs_sqlite_mode_when_both_unavailable(
-        self, patch_lifespan_deps, caplog
-    ):
-        """Redis 和 MySQL 均不可用时，lifespan 应输出 SQLite 降级模式日志。"""
-        from app.main import lifespan, app
-
-        patch_lifespan_deps["init_redis"].return_value = None
-        patch_lifespan_deps["init_mysql"].return_value = None
-
-        with caplog.at_level(logging.ERROR, logger="app.main"):
-            async with lifespan(app):
-                pass
-
-        assert "存储模式: SQLite (Redis 和 MySQL 均不可用)" in caplog.text
-
-
-# ===== StorageManager 运行时降级与恢复测试 =====
-
-
-class TestStorageManagerFallback:
-    """StorageManager 运行时降级与恢复测试。"""
-
-    def test_falls_back_to_mysql_when_redis_unavailable(self, mysql_engine):
-        """Redis 不可用但 MySQL 可用时，从 MySQL 读取数据。"""
-        _seed_market_data(mysql_engine, current_price=123.45)
-
-        fake_redis = FakeRedis(available=False)
-        manager = StorageManager(redis_client=fake_redis, mysql_engine=mysql_engine)
-
-        result = manager.get_market_data("AG2606", "futures", "5min")
-
-        assert result is not None
-        assert result["current_price"] == 123.45
-
-    def test_returns_none_when_both_unavailable(self):
-        """Redis 和 MySQL 均不可用时，StorageManager 返回 None（由调用方降级到 SQLite）。"""
-        fake_redis = FakeRedis(available=False)
-        manager = StorageManager(redis_client=fake_redis, mysql_engine=None)
-
-        result = manager.get_market_data("AG2606", "futures", "5min")
-
-        assert result is None
-
-    def test_recovers_to_redis_after_interval(self, mysql_engine):
-        """Redis 恢复后，超过惰性检测间隔应重新使用 Redis 并回填缓存。"""
-        _seed_market_data(mysql_engine, current_price=123.45)
-
-        fake_redis = FakeRedis(available=False)
-        manager = StorageManager(
-            redis_client=fake_redis, mysql_engine=mysql_engine, check_interval=0.1
-        )
-
-        # Redis 不可用，首次读取应来自 MySQL
-        result = manager.get_market_data("AG2606", "futures", "5min")
-        assert result["current_price"] == 123.45
-        # Redis 不可用，不应有回填
-        assert fake_redis.get("market_data:AG2606:5min") is None
-
-        # 恢复 Redis
-        fake_redis.set_available(True)
-        # 等待检测间隔过期
-        time.sleep(0.15)
-
-        # 再次读取：Redis ping 通过，get 返回 None，回源 MySQL 后回填 Redis
-        result = manager.get_market_data("AG2606", "futures", "5min")
-        assert result["current_price"] == 123.45
-        assert fake_redis.get("market_data:AG2606:5min") is not None
-
-
-# ===== API 接口降级测试 =====
-
-
-class TestApiFallbackResponses:
-    """API 接口在不同存储模式下的响应测试。"""
-
-    def test_api_returns_mysql_data_when_redis_unavailable(
-        self, patch_lifespan_deps, app_with_db, sqlite_engine, mysql_engine
-    ):
-        """Redis 不可用但 MySQL 可用时，接口从 MySQL 返回数据且无 500 错误。"""
-        _seed_market_data(mysql_engine, current_price=123.45)
-        _seed_market_data(sqlite_engine, current_price=456.78)
-
-        fake_redis = FakeRedis(available=False)
-        storage_manager = StorageManager(
-            redis_client=fake_redis, mysql_engine=mysql_engine, check_interval=0.1
-        )
-
-        patch_lifespan_deps["init_redis"].return_value = None
-        patch_lifespan_deps["init_mysql"].return_value = mysql_engine
-
-        with patch("app.mysql_database.mysql_engine", mysql_engine):
-            with patch("app.services.cache.get_storage_manager", return_value=storage_manager):
-                with TestClient(app_with_db) as client:
-                    response = client.get("/api/v1/data/latest/AG2606?period=5min")
-
-        assert response.status_code == 200
-        data = response.json()
-        assert data["current_price"] == 123.45
-
-    def test_api_returns_sqlite_data_when_both_unavailable(
-        self, patch_lifespan_deps, app_with_db, sqlite_engine
-    ):
-        """Redis 和 MySQL 均不可用时，接口降级到 SQLite 返回数据且无 500 错误。"""
-        _seed_market_data(sqlite_engine, current_price=456.78)
-
-        fake_redis = FakeRedis(available=False)
-        storage_manager = StorageManager(
-            redis_client=fake_redis, mysql_engine=None, check_interval=0.1
-        )
-
-        patch_lifespan_deps["init_redis"].return_value = None
-        patch_lifespan_deps["init_mysql"].return_value = None
-
-        with patch("app.services.cache.get_storage_manager", return_value=storage_manager):
-            with TestClient(app_with_db) as client:
-                response = client.get("/api/v1/data/latest/AG2606?period=5min")
-
-        assert response.status_code == 200
-        data = response.json()
-        assert data["current_price"] == 456.78
-
-    def test_api_returns_404_not_500_when_no_data_anywhere(
-        self, patch_lifespan_deps, app_with_db
-    ):
-        """任何存储层均无数据时，接口应返回 404 而非 500。"""
-        fake_redis = FakeRedis(available=False)
-        storage_manager = StorageManager(
-            redis_client=fake_redis, mysql_engine=None, check_interval=0.1
-        )
-
-        patch_lifespan_deps["init_redis"].return_value = None
-        patch_lifespan_deps["init_mysql"].return_value = None
-
-        with patch("app.services.cache.get_storage_manager", return_value=storage_manager):
-            with TestClient(app_with_db) as client:
-                response = client.get("/api/v1/data/latest/UNKNOWN?period=5min")
-
-        assert response.status_code == 404

tests/test_main_lifespan.py

@@ -1,185 +0,0 @@
-import logging
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-
-@pytest.fixture
-def patch_lifespan_deps():
-    """Patch all dependencies around lifespan so only storage init is exercised."""
-    mock_db = MagicMock()
-    mock_session_local = MagicMock(return_value=mock_db)
-
-    patches = [
-        patch("app.main.Base.metadata.create_all"),
-        patch("app.main.UserBase.metadata.create_all"),
-        patch("app.analysis_db.init_analysis_db"),
-        patch("app.database.SessionLocal", mock_session_local),
-        patch("app.auth_service.create_default_admin"),
-        patch("app.main.start_scheduler"),
-        patch("app.services.cache.list_tasks", return_value=[]),
-        patch("app.services.scheduler.add_job"),
-        patch("app.main.stop_scheduler"),
-        patch("app.redis_client.init_redis"),
-        patch("app.mysql_database.init_mysql"),
-    ]
-    started = [p.start() for p in patches]
-    yield {
-        "Base_create_all": started[0],
-        "UserBase_create_all": started[1],
-        "init_analysis_db": started[2],
-        "SessionLocal": started[3],
-        "create_default_admin": started[4],
-        "start_scheduler": started[5],
-        "list_tasks": started[6],
-        "add_job": started[7],
-        "stop_scheduler": started[8],
-        "init_redis": started[9],
-        "init_mysql": started[10],
-    }
-    for p in patches:
-        p.stop()
-
-    # 清理 StorageManager 全局单例，避免测试间状态泄漏
-    import app.storage_manager as _sm_module
-
-    _sm_module._storage_manager = None
-
-
-@pytest.mark.asyncio
-async def test_lifespan_calls_redis_and_mysql_init(patch_lifespan_deps, caplog):
-    """ lifespan 应调用 Redis 与 MySQL 初始化函数。 """
-    from app.main import lifespan, app
-
-    patch_lifespan_deps["init_redis"].return_value = MagicMock()
-    patch_lifespan_deps["init_mysql"].return_value = MagicMock()
-
-    with caplog.at_level(logging.INFO, logger="app.main"):
-        async with lifespan(app):
-            pass
-
-    patch_lifespan_deps["init_redis"].assert_called_once()
-    patch_lifespan_deps["init_mysql"].assert_called_once()
-
-
-@pytest.mark.asyncio
-async def test_lifespan_triggers_migration_when_mysql_ok(patch_lifespan_deps):
-    """ MySQL 可用时，lifespan 应触发 SQLite 到 MySQL 的迁移。 """
-    from app.main import lifespan, app
-
-    patch_lifespan_deps["init_redis"].return_value = None
-    patch_lifespan_deps["init_mysql"].return_value = MagicMock()
-
-    with patch("app.migration.migrate_sqlite_to_mysql") as mock_migrate:
-        async with lifespan(app):
-            pass
-
-    mock_migrate.assert_called_once()
-
-
-@pytest.mark.asyncio
-async def test_lifespan_skips_migration_when_mysql_unavailable(patch_lifespan_deps):
-    """ MySQL 不可用时，lifespan 不应调用迁移函数。 """
-    from app.main import lifespan, app
-
-    patch_lifespan_deps["init_redis"].return_value = None
-    patch_lifespan_deps["init_mysql"].return_value = None
-
-    with patch("app.migration.migrate_sqlite_to_mysql") as mock_migrate:
-        async with lifespan(app):
-            pass
-
-    mock_migrate.assert_not_called()
-
-
-@pytest.mark.asyncio
-async def test_lifespan_storage_mode_redis_and_mysql(patch_lifespan_deps, caplog):
-    """ Redis 与 MySQL 均可用时，日志显示 Redis + MySQL 模式。 """
-    from app.main import lifespan, app
-
-    patch_lifespan_deps["init_redis"].return_value = MagicMock()
-    patch_lifespan_deps["init_mysql"].return_value = MagicMock()
-
-    with caplog.at_level(logging.INFO, logger="app.main"):
-        async with lifespan(app):
-            pass
-
-    assert "存储模式: Redis + MySQL" in caplog.text
-
-
-@pytest.mark.asyncio
-async def test_lifespan_storage_mode_mysql_only(patch_lifespan_deps, caplog):
-    """ 仅 MySQL 可用时，日志显示 MySQL 降级模式。 """
-    from app.main import lifespan, app
-
-    patch_lifespan_deps["init_redis"].return_value = None
-    patch_lifespan_deps["init_mysql"].return_value = MagicMock()
-
-    with caplog.at_level(logging.WARNING, logger="app.main"):
-        async with lifespan(app):
-            pass
-
-    assert "存储模式: MySQL (Redis 不可用)" in caplog.text
-
-
-@pytest.mark.asyncio
-async def test_lifespan_storage_mode_sqlite_fallback(patch_lifespan_deps, caplog):
-    """ Redis 与 MySQL 均不可用时，日志显示 SQLite 降级模式。 """
-    from app.main import lifespan, app
-
-    patch_lifespan_deps["init_redis"].return_value = None
-    patch_lifespan_deps["init_mysql"].return_value = None
-
-    with caplog.at_level(logging.ERROR, logger="app.main"):
-        async with lifespan(app):
-            pass
-
-    assert "存储模式: SQLite (Redis 和 MySQL 均不可用)" in caplog.text
-
-
-@pytest.mark.asyncio
-async def test_lifespan_storage_init_failure_does_not_raise(patch_lifespan_deps, caplog):
-    """ 初始化 Redis/MySQL 失败抛出异常时，应用仍可正常启动。 """
-    from app.main import lifespan, app
-
-    patch_lifespan_deps["init_redis"].side_effect = Exception("redis down")
-    patch_lifespan_deps["init_mysql"].side_effect = Exception("mysql down")
-
-    with caplog.at_level(logging.ERROR, logger="app.main"):
-        async with lifespan(app):
-            pass
-
-    assert "存储模式: SQLite (Redis 和 MySQL 均不可用)" in caplog.text
-
-
-def test_storage_manager_initialize_accepts_clients_and_updates_references():
-    """initialize 应可选接收 redis_client 和 mysql_engine 并更新内部引用。"""
-    from app.storage_manager import StorageManager
-
-    manager = StorageManager(redis_client=None, mysql_engine=None)
-    fake_redis = MagicMock()
-    fake_mysql = MagicMock()
-
-    manager.initialize(redis_client=fake_redis, mysql_engine=fake_mysql)
-
-    assert manager.redis_client is fake_redis
-    assert manager.mysql_engine is fake_mysql
-
-
-@pytest.mark.asyncio
-async def test_lifespan_injects_redis_and_mysql_into_storage_manager(patch_lifespan_deps):
-    """lifespan 初始化后应将 Redis/MySQL 客户端注入 StorageManager 单例。"""
-    from app.main import lifespan, app
-    from app.storage_manager import StorageManager
-
-    fake_redis = MagicMock()
-    fake_mysql = MagicMock()
-    patch_lifespan_deps["init_redis"].return_value = fake_redis
-    patch_lifespan_deps["init_mysql"].return_value = fake_mysql
-
-    mock_manager = MagicMock(spec=StorageManager)
-    with patch("app.storage_manager.get_storage_manager", return_value=mock_manager):
-        async with lifespan(app):
-            pass
-
-    mock_manager.initialize.assert_called_once_with(fake_redis, fake_mysql)

tests/test_migration.py

@@ -1,157 +0,0 @@
-"""
-数据缓冲平台 - SQLite 到 MySQL 数据迁移脚本测试
-"""
-import logging
-from datetime import datetime
-from unittest.mock import MagicMock, patch
-
-import pytest
-from sqlalchemy import create_engine
-from sqlalchemy.orm import sessionmaker
-
-from app.models import Base, MarketData, SymbolTimestamp
-
-
-def _create_sqlite_source(tmp_path):
-    """创建包含测试数据的文件 SQLite 源数据库。"""
-    db_path = tmp_path / "test_source.db"
-    engine = create_engine(f"sqlite:///{db_path}")
-    MarketData.__table__.create(bind=engine)
-    SymbolTimestamp.__table__.create(bind=engine)
-    Session = sessionmaker(bind=engine)
-    session = Session()
-    fetched_at = datetime(2026, 7, 4, 10, 0, 0)
-    session.add_all(
-        [
-            MarketData(
-                symbol="AG2606",
-                data_type="futures",
-                period="5min",
-                candles_json='[{"open": 100, "close": 110}]',
-                current_price=123.45,
-                fetched_at=fetched_at,
-                candle_count=1,
-            ),
-            MarketData(
-                symbol="AG2606",
-                data_type="futures",
-                period="15min",
-                candles_json='[{"open": 105, "close": 115}]',
-                current_price=123.45,
-                fetched_at=fetched_at,
-                candle_count=1,
-            ),
-            SymbolTimestamp(
-                symbol="AG2606",
-                data_type="futures",
-                last_refresh_at=fetched_at,
-                refresh_count=5,
-            ),
-        ]
-    )
-    session.commit()
-    session.close()
-    return engine
-
-
-def _make_mysql_session(market_data_count=0, symbol_timestamp_count=0):
-    """构造模拟 MySQL 会话，支持记录写入和计数查询。"""
-    mysql_session = MagicMock()
-    mysql_session.__enter__ = MagicMock(return_value=mysql_session)
-    mysql_session.__exit__ = MagicMock(return_value=False)
-
-    added_market_data = []
-    added_symbol_timestamps = []
-
-    def mock_query(model):
-        query = MagicMock()
-        if model is MarketData:
-            query.count.return_value = market_data_count
-        elif model is SymbolTimestamp:
-            query.count.return_value = symbol_timestamp_count
-        return query
-
-    mysql_session.query.side_effect = mock_query
-    mysql_session.add_all.side_effect = lambda records: (
-        added_market_data.extend(records)
-        if records and isinstance(records[0], MarketData)
-        else added_symbol_timestamps.extend(records)
-    )
-
-    return mysql_session, added_market_data, added_symbol_timestamps
-
-
-class TestMigrateSqliteToMysql:
-    """migrate_sqlite_to_mysql 行为测试。"""
-
-    def test_migrates_data_when_mysql_tables_are_empty(self, caplog, tmp_path):
-        """MySQL 表为空时，应从 SQLite 迁移全部数据。"""
-        sqlite_engine = _create_sqlite_source(tmp_path)
-        mysql_session, added_market_data, added_symbol_timestamps = _make_mysql_session(
-            market_data_count=0, symbol_timestamp_count=0
-        )
-
-        with patch("app.migration.create_engine", return_value=sqlite_engine):
-            with patch(
-                "app.migration.MySQLSessionLocal", return_value=mysql_session
-            ):
-                with caplog.at_level(logging.INFO, logger="app.migration"):
-                    from app.migration import migrate_sqlite_to_mysql
-
-                    result = migrate_sqlite_to_mysql()
-
-        assert result is True
-        assert len(added_market_data) == 2
-        assert len(added_symbol_timestamps) == 1
-        assert added_market_data[0].symbol == "AG2606"
-        assert added_market_data[0].period == "5min"
-        assert added_symbol_timestamps[0].symbol == "AG2606"
-        assert "迁移完成" in caplog.text
-        assert "market_data: 2" in caplog.text
-        assert "symbol_timestamps: 1" in caplog.text
-        mysql_session.commit.assert_called_once()
-
-    def test_skips_migration_when_mysql_has_data(self, caplog, tmp_path):
-        """MySQL 表非空时，应跳过迁移并输出提示日志。"""
-        sqlite_engine = _create_sqlite_source(tmp_path)
-        mysql_session, added_market_data, added_symbol_timestamps = _make_mysql_session(
-            market_data_count=1, symbol_timestamp_count=1
-        )
-
-        with patch("app.migration.create_engine", return_value=sqlite_engine):
-            with patch(
-                "app.migration.MySQLSessionLocal", return_value=mysql_session
-            ):
-                with caplog.at_level(logging.INFO, logger="app.migration"):
-                    from app.migration import migrate_sqlite_to_mysql
-
-                    result = migrate_sqlite_to_mysql()
-
-        assert result is False
-        assert len(added_market_data) == 0
-        assert len(added_symbol_timestamps) == 0
-        assert "MySQL 已存在数据" in caplog.text
-        assert "跳过迁移" in caplog.text
-        mysql_session.commit.assert_not_called()
-
-    def test_migrates_empty_table_when_other_table_has_data(self, caplog, tmp_path):
-        """按表分别判断：仅空表需要迁移，非空表跳过。"""
-        sqlite_engine = _create_sqlite_source(tmp_path)
-        mysql_session, added_market_data, added_symbol_timestamps = _make_mysql_session(
-            market_data_count=1, symbol_timestamp_count=0
-        )
-
-        with patch("app.migration.create_engine", return_value=sqlite_engine):
-            with patch(
-                "app.migration.MySQLSessionLocal", return_value=mysql_session
-            ):
-                with caplog.at_level(logging.INFO, logger="app.migration"):
-                    from app.migration import migrate_sqlite_to_mysql
-
-                    result = migrate_sqlite_to_mysql()
-
-        assert result is True
-        assert len(added_market_data) == 0
-        assert len(added_symbol_timestamps) == 1
-        assert added_symbol_timestamps[0].symbol == "AG2606"
-        mysql_session.commit.assert_called_once()

tests/test_mysql_database.py

@@ -1,23 +0,0 @@
-"""
-数据缓冲平台 - MySQL 数据库连接测试
-"""
-from unittest.mock import MagicMock, patch
-
-from app.mysql_database import init_mysql
-
-
-def test_init_mysql_url_encodes_password():
-    """MySQL 密码应使用 urllib.parse.quote_plus 进行 URL 编码。"""
-    with patch("app.mysql_database.create_engine") as mock_create_engine:
-        mock_engine = MagicMock()
-        mock_create_engine.return_value = mock_engine
-        with patch("app.mysql_database.MYSQL_PASSWORD", "p@ss/w+ord"):
-            with patch("app.mysql_database.MYSQL_USER", "user"):
-                with patch("app.mysql_database.MYSQL_HOST", "host"):
-                    with patch("app.mysql_database.MYSQL_PORT", "3306"):
-                        with patch("app.mysql_database.MYSQL_DATABASE", "buffer"):
-                            init_mysql()
-
-    url = mock_create_engine.call_args[0][0]
-    assert "p%40ss%2Fw%2Bord" in url
-    assert "p@ss" not in url

tests/test_redis_cache_scenarios.py

@@ -1,280 +0,0 @@
-"""
-Redis 缓存命中/未命中场景验证测试
-
-覆盖：
-1. 调用 save_market_data 写入数据后，Redis 与 MySQL 同时存在一致数据
-2. 首次调用 get_market_data（Redis 未命中）从 MySQL 读取并回填 Redis
-3. 再次调用 get_market_data（Redis 命中）直接返回缓存数据，不访问 MySQL
-4. 手动删除 Redis key 后，再次读取回源 MySQL 并重新回填 Redis
-"""
-import json
-import logging
-from datetime import datetime
-from unittest.mock import MagicMock
-
-import pytest
-from sqlalchemy import create_engine, text
-from sqlalchemy.orm import sessionmaker
-
-from app.models import Base, MarketData
-from app.storage_manager import StorageManager
-
-# test_main_lifespan.py 中的 fixture 会 patch app.main.Base.metadata.create_all 且未正确恢复，
-# 导致后续依赖 create_all 的测试失败。这里保留原始方法引用，必要时恢复。
-_original_create_all = Base.metadata.create_all
-
-
-class FakeRedis:
-    """轻量级 Redis 替身，仅支持本测试所需的方法。"""
-
-    def __init__(self):
-        self._store = {}
-
-    def ping(self):
-        return True
-
-    def get(self, key):
-        return self._store.get(key)
-
-    def setex(self, key, ttl, value):
-        self._store[key] = value
-
-    def delete(self, *keys):
-        for key in keys:
-            self._store.pop(key, None)
-
-    def keys(self, pattern):
-        # 仅支持以 * 结尾的通配模式
-        prefix = pattern.rstrip("*")
-        return [k for k in self._store if k.startswith(prefix)]
-
-    def exists(self, key):
-        return key in self._store
-
-
-@pytest.fixture
-def mysql_engine():
-    """提供已创建表结构的内存 SQLite 引擎，作为 MySQL 替身。"""
-    # 防御：修复上游 fixture 对 Base.metadata.create_all 的 patch 泄漏
-    if isinstance(Base.metadata.create_all, MagicMock):
-        Base.metadata.create_all = _original_create_all
-
-    engine = create_engine("sqlite:///:memory:")
-    Base.metadata.create_all(bind=engine)
-
-    # 确认表已创建
-    with engine.connect() as conn:
-        result = conn.execute(
-            text("SELECT name FROM sqlite_master WHERE type='table' AND name='market_data'")
-        )
-        assert result.fetchone() is not None
-
-    yield engine
-    engine.dispose()
-
-
-@pytest.fixture
-def fake_redis():
-    return FakeRedis()
-
-
-@pytest.fixture
-def sample_data():
-    fetched_at = datetime(2026, 7, 4, 10, 0, 0)
-    return {
-        "type": "futures",
-        "current_price": 123.45,
-        "timestamp": fetched_at.isoformat(),
-        "timeframes": {
-            "5min": [{"datetime": "2026-07-04T09:55:00", "open": 100, "close": 110}],
-            "15min": [{"datetime": "2026-07-04T09:45:00", "open": 105, "close": 115}],
-        },
-    }
-
-
-def _seed_mysql_market_data(engine, symbol="AG2606", data_type="futures"):
-    """在 MySQL 替身中写入行情数据。"""
-    fetched_at = datetime(2026, 7, 4, 10, 0, 0)
-    Session = sessionmaker(bind=engine)
-    with Session() as db:
-        db.add(
-            MarketData(
-                symbol=symbol,
-                data_type=data_type,
-                period="5min",
-                candles_json=json.dumps(
-                    [{"datetime": "2026-07-04T09:55:00", "open": 100, "close": 110}]
-                ),
-                current_price=123.45,
-                fetched_at=fetched_at,
-                candle_count=1,
-            )
-        )
-        db.commit()
-
-
-class TestSaveMarketData:
-    """save_market_data 写入与缓存回填场景。"""
-
-    def test_save_market_data_writes_mysql_and_backfills_redis(
-        self, fake_redis, mysql_engine, sample_data
-    ):
-        """写入后 MySQL 与 Redis 均保存一致数据。"""
-        manager = StorageManager(
-            redis_client=fake_redis, mysql_engine=mysql_engine
-        )
-
-        assert manager.save_market_data("AG2606", sample_data) is True
-
-        # MySQL 中应写入两条记录
-        Session = sessionmaker(bind=mysql_engine)
-        with Session() as db:
-            records = db.query(MarketData).filter_by(symbol="AG2606").all()
-            assert len(records) == 2
-            periods = {r.period for r in records}
-            assert periods == {"5min", "15min"}
-            for r in records:
-                assert r.current_price == 123.45
-
-        # Redis 中应回填对应缓存键
-        assert fake_redis.exists("market_data:AG2606:5min")
-        assert fake_redis.exists("market_data:AG2606:15min")
-
-        cached_5min = json.loads(fake_redis.get("market_data:AG2606:5min"))
-        assert cached_5min["current_price"] == 123.45
-        assert cached_5min["candles"] == sample_data["timeframes"]["5min"]
-
-
-class TestRedisCacheHitMiss:
-    """Redis 缓存命中/未命中读取场景。"""
-
-    def test_first_read_miss_falls_back_to_mysql_and_backfills_redis(
-        self, fake_redis, mysql_engine
-    ):
-        """Redis 未命中时从 MySQL 读取并回填 Redis。"""
-        _seed_mysql_market_data(mysql_engine)
-        manager = StorageManager(
-            redis_client=fake_redis, mysql_engine=mysql_engine
-        )
-
-        assert fake_redis.get("market_data:AG2606:5min") is None
-
-        result = manager.get_market_data("AG2606", "futures", "5min")
-
-        expected = {
-            "current_price": 123.45,
-            "timestamp": datetime(2026, 7, 4, 10, 0, 0).isoformat(),
-            "candles": [{"datetime": "2026-07-04T09:55:00", "open": 100, "close": 110}],
-        }
-        assert result == expected
-
-        # Redis 应已被回填
-        assert fake_redis.exists("market_data:AG2606:5min")
-        cached = json.loads(fake_redis.get("market_data:AG2606:5min"))
-        assert cached == expected
-
-    def test_second_read_hit_returns_from_redis_without_mysql_access(
-        self, fake_redis, mysql_engine
-    ):
-        """Redis 命中时直接返回缓存，不再访问 MySQL。"""
-        _seed_mysql_market_data(mysql_engine)
-        manager = StorageManager(
-            redis_client=fake_redis, mysql_engine=mysql_engine
-        )
-
-        first = manager.get_market_data("AG2606", "futures", "5min")
-        assert fake_redis.exists("market_data:AG2606:5min")
-
-        # 将 MySQL 引擎替换为会抛异常的 mock，以证明第二次读取不会访问 MySQL
-        bad_engine = MagicMock()
-        bad_engine.connect.side_effect = Exception("MySQL should not be accessed")
-        manager.mysql_engine = bad_engine
-
-        second = manager.get_market_data("AG2606", "futures", "5min")
-
-        assert second == first
-        bad_engine.connect.assert_not_called()
-
-    def test_after_redis_key_deleted_falls_back_to_mysql_again(
-        self, fake_redis, mysql_engine
-    ):
-        """手动删除 Redis key 后，读取回源 MySQL 并重新回填 Redis。"""
-        _seed_mysql_market_data(mysql_engine)
-        manager = StorageManager(
-            redis_client=fake_redis, mysql_engine=mysql_engine
-        )
-
-        first = manager.get_market_data("AG2606", "futures", "5min")
-        assert fake_redis.exists("market_data:AG2606:5min")
-
-        # 模拟 TTL 过期或手动失效
-        fake_redis.delete("market_data:AG2606:5min")
-        assert fake_redis.get("market_data:AG2606:5min") is None
-
-        second = manager.get_market_data("AG2606", "futures", "5min")
-
-        assert second == first
-        assert fake_redis.exists("market_data:AG2606:5min")
-
-    def test_cache_hit_data_matches_mysql_data(
-        self, fake_redis, mysql_engine
-    ):
-        """缓存命中时返回的数据应与 MySQL 中的数据一致。"""
-        _seed_mysql_market_data(mysql_engine)
-        manager = StorageManager(
-            redis_client=fake_redis, mysql_engine=mysql_engine
-        )
-
-        # 首次读取触发回填
-        from_redis = manager.get_market_data("AG2606", "futures", "5min")
-
-        # 直接从 MySQL 读取原始记录作为基准
-        Session = sessionmaker(bind=mysql_engine)
-        with Session() as db:
-            record = (
-                db.query(MarketData)
-                .filter_by(symbol="AG2606", data_type="futures", period="5min")
-                .first()
-            )
-            assert record is not None
-            assert from_redis["current_price"] == record.current_price
-            assert from_redis["candles"] == json.loads(record.candles_json)
-
-
-class TestCacheLogMessages:
-    """验证缓存命中/未命中的日志输出。"""
-
-    @pytest.mark.xfail(
-        reason="当前 StorageManager 未输出 'Redis 缓存命中' 日志，仅记录行为断言",
-        strict=True,
-    )
-    def test_cache_hit_logs_redis_hit(self, fake_redis, mysql_engine, caplog):
-        """Redis 命中时日志应包含 'Redis 缓存命中'。"""
-        _seed_mysql_market_data(mysql_engine)
-        manager = StorageManager(
-            redis_client=fake_redis, mysql_engine=mysql_engine
-        )
-        manager.get_market_data("AG2606", "futures", "5min")  # 回填
-
-        with caplog.at_level(logging.INFO, logger="app.storage_manager"):
-            manager.get_market_data("AG2606", "futures", "5min")  # 命中
-
-        assert "Redis 缓存命中" in caplog.text
-
-    @pytest.mark.xfail(
-        reason="当前 StorageManager 未输出 'Redis 未命中，从 MySQL 读取' 日志，仅记录行为断言",
-        strict=True,
-    )
-    def test_cache_miss_logs_redis_miss_and_mysql_read(
-        self, fake_redis, mysql_engine, caplog
-    ):
-        """Redis 未命中并回源 MySQL 时日志应包含 'Redis 未命中，从 MySQL 读取'。"""
-        _seed_mysql_market_data(mysql_engine)
-        manager = StorageManager(
-            redis_client=fake_redis, mysql_engine=mysql_engine
-        )
-
-        with caplog.at_level(logging.INFO, logger="app.storage_manager"):
-            manager.get_market_data("AG2606", "futures", "5min")
-
-        assert "Redis 未命中，从 MySQL 读取" in caplog.text

tests/test_storage_manager.py

@@ -1,931 +0,0 @@
-import importlib
-import json
-import logging
-import time
-from datetime import datetime, timedelta
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-from app.storage_manager import StorageManager, get_storage_manager
-
-
-class TestStorageManagerSkeleton:
-    """StorageManager 骨架与降级检测测试。"""
-
-    def test_init_holds_client_and_engine_references(self):
-        """__init__ 应持有 redis_client / mysql_engine 引用。"""
-        redis_client = MagicMock()
-        mysql_engine = MagicMock()
-
-        manager = StorageManager(redis_client=redis_client, mysql_engine=mysql_engine)
-
-        assert manager.redis_client is redis_client
-        assert manager.mysql_engine is mysql_engine
-
-    def test_init_sets_default_flags(self):
-        """初始化时应将可用性标志设为 False。"""
-        manager = StorageManager(redis_client=None, mysql_engine=None)
-
-        assert manager.redis_available is False
-        assert manager.mysql_available is False
-
-    def test_check_redis_returns_cached_result_within_interval(self):
-        """30 秒间隔内应返回缓存的 Redis 可用性结果，不重新探测。"""
-        redis_client = MagicMock()
-        redis_client.ping.side_effect = Exception("redis down")
-
-        manager = StorageManager(redis_client=redis_client, mysql_engine=None)
-        first = manager.check_redis()
-        redis_client.ping.side_effect = None
-        second = manager.check_redis()
-
-        assert first is False
-        assert second is False
-        assert redis_client.ping.call_count == 1
-
-    def test_check_redis_recovers_after_interval(self):
-        """超过检测间隔后，Redis 恢复应返回 True。"""
-        redis_client = MagicMock()
-        redis_client.ping.side_effect = Exception("redis down")
-
-        manager = StorageManager(
-            redis_client=redis_client, mysql_engine=None, check_interval=0.1
-        )
-        assert manager.check_redis() is False
-
-        redis_client.ping.side_effect = None
-        time.sleep(0.15)
-
-        assert manager.check_redis() is True
-
-    def test_check_redis_false_when_client_is_none(self):
-        """redis_client 为 None 时 check_redis 返回 False。"""
-        manager = StorageManager(redis_client=None, mysql_engine=None)
-
-        assert manager.check_redis() is False
-
-    def test_check_mysql_returns_cached_result_within_interval(self):
-        """30 秒间隔内应返回缓存的 MySQL 可用性结果，不重新探测。"""
-        mysql_engine = MagicMock()
-        mysql_engine.connect.side_effect = Exception("mysql down")
-
-        manager = StorageManager(redis_client=None, mysql_engine=mysql_engine)
-        first = manager.check_mysql()
-        mysql_engine.connect.side_effect = None
-        second = manager.check_mysql()
-
-        assert first is False
-        assert second is False
-        assert mysql_engine.connect.call_count == 1
-
-    def test_check_mysql_recovers_after_interval(self):
-        """超过检测间隔后，MySQL 恢复应返回 True。"""
-        mysql_engine = MagicMock()
-        mysql_engine.connect.side_effect = Exception("mysql down")
-
-        manager = StorageManager(
-            redis_client=None, mysql_engine=mysql_engine, check_interval=0.1
-        )
-        assert manager.check_mysql() is False
-
-        mysql_engine.connect.side_effect = None
-        time.sleep(0.15)
-
-        assert manager.check_mysql() is True
-
-    def test_check_mysql_false_when_engine_is_none(self):
-        """mysql_engine 为 None 时 check_mysql 返回 False。"""
-        manager = StorageManager(redis_client=None, mysql_engine=None)
-
-        assert manager.check_mysql() is False
-
-    def test_is_available_true_when_redis_available(self):
-        """Redis 可用时 is_available 返回 True。"""
-        redis_client = MagicMock()
-        manager = StorageManager(redis_client=redis_client, mysql_engine=None)
-
-        assert manager.is_available() is True
-
-    def test_is_available_true_when_mysql_available(self):
-        """MySQL 可用时 is_available 返回 True。"""
-        mysql_engine = MagicMock()
-        manager = StorageManager(redis_client=None, mysql_engine=mysql_engine)
-
-        assert manager.is_available() is True
-
-    def test_is_available_false_when_both_unavailable(self):
-        """Redis 与 MySQL 均不可用时 is_available 返回 False。"""
-        redis_client = MagicMock()
-        redis_client.ping.side_effect = Exception("redis down")
-        mysql_engine = MagicMock()
-        mysql_engine.connect.side_effect = Exception("mysql down")
-
-        manager = StorageManager(redis_client=redis_client, mysql_engine=mysql_engine)
-
-        assert manager.is_available() is False
-
-    def test_initialize_checks_backends_and_logs(self, caplog):
-        """initialize 应检测后端可用性并输出日志。"""
-        redis_client = MagicMock()
-        mysql_engine = MagicMock()
-        manager = StorageManager(redis_client=redis_client, mysql_engine=mysql_engine)
-
-        with caplog.at_level(logging.INFO):
-            manager.initialize()
-
-        assert "Redis 可用" in caplog.text
-        assert "MySQL 可用" in caplog.text
-
-    def test_initialize_logs_fallback_when_unavailable(self, caplog):
-        """后端不可用时 initialize 应输出降级日志。"""
-        manager = StorageManager(redis_client=None, mysql_engine=None)
-
-        with caplog.at_level(logging.WARNING):
-            manager.initialize()
-
-        assert "Redis 不可用" in caplog.text
-        assert "MySQL 不可用" in caplog.text
-
-
-class TestStorageManagerSingleton:
-    """全局单例工厂函数测试。"""
-
-    def test_get_storage_manager_returns_same_instance(self):
-        """多次调用 get_storage_manager 应返回同一实例。"""
-        first = get_storage_manager()
-        second = get_storage_manager()
-
-        assert first is second
-
-    def test_get_storage_manager_returns_storage_manager(self):
-        """get_storage_manager 应返回 StorageManager 实例。"""
-        manager = get_storage_manager()
-
-        assert isinstance(manager, StorageManager)
-
-
-class TestStorageManagerReadLogic:
-    """StorageManager Redis → MySQL 读取逻辑测试。"""
-
-    def test_get_market_data_returns_redis_value_on_cache_hit(self):
-        """Redis 命中时直接返回反序列化数据，不访问 MySQL。"""
-        redis_client = MagicMock()
-        mysql_engine = MagicMock()
-        expected = {
-            "current_price": 123.45,
-            "timestamp": "2026-07-04T10:00:00",
-            "candles": [{"open": 100, "close": 110}],
-        }
-        redis_client.get.return_value = json.dumps(expected)
-        manager = StorageManager(redis_client=redis_client, mysql_engine=mysql_engine)
-
-        result = manager.get_market_data("AG2606", "futures", "5min")
-
-        assert result == expected
-        redis_client.get.assert_called_once_with("market_data:AG2606:5min")
-        mysql_engine.connect.assert_not_called()
-
-    def test_get_market_data_falls_back_to_mysql_and_backfills_redis(self):
-        """Redis 未命中时从 MySQL 读取并回填 Redis（TTL 30 天）。"""
-        redis_client = MagicMock()
-        redis_client.get.return_value = None
-        mysql_engine = MagicMock()
-        manager = StorageManager(redis_client=redis_client, mysql_engine=mysql_engine)
-
-        fetched_at = datetime(2026, 7, 4, 10, 0, 0)
-        record = MagicMock()
-        record.current_price = 123.45
-        record.fetched_at = fetched_at
-        record.candles_json = json.dumps([{"open": 100, "close": 110}])
-
-        mock_query = MagicMock()
-        mock_query.filter_by.return_value.first.return_value = record
-        mock_session = MagicMock()
-        mock_session.return_value = mock_session
-        mock_session.query.return_value = mock_query
-        mock_session.__enter__ = MagicMock(return_value=mock_session)
-        mock_session.__exit__ = MagicMock(return_value=False)
-
-        mock_sessionmaker = MagicMock(return_value=mock_session)
-
-        with patch("app.storage_manager.sessionmaker", mock_sessionmaker):
-            result = manager.get_market_data("AG2606", "futures", "5min")
-
-        expected = {
-            "current_price": 123.45,
-            "timestamp": "2026-07-04T10:00:00",
-            "candles": [{"open": 100, "close": 110}],
-        }
-        assert result == expected
-        mock_sessionmaker.assert_called_once_with(bind=mysql_engine)
-        mock_query.filter_by.assert_called_once_with(
-            symbol="AG2606", data_type="futures", period="5min"
-        )
-        redis_client.setex.assert_called_once_with(
-            "market_data:AG2606:5min", 2592000, json.dumps(expected, ensure_ascii=False)
-        )
-
-    def test_get_market_data_returns_none_when_mysql_unavailable(self):
-        """Redis 和 MySQL 均不可用时返回 None，由调用方降级到 SQLite。"""
-        redis_client = MagicMock()
-        redis_client.ping.side_effect = Exception("redis down")
-        mysql_engine = MagicMock()
-        mysql_engine.connect.side_effect = Exception("mysql down")
-        manager = StorageManager(redis_client=redis_client, mysql_engine=mysql_engine)
-
-        result = manager.get_market_data("AG2606", "futures", "5min")
-
-        assert result is None
-
-    def test_get_market_data_falls_back_to_mysql_when_redis_read_fails(self):
-        """Redis 读取失败但 MySQL 可用时，应降级到 MySQL 并回填 Redis。"""
-        redis_client = MagicMock()
-        redis_client.get.side_effect = Exception("redis read failed")
-        mysql_engine = MagicMock()
-        manager = StorageManager(redis_client=redis_client, mysql_engine=mysql_engine)
-
-        fetched_at = datetime(2026, 7, 4, 10, 0, 0)
-        record = MagicMock()
-        record.current_price = 123.45
-        record.fetched_at = fetched_at
-        record.candles_json = json.dumps([{"open": 100, "close": 110}])
-
-        mock_query = MagicMock()
-        mock_query.filter_by.return_value.first.return_value = record
-        mock_session = MagicMock()
-        mock_session.return_value = mock_session
-        mock_session.query.return_value = mock_query
-        mock_session.__enter__ = MagicMock(return_value=mock_session)
-        mock_session.__exit__ = MagicMock(return_value=False)
-
-        mock_sessionmaker = MagicMock(return_value=mock_session)
-
-        with patch("app.storage_manager.sessionmaker", mock_sessionmaker):
-            result = manager.get_market_data("AG2606", "futures", "5min")
-
-        expected = {
-            "current_price": 123.45,
-            "timestamp": "2026-07-04T10:00:00",
-            "candles": [{"open": 100, "close": 110}],
-        }
-        assert result == expected
-        redis_client.setex.assert_called_once_with(
-            "market_data:AG2606:5min", 2592000, json.dumps(expected, ensure_ascii=False)
-        )
-
-    def test_get_market_data_returns_none_when_mysql_read_fails(self):
-        """Redis 不可用且 MySQL 读取失败时返回 None。"""
-        redis_client = MagicMock()
-        redis_client.ping.side_effect = Exception("redis down")
-        mysql_engine = MagicMock()
-        manager = StorageManager(redis_client=redis_client, mysql_engine=mysql_engine)
-
-        mock_session = MagicMock()
-        mock_session.return_value = mock_session
-        mock_session.query.side_effect = Exception("mysql read failed")
-        mock_session.__enter__ = MagicMock(return_value=mock_session)
-        mock_session.__exit__ = MagicMock(return_value=False)
-
-        mock_sessionmaker = MagicMock(return_value=mock_session)
-
-        with patch("app.storage_manager.sessionmaker", mock_sessionmaker):
-            result = manager.get_market_data("AG2606", "futures", "5min")
-
-        assert result is None
-
-    def test_get_symbol_timestamp_returns_redis_value_on_cache_hit(self):
-        """Redis 命中时直接返回合约时间戳数据，不访问 MySQL。"""
-        redis_client = MagicMock()
-        mysql_engine = MagicMock()
-        expected = {
-            "last_refresh_at": "2026-07-04T10:00:00",
-            "refresh_count": 42,
-        }
-        redis_client.get.return_value = json.dumps(expected)
-        manager = StorageManager(redis_client=redis_client, mysql_engine=mysql_engine)
-
-        result = manager.get_symbol_timestamp("AG2606", "futures")
-
-        assert result == expected
-        redis_client.get.assert_called_once_with("symbol_timestamps:AG2606")
-        mysql_engine.connect.assert_not_called()
-
-    def test_get_symbol_timestamp_falls_back_to_mysql_and_backfills_redis(self):
-        """Redis 未命中时从 MySQL 读取时间戳并回填 Redis（TTL 30 天）。"""
-        redis_client = MagicMock()
-        redis_client.get.return_value = None
-        mysql_engine = MagicMock()
-        manager = StorageManager(redis_client=redis_client, mysql_engine=mysql_engine)
-
-        last_refresh = datetime(2026, 7, 4, 10, 0, 0)
-        record = MagicMock()
-        record.last_refresh_at = last_refresh
-        record.refresh_count = 42
-
-        mock_query = MagicMock()
-        mock_query.filter_by.return_value.first.return_value = record
-        mock_session = MagicMock()
-        mock_session.return_value = mock_session
-        mock_session.query.return_value = mock_query
-        mock_session.__enter__ = MagicMock(return_value=mock_session)
-        mock_session.__exit__ = MagicMock(return_value=False)
-
-        mock_sessionmaker = MagicMock(return_value=mock_session)
-
-        with patch("app.storage_manager.sessionmaker", mock_sessionmaker):
-            result = manager.get_symbol_timestamp("AG2606", "futures")
-
-        expected = {
-            "last_refresh_at": "2026-07-04T10:00:00",
-            "refresh_count": 42,
-        }
-        assert result == expected
-        mock_sessionmaker.assert_called_once_with(bind=mysql_engine)
-        mock_query.filter_by.assert_called_once_with(symbol="AG2606", data_type="futures")
-        redis_client.setex.assert_called_once_with(
-            "symbol_timestamps:AG2606", 2592000, json.dumps(expected, ensure_ascii=False)
-        )
-
-
-    def test_is_fresh_true_within_cache_ttl(self):
-        """数据在 CACHE_TTL_SECONDS（默认 300 秒）内时 is_fresh 为 True。"""
-        manager = StorageManager(redis_client=None, mysql_engine=None)
-        fetched_at = datetime(2026, 7, 4, 10, 0, 0)
-        now = fetched_at + timedelta(seconds=60)
-
-        mock_datetime = MagicMock()
-        mock_datetime.now.return_value = now
-        mock_datetime.fromisoformat = datetime.fromisoformat
-
-        with patch("app.storage_manager.datetime", mock_datetime):
-            result = manager._merge_period_results(
-                "AG2606",
-                "futures",
-                {
-                    "5min": {
-                        "current_price": 123.45,
-                        "timestamp": fetched_at.isoformat(),
-                        "candles": [],
-                    }
-                },
-            )
-
-        assert result["is_fresh"] is True
-
-    def test_is_fresh_false_beyond_cache_ttl(self):
-        """数据超过 CACHE_TTL_SECONDS（默认 300 秒）时 is_fresh 为 False。"""
-        manager = StorageManager(redis_client=None, mysql_engine=None)
-        fetched_at = datetime(2026, 7, 4, 10, 0, 0)
-        now = fetched_at + timedelta(seconds=301)
-
-        mock_datetime = MagicMock()
-        mock_datetime.now.return_value = now
-        mock_datetime.fromisoformat = datetime.fromisoformat
-
-        with patch("app.storage_manager.datetime", mock_datetime):
-            result = manager._merge_period_results(
-                "AG2606",
-                "futures",
-                {
-                    "5min": {
-                        "current_price": 123.45,
-                        "timestamp": fetched_at.isoformat(),
-                        "candles": [],
-                    }
-                },
-            )
-
-        assert result["is_fresh"] is False
-
-
-class TestStorageManagerWriteLogic:
-    """StorageManager 双写一致性测试。"""
-
-    def test_save_market_data_deletes_cache_writes_mysql_and_updates_redis(self):
-        """MySQL 写入成功时，应先删缓存、再写 MySQL、最后回填 Redis。"""
-        redis_client = MagicMock()
-        mysql_engine = MagicMock()
-        manager = StorageManager(redis_client=redis_client, mysql_engine=mysql_engine)
-
-        fetched_at = datetime(2026, 7, 4, 10, 0, 0)
-        data = {
-            "type": "futures",
-            "current_price": 123.45,
-            "timestamp": fetched_at.isoformat(),
-            "timeframes": {
-                "5min": [{"open": 100, "close": 110}],
-                "15min": [{"open": 105, "close": 115}],
-            },
-        }
-
-        records = []
-
-        def mock_filter_by(symbol=None, data_type=None, period=None):
-            existing = next(
-                (
-                    r
-                    for r in records
-                    if r.symbol == symbol and r.data_type == data_type and r.period == period
-                ),
-                None,
-            )
-            fb_query = MagicMock()
-            fb_query.first.return_value = existing
-            return fb_query
-
-        mock_query = MagicMock()
-        mock_query.filter_by.side_effect = mock_filter_by
-
-        mock_session = MagicMock()
-        mock_session.return_value = mock_session
-        mock_session.query.return_value = mock_query
-        mock_session.add.side_effect = records.append
-        mock_session.commit = MagicMock()
-        mock_session.rollback = MagicMock()
-        mock_session.__enter__ = MagicMock(return_value=mock_session)
-        mock_session.__exit__ = MagicMock(return_value=False)
-
-        mock_sessionmaker = MagicMock(return_value=mock_session)
-
-        with patch("app.storage_manager.sessionmaker", mock_sessionmaker):
-            with patch("app.storage_manager.datetime") as mock_datetime:
-                mock_datetime.now.return_value = fetched_at
-                result = manager.save_market_data("AG2606", data)
-
-        assert result is True
-        assert len(records) == 2
-        assert records[0].symbol == "AG2606"
-        assert records[0].data_type == "futures"
-        assert records[0].period == "5min"
-        assert records[0].current_price == 123.45
-        assert records[0].candle_count == 1
-        assert records[0].fetched_at == fetched_at
-
-        redis_client.delete.assert_called_once_with(
-            "market_data:AG2606:5min", "market_data:AG2606:15min"
-        )
-        redis_client.setex.assert_any_call(
-            "market_data:AG2606:5min",
-            2592000,
-            json.dumps(
-                {
-                    "current_price": 123.45,
-                    "timestamp": fetched_at.isoformat(),
-                    "candles": [{"open": 100, "close": 110}],
-                },
-                ensure_ascii=False,
-            ),
-        )
-        redis_client.setex.assert_any_call(
-            "market_data:AG2606:15min",
-            2592000,
-            json.dumps(
-                {
-                    "current_price": 123.45,
-                    "timestamp": fetched_at.isoformat(),
-                    "candles": [{"open": 105, "close": 115}],
-                },
-                ensure_ascii=False,
-            ),
-        )
-
-    def test_save_market_data_returns_false_and_skips_redis_on_mysql_failure(self):
-        """MySQL 写入失败时应回滚事务，不更新 Redis，并返回 False。"""
-        redis_client = MagicMock()
-        mysql_engine = MagicMock()
-        manager = StorageManager(redis_client=redis_client, mysql_engine=mysql_engine)
-
-        data = {
-            "type": "futures",
-            "current_price": 123.45,
-            "timestamp": datetime(2026, 7, 4, 10, 0, 0).isoformat(),
-            "timeframes": {"5min": [{"open": 100, "close": 110}]},
-        }
-
-        mock_session = MagicMock()
-        mock_session.return_value = mock_session
-        mock_session.commit.side_effect = Exception("mysql write failed")
-        mock_session.rollback = MagicMock()
-        mock_session.__enter__ = MagicMock(return_value=mock_session)
-        mock_session.__exit__ = MagicMock(return_value=False)
-        mock_sessionmaker = MagicMock(return_value=mock_session)
-
-        with patch("app.storage_manager.sessionmaker", mock_sessionmaker):
-            result = manager.save_market_data("AG2606", data)
-
-        assert result is False
-        redis_client.delete.assert_called_once_with("market_data:AG2606:5min")
-        redis_client.setex.assert_not_called()
-        mock_session.rollback.assert_called_once()
-
-    def test_save_market_data_returns_true_when_redis_update_fails(self, caplog):
-        """MySQL 成功但 Redis 回填失败时，应返回 True 并记录警告日志。"""
-        redis_client = MagicMock()
-        redis_client.setex.side_effect = Exception("redis write failed")
-        mysql_engine = MagicMock()
-        manager = StorageManager(redis_client=redis_client, mysql_engine=mysql_engine)
-
-        fetched_at = datetime(2026, 7, 4, 10, 0, 0)
-        data = {
-            "type": "futures",
-            "current_price": 123.45,
-            "timestamp": fetched_at.isoformat(),
-            "timeframes": {"5min": [{"open": 100, "close": 110}]},
-        }
-
-        mock_session = MagicMock()
-        mock_session.return_value = mock_session
-        mock_session.__enter__ = MagicMock(return_value=mock_session)
-        mock_session.__exit__ = MagicMock(return_value=False)
-        mock_sessionmaker = MagicMock(return_value=mock_session)
-
-        with patch("app.storage_manager.sessionmaker", mock_sessionmaker):
-            with patch("app.storage_manager.datetime") as mock_datetime:
-                mock_datetime.now.return_value = fetched_at
-                with caplog.at_level(logging.WARNING):
-                    result = manager.save_market_data("AG2606", data)
-
-        assert result is True
-        mock_session.commit.assert_called_once()
-        assert "Redis 更新失败" in caplog.text
-
-    def test_save_market_data_uses_input_timestamp(self):
-        """save_market_data 应优先使用输入数据中的 timestamp，而非 datetime.now()。"""
-        redis_client = MagicMock()
-        mysql_engine = MagicMock()
-        manager = StorageManager(redis_client=redis_client, mysql_engine=mysql_engine)
-
-        input_timestamp = datetime(2026, 1, 15, 8, 30, 0)
-        data = {
-            "type": "futures",
-            "current_price": 123.45,
-            "timestamp": input_timestamp.isoformat(),
-            "timeframes": {"5min": [{"open": 100, "close": 110}]},
-        }
-
-        records = []
-
-        def mock_filter_by(symbol=None, data_type=None, period=None):
-            existing = next(
-                (
-                    r
-                    for r in records
-                    if r.symbol == symbol and r.data_type == data_type and r.period == period
-                ),
-                None,
-            )
-            fb_query = MagicMock()
-            fb_query.first.return_value = existing
-            return fb_query
-
-        mock_query = MagicMock()
-        mock_query.filter_by.side_effect = mock_filter_by
-
-        mock_session = MagicMock()
-        mock_session.return_value = mock_session
-        mock_session.query.return_value = mock_query
-        mock_session.add.side_effect = records.append
-        mock_session.commit = MagicMock()
-        mock_session.rollback = MagicMock()
-        mock_session.__enter__ = MagicMock(return_value=mock_session)
-        mock_session.__exit__ = MagicMock(return_value=False)
-
-        mock_sessionmaker = MagicMock(return_value=mock_session)
-
-        with patch("app.storage_manager.sessionmaker", mock_sessionmaker):
-            result = manager.save_market_data("AG2606", data)
-
-        assert result is True
-        assert len(records) == 1
-        assert records[0].fetched_at == input_timestamp
-        redis_client.setex.assert_called_once_with(
-            "market_data:AG2606:5min",
-            2592000,
-            json.dumps(
-                {
-                    "current_price": 123.45,
-                    "timestamp": input_timestamp.isoformat(),
-                    "candles": [{"open": 100, "close": 110}],
-                },
-                ensure_ascii=False,
-            ),
-        )
-
-    def test_save_market_data_falls_back_to_now_on_invalid_timestamp(self):
-        """timestamp 无法解析时应回退到当前时间。"""
-        redis_client = MagicMock()
-        mysql_engine = MagicMock()
-        manager = StorageManager(redis_client=redis_client, mysql_engine=mysql_engine)
-
-        fallback_time = datetime(2026, 3, 1, 12, 0, 0)
-        data = {
-            "type": "futures",
-            "current_price": 123.45,
-            "timestamp": "not-a-valid-timestamp",
-            "timeframes": {"5min": [{"open": 100, "close": 110}]},
-        }
-
-        records = []
-
-        def mock_filter_by(symbol=None, data_type=None, period=None):
-            existing = next(
-                (
-                    r
-                    for r in records
-                    if r.symbol == symbol and r.data_type == data_type and r.period == period
-                ),
-                None,
-            )
-            fb_query = MagicMock()
-            fb_query.first.return_value = existing
-            return fb_query
-
-        mock_query = MagicMock()
-        mock_query.filter_by.side_effect = mock_filter_by
-
-        mock_session = MagicMock()
-        mock_session.return_value = mock_session
-        mock_session.query.return_value = mock_query
-        mock_session.add.side_effect = records.append
-        mock_session.commit = MagicMock()
-        mock_session.rollback = MagicMock()
-        mock_session.__enter__ = MagicMock(return_value=mock_session)
-        mock_session.__exit__ = MagicMock(return_value=False)
-
-        mock_sessionmaker = MagicMock(return_value=mock_session)
-
-        with patch("app.storage_manager.sessionmaker", mock_sessionmaker):
-            with patch("app.storage_manager._datetime.datetime") as mock_datetime:
-                mock_datetime.now.return_value = fallback_time
-                mock_datetime.fromisoformat.side_effect = ValueError(
-                    "Invalid isoformat string"
-                )
-                result = manager.save_market_data("AG2606", data)
-
-        assert result is True
-        assert len(records) == 1
-        assert records[0].fetched_at == fallback_time
-
-    def test_save_market_data_writes_mysql_when_redis_unavailable(self):
-        """Redis 不可用但 MySQL 可用时，save_market_data 应直接写入 MySQL 并返回 True。"""
-        redis_client = MagicMock()
-        redis_client.ping.side_effect = Exception("redis down")
-        mysql_engine = MagicMock()
-        manager = StorageManager(redis_client=redis_client, mysql_engine=mysql_engine)
-
-        fetched_at = datetime(2026, 7, 4, 10, 0, 0)
-        data = {
-            "type": "futures",
-            "current_price": 123.45,
-            "timestamp": fetched_at.isoformat(),
-            "timeframes": {"5min": [{"open": 100, "close": 110}]},
-        }
-
-        records = []
-
-        def mock_filter_by(symbol=None, data_type=None, period=None):
-            existing = next(
-                (
-                    r
-                    for r in records
-                    if r.symbol == symbol and r.data_type == data_type and r.period == period
-                ),
-                None,
-            )
-            fb_query = MagicMock()
-            fb_query.first.return_value = existing
-            return fb_query
-
-        mock_query = MagicMock()
-        mock_query.filter_by.side_effect = mock_filter_by
-
-        mock_session = MagicMock()
-        mock_session.return_value = mock_session
-        mock_session.query.return_value = mock_query
-        mock_session.add.side_effect = records.append
-        mock_session.commit = MagicMock()
-        mock_session.rollback = MagicMock()
-        mock_session.__enter__ = MagicMock(return_value=mock_session)
-        mock_session.__exit__ = MagicMock(return_value=False)
-
-        mock_sessionmaker = MagicMock(return_value=mock_session)
-
-        with patch("app.storage_manager.sessionmaker", mock_sessionmaker):
-            result = manager.save_market_data("AG2606", data)
-
-        assert result is True
-        assert len(records) == 1
-        assert records[0].symbol == "AG2606"
-        redis_client.delete.assert_not_called()
-        redis_client.setex.assert_not_called()
-
-    def test_save_market_data_returns_true_when_timeframes_empty(self):
-        """timeframes 为空时，save_market_data 应直接返回 True 且不操作缓存。"""
-        redis_client = MagicMock()
-        mysql_engine = MagicMock()
-        manager = StorageManager(redis_client=redis_client, mysql_engine=mysql_engine)
-
-        data = {
-            "type": "futures",
-            "current_price": 123.45,
-            "timestamp": datetime(2026, 7, 4, 10, 0, 0).isoformat(),
-            "timeframes": {},
-        }
-
-        mock_session = MagicMock()
-        mock_session.return_value = mock_session
-        mock_session.commit = MagicMock()
-        mock_session.rollback = MagicMock()
-        mock_session.__enter__ = MagicMock(return_value=mock_session)
-        mock_session.__exit__ = MagicMock(return_value=False)
-
-        mock_sessionmaker = MagicMock(return_value=mock_session)
-
-        with patch("app.storage_manager.sessionmaker", mock_sessionmaker):
-            result = manager.save_market_data("AG2606", data)
-
-        assert result is True
-        mock_session.commit.assert_called_once()
-        redis_client.delete.assert_not_called()
-        redis_client.setex.assert_not_called()
-
-    def test_save_symbol_timestamp_deletes_cache_writes_mysql_and_updates_redis(self):
-        """合约时间戳双写成功时，应先删缓存、再写 MySQL、最后回填 Redis。"""
-        redis_client = MagicMock()
-        mysql_engine = MagicMock()
-        manager = StorageManager(redis_client=redis_client, mysql_engine=mysql_engine)
-
-        refresh_time = datetime(2026, 7, 4, 10, 0, 0)
-
-        records = []
-
-        def mock_filter_by(symbol=None, data_type=None):
-            existing = next(
-                (r for r in records if r.symbol == symbol and r.data_type == data_type),
-                None,
-            )
-            fb_query = MagicMock()
-            fb_query.first.return_value = existing
-            return fb_query
-
-        mock_query = MagicMock()
-        mock_query.filter_by.side_effect = mock_filter_by
-
-        mock_session = MagicMock()
-        mock_session.return_value = mock_session
-        mock_session.query.return_value = mock_query
-        mock_session.add.side_effect = records.append
-        mock_session.commit = MagicMock()
-        mock_session.rollback = MagicMock()
-        mock_session.__enter__ = MagicMock(return_value=mock_session)
-        mock_session.__exit__ = MagicMock(return_value=False)
-
-        mock_sessionmaker = MagicMock(return_value=mock_session)
-
-        with patch("app.storage_manager.sessionmaker", mock_sessionmaker):
-            result = manager.save_symbol_timestamp("AG2606", "futures", refresh_time)
-
-        assert result is True
-        assert len(records) == 1
-        assert records[0].symbol == "AG2606"
-        assert records[0].data_type == "futures"
-        assert records[0].last_refresh_at == refresh_time
-        assert records[0].refresh_count == 1
-
-        redis_client.delete.assert_called_once_with("symbol_timestamps:AG2606")
-        redis_client.setex.assert_called_once_with(
-            "symbol_timestamps:AG2606",
-            2592000,
-            json.dumps(
-                {"last_refresh_at": refresh_time.isoformat(), "refresh_count": 1},
-                ensure_ascii=False,
-            ),
-        )
-
-    def test_save_symbol_timestamp_returns_false_on_mysql_failure(self):
-        """合约时间戳 MySQL 写入失败时应返回 False 且不更新 Redis。"""
-        redis_client = MagicMock()
-        mysql_engine = MagicMock()
-        manager = StorageManager(redis_client=redis_client, mysql_engine=mysql_engine)
-
-        mock_session = MagicMock()
-        mock_session.return_value = mock_session
-        mock_session.commit.side_effect = Exception("mysql write failed")
-        mock_session.rollback = MagicMock()
-        mock_session.__enter__ = MagicMock(return_value=mock_session)
-        mock_session.__exit__ = MagicMock(return_value=False)
-        mock_sessionmaker = MagicMock(return_value=mock_session)
-
-        with patch("app.storage_manager.sessionmaker", mock_sessionmaker):
-            result = manager.save_symbol_timestamp(
-                "AG2606", "futures", datetime(2026, 7, 4, 10, 0, 0)
-            )
-
-        assert result is False
-        redis_client.delete.assert_called_once_with("symbol_timestamps:AG2606")
-        redis_client.setex.assert_not_called()
-        mock_session.rollback.assert_called_once()
-
-    def test_delete_cache_removes_market_data_keys(self):
-        """delete_cache 应批量删除指定周期的 Redis 缓存键。"""
-        redis_client = MagicMock()
-        manager = StorageManager(redis_client=redis_client, mysql_engine=None)
-
-        manager.delete_cache("AG2606", ["5min", "15min"])
-
-        redis_client.delete.assert_called_once_with(
-            "market_data:AG2606:5min", "market_data:AG2606:15min"
-        )
-
-
-class TestStorageManagerConfig:
-    """配置读取相关测试。"""
-
-    def test_redis_ttl_reads_config_value(self):
-        """StorageManager 应分别读取 app.config.REDIS_TTL_SECONDS 与 CACHE_TTL_SECONDS。"""
-        import app.config as config
-        import app.storage_manager as sm
-
-        original_redis_ttl = config.REDIS_TTL_SECONDS
-        original_cache_ttl = config.CACHE_TTL_SECONDS
-        original_singleton = sm._storage_manager
-        config.REDIS_TTL_SECONDS = 1234
-        config.CACHE_TTL_SECONDS = 5678
-        try:
-            importlib.reload(sm)
-            assert sm.REDIS_TTL_SECONDS == 1234
-            assert sm.CACHE_TTL_SECONDS == 5678
-        finally:
-            config.REDIS_TTL_SECONDS = original_redis_ttl
-            config.CACHE_TTL_SECONDS = original_cache_ttl
-            importlib.reload(sm)
-            sm._storage_manager = original_singleton
-
-
-class TestStorageManagerAtomicWrite:
-    """save_market_data_with_timestamp 原子写入测试。"""
-
-    def test_save_market_data_with_timestamp_writes_market_data_and_timestamp(self):
-        """同一 MySQL 事务中写入行情数据与合约时间戳。"""
-        from sqlalchemy import create_engine
-        from sqlalchemy.orm import sessionmaker
-
-        from app.models import Base, MarketData, SymbolTimestamp
-
-        redis_client = MagicMock()
-        mysql_engine = create_engine("sqlite:///:memory:")
-        Base.metadata.create_all(bind=mysql_engine)
-        manager = StorageManager(redis_client=redis_client, mysql_engine=mysql_engine)
-
-        fetched_at = datetime(2026, 7, 4, 10, 0, 0)
-        data = {
-            "type": "futures",
-            "current_price": 123.45,
-            "timestamp": fetched_at.isoformat(),
-            "timeframes": {
-                "5min": [{"open": 100, "close": 110}],
-                "15min": [{"open": 105, "close": 115}],
-            },
-        }
-        refresh_time = datetime(2026, 7, 4, 10, 1, 0)
-
-        result = manager.save_market_data_with_timestamp("AG2606", data, refresh_time)
-
-        assert result is True
-        SessionLocal = sessionmaker(bind=mysql_engine)
-        with SessionLocal() as db:
-            market_records = db.query(MarketData).filter_by(symbol="AG2606").all()
-            assert len(market_records) == 2
-            periods = {r.period for r in market_records}
-            assert periods == {"5min", "15min"}
-
-            ts = db.query(SymbolTimestamp).filter_by(symbol="AG2606", data_type="futures").first()
-            assert ts is not None
-            assert ts.last_refresh_at == refresh_time
-            assert ts.refresh_count == 1
-
-        redis_client.delete.assert_called_once_with(
-            "market_data:AG2606:5min",
-            "market_data:AG2606:15min",
-            "symbol_timestamps:AG2606",
-        )
-
-    def test_save_market_data_with_timestamp_returns_false_on_mysql_failure(self):
-        """MySQL 写入失败时返回 False，不同步时间戳。"""
-        redis_client = MagicMock()
-        manager = StorageManager(redis_client=redis_client, mysql_engine=None)
-
-        data = {
-            "type": "futures",
-            "current_price": 123.45,
-            "timestamp": datetime(2026, 7, 4, 10, 0, 0).isoformat(),
-            "timeframes": {"5min": [{"open": 100, "close": 110}]},
-        }
-
-        result = manager.save_market_data_with_timestamp(
-            "AG2606", data, datetime(2026, 7, 4, 10, 1, 0)
-        )
-
-        assert result is False
-        redis_client.setex.assert_not_called()