422 lines
15 KiB
Python
422 lines
15 KiB
Python
"""策略配置中心
|
|
|
|
把可迭代的策略参数和 Prompt 版本持久化到数据库。
|
|
代码里的默认策略只作为兜底；一旦数据库有激活配置，下一轮扫描直接读取配置。
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import logging
|
|
from datetime import datetime
|
|
from typing import Any
|
|
|
|
from sqlalchemy import text
|
|
|
|
from app.db.database import get_db
|
|
from app.db import tables
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
CONFIG_FIELDS = {
|
|
"name",
|
|
"description",
|
|
"entry_signal_priority",
|
|
"score_weights",
|
|
"min_score",
|
|
"buy_threshold",
|
|
"max_position_pct",
|
|
"allow_trading",
|
|
"actionable_limit",
|
|
"watch_limit",
|
|
"target_focus_sectors",
|
|
"market_stance",
|
|
"decision_note",
|
|
"notes",
|
|
}
|
|
|
|
PROMPT_DEFAULT_KEYS = {
|
|
"stock_prefilter": "STOCK_PREFILTER_PROMPT",
|
|
"single_stock_analysis": "SINGLE_STOCK_ANALYSIS_PROMPT",
|
|
"strategy_iteration": "STRATEGY_ITERATION_PROMPT",
|
|
}
|
|
|
|
|
|
def profile_to_config(profile) -> dict[str, Any]:
|
|
data = profile.model_dump() if hasattr(profile, "model_dump") else dict(profile)
|
|
return {key: data[key] for key in CONFIG_FIELDS if key in data}
|
|
|
|
|
|
def apply_config_to_profile(profile, config: dict[str, Any] | None, generated_by: str = "config"):
|
|
if not config:
|
|
return profile
|
|
updated = profile.model_copy(deep=True)
|
|
for key, value in config.items():
|
|
if key in CONFIG_FIELDS and hasattr(updated, key):
|
|
setattr(updated, key, value)
|
|
updated.generated_by = generated_by
|
|
return updated
|
|
|
|
|
|
async def load_active_strategy_profile(profile):
|
|
row = await _load_active_strategy_row(profile.strategy_id)
|
|
if not row:
|
|
return profile
|
|
config = _json_loads(row["config_json"], {})
|
|
updated = apply_config_to_profile(profile, config, generated_by=f"config:v{row['version']}")
|
|
updated.feedback_applied = True
|
|
updated.feedback_notes = [
|
|
f"策略配置版本 v{row['version']} ({row['source']}) 已生效",
|
|
row["change_reason"] or "使用配置中心激活版本",
|
|
]
|
|
return updated
|
|
|
|
|
|
async def get_active_strategy_configs() -> list[dict]:
|
|
await ensure_default_configs()
|
|
async with get_db() as db:
|
|
result = await db.execute(
|
|
text(
|
|
"SELECT * FROM strategy_configs "
|
|
"WHERE is_active = 1 "
|
|
"ORDER BY strategy_id ASC, version DESC"
|
|
)
|
|
)
|
|
return [_format_strategy_row(row._mapping) for row in result.fetchall()]
|
|
|
|
|
|
async def get_recent_config_changes(limit: int = 20) -> list[dict]:
|
|
async with get_db() as db:
|
|
result = await db.execute(
|
|
text(
|
|
"SELECT * FROM strategy_config_changes "
|
|
"ORDER BY id DESC LIMIT :limit"
|
|
),
|
|
{"limit": limit},
|
|
)
|
|
return [_format_change_row(row._mapping) for row in result.fetchall()]
|
|
|
|
|
|
async def get_active_prompt_configs() -> list[dict]:
|
|
await ensure_default_configs()
|
|
async with get_db() as db:
|
|
result = await db.execute(
|
|
text(
|
|
"SELECT * FROM prompt_configs "
|
|
"WHERE is_active = 1 "
|
|
"ORDER BY prompt_key ASC, version DESC"
|
|
)
|
|
)
|
|
return [_format_prompt_row(row._mapping) for row in result.fetchall()]
|
|
|
|
|
|
async def get_prompt_content(prompt_key: str, default: str) -> str:
|
|
async with get_db() as db:
|
|
result = await db.execute(
|
|
text(
|
|
"SELECT content FROM prompt_configs "
|
|
"WHERE prompt_key = :key AND is_active = 1 "
|
|
"ORDER BY version DESC LIMIT 1"
|
|
),
|
|
{"key": prompt_key},
|
|
)
|
|
row = result.fetchone()
|
|
return str(row._mapping["content"]) if row else default
|
|
|
|
|
|
async def create_active_strategy_config(
|
|
strategy_id: str,
|
|
config: dict[str, Any],
|
|
*,
|
|
source: str,
|
|
reason: str,
|
|
evidence: dict[str, Any] | None = None,
|
|
change_type: str = "manual",
|
|
) -> dict:
|
|
"""写入一个新的激活策略配置版本，并记录变更。"""
|
|
async with get_db() as db:
|
|
base = await _load_active_strategy_row(strategy_id, db=db)
|
|
version = int(base["version"]) + 1 if base else 1
|
|
before = _json_loads(base["config_json"], {}) if base else {}
|
|
diff = _build_diff(before, config)
|
|
|
|
await db.execute(
|
|
text("UPDATE strategy_configs SET is_active = 0 WHERE strategy_id = :sid"),
|
|
{"sid": strategy_id},
|
|
)
|
|
await db.execute(
|
|
tables.strategy_configs_table.insert().values(
|
|
strategy_id=strategy_id,
|
|
version=version,
|
|
config_json=json.dumps(config, ensure_ascii=False),
|
|
is_active=True,
|
|
source=source,
|
|
change_reason=reason,
|
|
evidence_json=json.dumps(evidence or {}, ensure_ascii=False),
|
|
)
|
|
)
|
|
await db.execute(
|
|
tables.strategy_config_changes_table.insert().values(
|
|
change_type=change_type,
|
|
status="applied",
|
|
strategy_id=strategy_id,
|
|
base_version=int(base["version"]) if base else 0,
|
|
new_version=version,
|
|
diff_json=json.dumps(diff, ensure_ascii=False),
|
|
evidence_json=json.dumps(evidence or {}, ensure_ascii=False),
|
|
reason=reason,
|
|
applied_at=datetime.now(),
|
|
)
|
|
)
|
|
await db.commit()
|
|
|
|
row = await _load_active_strategy_row(strategy_id)
|
|
return _format_strategy_row(row)
|
|
|
|
|
|
async def rollback_strategy_config(strategy_id: str) -> dict:
|
|
"""回滚到当前策略的上一个版本。"""
|
|
async with get_db() as db:
|
|
active = await _load_active_strategy_row(strategy_id, db=db)
|
|
if not active:
|
|
raise ValueError("当前策略没有激活配置")
|
|
result = await db.execute(
|
|
text(
|
|
"SELECT * FROM strategy_configs "
|
|
"WHERE strategy_id = :sid AND version < :version "
|
|
"ORDER BY version DESC LIMIT 1"
|
|
),
|
|
{"sid": strategy_id, "version": active["version"]},
|
|
)
|
|
previous_row = result.fetchone()
|
|
if not previous_row:
|
|
raise ValueError("没有可回滚的上一版本")
|
|
current = active
|
|
previous = previous_row._mapping
|
|
await db.execute(
|
|
text("UPDATE strategy_configs SET is_active = 0 WHERE strategy_id = :sid"),
|
|
{"sid": strategy_id},
|
|
)
|
|
await db.execute(
|
|
text("UPDATE strategy_configs SET is_active = 1, source = 'rollback' WHERE id = :id"),
|
|
{"id": previous["id"]},
|
|
)
|
|
await db.execute(
|
|
tables.strategy_config_changes_table.insert().values(
|
|
change_type="rollback",
|
|
status="applied",
|
|
strategy_id=strategy_id,
|
|
base_version=int(current["version"]),
|
|
new_version=int(previous["version"]),
|
|
diff_json=json.dumps(
|
|
_build_diff(_json_loads(current["config_json"], {}), _json_loads(previous["config_json"], {})),
|
|
ensure_ascii=False,
|
|
),
|
|
reason=f"回滚 {strategy_id} 到 v{previous['version']}",
|
|
applied_at=datetime.now(),
|
|
)
|
|
)
|
|
await db.commit()
|
|
row = await _load_active_strategy_row(strategy_id)
|
|
return _format_strategy_row(row)
|
|
|
|
|
|
async def ensure_default_configs() -> None:
|
|
"""首次启动时把代码默认策略和默认 Prompt 种子写入数据库。"""
|
|
from app.llm.strategy_selector import get_strategy_profile_by_id
|
|
from app.llm import prompts
|
|
|
|
strategy_ids = ["breakout_attack", "pullback_rotation", "launch_probe", "defensive_watch"]
|
|
async with get_db() as db:
|
|
for strategy_id in strategy_ids:
|
|
count = (await db.execute(
|
|
text("SELECT COUNT(*) FROM strategy_configs WHERE strategy_id = :sid"),
|
|
{"sid": strategy_id},
|
|
)).scalar() or 0
|
|
if count:
|
|
continue
|
|
profile = get_strategy_profile_by_id(strategy_id)
|
|
await db.execute(
|
|
tables.strategy_configs_table.insert().values(
|
|
strategy_id=strategy_id,
|
|
version=1,
|
|
config_json=json.dumps(profile_to_config(profile), ensure_ascii=False),
|
|
is_active=True,
|
|
source="default_seed",
|
|
change_reason="初始化默认策略配置",
|
|
)
|
|
)
|
|
|
|
prompt_defaults = {
|
|
"stock_prefilter": getattr(prompts, "STOCK_PREFILTER_PROMPT", ""),
|
|
"single_stock_analysis": getattr(prompts, "SINGLE_STOCK_ANALYSIS_PROMPT", ""),
|
|
"strategy_iteration": getattr(prompts, "STRATEGY_ITERATION_PROMPT", ""),
|
|
}
|
|
for prompt_key, content in prompt_defaults.items():
|
|
if not content:
|
|
continue
|
|
count = (await db.execute(
|
|
text("SELECT COUNT(*) FROM prompt_configs WHERE prompt_key = :key"),
|
|
{"key": prompt_key},
|
|
)).scalar() or 0
|
|
if count:
|
|
continue
|
|
await db.execute(
|
|
tables.prompt_configs_table.insert().values(
|
|
prompt_key=prompt_key,
|
|
version=1,
|
|
content=content,
|
|
is_active=True,
|
|
source="default_seed",
|
|
change_reason="初始化默认 Prompt 配置",
|
|
)
|
|
)
|
|
await db.commit()
|
|
|
|
|
|
async def maybe_auto_apply_review_adjustment(report: dict) -> dict | None:
|
|
"""根据复盘报告做小幅自动配置调整。
|
|
|
|
大幅结构调整仍只进入报告建议，不自动改配置。
|
|
"""
|
|
sample_size = int(report.get("sample_size") or 0)
|
|
if sample_size < 10:
|
|
return None
|
|
if await _has_auto_change_today():
|
|
return None
|
|
|
|
for suggestion in report.get("adjustment_suggestions", []) or []:
|
|
strategy_id = suggestion.get("target", "")
|
|
if strategy_id not in {"breakout_attack", "pullback_rotation", "launch_probe", "defensive_watch"}:
|
|
continue
|
|
active = await _load_active_strategy_row(strategy_id)
|
|
if not active:
|
|
continue
|
|
config = _json_loads(active["config_json"], {})
|
|
changed = _apply_small_adjustment(config, suggestion.get("action", ""))
|
|
if not changed:
|
|
continue
|
|
evidence = {
|
|
"sample_size": sample_size,
|
|
"summary": report.get("summary", ""),
|
|
"suggestion": suggestion,
|
|
}
|
|
return await create_active_strategy_config(
|
|
strategy_id,
|
|
config,
|
|
source="auto_review",
|
|
reason=suggestion.get("reason", "复盘触发小幅自动配置调整"),
|
|
evidence=evidence,
|
|
change_type="auto_applied",
|
|
)
|
|
return None
|
|
|
|
|
|
async def _load_active_strategy_row(strategy_id: str, db=None):
|
|
own_session = db is None
|
|
if own_session:
|
|
async with get_db() as session:
|
|
return await _load_active_strategy_row(strategy_id, db=session)
|
|
result = await db.execute(
|
|
text(
|
|
"SELECT * FROM strategy_configs "
|
|
"WHERE strategy_id = :sid AND is_active = 1 "
|
|
"ORDER BY version DESC LIMIT 1"
|
|
),
|
|
{"sid": strategy_id},
|
|
)
|
|
row = result.fetchone()
|
|
return row._mapping if row else None
|
|
|
|
|
|
async def _has_auto_change_today() -> bool:
|
|
async with get_db() as db:
|
|
count = (await db.execute(
|
|
text(
|
|
"SELECT COUNT(*) FROM strategy_config_changes "
|
|
"WHERE change_type = 'auto_applied' "
|
|
"AND date(created_at) = date('now', 'localtime')"
|
|
)
|
|
)).scalar() or 0
|
|
return count > 0
|
|
|
|
|
|
def _apply_small_adjustment(config: dict[str, Any], action: str) -> bool:
|
|
if action == "tighten":
|
|
config["buy_threshold"] = min(float(config.get("buy_threshold", 60)) + 1, 80)
|
|
config["max_position_pct"] = max(float(config.get("max_position_pct", 10)) - 5, 0)
|
|
config["actionable_limit"] = max(int(config.get("actionable_limit", 1)) - 1, 0)
|
|
return True
|
|
if action == "promote":
|
|
config["buy_threshold"] = max(float(config.get("buy_threshold", 60)) - 1, float(config.get("min_score", 0)))
|
|
config["watch_limit"] = min(int(config.get("watch_limit", 3)) + 1, 8)
|
|
return True
|
|
if action == "reduce":
|
|
config["buy_threshold"] = min(float(config.get("buy_threshold", 60)) + 1, 80)
|
|
config["watch_limit"] = max(int(config.get("watch_limit", 3)) - 1, 1)
|
|
return True
|
|
return False
|
|
|
|
|
|
def _build_diff(before: dict[str, Any], after: dict[str, Any]) -> dict[str, dict[str, Any]]:
|
|
diff: dict[str, dict[str, Any]] = {}
|
|
for key in sorted(set(before) | set(after)):
|
|
if before.get(key) != after.get(key):
|
|
diff[key] = {"from": before.get(key), "to": after.get(key)}
|
|
return diff
|
|
|
|
|
|
def _json_loads(value: str | None, default):
|
|
try:
|
|
return json.loads(value or "")
|
|
except Exception:
|
|
return default
|
|
|
|
|
|
def _format_strategy_row(row) -> dict:
|
|
if not row:
|
|
return {}
|
|
return {
|
|
"id": row["id"],
|
|
"strategy_id": row["strategy_id"],
|
|
"version": row["version"],
|
|
"config": _json_loads(row["config_json"], {}),
|
|
"is_active": bool(row["is_active"]),
|
|
"source": row["source"] or "",
|
|
"change_reason": row["change_reason"] or "",
|
|
"evidence": _json_loads(row["evidence_json"], {}),
|
|
"effective_from": str(row["effective_from"] or ""),
|
|
"created_at": str(row["created_at"] or ""),
|
|
}
|
|
|
|
|
|
def _format_prompt_row(row) -> dict:
|
|
return {
|
|
"id": row["id"],
|
|
"prompt_key": row["prompt_key"],
|
|
"version": row["version"],
|
|
"content": row["content"],
|
|
"is_active": bool(row["is_active"]),
|
|
"source": row["source"] or "",
|
|
"change_reason": row["change_reason"] or "",
|
|
"evidence": _json_loads(row["evidence_json"], {}),
|
|
"created_at": str(row["created_at"] or ""),
|
|
}
|
|
|
|
|
|
def _format_change_row(row) -> dict:
|
|
return {
|
|
"id": row["id"],
|
|
"change_type": row["change_type"],
|
|
"status": row["status"],
|
|
"strategy_id": row["strategy_id"] or "",
|
|
"prompt_key": row["prompt_key"] or "",
|
|
"base_version": row["base_version"] or 0,
|
|
"new_version": row["new_version"] or 0,
|
|
"diff": _json_loads(row["diff_json"], {}),
|
|
"evidence": _json_loads(row["evidence_json"], {}),
|
|
"reason": row["reason"] or "",
|
|
"created_at": str(row["created_at"] or ""),
|
|
"applied_at": str(row["applied_at"] or ""),
|
|
}
|