From 697c27bb023bbdecc5854f94e2d86f1e11b94ccc Mon Sep 17 00:00:00 2001 From: shy3130 Date: Sun, 16 Aug 2026 23:39:07 +0800 Subject: [PATCH] =?UTF-8?q?feat(v0.2):=20=E5=B8=82=E5=9C=BA=E9=98=B6?= =?UTF-8?q?=E6=AE=B5=E4=B8=8E=E4=B8=BB=E7=BA=BF=E8=AF=86=E5=88=AB=20+=20?= =?UTF-8?q?=E5=9B=A0=E5=AD=90=E6=8C=96=E6=8E=98=E5=85=A8=E9=93=BE=E8=B7=AF?= =?UTF-8?q?=20+=20=E6=95=B0=E6=8D=AE=E5=B1=82=E5=AE=8C=E5=96=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 市场环境: 新增情绪周期6阶段(冰点/启动/主升/高潮/退潮/修复, 连板梯队驱动, EMA平滑+2日确认+弱档否决, 平均段长9.7天)与概念/行业主线排名(涨停梯队聚合, 可配置宽基/风格标签过滤); 市场环境页重构, regime 透明加列, 与5档state并存 - 挖掘: 因子与策略挖掘全链路(API/worker/进程锁/候选库/前端工作台/文档), 周度调度默认关闭且永不自动发布 - 回测: 财务快照因子(点时口径), 批量回测预计算共享下期收益, 信号路径矩阵列依赖展开修复(consecutive_limit_ups 缺列报错) - 数据/性能: enriched 生成与预热治理, 重任务限流, 行情/K线缓存复用, 时区修复 - 测试: 后端全量 914 通过; GUI 黑盒验证截图存证 gui-test-screenshots/ --- README.md | 3 +- backend/app/api/backtest.py | 83 +- backend/app/api/data.py | 36 +- backend/app/api/kline.py | 100 +- backend/app/api/mining.py | 736 ++++++++ backend/app/api/regime.py | 203 +- backend/app/api/screener.py | 17 +- backend/app/api/settings.py | 41 +- backend/app/api/strategy.py | 45 +- backend/app/api/watchlist.py | 2 +- backend/app/backtest/candidates.py | 191 +- backend/app/backtest/engine.py | 162 +- backend/app/backtest/factor.py | 734 +++++++- backend/app/backtest/fundamentals.py | 209 +++ backend/app/backtest/matrix.py | 168 ++ backend/app/backtest/mining.py | 1660 +++++++++++++++++ backend/app/backtest/mining_runtime.py | 1489 +++++++++++++++ backend/app/backtest/regime_alignment.py | 129 ++ backend/app/backtest/strategy.py | 100 +- backend/app/backtest/worker.py | 30 +- backend/app/enriched_generation.py | 319 ++++ backend/app/indicators/pipeline.py | 43 +- backend/app/jobs/daily_pipeline.py | 48 +- backend/app/main.py | 152 +- backend/app/services/ext_data.py | 45 +- backend/app/services/financial_sync.py | 63 +- backend/app/services/heavy_job_limiter.py | 121 ++ backend/app/services/kline_sync.py | 12 +- backend/app/services/market_mainline.py | 248 +++ backend/app/services/market_phase.py | 255 +++ backend/app/services/matrix_prewarm_owner.py | 48 + backend/app/services/mining_candidates.py | 793 ++++++++ backend/app/services/mining_jobs.py | 620 ++++++ backend/app/services/mining_manager.py | 263 +++ backend/app/services/mining_preflight.py | 139 ++ backend/app/services/mining_process_lock.py | 78 + backend/app/services/mining_schedule.py | 391 ++++ backend/app/services/preferences.py | 144 +- backend/app/services/quote_service.py | 44 +- backend/app/services/regime_builder.py | 50 + backend/app/strategy/ai_generator.py | 1 + .../strategy/builtin/factor_rank_research.py | 209 +++ backend/app/strategy/config.py | 43 +- backend/app/strategy/engine.py | 40 +- backend/app/strategy/scoring.py | 83 + backend/app/tickflow/repository.py | 212 ++- backend/tests/backtest/test_dependencies.py | 73 +- backend/tests/backtest/test_factor_batch.py | 18 +- backend/tests/backtest/test_factor_metrics.py | 391 ++++ .../backtest/test_factor_rank_research.py | 218 +++ .../tests/backtest/test_matrix_strategy.py | 88 +- backend/tests/backtest/test_mining.py | 941 ++++++++++ backend/tests/backtest/test_mining_runtime.py | 314 ++++ .../backtest/test_research_candidates.py | 158 +- .../test_strategy_backtest_correctness.py | 73 +- backend/tests/backtest/test_worker_process.py | 263 ++- backend/tests/test_data_clear_generation.py | 154 ++ backend/tests/test_data_status_storage.py | 61 + backend/tests/test_enriched_generation.py | 165 ++ .../test_enriched_range_warming_guard.py | 56 + .../tests/test_ext_config_load_all_cache.py | 99 + backend/tests/test_ext_config_store_safety.py | 43 + backend/tests/test_factor_library_v2.py | 173 ++ backend/tests/test_fundamental_factors.py | 193 ++ backend/tests/test_get_daily_cache_reuse.py | 106 ++ backend/tests/test_heavy_job_limiter.py | 96 + backend/tests/test_indicator_needed.py | 13 + backend/tests/test_kline_hot_path_memory.py | 155 ++ backend/tests/test_kline_sync_timezone.py | 38 + backend/tests/test_last_fetch_throttle.py | 64 + backend/tests/test_main_mining_lifespan.py | 83 + backend/tests/test_market_mainline.py | 162 ++ backend/tests/test_market_phase.py | 200 ++ .../test_matrix_field_columns_expansion.py | 65 + backend/tests/test_matrix_prewarm_owner.py | 75 + backend/tests/test_mining_api.py | 606 ++++++ backend/tests/test_mining_candidates.py | 679 +++++++ backend/tests/test_mining_jobs.py | 263 +++ backend/tests/test_mining_manager.py | 352 ++++ backend/tests/test_mining_process_lock.py | 77 + backend/tests/test_mining_schedule.py | 427 +++++ backend/tests/test_minute_range_api.py | 8 +- .../tests/test_override_signature_cache.py | 97 + backend/tests/test_preferences_cache.py | 123 ++ backend/tests/test_price_limits.py | 39 + backend/tests/test_quote_name_map_reuse.py | 57 + backend/tests/test_realtime_turnover_rate.py | 1 + backend/tests/test_regime_builder.py | 29 +- backend/tests/test_repository_index.py | 37 + backend/tests/test_screener_builtin_params.py | 5 + .../tests/test_settings_mining_schedule.py | 71 + backend/tests/test_st_limit_and_sharpe.py | 1 + docs/features.md | 6 +- docs/market-phase.md | 95 + docs/mining.md | 138 ++ docs/strategy.md | 2 + frontend/src/components/Layout.tsx | 29 +- frontend/src/lib/api.ts | 384 +++- frontend/src/lib/miningTask.ts | 376 ++++ frontend/src/lib/queryKeys.ts | 24 +- frontend/src/lib/useQuoteStream.ts | 7 + frontend/src/pages/Backtest.tsx | 24 +- frontend/src/pages/Dashboard.tsx | 1 - frontend/src/pages/LimitUpLadder.tsx | 5 +- frontend/src/pages/Mining.tsx | 37 + frontend/src/pages/Monitor.tsx | 4 +- frontend/src/pages/Regime.tsx | 397 +++- frontend/src/pages/Screener.tsx | 35 +- frontend/src/pages/Watchlist.tsx | 35 +- .../src/pages/backtest/MiningWorkbench.tsx | 698 +++++++ .../backtest/ResearchCandidatesDialog.tsx | 4 +- .../charts/FactorCorrelationHeatmap.tsx | 191 ++ .../pages/backtest/charts/MiningOosChart.tsx | 201 ++ .../backtest/charts/RegimeComparisonChart.tsx | 182 ++ .../src/pages/backtest/charts/useECharts.ts | 9 +- frontend/src/pages/settings/MenuSettings.tsx | 27 +- frontend/src/router.tsx | 3 + gui-test-screenshots/phase_t1_overview.png | Bin 0 -> 219323 bytes gui-test-screenshots/phase_t2_segments.png | Bin 0 -> 219323 bytes .../phase_t3_filter_panel.png | Bin 0 -> 273856 bytes gui-test-screenshots/phase_t4_mobile.png | Bin 0 -> 122648 bytes .../t1-desktop-empty-dark.png | Bin 0 -> 200478 bytes .../t2-validation-error-dark.png | Bin 0 -> 200441 bytes gui-test-screenshots/t3-run-failed-dark.png | Bin 0 -> 202152 bytes gui-test-screenshots/t4-1024-dark.png | Bin 0 -> 163214 bytes gui-test-screenshots/t5-390-dark.png | Bin 0 -> 95994 bytes gui-test-screenshots/t6-360-dark.png | Bin 0 -> 92351 bytes gui-test-screenshots/t7-360-light.png | Bin 0 -> 89167 bytes gui-test-screenshots/t8-desktop-light.png | Bin 0 -> 187531 bytes 129 files changed, 20324 insertions(+), 602 deletions(-) create mode 100644 backend/app/api/mining.py create mode 100644 backend/app/backtest/fundamentals.py create mode 100644 backend/app/backtest/mining.py create mode 100644 backend/app/backtest/mining_runtime.py create mode 100644 backend/app/backtest/regime_alignment.py create mode 100644 backend/app/enriched_generation.py create mode 100644 backend/app/services/heavy_job_limiter.py create mode 100644 backend/app/services/market_mainline.py create mode 100644 backend/app/services/market_phase.py create mode 100644 backend/app/services/matrix_prewarm_owner.py create mode 100644 backend/app/services/mining_candidates.py create mode 100644 backend/app/services/mining_jobs.py create mode 100644 backend/app/services/mining_manager.py create mode 100644 backend/app/services/mining_preflight.py create mode 100644 backend/app/services/mining_process_lock.py create mode 100644 backend/app/services/mining_schedule.py create mode 100644 backend/app/strategy/builtin/factor_rank_research.py create mode 100644 backend/tests/backtest/test_factor_metrics.py create mode 100644 backend/tests/backtest/test_factor_rank_research.py create mode 100644 backend/tests/backtest/test_mining.py create mode 100644 backend/tests/backtest/test_mining_runtime.py create mode 100644 backend/tests/test_data_clear_generation.py create mode 100644 backend/tests/test_data_status_storage.py create mode 100644 backend/tests/test_enriched_generation.py create mode 100644 backend/tests/test_enriched_range_warming_guard.py create mode 100644 backend/tests/test_ext_config_load_all_cache.py create mode 100644 backend/tests/test_ext_config_store_safety.py create mode 100644 backend/tests/test_factor_library_v2.py create mode 100644 backend/tests/test_fundamental_factors.py create mode 100644 backend/tests/test_get_daily_cache_reuse.py create mode 100644 backend/tests/test_heavy_job_limiter.py create mode 100644 backend/tests/test_kline_hot_path_memory.py create mode 100644 backend/tests/test_kline_sync_timezone.py create mode 100644 backend/tests/test_last_fetch_throttle.py create mode 100644 backend/tests/test_main_mining_lifespan.py create mode 100644 backend/tests/test_market_mainline.py create mode 100644 backend/tests/test_market_phase.py create mode 100644 backend/tests/test_matrix_field_columns_expansion.py create mode 100644 backend/tests/test_matrix_prewarm_owner.py create mode 100644 backend/tests/test_mining_api.py create mode 100644 backend/tests/test_mining_candidates.py create mode 100644 backend/tests/test_mining_jobs.py create mode 100644 backend/tests/test_mining_manager.py create mode 100644 backend/tests/test_mining_process_lock.py create mode 100644 backend/tests/test_mining_schedule.py create mode 100644 backend/tests/test_override_signature_cache.py create mode 100644 backend/tests/test_preferences_cache.py create mode 100644 backend/tests/test_quote_name_map_reuse.py create mode 100644 backend/tests/test_settings_mining_schedule.py create mode 100644 docs/market-phase.md create mode 100644 docs/mining.md create mode 100644 frontend/src/lib/miningTask.ts create mode 100644 frontend/src/pages/Mining.tsx create mode 100644 frontend/src/pages/backtest/MiningWorkbench.tsx create mode 100644 frontend/src/pages/backtest/charts/FactorCorrelationHeatmap.tsx create mode 100644 frontend/src/pages/backtest/charts/MiningOosChart.tsx create mode 100644 frontend/src/pages/backtest/charts/RegimeComparisonChart.tsx create mode 100644 gui-test-screenshots/phase_t1_overview.png create mode 100644 gui-test-screenshots/phase_t2_segments.png create mode 100644 gui-test-screenshots/phase_t3_filter_panel.png create mode 100644 gui-test-screenshots/phase_t4_mobile.png create mode 100644 gui-test-screenshots/t1-desktop-empty-dark.png create mode 100644 gui-test-screenshots/t2-validation-error-dark.png create mode 100644 gui-test-screenshots/t3-run-failed-dark.png create mode 100644 gui-test-screenshots/t4-1024-dark.png create mode 100644 gui-test-screenshots/t5-390-dark.png create mode 100644 gui-test-screenshots/t6-360-dark.png create mode 100644 gui-test-screenshots/t7-360-light.png create mode 100644 gui-test-screenshots/t8-desktop-light.png diff --git a/README.md b/README.md index c7e0b5e..718f332 100644 --- a/README.md +++ b/README.md @@ -54,7 +54,7 @@ | :--------------- | :--------------------------------------------------------------------- | :-------------------------------- | | 🔍 **选股引擎** | 18 个内置策略 + 自定义信号 + AI 生成 + 代码迁移,Polars 毫秒级扫全 A 股 | [strategy.md](./docs/strategy.md) | | 📊 **指标流水线** | MA/EMA/MACD/RSI/KDJ/布林/量比等,一次扫表落盘 enriched Parquet | [features.md](./docs/features.md) | -| 🧪 **回测引擎** | 三种模式(个股/策略组合/自由信号),T+1/手续费/滑点/止损,SSE 流式进度 | [features.md](./docs/features.md) | +| 🧪 **回测研究** | 因子/策略回测 + 嵌套样本外挖掘,T+1/费用/滑点约束,SSE 持久任务 | [mining.md](./docs/mining.md) | | 📡 **监控中心** | 四类监控(策略/个股信号/价格/异动),多条件 AND/OR + 语音播报 + 飞书推送 | [features.md](./docs/features.md) | | 📈 **个股分析** | 9 类关键价位 + AI 四维分析(技术/基本面/财务/消息面) | [features.md](./docs/features.md) | | 🏆 **连板梯队** | 连板层级统计 + 概念涨幅轮动 + 盘后 AI 复盘 + 炸板/翘板预警 | [features.md](./docs/features.md) | @@ -238,6 +238,7 @@ PORT=3018 # 服务端口 | [docs/features.md](./docs/features.md) | 各功能模块详细说明(选股/指标/回测/监控/个股分析/数据扩展) | | [docs/custom-data-source.md](./docs/custom-data-source.md) | 自定义数据源接入、YAML 配置与 mock 联调示例 | | [docs/strategy.md](./docs/strategy.md) | 策略体系(18 内置策略 + 三种扩展方式 + 文件结构) | +| [docs/mining.md](./docs/mining.md) | 因子与策略挖掘口径、防泄漏、任务隔离和发布边界 | | [docs/secondary-development.md](./docs/secondary-development.md) | 代码二次开发、前端插槽、后端策略接口与 AI 开发模板 | | [backend/app/strategy/prompts/strategy-guide.md](./backend/app/strategy/prompts/strategy-guide.md) | 策略开发完整规范(AI 生成与手写) | diff --git a/backend/app/api/backtest.py b/backend/app/api/backtest.py index d834f32..2605e73 100644 --- a/backend/app/api/backtest.py +++ b/backend/app/api/backtest.py @@ -381,7 +381,10 @@ def strategy_run(req: StrategyBacktestRequest, request: Request): regime_filter=req.regime_filter, ) task = make_worker_task("backtest", settings.data_dir, cfg) - return run_worker_task(task) + from app.services.heavy_job_limiter import shared_heavy_job_limiter + + with shared_heavy_job_limiter.slot("normal"): + return run_worker_task(task) # ── SSE 流式回测 (实时进度 + 可取消 + 支持重连) ─────────────────── @@ -409,10 +412,6 @@ _running_jobs: dict[str, _BacktestJob] = {} _jobs_lock = threading.Lock() _JOB_TTL = 300 # 完成后保留 5 分钟 -# 并发回测上限: 多个重回测同时跑会 OOM (服务器内存约 1.8GB)。用信号量限并发, -# 超出的任务在 _run_backtest 里排队, SSE 连接照常保持, run 一开始就有进度。 -_backtest_semaphore = threading.Semaphore(2) - def _cleanup_stale_jobs(): """清理过期任务 (完成超过 TTL 的)。全程持 _jobs_lock: 迭代+pop 与其他访问互斥。""" @@ -588,21 +587,27 @@ async def strategy_stream( ) def _run_backtest(): - # 信号量限并发: 超额任务在此阻塞排队, 不并发吃满内存 (等待期间 cancel_event - # 仍可置位, svc.run 会据此提前返回 cancelled)。持槽跑完在 finally 释放。 - _backtest_semaphore.acquire() + from app.services.heavy_job_limiter import ( + HeavyJobCancelledError, + shared_heavy_job_limiter, + ) + try: - task = make_worker_task("backtest", settings.data_dir, cfg) - result = run_worker_task( - task, - lambda d: job.progress.append(d), - job.cancel_event, - ) + with shared_heavy_job_limiter.slot( + "normal", + cancel_event=job.cancel_event, + ): + task = make_worker_task("backtest", settings.data_dir, cfg) + result = run_worker_task( + task, + lambda d: job.progress.append(d), + job.cancel_event, + ) _finish_job(job, result=result) + except HeavyJobCancelledError: + _finish_job(job, error="回测已取消") except Exception as e: _finish_job(job, error=str(e)) - finally: - _backtest_semaphore.release() # 启动后台线程 (不阻塞事件循环) threading.Thread(target=_run_backtest, daemon=True).start() @@ -886,14 +891,25 @@ async def optimize_stream( ) def _run_opt(): + from app.services.heavy_job_limiter import ( + HeavyJobCancelledError, + shared_heavy_job_limiter, + ) + try: - task = make_worker_task("optimize", settings.data_dir, ocfg) - result = run_worker_task( - task, - lambda d: job.progress.append(d), - job.cancel_event, - ) + with shared_heavy_job_limiter.slot( + "normal", + cancel_event=job.cancel_event, + ): + task = make_worker_task("optimize", settings.data_dir, ocfg) + result = run_worker_task( + task, + lambda d: job.progress.append(d), + job.cancel_event, + ) _finish_job(job, result=result) + except HeavyJobCancelledError: + _finish_job(job, error="优化已取消") except Exception as e: _finish_job(job, error=str(e)) @@ -1101,14 +1117,25 @@ async def walkforward_stream( ) def _run_wf(): + from app.services.heavy_job_limiter import ( + HeavyJobCancelledError, + shared_heavy_job_limiter, + ) + try: - task = make_worker_task("walkforward", settings.data_dir, wf_cfg) - result = run_worker_task( - task, - lambda d: job.progress.append(d), - job.cancel_event, - ) + with shared_heavy_job_limiter.slot( + "normal", + cancel_event=job.cancel_event, + ): + task = make_worker_task("walkforward", settings.data_dir, wf_cfg) + result = run_worker_task( + task, + lambda d: job.progress.append(d), + job.cancel_event, + ) _finish_job(job, result=result) + except HeavyJobCancelledError: + _finish_job(job, error="walk-forward 已取消") except Exception as e: _finish_job(job, error=str(e)) diff --git a/backend/app/api/data.py b/backend/app/api/data.py index ce3ec92..3526d7f 100644 --- a/backend/app/api/data.py +++ b/backend/app/api/data.py @@ -11,6 +11,7 @@ from typing import Any, Callable from fastapi import APIRouter, Request +from app.enriched_generation import EnrichedPublication from app.indicators.pipeline import ENRICHED_COLUMNS logger = logging.getLogger(__name__) @@ -504,26 +505,21 @@ def _compute_storage(data_dir: Path) -> dict: stats[f"{key}_files"] = fc stats[f"{key}_size_mb"] = sz - # total: 再加上其他零散文件(pools, financials, capabilities.json 等) - other_dirs = ["pools", "financials", "backtest_results", "screener_results", "ai_cache"] + # total: 再加上其他零散目录 (financials 有下方专属明细统计, 不在此列) + other_dirs = ["pools", "backtest_results", "screener_results", "ai_cache"] for name in other_dirs: d = data_dir / name if d.exists(): _, s = _scan_dir_stats(d) total_size += s - # financials 单独统计 + # financials 单独统计 (明细与 total 各计入一次, 不得与其他目录循环重复累加) fin_dir = data_dir / "financials" if fin_dir.exists(): fc, sz = _scan_dir_stats(fin_dir) stats["financials_files"] = fc stats["financials_size_mb"] = sz total_size += sz - for name in other_dirs: - d = data_dir / name - if d.exists(): - _, s = _scan_dir_stats(d) - total_size += s # 根目录散文件 for entry in os.scandir(data_dir): if entry.is_file(follow_symlinks=False): @@ -626,6 +622,10 @@ def clear_data(request: Request): repo = request.app.state.repo data_dir = repo.store.data_dir deleted = 0 + publications = { + "kline_daily_enriched": EnrichedPublication(data_dir, "stock"), + "kline_etf_enriched": EnrichedPublication(data_dir, "etf"), + } for sub in ( "kline_daily", "kline_daily_enriched", "kline_index_daily", "kline_index_enriched", @@ -634,15 +634,27 @@ def clear_data(request: Request): "backtest_results", "screener_results", "ai_cache", ): d = data_dir / sub - if d.exists(): - # 先删所有 parquet 文件 - for f in d.rglob("*.parquet"): + if not d.exists(): + continue + publication = publications.get(sub) + parquet_files = list(d.rglob("*.parquet")) + if publication is not None and parquet_files: + publication.begin() + try: + for f in parquet_files: f.unlink() deleted += 1 - # 再删除空的日期分区子目录（date=YYYY-MM-DD 等） + if publication is not None: + publication.mark_changed() for child in list(d.iterdir()): if child.is_dir(): shutil.rmtree(child, ignore_errors=True) + if publication is not None: + publication.commit() + except BaseException: + if publication is not None: + publication.abandon() + raise # 清除同步历史（内存 + 磁盘 job_store/ 文件夹） from app.services.pipeline_jobs import job_store diff --git a/backend/app/api/kline.py b/backend/app/api/kline.py index 15f7fea..e5fd5c0 100644 --- a/backend/app/api/kline.py +++ b/backend/app/api/kline.py @@ -12,7 +12,7 @@ from fastapi import APIRouter, HTTPException, Query, Request from app.indicators.pipeline import compute_enriched, compute_enriched_single from app.market_time import cn_now, cn_today from app.price_limits import is_risk_warning_name, price_limit_pct -from app.db_safe import is_valid_ext_ident, quote_ident +from app.db_safe import is_valid_ext_ident from app.services import kline_sync logger = logging.getLogger(__name__) @@ -175,21 +175,28 @@ def instruments_names(request: Request, symbols: list[str]): def _get_stock_info(repo, symbol: str) -> dict: - """从 instruments 视图查标的名称 + 股本。""" + """从 instruments 内存缓存查标的名称 + 股本。 + + 该接口在个股弹窗打开时每秒被调用 (SSE invalidate 触发重拉), 走 + repo.get_instruments() 的 Polars 内存缓存按 symbol 过滤, 不再每请求 + DuckDB 扫 instruments parquet。列缺失时返回空 dict, 与旧 SQL 报错路径一致。 + """ + import polars as pl try: - row = repo.execute_one( - "SELECT name, total_shares, float_shares FROM instruments WHERE symbol = ? LIMIT 1", - [symbol], - ) + df = repo.get_instruments() + needed = ("symbol", "name", "total_shares", "float_shares") + if df.is_empty() or not all(c in df.columns for c in needed): + return {} + hit = df.filter(pl.col("symbol") == symbol).head(1) + if hit.is_empty(): + return {} + return { + "name": hit["name"][0], + "total_shares": hit["total_shares"][0], + "float_shares": hit["float_shares"][0], + } except Exception: # noqa: BLE001 return {} - if not row: - return {} - return { - "name": row[0], - "total_shares": row[1], - "float_shares": row[2], - } def _get_asset_info(repo, symbol: str, asset_type: str) -> dict: @@ -377,7 +384,8 @@ def _attach_ext(resp: dict, repo, symbol: str, ext_columns: Optional[str]) -> di """按 ext_columns 规格为单只股票 LEFT JOIN 扩展数据，平铺到 stock_info['ext']。 key 形如 "{config_id}__{field_name}"，与自选列表 enriched 接口保持一致。 - JOIN 逻辑参考 watchlist.watchlist_enriched；任何 ext 表/字段缺失都静默跳过。 + 委托 screener._load_ext_value_maps 取值: 复用其 (路径,mtime) 签名缓存, + 个股弹窗每秒重拉时不再重复读 ext parquet; 任何 ext 表/字段缺失都静默跳过。 """ if not ext_columns or not ext_columns.strip(): return resp @@ -394,43 +402,17 @@ def _attach_ext(resp: dict, repo, symbol: str, ext_columns: Optional[str]) -> di if not specs: return resp - import polars as pl - data_dir = repo.store.data_dir try: - from app.services.ext_data import ExtConfigStore - from app.api.ext_data import _read_ext_dataframe - ext_store = ExtConfigStore(data_dir) - configs = {c.id: c for c in ext_store.load_all()} + from app.api.screener import _load_ext_value_maps + value_maps = _load_ext_value_maps(repo, ext_columns) except Exception: # noqa: BLE001 - configs = {} + value_maps = {} ext_values: dict = {} for config_id, field_name in specs: ext_col_name = f"{config_id}__{field_name}" - value = None - try: - cfg = configs.get(config_id) - if cfg: - ext_df, _ = _read_ext_dataframe(cfg, data_dir) - else: - ext_df = pl.from_arrow( - repo.store.db.query( - f"SELECT symbol, {quote_ident(field_name)} FROM ext_{config_id}" - ).arrow() - ) - if not ext_df.is_empty() and "symbol" in ext_df.columns and field_name in ext_df.columns: - # 时序表取最新分区，避免一个 symbol 多行 - row = ( - ext_df - .select(["symbol", field_name]) - .unique(subset=["symbol"], keep="last") - .filter(pl.col("symbol") == symbol) - ) - if not row.is_empty(): - value = row[field_name][0] - except Exception as e: # noqa: BLE001 - logger.debug("kline ext join failed for %s.%s: %s", config_id, field_name, e) - ext_values[ext_col_name] = value + vmap = value_maps.get(ext_col_name) or {} + ext_values[ext_col_name] = vmap.get(symbol) stock_info = dict(resp.get("stock_info") or {}) stock_info["ext"] = ext_values @@ -575,12 +557,13 @@ def get_daily_batch(request: Request, body: dict): return {"data": {}} df = pl.concat(frames, how="diagonal_relaxed") - # 按 symbol 分组, 每只取最近 N 条 + # 按 symbol 分组, 每只取最近 N 条。 + # partition_by 一次切分, 避免 N 只自选时对同一批数据做 N 次全帧过滤。 result: dict[str, list[dict]] = {} - for sym in symbols: - sub = df.filter(pl.col("symbol") == sym).sort("date").tail(days) + for part in df.partition_by("symbol", maintain_order=True): + sub = part.sort("date").tail(days) if not sub.is_empty(): - result[sym] = sub.to_dicts() + result[sub["symbol"][0]] = sub.to_dicts() return {"data": result} @@ -662,14 +645,15 @@ def get_minute_batch(request: Request, body: dict): else: expected = 240 - # 按 symbol 分组, 判定哪些不完整需要补拉 + # 按 symbol 分组, 判定哪些不完整需要补拉 (partition_by 一次切分, 同 daily-batch) result: dict[str, list[dict]] = {} incomplete: list[str] = [] + local_parts: dict[str, pl.DataFrame] = {} + if not df_local.is_empty(): + for part in df_local.partition_by("symbol", maintain_order=True): + local_parts[part["symbol"][0]] = part.sort("datetime") for sym in symbols: - if df_local.is_empty(): - sub = pl.DataFrame() - else: - sub = df_local.filter(pl.col("symbol") == sym).sort("datetime") + sub = local_parts.get(sym, pl.DataFrame()) if expected > 0 and (sub.is_empty() or len(sub) < expected * 0.9): incomplete.append(sym) elif not sub.is_empty(): @@ -712,9 +696,13 @@ def get_minute_batch(request: Request, body: dict): live_parts.append(df_e) if live_parts: live_df = pl.concat(live_parts, how="diagonal_relaxed") + live_map: dict[str, pl.DataFrame] = { + part["symbol"][0]: part.sort("datetime") + for part in live_df.partition_by("symbol", maintain_order=True) + } for sym in incomplete: - sub = live_df.filter(pl.col("symbol") == sym).sort("datetime") - if not sub.is_empty(): + sub = live_map.get(sym) + if sub is not None and not sub.is_empty(): result[sym] = sub.to_dicts() return {"data": result} diff --git a/backend/app/api/mining.py b/backend/app/api/mining.py new file mode 100644 index 0000000..b028f0e --- /dev/null +++ b/backend/app/api/mining.py @@ -0,0 +1,736 @@ +"""Persistent factor and strategy mining HTTP API.""" +from __future__ import annotations + +import asyncio +import json +import math +from collections.abc import AsyncIterator, Mapping, Sequence +from datetime import date +from typing import Annotated, Any, Literal + +import polars as pl +from fastapi import APIRouter, Header, HTTPException, Query, Request +from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator +from sse_starlette.sse import EventSourceResponse + +from app.backtest.factor import FACTOR_COLUMNS +from app.backtest.mining import ( + MAX_BEAM_WIDTH, + MAX_COMBINATION_SIZE, + MAX_FINALISTS, + evaluate_candidate_gate, +) +from app.services import preferences +from app.services.mining_jobs import ( + RUN_STATUSES, + SUCCESS_RUN_STATUSES, + TERMINAL_RUN_STATUSES, + MiningRunStore, + MiningRunStoreError, + MiningRunValidationError, +) +from app.services.mining_preflight import ( + mining_availability, + require_mining_availability, +) +from app.services.mining_schedule import ( + MINING_ALGORITHM_VERSION, + build_data_fingerprint, +) + +router = APIRouter(prefix="/api/backtest/mining", tags=["backtest"]) +_FACTOR_IDS = frozenset(str(item["id"]) for item in FACTOR_COLUMNS) +_MAX_ARTIFACT_BYTES = 64 * 1024 * 1024 +_SSE_POLL_SECONDS = 0.5 +_SSE_HEARTBEAT_SECONDS = 15.0 + + +class MiningStartRequest(BaseModel): + model_config = ConfigDict(extra="forbid", strict=True) + + factor_names: list[str] = Field(min_length=1, max_length=48) + strategy_ids: list[str] = Field(default_factory=list, max_length=8) + symbols: list[str] | None = None + asset_type: Literal["stock", "etf"] = "stock" + start: date | None = None + end: date | None = None + budget_profile: Literal["exploratory", "balanced", "strict"] = "balanced" + commission_pct: float = Field(0.0002, ge=0.0, le=0.05, allow_inf_nan=False) + stamp_tax_pct: float = Field(0.0005, ge=0.0, le=0.05, allow_inf_nan=False) + slippage_bps: float = Field(5.0, ge=0.0, le=1000.0, allow_inf_nan=False) + correlation_threshold: float = Field(0.75, gt=0.0, le=1.0, allow_inf_nan=False) + max_combination_factors: int = Field(4, ge=1, le=MAX_COMBINATION_SIZE) + beam_width: int = Field(12, ge=1, le=MAX_BEAM_WIDTH) + max_finalists: int = Field(MAX_FINALISTS, ge=1, le=MAX_FINALISTS) + force: bool = False + + @field_validator("start", "end", mode="before") + @classmethod + def _iso_dates(cls, value: Any) -> Any: + if isinstance(value, str): + try: + return date.fromisoformat(value) + except ValueError as exc: + raise ValueError("dates must use ISO YYYY-MM-DD format") from exc + return value + + @field_validator("factor_names", "strategy_ids") + @classmethod + def _unique_ids(cls, values: list[str]) -> list[str]: + if any(not value or len(value) > 120 for value in values): + raise ValueError("IDs must contain 1 to 120 characters") + if len(set(values)) != len(values): + raise ValueError("IDs must be unique") + return values + + @field_validator("factor_names") + @classmethod + def _known_factors(cls, values: list[str]) -> list[str]: + unknown = sorted(set(values) - _FACTOR_IDS) + if unknown: + raise ValueError(f"unknown mining factors: {unknown}") + return values + + @field_validator("symbols") + @classmethod + def _symbols(cls, values: list[str] | None) -> list[str] | None: + if values is None: + return None + cleaned = [value for value in values if value] + if len(cleaned) > 10_000: + raise ValueError("symbols contains more than 10000 entries") + if len(set(cleaned)) != len(cleaned): + raise ValueError("symbols must be unique") + return cleaned or None + + @model_validator(mode="after") + def _date_range(self) -> MiningStartRequest: + if self.start is not None and self.end is not None and self.start > self.end: + raise ValueError("start must not be after end") + return self + + +class MiningSchedulePatch(BaseModel): + model_config = ConfigDict(extra="forbid", strict=True) + + mining_schedule_enabled: bool | None = None + mining_schedule_weekday: int | None = Field(None, ge=0, le=4) + mining_budget_profile: Literal["balanced", "strict"] | None = None + + +@router.get("/availability") +def get_availability( + request: Request, + asset_type: Annotated[Literal["stock", "etf"], Query()] = "stock", + budget_profile: Annotated[ + Literal["exploratory", "balanced", "strict"], Query() + ] = "balanced", + start: Annotated[date | None, Query()] = None, + end: Annotated[date | None, Query()] = None, +) -> dict[str, Any]: + try: + return mining_availability( + request.app.state.repo.store.data_dir, + asset_type=asset_type, + budget_profile=budget_profile, + start=start, + end=end, + ).to_dict() + except ValueError as exc: + raise HTTPException(status_code=400, detail=str(exc)) from exc + + +@router.get("/runs") +def list_runs( + request: Request, + limit: Annotated[int, Query(ge=1, le=200)] = 50, + status: Annotated[list[str] | None, Query()] = None, +) -> dict[str, Any]: + manager = _manager(request) + statuses = None + if status: + unknown = sorted(set(status) - RUN_STATUSES) + if unknown: + raise HTTPException(status_code=400, detail=f"unsupported mining statuses: {unknown}") + statuses = status + try: + manifests = manager.store.list_runs(limit=limit, statuses=statuses) + return {"items": [_project_run(manager.store, item) for item in manifests]} + except MiningRunValidationError as exc: + raise HTTPException(status_code=400, detail=str(exc)) from exc + except MiningRunStoreError as exc: + raise HTTPException(status_code=500, detail="failed to read mining runs") from exc + + +@router.post("/runs") +def start_run(payload: MiningStartRequest, request: Request) -> dict[str, Any]: + manager = _manager(request) + worker_request = payload.model_dump(mode="json", exclude={"force"}) + try: + _validate_selected_strategies( + request.app.state.strategy_engine, + payload.strategy_ids, + payload.asset_type, + ) + require_mining_availability( + request.app.state.repo.store.data_dir, + asset_type=payload.asset_type, + budget_profile=payload.budget_profile, + start=payload.start, + end=payload.end, + ) + fingerprint = build_data_fingerprint( + request.app.state.repo, + request.app.state, + worker_request, + ) + existing = None + if not payload.force: + from app.services.mining_jobs import ( + ACTIVE_RUN_STATUSES, + SUCCESS_RUN_STATUSES, + compute_run_signature, + ) + + signature = compute_run_signature(worker_request, fingerprint) + existing = manager.store.find_by_signature( + signature, + statuses=ACTIVE_RUN_STATUSES | SUCCESS_RUN_STATUSES, + ) + manifest = manager.start( + worker_request, + fingerprint, + force=payload.force, + source="manual", + ) + projected = _project_run(manager.store, manifest) + projected["reused"] = existing is not None + return projected + except (MiningRunValidationError, ValueError) as exc: + raise HTTPException(status_code=400, detail=str(exc)) from exc + except MiningRunStoreError as exc: + raise HTTPException(status_code=500, detail="failed to persist mining run") from exc + + +@router.get("/runs/{run_id}") +def get_run(run_id: str, request: Request) -> dict[str, Any]: + store = _manager(request).store + return _project_run(store, _required_manifest(store, run_id)) + + +@router.post("/runs/{run_id}/cancel") +def cancel_run(run_id: str, request: Request) -> dict[str, Any]: + manager = _manager(request) + try: + return _project_run(manager.store, manager.cancel(run_id)) + except KeyError as exc: + raise HTTPException(status_code=404, detail="mining run not found") from exc + except MiningRunValidationError as exc: + raise HTTPException(status_code=400, detail=str(exc)) from exc + + +@router.get("/runs/{run_id}/result") +def get_result(run_id: str, request: Request) -> dict[str, Any]: + store = _manager(request).store + manifest = _required_manifest(store, run_id) + status = str(manifest["status"]) + if status not in SUCCESS_RUN_STATUSES: + status_code = 409 if status not in TERMINAL_RUN_STATUSES else 422 + raise HTTPException( + status_code=status_code, + detail=f"mining result is unavailable for status {status}", + ) + try: + summary = store.read_summary(run_id) + frames = { + name: _read_registered_artifact(store, manifest, name) + for name in ("factors", "correlation", "candidates", "folds") + } + return _project_result(manifest, summary, frames) + except ( + MiningRunStoreError, + OSError, + pl.exceptions.PolarsError, + ValueError, + ) as exc: + raise HTTPException( + status_code=500, + detail="mining result artifacts are unavailable", + ) from exc + + +@router.get("/runs/{run_id}/events") +def stream_events( + run_id: str, + request: Request, + last_event_id: str | None = Header(None, alias="Last-Event-ID"), +) -> EventSourceResponse: + store = _manager(request).store + _required_manifest(store, run_id) + cursor = _event_cursor(last_event_id) + + async def generate() -> AsyncIterator[dict[str, str]]: + nonlocal cursor + last_emit = asyncio.get_running_loop().time() + terminal_sent = False + first_batch = True + while not await request.is_disconnected(): + events = await asyncio.to_thread(store.read_events, run_id, after_id=cursor) + if first_batch and events and int(events[0]["id"]) > cursor + 1: + summary = await asyncio.to_thread(store.read_summary, run_id) + progress = summary.get("progress") + if isinstance(progress, Mapping): + yield { + "id": str(cursor), + "event": "progress", + "data": json.dumps(progress, ensure_ascii=False, allow_nan=False), + } + last_emit = asyncio.get_running_loop().time() + first_batch = False + for event in events: + cursor = int(event["id"]) + event_type = "failed" if event.get("type") == "error" else str(event["type"]) + payload = dict(event.get("payload") or {}) + if event_type in TERMINAL_RUN_STATUSES: + payload.setdefault("status", event_type) + terminal_sent = True + yield { + "id": str(cursor), + "event": event_type, + "data": json.dumps(payload, ensure_ascii=False, allow_nan=False), + } + last_emit = asyncio.get_running_loop().time() + manifest = await asyncio.to_thread(store.get, run_id) + if manifest is None: + return + status = str(manifest["status"]) + if status in TERMINAL_RUN_STATUSES: + if not terminal_sent: + event_type = "failed" if status == "failed" else status + yield { + "id": str(cursor), + "event": event_type, + "data": json.dumps( + {"status": status, "message": manifest.get("error")}, + ensure_ascii=False, + ), + } + return + now = asyncio.get_running_loop().time() + if now - last_emit >= _SSE_HEARTBEAT_SECONDS: + yield {"event": "heartbeat", "data": "{}"} + last_emit = now + await asyncio.sleep(_SSE_POLL_SECONDS) + + return EventSourceResponse(generate(), ping=_SSE_HEARTBEAT_SECONDS) + + +@router.post("/runs/{run_id}/candidates/{signature}/promote") +def promote_candidate(run_id: str, signature: str, request: Request) -> dict[str, Any]: + service = _candidate_service(request) + try: + return service.promote(run_id, signature) + except KeyError as exc: + raise HTTPException(status_code=404, detail="mining run or candidate not found") from exc + except ValueError as exc: + raise HTTPException(status_code=400, detail=str(exc)) from exc + except RuntimeError as exc: + raise HTTPException(status_code=500, detail=str(exc)) from exc + + +@router.post("/runs/{run_id}/candidates/{signature}/publish") +def publish_candidate(run_id: str, signature: str, request: Request) -> dict[str, Any]: + service = _candidate_service(request) + try: + return service.publish(run_id, signature) + except KeyError as exc: + raise HTTPException(status_code=404, detail="mining run or candidate not found") from exc + except FileExistsError as exc: + raise HTTPException(status_code=409, detail=str(exc)) from exc + except ValueError as exc: + raise HTTPException(status_code=400, detail=str(exc)) from exc + except RuntimeError as exc: + raise HTTPException(status_code=500, detail=str(exc)) from exc + + +@router.get("/config") +def get_config() -> dict[str, Any]: + return preferences.get_mining_schedule() + + +@router.patch("/config") +def update_config(payload: MiningSchedulePatch) -> dict[str, Any]: + current = preferences.get_mining_schedule() + updates = payload.model_dump(exclude_none=True) + if not updates: + raise HTTPException(status_code=400, detail="at least one mining config field is required") + merged = {**current, **updates} + try: + return preferences.set_mining_schedule( + merged["mining_schedule_enabled"], + merged["mining_schedule_weekday"], + merged["mining_budget_profile"], + ) + except ValueError as exc: + raise HTTPException(status_code=400, detail=str(exc)) from exc + + +def _manager(request: Request): + manager = getattr(request.app.state, "mining_manager", None) + if manager is None: + raise HTTPException(status_code=503, detail="mining manager is unavailable") + return manager + + +def _candidate_service(request: Request): + service = getattr(request.app.state, "mining_candidate_service", None) + if service is not None: + return service + from app.backtest.candidates import CandidateStore + from app.services.mining_candidates import MiningCandidateService + + manager = _manager(request) + data_dir = request.app.state.repo.store.data_dir + monitor_engine = getattr(request.app.state, "monitor_engine", None) + service = MiningCandidateService( + data_dir, + manager.store, + CandidateStore(data_dir), + request.app.state.strategy_engine, + monitor_state_invalidator=( + monitor_engine.invalidate_strategy_state + if monitor_engine is not None + else None + ), + ) + request.app.state.mining_candidate_service = service + return service + + +def _required_manifest(store: MiningRunStore, run_id: str) -> dict[str, Any]: + try: + manifest = store.get(run_id) + except MiningRunValidationError as exc: + raise HTTPException(status_code=400, detail=str(exc)) from exc + except MiningRunStoreError as exc: + raise HTTPException(status_code=500, detail="failed to read mining run") from exc + if manifest is None: + raise HTTPException(status_code=404, detail="mining run not found") + return manifest + + +def _project_run(store: MiningRunStore, manifest: Mapping[str, Any]) -> dict[str, Any]: + run_id = str(manifest["run_id"]) + summary = store.read_summary(run_id) + events = store.read_events(run_id) + source = next( + ( + event.get("payload", {}).get("source") + for event in events + if event.get("type") == "queued" and event.get("payload", {}).get("source") + ), + None, + ) + if source is None and isinstance(manifest.get("data_fingerprint"), Mapping): + source = manifest["data_fingerprint"].get("source") + compact = _summary_projection(summary) if manifest["status"] in SUCCESS_RUN_STATUSES else None + return { + "run_id": run_id, + "signature": manifest["run_signature"], + "status": manifest["status"], + "request": manifest.get("request") or {}, + "source": source or "manual", + "created_at": manifest.get("created_at"), + "updated_at": manifest.get("updated_at"), + "started_at": manifest.get("started_at"), + "finished_at": manifest.get("finished_at"), + "data_as_of": summary.get("data_as_of"), + "progress": ( + summary.get("progress") + if isinstance(summary.get("progress"), Mapping) + else None + ), + "error": manifest.get("error"), + "summary": compact, + } + + +def _request_summary(manifest: Mapping[str, Any]) -> dict[str, Any]: + request = manifest.get("request") or {} + factor_names = request.get("factor_names") + strategy_ids = request.get("strategy_ids") + return { + "asset_type": request.get("asset_type") or "stock", + "budget_profile": request.get("budget_profile") or "balanced", + "start": request.get("start"), + "end": request.get("end"), + "factor_count": len(factor_names) if isinstance(factor_names, list) else 0, + "strategy_count": len(strategy_ids) if isinstance(strategy_ids, list) else 0, + "commission_pct": _finite(request.get("commission_pct")), + "stamp_tax_pct": _finite(request.get("stamp_tax_pct")), + "slippage_bps": _finite(request.get("slippage_bps")), + "correlation_threshold": _finite(request.get("correlation_threshold")), + } + + +def _summary_projection(summary: Mapping[str, Any]) -> dict[str, Any]: + worker = summary.get("worker") if isinstance(summary.get("worker"), Mapping) else {} + return { + "factor_count": int(summary.get("factor_count") or 0), + "selected_factor_count": int(summary.get("selected_factor_count") or 0), + "candidate_count": int(summary.get("candidate_count") or 0), + "valid_fold_count": int(summary.get("valid_fold_count") or 0), + "skipped_fold_count": int(summary.get("skipped_fold_count") or 0), + "confidence": summary.get("confidence") or "low", + "budget_exhausted": bool(summary.get("budget_exhausted", False)), + "elapsed_ms": _finite(summary.get("elapsed_ms")), + "peak_rss_bytes": _optional_int(worker.get("peak_rss_bytes")), + } + + +def _read_registered_artifact( + store: MiningRunStore, + manifest: Mapping[str, Any], + name: str, +) -> pl.DataFrame: + artifacts = manifest.get("artifacts") + if not isinstance(artifacts, Mapping) or name not in artifacts: + raise ValueError(f"mining artifact is not registered: {name}") + raw_path = artifacts[name] + if not isinstance(raw_path, str): + raise ValueError(f"mining artifact registration is invalid: {name}") + run_dir = store.artifact_path(str(manifest["run_id"]), name).parent # type: ignore[arg-type] + registered = (run_dir / raw_path).resolve() + if not registered.is_relative_to(run_dir.resolve()): + raise ValueError(f"mining artifact escapes its run directory: {name}") + if registered.suffix.lower() != ".parquet" or not registered.is_file(): + raise ValueError(f"mining artifact is unavailable: {name}") + if registered.stat().st_size > _MAX_ARTIFACT_BYTES: + raise ValueError(f"mining artifact exceeds size limit: {name}") + return pl.read_parquet(registered) + + +def _project_result( + manifest: Mapping[str, Any], + summary: Mapping[str, Any], + frames: Mapping[str, pl.DataFrame], +) -> dict[str, Any]: + factors = [_clean_record(row) for row in frames["factors"].to_dicts()] + correlation = _project_correlation(frames["correlation"]) + fold_records = [_project_fold(row) for row in frames["folds"].to_dicts()] + candidates = _project_candidates(frames["candidates"], fold_records) + selected_signature = candidates[0]["signature"] if candidates else None + folds = [ + _public_fold(row) + for row in fold_records + if row["regime_state"] == "overall" + and (selected_signature is None or row["candidate_signature"] == selected_signature) + ] + regimes = _project_regimes(fold_records, selected_signature) + worker = summary.get("worker") if isinstance(summary.get("worker"), Mapping) else {} + threshold = _finite((manifest.get("request") or {}).get("correlation_threshold")) + correlation["threshold"] = threshold if threshold is not None else 0.75 + return { + "run_id": manifest["run_id"], + "methodology_version": summary.get("methodology_version") or "factor_v2", + "algorithm_version": summary.get("algorithm_version") or MINING_ALGORITHM_VERSION, + "data_as_of": summary.get("data_as_of"), + "request_summary": _request_summary(manifest), + "summary": _summary_projection(summary), + "factors": factors, + "correlation": correlation, + "regimes": regimes, + "candidates": candidates, + "folds": folds, + "telemetry": { + "elapsed_ms": _finite(summary.get("elapsed_ms")), + "peak_rss_bytes": _optional_int(worker.get("peak_rss_bytes")), + "panel_scans": _optional_int(summary.get("panel_scans")), + "matrix_bytes": _optional_int(summary.get("matrix_bytes")), + "serialized_result_bytes": _optional_int(worker.get("serialized_result_bytes")), + "phase_ms": _finite_mapping(summary.get("phase_ms")), + }, + } + + +def _project_correlation(frame: pl.DataFrame) -> dict[str, Any]: + required = {"factor_x", "factor_y", "rho", "pair_count"} + if not required.issubset(frame.columns): + raise ValueError("correlation artifact schema is invalid") + labels = sorted(set(frame["factor_x"].to_list()) | set(frame["factor_y"].to_list())) + positions = {str(label): index for index, label in enumerate(labels)} + matrix: list[list[float | None]] = [[None for _ in labels] for _ in labels] + counts: list[list[int | None]] = [[None for _ in labels] for _ in labels] + for row in frame.iter_rows(named=True): + left = positions[str(row["factor_x"])] + right = positions[str(row["factor_y"])] + matrix[left][right] = _finite(row["rho"]) + counts[left][right] = _optional_int(row["pair_count"]) + return {"labels": labels, "matrix": matrix, "pair_counts": counts} + + +def _project_fold(row: Mapping[str, Any]) -> dict[str, Any]: + projected = _clean_record(row) + projected["selected_factors"] = _json_string_list(row.get("selected_factors_json")) + projected["candidate_signature"] = row.get("candidate_signature") + projected["regime_state"] = str(row.get("regime_state") or "overall") + projected["n_dates"] = int(row.get("n_dates") or 0) + return projected + + +def _public_fold(row: Mapping[str, Any]) -> dict[str, Any]: + return { + key: row.get(key) + for key in ( + "fold", "label", "train_start", "train_end", "test_start", "test_end", + "selected_factors", "total_return", "sharpe", "max_drawdown", "n_trades", + "skipped", "reason", "evaluation_kind", + ) + } + + +def _project_candidates( + frame: pl.DataFrame, + folds: Sequence[Mapping[str, Any]], +) -> list[dict[str, Any]]: + required = {"signature", "name", "kind", "factor_names_json", "confidence"} + if not required.issubset(frame.columns): + raise ValueError("candidates artifact schema is invalid") + candidates = [] + for row in frame.to_dicts(): + candidate = _clean_record(row) + candidate.pop("definition_json", None) + candidate.pop("factor_names_json", None) + candidate["factor_names"] = _json_string_list(row.get("factor_names_json")) + signature = str(row["signature"]) + candidate["folds"] = [ + _public_fold(fold) + for fold in folds + if fold["regime_state"] == "overall" + and fold["candidate_signature"] == signature + ] + gate = evaluate_candidate_gate( + confidence=row.get("confidence"), + valid_folds=row.get("valid_folds"), + positive_fold_ratio=row.get("oos_positive_fold_ratio"), + sharpe=row.get("oos_sharpe"), + max_drawdown=row.get("oos_max_drawdown"), + n_trades=row.get("oos_n_trades"), + ) + candidate["gate"] = { + "qualified": gate.qualified, + "reasons": list(gate.reasons), + } + candidates.append(candidate) + candidates.sort( + key=lambda item: ( + -(item.get("oos_sharpe") if item.get("oos_sharpe") is not None else -math.inf), + str(item["signature"]), + ) + ) + return candidates + + +def _project_regimes( + folds: Sequence[Mapping[str, Any]], + signature: str | None, +) -> list[dict[str, Any]]: + labels = {"overall": "整体", "strong": "强势", "range": "震荡", "weak": "弱势"} + result = [] + for state in ("overall", "strong", "range", "weak"): + rows = [ + row + for row in folds + if row["regime_state"] == state + and (signature is None or row["candidate_signature"] == signature) + and not row.get("skipped") + ] + result.append({ + "state": state, + "label": labels[state], + "n_dates": sum(int(row.get("n_dates") or 0) for row in rows), + "total_return": _mean(row.get("total_return") for row in rows), + "sharpe": _mean(row.get("sharpe") for row in rows), + "max_drawdown": _minimum(row.get("max_drawdown") for row in rows), + }) + return result + + +def _validate_selected_strategies( + strategy_engine: Any, + strategy_ids: Sequence[str], + asset_type: str, +) -> None: + for strategy_id in strategy_ids: + strategy = strategy_engine.get(strategy_id) + if strategy.meta.get("research_only"): + raise ValueError(f"research template cannot be mined as existing: {strategy_id}") + if strategy.execution_backend != "matrix_native": + raise ValueError(f"mining strategy is not matrix-native: {strategy_id}") + if "1d" not in strategy.meta.get("timeframes", ["1d"]): + raise ValueError(f"mining strategy is not daily-compatible: {strategy_id}") + if asset_type not in strategy.meta.get("asset_types", ["stock"]): + raise ValueError(f"mining strategy does not support {asset_type}: {strategy_id}") + + +def _event_cursor(value: str | None) -> int: + if value in (None, ""): + return 0 + try: + cursor = int(value) + except ValueError as exc: + raise HTTPException(status_code=400, detail="Last-Event-ID must be an integer") from exc + if cursor < 0: + raise HTTPException(status_code=400, detail="Last-Event-ID must be non-negative") + return cursor + + +def _json_string_list(value: Any) -> list[str]: + if not isinstance(value, str): + return [] + parsed = json.loads(value) + if not isinstance(parsed, list) or any(not isinstance(item, str) for item in parsed): + raise ValueError("artifact JSON list is invalid") + return parsed + + +def _clean_record(row: Mapping[str, Any]) -> dict[str, Any]: + return { + str(key): (_finite(value) if isinstance(value, float) else value) + for key, value in row.items() + } + + +def _finite(value: Any) -> float | None: + if value is None: + return None + try: + number = float(value) + except (TypeError, ValueError): + return None + return number if math.isfinite(number) else None + + +def _optional_int(value: Any) -> int | None: + number = _finite(value) + return int(number) if number is not None else None + + +def _finite_mapping(value: Any) -> dict[str, float] | None: + if not isinstance(value, Mapping): + return None + return { + str(key): number + for key, item in value.items() + if (number := _finite(item)) is not None + } + + +def _mean(values: Sequence[Any] | Any) -> float | None: + finite = [number for value in values if (number := _finite(value)) is not None] + return sum(finite) / len(finite) if finite else None + + +def _minimum(values: Sequence[Any] | Any) -> float | None: + finite = [number for value in values if (number := _finite(value)) is not None] + return min(finite) if finite else None diff --git a/backend/app/api/regime.py b/backend/app/api/regime.py index f484033..57b9bd7 100644 --- a/backend/app/api/regime.py +++ b/backend/app/api/regime.py @@ -7,8 +7,9 @@ from __future__ import annotations import threading import time from datetime import date -from typing import Any +from typing import Annotated, Any +import polars as pl from fastapi import APIRouter, Query, Request from app.services import regime_builder @@ -142,6 +143,8 @@ def regime_recompute(request: Request, start: date | None = None, end: date | No 与 daily_pipeline 的增量补差(compute_regime_incremental)不同 —— 此接口面向 人工「我要重新算一遍」的预期, 必须真正重算而非增量补缺口。 - 传 start: 仅重算 [start, end] 区间。 + - 重算后统一重标情绪周期阶段(refresh_phase_labels)并回填主线 + (概念+行业, 概念成分为当前快照回看历史, 早年有归属漂移)。 """ repo = request.app.state.repo data_dir = _data_dir(request) @@ -156,5 +159,201 @@ def regime_recompute(request: Request, start: date | None = None, end: date | No new_rows = regime_builder.run_regime_batch(repo, start=start, end=end) if not new_rows.is_empty(): regime_builder.upsert_regime_history(data_dir, new_rows) + phase_days = regime_builder.refresh_phase_labels(data_dir) + + from app.services import market_mainline + + mainline_rows = 0 + for kind in ("concept", "industry"): + rows = market_mainline.compute_mainline_range(repo, data_dir, start, end, kind=kind) + if not rows.is_empty(): + market_mainline.upsert_mainline_history(data_dir, rows) + mainline_rows += rows.height + invalidate_regime_cache() - return {"ok": True, "computed": new_rows.height if not new_rows.is_empty() else 0} + return { + "ok": True, + "computed": new_rows.height if not new_rows.is_empty() else 0, + "phase_days": phase_days, + "mainline_rows": mainline_rows, + } + + +@router.get("/phases") +def regime_phases( + request: Request, + start: date | None = None, + end: date | None = None, +): + """情绪周期阶段段列表: 连续同阶段合段, 附段内均值指标与主导主线。 + + 直接回答「什么阶段走什么主升」: 主升/高潮段的主导主线即该段行情主线。 + 主线按段内进入当日 top5 的天数与累计分排序, 取前 3。 + """ + from app.services.market_mainline import load_mainline_history + from app.services.market_phase import PHASE_LABELS + + data_dir = _data_dir(request) + df = regime_builder.load_regime_history(data_dir) + if df.is_empty() or "phase" not in df.columns: + return {"segments": [], "total": 0} + if start: + df = df.filter(pl_col_date(df, ">=", start)) + if end: + df = df.filter(pl_col_date(df, "<=", end)) + df = df.sort("date") + if df.is_empty(): + return {"segments": [], "total": 0} + + mainline = load_mainline_history(data_dir, "concept") + + segments: list[dict] = [] + cur: dict | None = None + for r in df.iter_rows(named=True): + phase = r.get("phase") + if cur is None or cur["phase"] != phase: + cur = { + "phase": phase, + "label": PHASE_LABELS.get(phase, phase), + "start": str(r["date"]), + "end": str(r["date"]), + "days": 0, + "_height": 0.0, + "_first_board": 0.0, + "_ge2": 0.0, + "_promo_sum": 0.0, + "_promo_n": 0, + "_seal": 0.0, + } + segments.append(cur) + cur["end"] = str(r["date"]) + cur["days"] += 1 + cur["_height"] += float(r.get("max_consecutive") or 0) + cur["_first_board"] += float(r.get("first_board") or 0) + cur["_ge2"] += float(r.get("ge2_count") or 0) + promo = r.get("promo_rate") + if promo is not None: + cur["_promo_sum"] += float(promo) + cur["_promo_n"] += 1 + cur["_seal"] += float(r.get("seal_rate") or 0) + + for seg in segments: + n = seg["days"] + seg["avg_height"] = round(seg.pop("_height") / n, 1) + seg["avg_first_board"] = round(seg.pop("_first_board") / n, 1) + seg["avg_ge2"] = round(seg.pop("_ge2") / n, 1) + seg["avg_promo"] = ( + round(seg.pop("_promo_sum") / seg["_promo_n"], 3) if seg["_promo_n"] else None + ) + seg.pop("_promo_n") + seg["avg_seal_rate"] = round(seg.pop("_seal") / n, 3) + seg["top_mainlines"] = _segment_mainlines( + mainline, date.fromisoformat(seg["start"]), date.fromisoformat(seg["end"]) + ) + + return {"segments": segments, "total": len(segments)} + + +def _segment_mainlines(mainline: pl.DataFrame, start: date, end: date, top: int = 3) -> list[dict]: + """段内主导主线: 按进入当日 top5 的天数与累计分排序。""" + if mainline.is_empty(): + return [] + seg = mainline.filter( + (pl.col("date") >= start) & (pl.col("date") <= end) & (pl.col("rank") <= 5) + ) + if seg.is_empty(): + return [] + ranked = ( + seg.group_by("member") + .agg( + pl.col("date").n_unique().alias("top5_days"), + pl.col("score").sum().alias("score_sum"), + pl.col("max_boards").max().alias("max_boards"), + pl.col("leader_symbol").first().alias("leader_symbol"), + ) + .sort(["top5_days", "score_sum"], descending=[True, True]) + .head(top) + ) + return [ + { + "member": r["member"], + "top5_days": r["top5_days"], + "score_sum": round(r["score_sum"], 1), + "max_boards": r["max_boards"], + "leader_symbol": r["leader_symbol"], + } + for r in ranked.to_dicts() + ] + + +@router.post("/mainline/recompute") +def mainline_recompute(request: Request): + """全量重算主线(概念+行业), 应用当前过滤配置。窄扫描, 秒级。 + + 修改过滤配置(preferences mainline-filter)后调用本接口生效, + 无需触发较重的 regime 全量重算。 + """ + from app.services import market_mainline + + repo = request.app.state.repo + data_dir = _data_dir(request) + earliest = regime_builder.earliest_enriched_date(repo) + if earliest is None: + return {"ok": True, "rows": 0} + rows = 0 + for kind in ("concept", "industry"): + computed = market_mainline.compute_mainline_range( + repo, data_dir, earliest, date.today(), kind=kind + ) + if not computed.is_empty(): + market_mainline.upsert_mainline_history(data_dir, computed) + rows += computed.height + return {"ok": True, "rows": rows} + + +@router.get("/mainline") +def regime_mainline( + request: Request, + start: date | None = None, + end: date | None = None, + top: Annotated[int, Query(ge=1, le=30)] = 10, + kind: Annotated[str, Query(pattern="^(concept|industry)$")] = "concept", +): + """每日主线排行(截 rank<=top) + 窗口内持续性汇总。 + + membership_note 说明概念成分口径(当前快照回看历史)。 + """ + from app.services.market_mainline import MEMBERSHIP_NOTE, load_mainline_history + + try: + from app.services import preferences + + filter_cfg = preferences.get_mainline_filter_config() + except Exception: + filter_cfg = {"min_members": 4, "max_members": 600, "blacklist": []} + df = load_mainline_history(_data_dir(request), kind) + if df.is_empty(): + return {"rows": [], "leaders": [], "membership_note": MEMBERSHIP_NOTE, "filter": filter_cfg} + if start: + df = df.filter(pl_col_date(df, ">=", start)) + if end: + df = df.filter(pl_col_date(df, "<=", end)) + df = df.sort(["date", "rank"]) + rows_df = df.filter(pl.col("rank") <= top) + leaders = ( + df.filter(pl.col("rank") == 1) + .group_by("member") + .agg( + pl.col("date").n_unique().alias("top1_days"), + pl.col("score").mean().round(1).alias("avg_score"), + pl.col("max_boards").max().alias("max_boards"), + ) + .sort(["top1_days", "avg_score"], descending=[True, True]) + .head(10) + ) + return { + "rows": _df_to_records(rows_df), + "leaders": leaders.to_dicts(), + "membership_note": MEMBERSHIP_NOTE, + "filter": filter_cfg, + } diff --git a/backend/app/api/screener.py b/backend/app/api/screener.py index b05a5f1..784d105 100644 --- a/backend/app/api/screener.py +++ b/backend/app/api/screener.py @@ -238,6 +238,8 @@ def strategies( raise HTTPException(status_code=503, detail="策略引擎未初始化") presets = [] for meta in engine.list_strategies(): + if meta.get("research_only"): + continue if asset_type not in meta.get("asset_types", ["stock"]): continue if timeframe not in meta.get("timeframes", ["1d"]): @@ -292,6 +294,8 @@ def run_preset(req: PresetRequest, request: Request): try: if not engine.has(req.strategy_id): raise ValueError(f"unknown strategy: {req.strategy_id}") + if engine.get(req.strategy_id).meta.get("research_only"): + raise ValueError(f"unknown strategy: {req.strategy_id}") params = dict(overrides.get("params") or {}) context = svc.build_strategy_context( engine, @@ -520,14 +524,19 @@ def run_all(request: Request, body: Optional[dict] = None): requested_ids = body.get("strategy_ids") if requested_ids and isinstance(requested_ids, list): all_ids = [str(sid) for sid in requested_ids] - unknown = [sid for sid in all_ids if not engine.has(sid)] + unknown = [ + sid + for sid in all_ids + if not engine.has(sid) or engine.get(sid).meta.get("research_only") + ] if unknown: raise HTTPException(status_code=404, detail=f"unknown strategies: {unknown}") else: all_ids = [ meta["id"] for meta in engine.list_strategies() - if asset_type in meta.get("asset_types", ["stock"]) + if not meta.get("research_only") + and asset_type in meta.get("asset_types", ["stock"]) and timeframe in meta.get("timeframes", ["1d"]) ] @@ -707,7 +716,9 @@ def limit_ladder( sealed_ready = False sealed_age: float | None = None if depth_svc: - sealed_map = depth_svc.get_sealed_map(as_of, is_down=is_down) + # 复用上方双方向计数已读取的 sealed map: 同一请求、同一 as_of、同一对象, + # 不再第三次读取 (内存路径含全量浅拷贝, parquet 路径含整文件读)。 + sealed_map = down_map if is_down else up_map sealed_ready = bool(sealed_map) and depth_svc.is_sealed_ready(as_of) sealed_age = depth_svc.get_sealed_age(as_of) if sealed_ready else None diff --git a/backend/app/api/settings.py b/backend/app/api/settings.py index 6175b22..a106025 100644 --- a/backend/app/api/settings.py +++ b/backend/app/api/settings.py @@ -6,9 +6,10 @@ from __future__ import annotations import logging import time +from typing import Literal from fastapi import APIRouter, HTTPException, Request -from pydantic import BaseModel, Field +from pydantic import BaseModel, ConfigDict, Field from app import secrets_store from app.data_providers.custom.config import MAX_TIMEOUT @@ -427,6 +428,14 @@ class CustomSourceTestIn(BaseModel): config: CustomSourceIn | None = None +class MiningSchedulePrefs(BaseModel): + model_config = ConfigDict(extra="forbid", strict=True) + + mining_schedule_enabled: bool + mining_schedule_weekday: int = Field(ge=0, le=4) + mining_budget_profile: Literal["balanced", "strict"] + + @router.get("/preferences") def get_preferences() -> dict: """返回用户偏好设置。""" @@ -485,6 +494,7 @@ def get_preferences() -> dict: "depth_finalize_time": preferences.get_depth_finalize_time(), "review_schedule": preferences.get_review_schedule(), "review_push_channels": preferences.get_review_push_channels(), + **preferences.get_mining_schedule(), } @@ -657,6 +667,18 @@ def update_data_source_job_timeouts(req: DataSourceJobTimeoutPrefs) -> dict: return req.model_dump() +@router.put("/preferences/mining-schedule") +def update_mining_schedule(req: MiningSchedulePrefs) -> dict: + """一次更新周度自动 mining 配置。""" + from app.services import preferences + + return preferences.set_mining_schedule( + req.mining_schedule_enabled, + req.mining_schedule_weekday, + req.mining_budget_profile, + ) + + @router.get("/preferences/watchlist-columns") def get_watchlist_columns() -> dict: """返回自选列表列配置。""" @@ -927,6 +949,23 @@ class PipelineIndexSymbolsIn(BaseModel): symbols: str = "" +class MainlineFilterIn(BaseModel): + """市场主线过滤配置(宽基/风格标签按成员数过滤 + 名称黑名单)。""" + + min_members: int | None = None + max_members: int | None = None + blacklist: list[str] | str | None = None + + +@router.put("/preferences/mainline-filter") +def update_mainline_filter(req: MainlineFilterIn) -> dict: + """更新市场主线过滤配置。部分更新; 修改后需重算主线(POST /api/regime/mainline/recompute)生效。""" + from app.services import preferences + + payload = req.model_dump() + return preferences.set_mainline_filter_config(payload) + + @router.put("/preferences/pipeline-index-symbols") def update_pipeline_index_symbols(req: PipelineIndexSymbolsIn) -> dict: """保存指数自定义拉取代码。""" diff --git a/backend/app/api/strategy.py b/backend/app/api/strategy.py index 48c5390..53803fc 100644 --- a/backend/app/api/strategy.py +++ b/backend/app/api/strategy.py @@ -43,6 +43,16 @@ def _get_engine(request: Request) -> StrategyEngine: return engine +def _get_public_strategy(engine: StrategyEngine, strategy_id: str) -> StrategyDef: + try: + strategy = engine.get(strategy_id) + except ValueError as exc: + raise HTTPException(status_code=404, detail=str(exc)) from exc + if strategy.meta.get("research_only"): + raise HTTPException(status_code=404, detail=f"unknown strategy: {strategy_id}") + return strategy + + def _get_monitor(request: Request) -> StrategyMonitorService: mon = getattr(request.app.state, "strategy_monitor", None) if not mon: @@ -288,6 +298,8 @@ def list_strategies( result = [] for meta in engine.list_strategies(): + if meta.get("research_only"): + continue if asset_type and asset_type not in meta.get("asset_types", ["stock"]): continue if timeframe and timeframe not in meta.get("timeframes", ["1d"]): @@ -302,10 +314,7 @@ def list_strategies( @router.get("/{strategy_id}") def get_strategy(strategy_id: str, request: Request): engine = _get_engine(request) - try: - s = engine.get(strategy_id) - except ValueError as e: - raise HTTPException(status_code=404, detail=str(e)) from e + s = _get_public_strategy(engine, strategy_id) overrides = strategy_config.load_override(_data_dir(request), strategy_id) return _strategy_detail(s, overrides or None, engine) @@ -316,6 +325,7 @@ def get_strategy(strategy_id: str, request: Request): @router.post("/run") def run_strategy(req: RunRequest, request: Request): engine = _get_engine(request) + _get_public_strategy(engine, req.strategy_id) data_dir = _data_dir(request) # 读取用户覆盖配置 @@ -377,7 +387,8 @@ def run_all(req: RunAllRequest, request: Request): strategy_ids = [ meta["id"] for meta in engine.list_strategies() - if req.asset_type in meta.get("asset_types", ["stock"]) + if not meta.get("research_only") + and req.asset_type in meta.get("asset_types", ["stock"]) and req.timeframe in meta.get("timeframes", ["1d"]) ] from app.services.screener import ScreenerService @@ -412,8 +423,7 @@ def run_all(req: RunAllRequest, request: Request): @router.post("/config") def save_config(req: SaveConfigRequest, request: Request): engine = _get_engine(request) - if not engine.has(req.strategy_id): - raise HTTPException(status_code=404, detail=f"策略 {req.strategy_id} 不存在") + _get_public_strategy(engine, req.strategy_id) _validate_scoring_config(req.overrides) # 剥离与策略默认值相同的字段，只保存用户真正修改过的值 @@ -426,8 +436,7 @@ def save_config(req: SaveConfigRequest, request: Request): @router.patch("/config") def patch_config(req: SaveConfigRequest, request: Request): engine = _get_engine(request) - if not engine.has(req.strategy_id): - raise HTTPException(status_code=404, detail=f"策略 {req.strategy_id} 不存在") + _get_public_strategy(engine, req.strategy_id) data_dir = _data_dir(request) overrides = strategy_config.load_override(data_dir, req.strategy_id) overrides.update(req.overrides) @@ -491,6 +500,7 @@ def _strip_defaults(strategy_id: str, overrides: dict, engine) -> dict: @router.delete("/config/{strategy_id}") def reset_config(strategy_id: str, request: Request): + _get_public_strategy(_get_engine(request), strategy_id) strategy_config.delete_override(_data_dir(request), strategy_id) return {"ok": True} @@ -755,10 +765,7 @@ def get_strategy_source(strategy_id: str, request: Request): # 先查 StrategyEngine 获取文件路径 engine = _get_engine(request) - try: - s = engine.get(strategy_id) - except ValueError: - raise HTTPException(status_code=404, detail=f"策略 {strategy_id} 不存在") + s = _get_public_strategy(engine, strategy_id) path = s.file_path if not path or not path.exists(): @@ -964,14 +971,12 @@ def _save_composite_strategy(req: StrategyCompositeSaveRequest, request: Request children = [{"strategy_id": c.strategy_id, "weight": c.weight} for c in req.children] # 子策略存在性预检(给出清晰错误, 而非等到 reload 后孤儿移除的笼统报错)。 for c in children: - if not engine.has(c["strategy_id"]): - raise ValueError(f"子策略 {c['strategy_id']!r} 不存在") try: - child_def = engine.get(c["strategy_id"]) - if child_def.execution_backend == "composite": - raise ValueError(f"子策略 {c['strategy_id']!r} 也是叠加策略; 首版禁止嵌套叠加") - except ValueError: - raise + child_def = _get_public_strategy(engine, c["strategy_id"]) + except HTTPException as exc: + raise ValueError(f"子策略 {c['strategy_id']!r} 不存在") from exc + if child_def.execution_backend == "composite": + raise ValueError(f"子策略 {c['strategy_id']!r} 也是叠加策略; 首版禁止嵌套叠加") code = _render_composite_code( sid, req.name, req.description, children, req.merge_mode, req.min_confirm diff --git a/backend/app/api/watchlist.py b/backend/app/api/watchlist.py index 9b29660..2ff2966 100644 --- a/backend/app/api/watchlist.py +++ b/backend/app/api/watchlist.py @@ -212,7 +212,7 @@ def clear_all(): # 自选页需要的列 _WATCHLIST_COLS = [ - "symbol", "close", "change_pct", "change_amount", "amount", + "symbol", "close", "open", "high", "low", "change_pct", "change_amount", "amount", "turnover_rate", "amplitude", "annual_vol_20d", "vol_ratio_5d", diff --git a/backend/app/backtest/candidates.py b/backend/app/backtest/candidates.py index 6af771d..52b55f2 100644 --- a/backend/app/backtest/candidates.py +++ b/backend/app/backtest/candidates.py @@ -1,4 +1,5 @@ """量化研究候选方案的轻量本地存储。""" + from __future__ import annotations import json @@ -17,28 +18,108 @@ MAX_NAME_LENGTH = 80 MAX_PAYLOAD_BYTES = 32 * 1024 MAX_FILE_BYTES = 2 * 1024 * 1024 +_MINING_SOURCE_CONFIG_FIELDS = frozenset( + { + "origin_run_id", + "candidate_signature", + "regime_state", + "algorithm_version", + "methodology_version", + } +) _CONFIG_FIELDS: dict[str, frozenset[str]] = { - "factor": frozenset({ - "factor_name", "symbols", "start", "end", "n_groups", "rebalance", "weight", - "fees_pct", "slippage_bps", "asset_type", - }), - "strategy": frozenset({ - "strategy_id", "symbols", "start", "end", "params", "overrides", "matching", - "entry_fill", "exit_fill", "fees_pct", "commission_pct", "stamp_tax_pct", - "slippage_bps", "max_positions", "max_exposure_pct", "initial_capital", - "position_sizing", "mode", "holding_days", "asset_type", "minute_fill", - "regime_filter", - }), + "factor": frozenset( + { + "factor_name", + "symbols", + "start", + "end", + "n_groups", + "rebalance", + "weight", + "fees_pct", + "slippage_bps", + "asset_type", + } + ) + | _MINING_SOURCE_CONFIG_FIELDS, + "strategy": frozenset( + { + "strategy_id", + "symbols", + "start", + "end", + "params", + "overrides", + "matching", + "entry_fill", + "exit_fill", + "fees_pct", + "commission_pct", + "stamp_tax_pct", + "slippage_bps", + "max_positions", + "max_exposure_pct", + "initial_capital", + "position_sizing", + "mode", + "holding_days", + "asset_type", + "minute_fill", + "regime_filter", + "factor_names", + "directions", + "weights", + } + ) + | _MINING_SOURCE_CONFIG_FIELDS, } +_MINING_METRIC_FIELDS = frozenset( + { + "oos_sharpe", + "oos_return", + "oos_max_drawdown", + "oos_positive_fold_ratio", + "oos_n_trades", + "valid_folds", + "skipped_folds", + "confidence", + "coverage", + "turnover", + "long_short_sharpe", + } +) _METRIC_FIELDS: dict[str, frozenset[str]] = { - "factor": frozenset({ - "ic_mean", "ic_std", "ir", "ic_win_rate", "long_short_return", - "long_short_max_drawdown", "n_symbols", "n_dates", "elapsed_ms", - }), - "strategy": frozenset({ - "total_return", "annual_return", "max_drawdown", "sharpe", "sortino", "win_rate", - "n_trades", "profit_factor", "avg_return", "median_return", "elapsed_ms", - }), + "factor": frozenset( + { + "ic_mean", + "ic_std", + "ir", + "ic_win_rate", + "long_short_return", + "long_short_max_drawdown", + "n_symbols", + "n_dates", + "elapsed_ms", + } + ) + | _MINING_METRIC_FIELDS, + "strategy": frozenset( + { + "total_return", + "annual_return", + "max_drawdown", + "sharpe", + "sortino", + "win_rate", + "n_trades", + "profit_factor", + "avg_return", + "median_return", + "elapsed_ms", + } + ) + | _MINING_METRIC_FIELDS, } _lock = threading.RLock() @@ -98,6 +179,70 @@ class CandidateStore: self._write(items) return item + def create_or_get_by_provenance( + self, + *, + origin_run_id: str, + candidate_signature: str, + kind: CandidateKind, + name: str, + source_id: str, + config: dict[str, Any], + metrics: dict[str, Any], + data_as_of: str | None, + status: CandidateStatus = "pending", + ) -> dict[str, Any]: + """Atomically return or create one item for a mining run candidate.""" + clean_name = self._validate_name(name) + clean_source_id = source_id.strip() + if not clean_source_id or len(clean_source_id) > 120: + raise CandidateValidationError("候选来源标识不能为空且不能超过 120 个字符") + clean_config = self._validate_config(kind, config) + clean_metrics = self._validate_metrics(kind, metrics) + if ( + clean_config.get("origin_run_id") != origin_run_id + or clean_config.get("candidate_signature") != candidate_signature + ): + raise CandidateValidationError("候选来源与配置中的挖掘溯源不一致") + + with _lock: + items = self._load() + for item in items: + item_config = item.get("config") or {} + if ( + item_config.get("origin_run_id") == origin_run_id + and item_config.get("candidate_signature") == candidate_signature + ): + if ( + item.get("kind") == kind + and item.get("source_id") == clean_source_id + and item_config == clean_config + and item.get("metrics") == clean_metrics + and item.get("data_as_of") == data_as_of + ): + return item + raise CandidateValidationError( + "相同挖掘溯源的候选内容冲突, 已停止覆盖" + ) + if len(items) >= MAX_CANDIDATES: + raise CandidateValidationError(f"候选方案最多保存 {MAX_CANDIDATES} 个") + now = datetime.now(UTC).isoformat() + item = { + "id": uuid.uuid4().hex, + "kind": kind, + "name": clean_name, + "source_id": clean_source_id, + "config": clean_config, + "metrics": clean_metrics, + "data_as_of": data_as_of, + "status": status, + "created_at": now, + "updated_at": now, + } + items.insert(0, item) + self._write(items) + return item + def update( self, candidate_id: str, @@ -203,7 +348,9 @@ class CandidateStore: def _validate_config(kind: CandidateKind, config: dict[str, Any]) -> dict[str, Any]: unknown = set(config) - _CONFIG_FIELDS[kind] if unknown: - raise CandidateValidationError(f"候选配置包含不允许的字段: {', '.join(sorted(unknown))}") + raise CandidateValidationError( + f"候选配置包含不允许的字段: {', '.join(sorted(unknown))}" + ) CandidateStore._check_json_size(config) return config @@ -211,7 +358,9 @@ class CandidateStore: def _validate_metrics(kind: CandidateKind, metrics: dict[str, Any]) -> dict[str, Any]: unknown = set(metrics) - _METRIC_FIELDS[kind] if unknown: - raise CandidateValidationError(f"候选指标包含不允许的字段: {', '.join(sorted(unknown))}") + raise CandidateValidationError( + f"候选指标包含不允许的字段: {', '.join(sorted(unknown))}" + ) if any(isinstance(value, (dict, list)) for value in metrics.values()): raise CandidateValidationError("候选指标只允许保存标量摘要") CandidateStore._check_json_size(metrics) diff --git a/backend/app/backtest/engine.py b/backend/app/backtest/engine.py index 7a6cdb7..b464462 100644 --- a/backend/app/backtest/engine.py +++ b/backend/app/backtest/engine.py @@ -26,6 +26,7 @@ from app.backtest.matrix import ( load_market_data_matrix_from_parquet, ) from app.config import settings +from app.enriched_generation import EnrichedGenerationUnavailableError from app.parquet import scan_enriched_parquet from app.tickflow.repository import KlineRepository @@ -213,8 +214,11 @@ class PanelCache: columns: list[str] | None, compute_fn, asset_type: str = "stock", + generation: str | None = None, ) -> pl.DataFrame: - key = self._make_key(symbols, start, end, columns, asset_type) + key = self._make_key( + symbols, start, end, columns, asset_type, generation + ) now = time.monotonic() with self._lock: @@ -280,13 +284,20 @@ class PanelCache: self._cache.clear() @staticmethod - def _make_key(symbols: list[str] | None, start: date, end: date, columns: list[str] | None, asset_type: str = "stock") -> str: + def _make_key( + symbols: list[str] | None, + start: date, + end: date, + columns: list[str] | None, + asset_type: str = "stock", + generation: str | None = None, + ) -> str: if symbols is None: h = "all" else: h = hashlib.md5(",".join(sorted(symbols)).encode()).hexdigest()[:12] cols = "all" if columns is None else hashlib.md5(",".join(sorted(columns)).encode()).hexdigest()[:8] - return f"{asset_type}:{h}:{start}:{end}:{cols}" + return f"{asset_type}:{generation or 'unmanaged'}:{h}:{start}:{end}:{cols}" # ================================================================ @@ -302,6 +313,23 @@ class BacktestEngine: # ── 数据加载 ────────────────────────────────────── + def data_generation(self, asset_type: str = "stock") -> str | None: + loader = getattr(self.repo, "get_matrix_data_generation", None) + return loader(asset_type) if callable(loader) else None + + def assert_data_generation( + self, + asset_type: str, + expected: str | None, + ) -> None: + if expected is None: + return + current = self.data_generation(asset_type) + if current != expected: + raise EnrichedGenerationUnavailableError( + "enriched data changed while the snapshot was being read" + ) + def load_panel( self, symbols: list[str] | None, @@ -309,9 +337,36 @@ class BacktestEngine: end: date, columns: list[str] | None = None, asset_type: str = "stock", + *, + expected_generation: str | None = None, ) -> pl.DataFrame: """加载 enriched 数据面板，带缓存。asset_type='etf' 时读 ETF enriched。""" - return self._cache.get_or_compute(symbols, start, end, columns, self._load_panel_inner, asset_type=asset_type) + attempts = 1 if expected_generation is not None else 2 + for attempt in range(attempts): + generation = ( + expected_generation + if expected_generation is not None + else self.data_generation(asset_type) + ) + panel = self._cache.get_or_compute( + symbols, + start, + end, + columns, + self._load_panel_inner, + asset_type=asset_type, + generation=generation, + ) + try: + self.assert_data_generation(asset_type, generation) + except EnrichedGenerationUnavailableError: + if attempt + 1 >= attempts: + raise + continue + return panel + raise EnrichedGenerationUnavailableError( + "unable to read a stable enriched data snapshot" + ) def load_panel_for_backtest( self, @@ -338,6 +393,25 @@ class BacktestEngine: if df.is_empty(): return df + from app.backtest.fundamentals import ( + attach_fundamental_factors, + load_fundamental_snapshot, + ) + + fundamental_names = sorted( + getattr(feature_plan, "fundamental_columns", frozenset()) + or frozenset() + ) + if fundamental_names: + # 财务因子列不落 enriched 存储, 在加载口按公告日门控并入。 + df = attach_fundamental_factors( + df, + load_fundamental_snapshot( + self.repo.store.data_dir if self.repo is not None else None + ), + fundamental_names, + ) + instruments = ( self.repo.get_instruments_asset(asset_type) if self.repo is not None @@ -402,6 +476,8 @@ class BacktestEngine: cache_profile: MatrixCacheProfile | None = None, coverage_start: date | None = None, coverage_end: date | None = None, + expected_generation: str | None = None, + cancel_event: threading.Event | None = None, ) -> MarketDataMatrix: """Load a matrix-native backtest directly from projected parquet batches.""" if feature_plan.execution_backend != "matrix_native": @@ -432,35 +508,67 @@ class BacktestEngine: ) generation_loader = getattr(self.repo, "get_matrix_data_generation", None) source_generation = ( - generation_loader(asset_type) - if cache_root is not None and callable(generation_loader) - else None - ) - try: - return load_market_data_matrix_from_parquet( - parquet_root, - start, - end, - field_columns=field_columns, - symbols=symbols, - instruments=instruments, - cache_root=cache_root, - coverage_start=coverage_start, - coverage_end=coverage_end, - cache_field_columns=cache_fields, - cache_max_bytes=cache_max_bytes, - profile_generation=( - cache_profile.generation if cache_profile is not None else "request" - ), - source_generation=source_generation, + expected_generation + if expected_generation is not None + else ( + generation_loader(asset_type) + if callable(generation_loader) + else None ) - except pa.ArrowException as exc: - raise ValueError(f"direct market matrix parquet scan failed: {exc}") from exc + ) + attempts = 1 if expected_generation is not None else 2 + for attempt in range(attempts): + try: + market = load_market_data_matrix_from_parquet( + parquet_root, + start, + end, + field_columns=field_columns, + symbols=symbols, + instruments=instruments, + cache_root=cache_root, + coverage_start=coverage_start, + coverage_end=coverage_end, + cache_field_columns=cache_fields, + cache_max_bytes=cache_max_bytes, + profile_generation=( + cache_profile.generation if cache_profile is not None else "request" + ), + source_generation=source_generation, + cancel_event=cancel_event, + ) + self.assert_data_generation(asset_type, source_generation) + from app.backtest.fundamentals import attach_matrix_fundamental_fields + + fundamental_names = sorted( + getattr(feature_plan, "fundamental_columns", frozenset()) + or frozenset() + ) + if fundamental_names: + # 财务因子不落 enriched 存储: 矩阵加载后按公告日门控附加字段。 + market = attach_matrix_fundamental_fields( + market, + self.repo.store.data_dir if self.repo is not None else None, + fundamental_names, + ) + return market + except EnrichedGenerationUnavailableError: + if attempt + 1 >= attempts: + raise + source_generation = self.data_generation(asset_type) + except pa.ArrowException as exc: + raise ValueError(f"direct market matrix parquet scan failed: {exc}") from exc + raise EnrichedGenerationUnavailableError( + "unable to read a stable enriched matrix snapshot" + ) def cache_stats(self) -> dict: """暴露 PanelCache 遥测快照 (扫盘耗时/次数/命中/复用), 供上层量化 IO 占比。""" return self._cache.stats() + def clear_panel_cache(self) -> None: + self._cache.invalidate() + def _load_panel_inner( self, symbols: list[str] | None, diff --git a/backend/app/backtest/factor.py b/backend/app/backtest/factor.py index 2b48e39..5ecfade 100644 --- a/backend/app/backtest/factor.py +++ b/backend/app/backtest/factor.py @@ -7,14 +7,22 @@ from __future__ import annotations import logging import time import uuid +from collections.abc import Mapping from dataclasses import dataclass, field from datetime import date, timedelta -from typing import Literal +from itertools import pairwise +from pathlib import Path +from typing import Any, Literal import numpy as np import polars as pl from app.backtest.engine import BacktestEngine +from app.backtest.fundamentals import ( + FUNDAMENTAL_FACTOR_NAMES, + attach_fundamental_factors, + load_fundamental_snapshot, +) from app.strategy.scoring import ( VIRTUAL_SCORING_DEPENDENCIES as DERIVED_FACTOR_DEPENDENCIES, ) @@ -76,9 +84,33 @@ FACTOR_COLUMNS: list[dict] = [ {"id": "close_position", "label": "收盘位置", "group": "价格位置", "desc": "收盘价在当日最低价到最高价之间的位置"}, {"id": "distance_to_high_60d", "label": "距60日高点", "group": "价格位置", "desc": "收盘价 / 60日最高收盘价 - 1"}, {"id": "distance_from_low_60d", "label": "距60日低点", "group": "价格位置", "desc": "收盘价 / 60日最低收盘价 - 1"}, + {"id": "vwap_bias", "label": "VWAP乖离", "group": "价格位置", "desc": "收盘价 / 当日成交均价 - 1, 成交均价 = 成交额 / (成交量x100)"}, + + {"id": "max_ret_20d", "label": "20日最大单日涨幅", "group": "收益形态", "desc": "近20个交易日单日涨幅最大值(彩票效应, 高值代表博彩型特征强)"}, + {"id": "ret_skew_20d", "label": "20日收益偏度", "group": "收益形态", "desc": "近20个交易日日收益偏度, 高值代表右偏(偶发大涨)"}, + {"id": "up_days_20d", "label": "20日上涨天数", "group": "收益形态", "desc": "近20个交易日中上涨天数(0~20)"}, + + {"id": "amihud_20d", "label": "20日Amihud非流动性", "group": "流动性", "desc": "近20日平均 |日涨跌幅| / 成交额(亿元), 高值代表流动性差"}, + {"id": "turnover_z_60d", "label": "换手率60日z分", "group": "流动性", "desc": "(当日换手率 - 前60日均值) / 前60日标准差, 衡量换手异动"}, + + {"id": "vol_price_corr_20d", "label": "20日量价相关", "group": "量价", "desc": "近20个交易日日涨跌幅与成交量的相关系数, 高值代表量价同向"}, + {"id": "vol_trend_5_60", "label": "量能趋势(5/60)", "group": "量价", "desc": "5日平均成交量 / 60日平均成交量 - 1"}, + + {"id": "limit_up_count_20d", "label": "涨停基因(20日)", "group": "涨停基因", "desc": "近20个交易日涨停次数"}, + {"id": "limit_up_count_60d", "label": "涨停基因(60日)", "group": "涨停基因", "desc": "近60个交易日涨停次数"}, + + {"id": "pb_latest", "label": "市净率(最新公告)", "group": "财务", "desc": "收盘价 / 最新已公告每股净资产; 无财务数据或公告前为空"}, + {"id": "roe_latest", "label": "ROE(最新公告)", "group": "财务", "desc": "最新已公告净资产收益率(%); 无财务数据或公告前为空"}, + {"id": "gross_margin_latest", "label": "毛利率(最新公告)", "group": "财务", "desc": "最新已公告销售毛利率(%)"}, + {"id": "net_margin_latest", "label": "净利率(最新公告)", "group": "财务", "desc": "最新已公告销售净利率(%)"}, + {"id": "revenue_yoy_latest", "label": "营收增速(最新公告)", "group": "财务", "desc": "最新已公告营业收入同比(%)"}, + {"id": "net_income_yoy_latest", "label": "净利增速(最新公告)", "group": "财务", "desc": "最新已公告归母净利润同比(%)"}, + {"id": "debt_ratio_latest", "label": "资产负债率(最新公告)", "group": "财务", "desc": "最新已公告资产负债率(%)"}, ] FACTOR_WARMUP_DAYS = 120 +FACTOR_METHODOLOGY_VERSION = "factor_v2" +_DAILY_FORWARD_HORIZONS = (1, 3, 5) @dataclass @@ -93,6 +125,8 @@ class FactorConfig: fees_pct: float = 0.0002 slippage_bps: float = 5.0 asset_type: str = "stock" + commission_pct: float | None = None + stamp_tax_pct: float | None = None @dataclass @@ -127,6 +161,14 @@ class FactorResult: n_symbols: int = 0 n_dates: int = 0 error: str | None = None + # factor_v2 兼容扩展字段必须追加在旧字段之后, 保留位置参数语义。 + methodology_version: str = FACTOR_METHODOLOGY_VERSION + coverage: float | None = None + turnover: float | None = None + long_short_sharpe: float | None = None + yearly_ic: list[dict] = field(default_factory=list) + ic_decay: list[dict] = field(default_factory=list) + regime_stats: list[dict] = field(default_factory=list) @dataclass @@ -141,6 +183,8 @@ class FactorBatchConfig: fees_pct: float = 0.0002 slippage_bps: float = 5.0 asset_type: str = "stock" + commission_pct: float | None = None + stamp_tax_pct: float | None = None @dataclass @@ -157,6 +201,13 @@ class FactorBatchItem: n_dates: int = 0 elapsed_ms: float = 0.0 error: str | None = None + methodology_version: str = FACTOR_METHODOLOGY_VERSION + coverage: float | None = None + turnover: float | None = None + long_short_sharpe: float | None = None + yearly_ic: list[dict] = field(default_factory=list) + ic_decay: list[dict] = field(default_factory=list) + regime_stats: list[dict] = field(default_factory=list) @dataclass @@ -174,16 +225,56 @@ class FactorBacktestService: def __init__(self, engine: BacktestEngine) -> None: self.engine = engine - def run(self, config: FactorConfig) -> FactorResult: + def run( + self, + config: FactorConfig, + *, + regime_by_date: Mapping[object, Any] | None = None, + ) -> FactorResult: t0 = time.perf_counter() run_id = uuid.uuid4().hex[:10] - panel = self._load_factor_panel(config, [config.factor_name]) + generation = self._data_generation(config.asset_type) + panel = self._load_factor_panel( + config, + [config.factor_name], + expected_generation=generation, + ) if panel.is_empty(): return self._error_result(config, run_id, t0, "无数据, 请检查日期范围或先运行盘后管道") - return self._evaluate_panel(panel, config, run_id, t0) + if config.factor_name in FUNDAMENTAL_FACTOR_NAMES and self._fundamentals_missing(): + return self._error_result( + config, run_id, t0, + "本地没有财务数据: 请先在数据页同步财务数据后再使用财务因子", + ) - def run_batch(self, config: FactorBatchConfig) -> FactorBatchResult: + trading_dates = self._global_trading_dates(config) + self._assert_data_generation(config.asset_type, generation) + panel = self._attach_shared_next_return( + panel, + config, + trading_dates=trading_dates, + ) + evaluate_kwargs = ( + {"regime_by_date": regime_by_date} + if regime_by_date is not None + else {} + ) + return self._evaluate_panel( + panel, + config, + run_id, + t0, + market_trading_dates=trading_dates, + **evaluate_kwargs, + ) + + def run_batch( + self, + config: FactorBatchConfig, + *, + regime_by_date: Mapping[object, Any] | None = None, + ) -> FactorBatchResult: """在同一份 Panel 上依次评估多个因子, 避免重复读取和计算指标。""" t0 = time.perf_counter() run_id = uuid.uuid4().hex[:10] @@ -196,7 +287,12 @@ class FactorBacktestService: error="至少选择一个因子", ) - panel = self._load_factor_panel(config, factor_names) + generation = self._data_generation(config.asset_type) + panel = self._load_factor_panel( + config, + factor_names, + expected_generation=generation, + ) if panel.is_empty(): return FactorBatchResult( run_id=run_id, @@ -206,9 +302,19 @@ class FactorBacktestService: ) # P1: 预计算共享下期收益 (仅依赖 close/date/symbol), 避免每个因子重复 shift/调仓日 JOIN。 - panel = self._attach_shared_next_return(panel, config) + trading_dates = self._global_trading_dates(config) + self._assert_data_generation(config.asset_type, generation) + panel = self._attach_shared_next_return( + panel, + config, + trading_dates=trading_dates, + ) metadata = {item["id"]: item for item in FACTOR_COLUMNS} + fundamentals_missing = ( + any(name in FUNDAMENTAL_FACTOR_NAMES for name in factor_names) + and self._fundamentals_missing() + ) items: list[FactorBatchItem] = [] for factor_name in factor_names: item_t0 = time.perf_counter() @@ -221,16 +327,34 @@ class FactorBacktestService: rebalance=config.rebalance, weight=config.weight, fees_pct=config.fees_pct, + commission_pct=config.commission_pct, + stamp_tax_pct=config.stamp_tax_pct, slippage_bps=config.slippage_bps, asset_type=config.asset_type, ) meta = metadata.get(factor_name, {}) + if factor_name in FUNDAMENTAL_FACTOR_NAMES and fundamentals_missing: + items.append(FactorBatchItem( + factor_name=factor_name, + label=str(meta.get("label", factor_name)), + group=str(meta.get("group", "")), + elapsed_ms=round((time.perf_counter() - item_t0) * 1000, 1), + error="本地没有财务数据: 请先在数据页同步财务数据后再使用财务因子", + )) + continue try: + evaluate_kwargs = ( + {"regime_by_date": regime_by_date} + if regime_by_date is not None + else {} + ) result = self._evaluate_panel( panel, factor_config, f"{run_id}-{len(items) + 1}", item_t0, + market_trading_dates=trading_dates, + **evaluate_kwargs, ) long_short = result.long_short_stats items.append(FactorBatchItem( @@ -242,6 +366,13 @@ class FactorBacktestService: ic_win_rate=result.ic_win_rate, long_short_return=long_short.get("total_return"), long_short_max_drawdown=long_short.get("max_drawdown"), + methodology_version=result.methodology_version, + coverage=result.coverage, + turnover=result.turnover, + long_short_sharpe=result.long_short_sharpe, + yearly_ic=result.yearly_ic, + ic_decay=result.ic_decay, + regime_stats=result.regime_stats, n_symbols=result.n_symbols, n_dates=result.n_dates, elapsed_ms=result.elapsed_ms, @@ -268,26 +399,57 @@ class FactorBacktestService: n_dates=n_dates, ) + def _data_generation(self, asset_type: str) -> str | None: + loader = getattr(self.engine, "data_generation", None) + return loader(asset_type) if callable(loader) else None + + def _fundamentals_missing(self) -> bool: + return load_fundamental_snapshot(self._fundamentals_data_dir()) is None + + def _fundamentals_data_dir(self) -> Path | None: + repo = getattr(self.engine, "repo", None) + return getattr(getattr(repo, "store", None), "data_dir", None) + + def _assert_data_generation( + self, + asset_type: str, + expected: str | None, + ) -> None: + verifier = getattr(self.engine, "assert_data_generation", None) + if callable(verifier): + verifier(asset_type, expected) + def _load_factor_panel( self, config: FactorConfig | FactorBatchConfig, factor_names: list[str], + *, + expected_generation: str | None = None, ) -> pl.DataFrame: panel_columns = [ "symbol", "date", "open", "high", "low", "close", "volume", "amount", "turnover_rate", ] - panel_columns.extend(name for name in factor_names if name not in panel_columns) + if any( + name in ("limit_up_count_20d", "limit_up_count_60d") + for name in factor_names + ): + panel_columns.append("consecutive_limit_ups") load_start = config.start if any(name != "turnover_rate" for name in factor_names): load_start = config.start - timedelta(days=FACTOR_WARMUP_DAYS) + load_kwargs = { + "columns": panel_columns, + "asset_type": config.asset_type, + } + if expected_generation is not None: + load_kwargs["expected_generation"] = expected_generation panel = self.engine.load_panel( config.symbols, load_start, config.end, - columns=panel_columns, - asset_type=config.asset_type, + **load_kwargs, ) if panel.is_empty(): return panel @@ -295,37 +457,129 @@ class FactorBacktestService: missing = set(factor_names) - set(panel.columns) if missing: panel = self._compute_missing_factors(panel, missing) + fundamental_names = [name for name in factor_names if name in FUNDAMENTAL_FACTOR_NAMES] + if fundamental_names: + # 点时财务因子: 公告日门控, 无数据标的保持 null (不参与该日截面)。 + panel = attach_fundamental_factors( + panel, + load_fundamental_snapshot(self._fundamentals_data_dir()), + fundamental_names, + ) return panel + def _global_trading_dates( + self, + config: FactorConfig | FactorBatchConfig, + ) -> list[date] | None: + """Read the market date axis from enriched partitions, independent of symbols.""" + repo = getattr(self.engine, "repo", None) + data_dir = getattr(getattr(repo, "store", None), "data_dir", None) + if data_dir is None: + return None + from app.tickflow.repository import enriched_dirname + + values: list[date] = [] + root = data_dir / enriched_dirname(config.asset_type) + for partition in root.glob("date=*"): + try: + value = date.fromisoformat(partition.name.removeprefix("date=")) + except ValueError: + continue + if value <= config.end and (partition / "part.parquet").is_file(): + values.append(value) + ordered = sorted(set(values)) + formal = [value for value in ordered if value >= config.start] + predecessor = next( + (value for value in reversed(ordered) if value < config.start), + None, + ) + if predecessor is not None: + formal.insert(0, predecessor) + return formal or None + @staticmethod def _attach_shared_next_return( - panel: pl.DataFrame, config: FactorBatchConfig, + panel: pl.DataFrame, + config: FactorConfig | FactorBatchConfig, + *, + trading_dates: list[date] | None = None, ) -> pl.DataFrame: - """对 [start, end] 内 close 有效序列计算一次 _next_return, 复用给批次内每个因子。 - - _next_return 仅依赖 (symbol, date, close, rebalance), 与具体因子无关; 因子空值 - 集中在预热期前缀, 过滤后剩余序列无内部空洞, 故与 _evaluate_panel 内逐因子在 - 过滤后面板上重算的结果完全等价。 - """ - if "_next_return" in panel.columns: + """Prepare returns once on the complete price axis before factor filtering.""" + forward_columns = [f"_forward_return_{horizon}d" for horizon in _DAILY_FORWARD_HORIZONS] + prepared_columns = ["_next_return", *forward_columns] + if all(column in panel.columns for column in prepared_columns): return panel + existing_columns = [column for column in prepared_columns if column in panel.columns] + if existing_columns: + panel = panel.drop(existing_columns) + base = ( panel.filter((pl.col("date") >= config.start) & (pl.col("date") <= config.end)) .filter(pl.col("close").is_not_null() & (pl.col("close") > 0)) .select(["symbol", "date", "close"]) + .unique(subset=["symbol", "date"], keep="last") .sort(["symbol", "date"]) ) if base.is_empty(): - return panel.with_columns(pl.lit(None).cast(pl.Float64).alias("_next_return")) + return panel.with_columns( + [pl.lit(None).cast(pl.Float64).alias(column) for column in forward_columns] + + [pl.lit(None).cast(pl.Float64).alias("_next_return")] + ) + + all_dates = sorted( + value + for value in ( + trading_dates if trading_dates is not None else base["date"].unique().to_list() + ) + if config.start <= value <= config.end + ) + date_dtype = base.schema["date"] + for horizon, return_column in zip( + _DAILY_FORWARD_HORIZONS, + forward_columns, + strict=True, + ): + if len(all_dates) <= horizon: + base = base.with_columns( + pl.lit(None).cast(pl.Float64).alias(return_column) + ) + continue + target_column = f"_target_date_{horizon}d" + target_close_column = f"_target_close_{horizon}d" + date_map = pl.DataFrame({ + "date": all_dates[:-horizon], + target_column: all_dates[horizon:], + }).with_columns( + pl.col("date").cast(date_dtype), + pl.col(target_column).cast(date_dtype), + ) + price_lookup = base.select( + "symbol", + pl.col("date").alias(target_column), + pl.col("close").alias(target_close_column), + ) + base = ( + base.join(date_map, on="date", how="left") + .join(price_lookup, on=["symbol", target_column], how="left") + .with_columns( + pl.when(pl.col(target_close_column).is_not_null()) + .then(pl.col(target_close_column) / pl.col("close") - 1.0) + .otherwise(None) + .cast(pl.Float64) + .alias(return_column) + ) + .drop([target_column, target_close_column]) + ) + if config.rebalance == "daily": base = base.with_columns( - (pl.col("close").shift(-1).over("symbol") / pl.col("close") - 1) - .alias("_next_return") + pl.col("_forward_return_1d").alias("_next_return") ) else: base = FactorBacktestService._calc_period_return(base, config.rebalance) + return panel.join( - base.select(["symbol", "date", "_next_return"]), + base.select(["symbol", "date", "_next_return", *forward_columns]), on=["symbol", "date"], how="left", ) @@ -336,6 +590,9 @@ class FactorBacktestService: config: FactorConfig, run_id: str, t0: float, + *, + regime_by_date: Mapping[object, Any] | None = None, + market_trading_dates: list[date] | None = None, ) -> FactorResult: def _err(msg: str) -> FactorResult: return self._error_result(config, run_id, t0, msg) @@ -345,62 +602,67 @@ class FactorBacktestService: return _err(f"因子列 '{factor_col}' 不存在于 enriched 数据中, 且无法从基础行情计算") if "close" not in source_panel.columns: return _err("enriched 数据缺少收盘价 close") + if "_next_return" not in source_panel.columns: + source_panel = self._attach_shared_next_return(source_panel, config) - # 批量模式由 run_batch 预计算 _next_return 并随 source_panel 传入, 直接复用; - # 单因子 run() 路径未预计算, 仍按原逻辑在此计算。 - select_cols = ["symbol", "date", "close", factor_col] - precomputed_return = "_next_return" in source_panel.columns - if precomputed_return: - select_cols.append("_next_return") - panel = source_panel.select(select_cols) - panel = panel.filter((pl.col("date") >= config.start) & (pl.col("date") <= config.end)) - - # 过滤有效行 - panel = panel.filter( - pl.col(factor_col).is_not_null() - & pl.col("close").is_not_null() - & (pl.col("close") > 0) + return_columns = [ + column + for column in ( + "_next_return", + *(f"_forward_return_{horizon}d" for horizon in _DAILY_FORWARD_HORIZONS), + ) + if column in source_panel.columns + ] + price_panel = ( + source_panel.select(["symbol", "date", "close", factor_col, *return_columns]) + .filter((pl.col("date") >= config.start) & (pl.col("date") <= config.end)) + .filter(pl.col("close").is_not_null() & (pl.col("close") > 0)) + ) + total_price_rows = price_panel.height + panel = price_panel.filter( + pl.col(factor_col).is_not_null() & pl.col(factor_col).is_finite() ) if panel.is_empty(): return _err("过滤后无有效数据") panel = panel.sort(["symbol", "date"]) - + coverage = panel.height / total_price_rows if total_price_rows else None n_symbols = panel["symbol"].n_unique() n_dates = panel["date"].n_unique() - # 计算下期收益 — _next_return 仅依赖 (symbol, date, close, rebalance), 与因子无关; - # 因子空值集中在预热期前缀, 过滤后剩余序列无内部空洞, 故预计算与逐因子重算结果等价。 - if not precomputed_return: - if config.rebalance == "daily": - panel = panel.with_columns( - (pl.col("close").shift(-1).over("symbol") / pl.col("close") - 1) - .alias("_next_return") - ) - else: - # weekly/monthly: 计算到下个调仓日的收益 - panel = self._calc_period_return(panel, config.rebalance) - # ── 1. IC 分析 ── ic_df = self._calc_ic(panel, factor_col) + valid_ic_df = ic_df.filter(pl.col("ic").is_not_null() & pl.col("ic").is_finite()) + ic_rows = valid_ic_df.iter_rows(named=True) ic_series = [ {"date": str(row["date"]), "ic": round(float(row["ic"]), 4)} - for row in ic_df.iter_rows(named=True) - if row["ic"] is not None and not np.isnan(float(row["ic"])) + for row in ic_rows ] - ic_values = [r["ic"] for r in ic_series] - ic_mean = float(np.mean(ic_values)) if ic_values else None - ic_std = float(np.std(ic_values)) if ic_values else None + ic_values = valid_ic_df["ic"].to_numpy() if not valid_ic_df.is_empty() else np.array([]) + ic_mean = float(np.mean(ic_values)) if ic_values.size else None + ic_std = float(np.std(ic_values)) if ic_values.size else None ir = (ic_mean / ic_std) if (ic_mean is not None and ic_std and ic_std > 1e-8) else None - ic_win_rate = (sum(1 for v in ic_values if v > 0) / len(ic_values)) if ic_values else None + ic_win_rate = float(np.mean(ic_values > 0)) if ic_values.size else None + yearly_ic = self._calc_yearly_ic(valid_ic_df) + ic_decay = self._calc_ic_decay(panel, factor_col) + regime_stats = self._calc_regime_stats( + valid_ic_df, + price_panel, + regime_by_date, + config.start, + config.end, + market_trading_dates=market_trading_dates, + ) # ── 2. 分层回测 ── panel = self._add_groups(panel, factor_col, config.n_groups) group_nav = self._calc_group_nav(panel, config) group_stats = self._calc_group_stats(group_nav, config.start, config.end, config.rebalance) + turnover = self._calc_turnover(panel, config) - # ── 3. 多空组合 ── + # ── 3. 理论因子多空组合 ── long_short_nav, long_short_stats = self._calc_long_short(group_nav, config) + long_short_sharpe = long_short_stats.get("sharpe") elapsed = (time.perf_counter() - t0) * 1000 return FactorResult( @@ -412,16 +674,27 @@ class FactorBacktestService: ic_win_rate=round(ic_win_rate, 4) if ic_win_rate is not None else None, ic_series=ic_series, group_stats=group_stats, - group_nav=group_nav, + group_nav=self._round_nav(group_nav), long_short_stats=long_short_stats, long_short_nav=long_short_nav, + coverage=round(coverage, 4) if coverage is not None else None, + turnover=round(turnover, 4) if turnover is not None else None, + long_short_sharpe=long_short_sharpe, + yearly_ic=yearly_ic, + ic_decay=ic_decay, + regime_stats=regime_stats, elapsed_ms=round(elapsed, 1), n_symbols=n_symbols, n_dates=n_dates, ) @staticmethod - def _compute_missing_factors(panel: pl.DataFrame, factor_cols: set[str]) -> pl.DataFrame: + def _compute_missing_factors( + panel: pl.DataFrame, + factor_cols: set[str], + *, + assume_sorted: bool = False, + ) -> pl.DataFrame: required = {"symbol", "date", "open", "high", "low", "close", "volume"} if not required.issubset(panel.columns): missing = sorted(required - set(panel.columns)) @@ -434,7 +707,11 @@ class FactorBacktestService: indicator_columns = factor_cols - derived for factor_name in derived: indicator_columns.update(DERIVED_FACTOR_DEPENDENCIES[factor_name]) - panel = compute_indicators(panel, needed=indicator_columns) + panel = compute_indicators( + panel, + needed=indicator_columns, + assume_sorted=assume_sorted, + ) return FactorBacktestService._compute_derived_factors(panel, derived) @staticmethod @@ -472,6 +749,154 @@ class FactorBacktestService: .sort("date") ) + @staticmethod + def _calc_yearly_ic(ic_df: pl.DataFrame) -> list[dict]: + if ic_df.is_empty(): + return [] + yearly = ( + ic_df.with_columns(pl.col("date").dt.year().alias("_year")) + .group_by("_year") + .agg( + pl.col("ic").mean().alias("ic_mean"), + pl.col("ic").std(ddof=0).alias("ic_std"), + (pl.col("ic") > 0).mean().alias("win_rate"), + pl.len().alias("n_dates"), + ) + .sort("_year") + ) + result: list[dict] = [] + for row in yearly.iter_rows(named=True): + mean = float(row["ic_mean"]) + std = float(row["ic_std"] or 0.0) + result.append({ + "year": int(row["_year"]), + "ic_mean": round(mean, 4), + "ir": round(mean / std, 4) if std > 1e-8 else None, + "win_rate": round(float(row["win_rate"]), 4), + "n_dates": int(row["n_dates"]), + }) + return result + + @staticmethod + def _calc_ic_decay(panel: pl.DataFrame, factor_col: str) -> list[dict]: + columns = [ + (horizon, f"_forward_return_{horizon}d") + for horizon in _DAILY_FORWARD_HORIZONS + if f"_forward_return_{horizon}d" in panel.columns + ] + if not columns: + return [] + decay_df = ( + panel.group_by("date") + .agg([ + pl.corr( + pl.col(factor_col).rank(method="average"), + pl.col(return_column).rank(method="average"), + ).alias(f"ic_{horizon}d") + for horizon, return_column in columns + ]) + .sort("date") + ) + result: list[dict] = [] + for horizon, _ in columns: + column = f"ic_{horizon}d" + values = decay_df.filter( + pl.col(column).is_not_null() & pl.col(column).is_finite() + )[column] + result.append({ + "horizon": horizon, + "ic_mean": round(float(values.mean()), 4) if len(values) else None, + "n_dates": len(values), + }) + return result + + @staticmethod + def _calc_regime_stats( + ic_df: pl.DataFrame, + price_panel: pl.DataFrame, + regime_by_date: Mapping[object, Any] | None, + required_start: date, + required_end: date, + *, + market_trading_dates: list[date] | None = None, + ) -> list[dict]: + if not regime_by_date: + return [] + + from app.backtest.regime_alignment import ( + align_regime_t_minus_one, + three_level_regime, + ) + + formal_labels = tuple( + str(value)[:10] for value in sorted(price_panel["date"].unique().to_list()) + ) + if market_trading_dates: + labels = tuple( + str(value)[:10] + for value in market_trading_dates + if value <= required_end + ) + else: + predecessor = max( + ( + str(value)[:10] + for value in regime_by_date + if str(value)[:10] < str(required_start) + ), + default=None, + ) + labels = ( + (predecessor, *formal_labels) + if predecessor is not None + else formal_labels + ) + aligned = align_regime_t_minus_one( + labels, + regime_by_date, + required_start, + required_end, + ) + ic_by_date = { + str(row["date"])[:10]: float(row["ic"]) + for row in ic_df.iter_rows(named=True) + } + grouped: dict[str, dict[str, list[float]]] = {} + for label, point in zip(labels, aligned, strict=True): + if label not in formal_labels or point is None: + continue + state, score = point + bucket = grouped.setdefault( + three_level_regime(state), + {"scores": [], "ics": [], "dates": []}, + ) + bucket["scores"].append(score) + bucket["dates"].append(label) + if label in ic_by_date: + bucket["ics"].append(ic_by_date[label]) + + order = {"strong": 0, "range": 1, "weak": 2} + result: list[dict] = [] + for state in sorted(grouped, key=lambda value: (order.get(value, 99), value)): + values = np.asarray(grouped[state]["ics"], dtype=np.float64) + scores = np.asarray(grouped[state]["scores"], dtype=np.float64) + mean = float(np.mean(values)) if values.size else None + std = float(np.std(values)) if values.size else None + result.append({ + "state": state, + "ic_mean": round(mean, 4) if mean is not None else None, + "ir": ( + round(mean / std, 4) + if mean is not None and std is not None and std > 1e-8 + else None + ), + "win_rate": round(float(np.mean(values > 0)), 4) if values.size else None, + "mean_score": round(float(np.mean(scores)), 2), + "n_dates": len(grouped[state]["dates"]), + "n_ic_dates": int(values.size), + }) + return result + # ── 调仓期收益 ── @staticmethod @@ -482,20 +907,21 @@ class FactorBacktestService: monthly: 下个月调仓日 close / 今日 close - 1 只在调仓日标记行有效，其他行为 null。 """ - import datetime as _dt - all_dates = sorted(panel["date"].unique().to_list()) - if rebalance == "weekly": - # 调仓日 = 每周一 rebalance_dates = set() - for d in all_dates: - if hasattr(d, "weekday"): - wd = d.weekday() - else: - wd = _dt.date.fromisoformat(str(d)).weekday() - if wd == 0: # Monday - rebalance_dates.add(d) + seen_weeks: set[tuple[int, int]] = set() + for current_date in all_dates: + normalized_date = ( + current_date + if hasattr(current_date, "isocalendar") + else date.fromisoformat(str(current_date)[:10]) + ) + iso_year, iso_week, _ = normalized_date.isocalendar() + week = (iso_year, iso_week) + if week not in seen_weeks: + seen_weeks.add(week) + rebalance_dates.add(current_date) else: # monthly # 调仓日 = 每月首个交易日 seen_months: set[str] = set() @@ -569,18 +995,21 @@ class FactorBacktestService: @staticmethod def _add_groups(panel: pl.DataFrame, factor_col: str, n_groups: int) -> pl.DataFrame: - """截面序号分桶，避免 qcut 在重复因子值截面上抛错。""" + """Tie-aware cross-sectional buckets; equal factor values never split.""" return ( - panel.sort(["date", factor_col, "symbol"]) - .with_columns( - (pl.cum_count("symbol").over("date") - 1).alias("_factor_ord"), + panel.with_columns( + pl.col(factor_col).rank(method="average").over("date").alias("_factor_rank"), pl.len().over("date").alias("_factor_count"), ) .with_columns( ( pl.lit("Q") + ( - ((pl.col("_factor_ord") * n_groups) / pl.col("_factor_count")) + ( + (pl.col("_factor_rank") - 1.0) + * n_groups + / pl.col("_factor_count") + ) .floor() .cast(pl.Int64) + 1 @@ -588,9 +1017,16 @@ class FactorBacktestService: .clip(1, n_groups) .cast(pl.Utf8) ) - .alias("_group") + .alias("_group"), + ( + pl.col("_factor_rank") + - (pl.col("_factor_count") + 1) / 2.0 + ) + .abs() + .add(0.5) + .alias("_factor_strength"), ) - .drop(["_factor_ord", "_factor_count"]) + .drop(["_factor_rank", "_factor_count"]) ) @staticmethod @@ -604,38 +1040,126 @@ class FactorBacktestService: # ── 分组净值 ── + @staticmethod + def _round_nav(group_nav: list[dict]) -> list[dict]: + return [ + { + key: value if key == "date" else round(float(value), 4) + for key, value in row.items() + } + for row in group_nav + ] + + @staticmethod + def _round_trip_cost(config: FactorConfig) -> float: + commission = ( + config.commission_pct + if config.commission_pct is not None + else config.fees_pct + ) + stamp_tax = config.stamp_tax_pct or 0.0 + slippage = config.slippage_bps / 10_000.0 + return 2.0 * commission + stamp_tax + 2.0 * slippage + @staticmethod def _calc_group_nav(panel: pl.DataFrame, config: FactorConfig) -> list[dict]: - """计算分组净值曲线 — 只在调仓日更新净值。""" - # 只保留有下期收益的行 (= 调仓日) - group_ret = ( - panel.filter(pl.col("_next_return").is_not_null() & pl.col("_group").is_not_null()) - .group_by(["date", "_group"]) - .agg(pl.col("_next_return").mean().alias("group_return")) + """Calculate group NAV with the configured cross-sectional weighting.""" + eligible = panel.filter( + pl.col("_next_return").is_not_null() & pl.col("_group").is_not_null() + ) + if config.weight == "factor_weight": + group_ret = ( + eligible.with_columns( + pl.when(pl.col("_factor_strength") > 0) + .then(pl.col("_factor_strength")) + .otherwise(1.0) + .alias("_weight") + ) + .group_by(["date", "_group"]) + .agg( + ( + (pl.col("_next_return") * pl.col("_weight")).sum() + / pl.col("_weight").sum() + ).alias("group_return") + ) + ) + else: + group_ret = eligible.group_by(["date", "_group"]).agg( + pl.col("_next_return").mean().alias("group_return") + ) + group_ret = group_ret.with_columns( + (pl.col("group_return") - FactorBacktestService._round_trip_cost(config)) + .alias("group_return") ) - # pivot: date × group - pivot = group_ret.pivot(index="date", columns="_group", values="group_return").sort("date") - + pivot = group_ret.pivot( + index="date", + on="_group", + values="group_return", + ).sort("date") if pivot.is_empty(): return [] - group_cols = sorted([c for c in pivot.columns if c != "date"], key=FactorBacktestService._group_sort_key) - - # 向量化累乘净值: null 视为 0 收益 (净值不变); 累乘保持全精度, 输出时 round(4), - # 等价于原 dict 累乘 `nav_values[c] *= (1+ret); entry[c] = round(nav_values[c], 4)`。 + group_cols = sorted( + [column for column in pivot.columns if column != "date"], + key=FactorBacktestService._group_sort_key, + ) nav_df = pivot.with_columns( - [(1.0 + pl.col(c).fill_null(0.0)).cum_prod().alias(c) for c in group_cols] + [(1.0 + pl.col(column).fill_null(0.0)).cum_prod().alias(column) for column in group_cols] ) result: list[dict] = [] for row in nav_df.iter_rows(named=True): entry: dict = {"date": str(row["date"])[:10]} - for c in group_cols: - entry[c] = round(float(row[c]), 4) + for column in group_cols: + entry[column] = float(row[column]) result.append(entry) - return result + @staticmethod + def _calc_turnover(panel: pl.DataFrame, config: FactorConfig) -> float | None: + eligible = panel.filter( + pl.col("_next_return").is_not_null() & pl.col("_group").is_not_null() + ) + if eligible.is_empty(): + return None + groups = sorted( + eligible["_group"].unique().to_list(), + key=FactorBacktestService._group_sort_key, + ) + if not groups: + return None + top_group = groups[-1] + weights = eligible.filter(pl.col("_group") == top_group) + if config.weight == "factor_weight": + weights = weights.with_columns( + pl.when(pl.col("_factor_strength") > 0) + .then(pl.col("_factor_strength")) + .otherwise(1.0) + .alias("_raw_weight") + ) + else: + weights = weights.with_columns(pl.lit(1.0).alias("_raw_weight")) + weights = weights.with_columns( + (pl.col("_raw_weight") / pl.col("_raw_weight").sum().over("date")) + .alias("_weight") + ) + + by_date: dict[object, dict[str, float]] = {} + for row in weights.select(["date", "symbol", "_weight"]).iter_rows(named=True): + by_date.setdefault(row["date"], {})[str(row["symbol"])] = float(row["_weight"]) + ordered_dates = sorted(by_date) + if len(ordered_dates) < 2: + return 0.0 + turnovers: list[float] = [] + for previous_date, current_date in pairwise(ordered_dates): + previous = by_date[previous_date] + current = by_date[current_date] + symbols = previous.keys() | current.keys() + turnovers.append( + 0.5 * sum(abs(current.get(symbol, 0.0) - previous.get(symbol, 0.0)) for symbol in symbols) + ) + return float(np.mean(turnovers)) + # ── 分组统计 ── @staticmethod @@ -732,13 +1256,26 @@ class FactorBacktestService: with np.errstate(divide="ignore", invalid="ignore"): top_ret = np.where(prev_top > 0, top / prev_top - 1.0, 0.0) bot_ret = np.where(prev_bot > 0, bot / prev_bot - 1.0, 0.0) - ls_ret = (top_ret - bot_ret) / 2.0 # 各分配 50% 资金 + ls_ret = ( + (top_ret - bot_ret) / 2.0 + - FactorBacktestService._round_trip_cost(config) + ) # 50/50 理论多空两腿 ls_value = np.cumprod(1.0 + ls_ret) # 最大回撤: 峰值 = max(1.0, 历史最高), 与原 peak 初值 1.0 一致 peak = np.maximum(np.maximum.accumulate(ls_value), 1.0) max_dd = float(np.min((ls_value - peak) / peak)) + ann_factor = {"daily": 252, "weekly": 52, "monthly": 12}.get( + config.rebalance, + 252, + ) + ls_std = float(np.std(ls_ret)) + sharpe = ( + float(np.mean(ls_ret) / ls_std) * np.sqrt(ann_factor) + if ls_std > 1e-8 + else 0.0 + ) ls_nav = [ {"date": group_nav[k]["date"], "value": round(float(ls_value[k]), 4)} for k in range(len(group_nav)) @@ -746,8 +1283,11 @@ class FactorBacktestService: ls_stats = { "total_return": round(float(ls_value[-1]) - 1.0, 4), "max_drawdown": round(max_dd, 4), + "sharpe": round(sharpe, 4), "top_group": top_col, "bottom_group": bottom_col, + "portfolio_type": "theoretical_factor_spread", + "executable_short": False, } return ls_nav, ls_stats @@ -763,6 +1303,8 @@ class FactorBacktestService: "rebalance": c.rebalance, "weight": c.weight, "fees_pct": c.fees_pct, + "commission_pct": c.commission_pct, + "stamp_tax_pct": c.stamp_tax_pct, "slippage_bps": c.slippage_bps, "asset_type": c.asset_type, } @@ -778,6 +1320,8 @@ class FactorBacktestService: "rebalance": c.rebalance, "weight": c.weight, "fees_pct": c.fees_pct, + "commission_pct": c.commission_pct, + "stamp_tax_pct": c.stamp_tax_pct, "slippage_bps": c.slippage_bps, "asset_type": c.asset_type, } diff --git a/backend/app/backtest/fundamentals.py b/backend/app/backtest/fundamentals.py new file mode 100644 index 0000000..d69f52a --- /dev/null +++ b/backend/app/backtest/fundamentals.py @@ -0,0 +1,209 @@ +"""财务因子: 基于本地财务快照的点时 (point-in-time) 无未来函数接入。 + +数据契约: +- 输入为 data/financials/metrics/part.parquet, 每行一份报告期指标; +- ``announce_date`` 是公告日。因子只在 **严格晚于公告日的交易日** 才有值 + (公告多在盘后发布, 保守取 T+1 生效), 此前保持 null; +- 财报历史按 (symbol, period_end) 累积 (见 services/financial_sync.py), + 同一期以最新公告为准; +- 无财务数据的标的/日期一律为 null, 绝不填 0 (填 0 会污染截面排名, + 例如资产负债率 0 会被当成最优杠杆)。下游 IC/分层/评分对 null 自动剔除。 + +性能: +- 财务表约数千行, join_asof 按 symbol 分组回填, 对百万行面板的代价是 + 毫秒级; 矩阵路径每个因子只物化一张 float32 TxN 矩阵 (T~900, N~5500 + 约 20MB), 且仅在策略/挖掘请求该因子时才构建。 +""" +from __future__ import annotations + +import logging +from pathlib import Path +from types import MappingProxyType +from typing import Any + +import numpy as np +import polars as pl + +logger = logging.getLogger(__name__) + +# 财务因子名 -> (metrics 表列名, 是否需要除以收盘价) +# pb_latest 单列声明为 bps 倒数口径: 因子值 = close / bps。 +FUNDAMENTAL_FACTORS: dict[str, dict[str, Any]] = { + "pb_latest": {"column": "bps", "price_ratio": True}, + "roe_latest": {"column": "roe", "price_ratio": False}, + "gross_margin_latest": {"column": "gross_margin", "price_ratio": False}, + "net_margin_latest": {"column": "net_margin", "price_ratio": False}, + "revenue_yoy_latest": {"column": "revenue_yoy", "price_ratio": False}, + "net_income_yoy_latest": {"column": "net_income_yoy", "price_ratio": False}, + "debt_ratio_latest": {"column": "debt_to_asset_ratio", "price_ratio": False}, +} + +FUNDAMENTAL_FACTOR_NAMES = frozenset(FUNDAMENTAL_FACTORS) + + +def load_fundamental_snapshot(data_dir: Path | None) -> pl.DataFrame | None: + """读取财务指标快照; 文件缺失或无有效行时返回 None。 + + 返回列: symbol, _announce (Date), 以及各因子对应的 metrics 列。 + """ + if data_dir is None: + return None + path = data_dir / "financials" / "metrics" / "part.parquet" + if not path.exists(): + return None + try: + frame = pl.read_parquet(path) + except Exception as exc: + logger.warning("读取财务指标快照失败: %s", exc) + return None + needed = {"symbol", "announce_date"} | { + spec["column"] for spec in FUNDAMENTAL_FACTORS.values() + } + if not needed.issubset(frame.columns): + logger.warning("财务指标快照缺少列: %s", sorted(needed - set(frame.columns))) + return None + snapshot = ( + frame.select(sorted(needed)) + .filter( + pl.col("symbol").is_not_null() + & pl.col("announce_date").is_not_null() + ) + .with_columns( + pl.col("announce_date").cast(pl.Utf8).str.slice(0, 10).str.to_date().alias("_announce") + ) + .sort(["symbol", "_announce"]) + ) + if snapshot.is_empty(): + return None + return snapshot + + +def attach_fundamental_factors( + panel: pl.DataFrame, + snapshot: pl.DataFrame | None, + names: Any, +) -> pl.DataFrame: + """把财务因子列按公告日门控地并入日频面板。 + + - snapshot 为 None (本地无财务数据): 产出全 null 列, 保持面板形状, + 由上层决定是否报"无财务数据"错误; + - 面板必须已按 (symbol, date) 排序 (存储与挖掘路径均满足)。 + """ + requested = [str(name) for name in names if str(name) in FUNDAMENTAL_FACTOR_NAMES] + missing_columns = [name for name in requested if name not in panel.columns] + if not missing_columns: + return panel + + if snapshot is None: + return panel.with_columns([ + pl.lit(None, dtype=pl.Float64).alias(name) + for name in missing_columns + ]) + + columns = sorted( + {FUNDAMENTAL_FACTORS[name]["column"] for name in missing_columns} + ) + right = snapshot.select(["symbol", "_announce", *columns]).sort(["symbol", "_announce"]) + joined = panel.join_asof( + right, + left_on="date", + right_on="_announce", + by="symbol", + strategy="backward", + check_sortedness=False, # 双侧均已按 (symbol, key) 排序, 免除逐组检查开销 + ) + announced = pl.col("_announce").is_not_null() & (pl.col("date") > pl.col("_announce")) + expressions = [] + for name in missing_columns: + spec = FUNDAMENTAL_FACTORS[name] + source = pl.col(spec["column"]) + if spec["price_ratio"]: + value = ( + pl.when(source > 0) + .then(pl.col("close") / source) + .otherwise(None) + ) + else: + value = source + expressions.append( + pl.when(announced).then(value).otherwise(None).alias(name) + ) + return joined.with_columns(expressions) + + +def build_fundamental_matrices( + market: Any, + snapshot: pl.DataFrame | None, + names: Any, +) -> dict[str, np.ndarray]: + """为 MarketDataMatrix 构建财务因子 TxN float32 字段。 + + 与 attach_fundamental_factors 同一口径: 公告日次一交易日起前向填充, + 无数据为 NaN。pb 类因子在矩阵侧用 close / bps 现算。 + """ + requested = [str(name) for name in names if str(name) in FUNDAMENTAL_FACTOR_NAMES] + if not requested: + return {} + + shape = market.shape + result: dict[str, np.ndarray] = {} + if snapshot is None: + for name in requested: + result[name] = np.full(shape, np.nan, dtype=np.float32) + return result + + asset_index = {symbol: index for index, symbol in enumerate(market.symbols)} + labels = market.timestamp_labels + label_dates = np.array([label[:10] for label in labels], dtype="datetime64[D]") + + raw_columns = { + FUNDAMENTAL_FACTORS[name]["column"]: np.full(shape, np.nan, dtype=np.float32) + for name in requested + } + announce_text = snapshot["announce_date"].str.slice(0, 10) + for row_index, symbol in enumerate(snapshot["symbol"].to_list()): + column_index = asset_index.get(symbol) + if column_index is None: + continue + announce = announce_text[row_index] + if announce is None: + continue + # 公告日之后 (严格大于) 的首个时间行索引 + start = int(np.searchsorted(label_dates, np.datetime64(announce, "D"), side="right")) + if start >= shape[0]: + continue + for column, target in raw_columns.items(): + value = snapshot[column][row_index] + if value is None or not np.isfinite(float(value)): + continue + target[start:, column_index] = float(value) + + for name in requested: + spec = FUNDAMENTAL_FACTORS[name] + source = raw_columns[spec["column"]] + if spec["price_ratio"]: + with np.errstate(divide="ignore", invalid="ignore"): + matrix = (market.close / source).astype(np.float32) + matrix[~(source > 0)] = np.nan + matrix[np.isinf(matrix)] = np.nan + else: + matrix = source + result[name] = matrix + return result + + +def attach_matrix_fundamental_fields(market: Any, data_dir: Path | None, names: Any) -> Any: + """把财务因子作为 matrix fields 附加到 (frozen) MarketDataMatrix 副本。""" + import dataclasses + + requested = [str(name) for name in names if str(name) in FUNDAMENTAL_FACTOR_NAMES] + if not requested: + return market + snapshot = load_fundamental_snapshot(data_dir) + extra = build_fundamental_matrices(market, snapshot, requested) + if not extra: + return market + merged = {**dict(market.fields), **extra} + for array in extra.values(): + array.flags.writeable = False + return dataclasses.replace(market, fields=MappingProxyType(merged)) diff --git a/backend/app/backtest/matrix.py b/backend/app/backtest/matrix.py index 5b8625f..d9cfda8 100644 --- a/backend/app/backtest/matrix.py +++ b/backend/app/backtest/matrix.py @@ -59,6 +59,17 @@ _ROLLING_MATERIALIZED_WINDOW_BUDGET_BYTES = 32 * 1024 * 1024 _MATRIX_DISK_CACHE_DEFAULT_MAX_BYTES = 512 * 1024 * 1024 logger = logging.getLogger(__name__) + + +class MatrixPrewarmCancelledError(RuntimeError): + """A matrix cache prewarm was cancelled during application shutdown.""" + + +def _raise_if_matrix_cancelled(cancel_event: threading.Event | None) -> None: + if cancel_event is not None and cancel_event.is_set(): + raise MatrixPrewarmCancelledError("matrix cache prewarm cancelled") + + _MATRIX_DISK_CACHE_LOCK = threading.RLock() _MATRIX_DISK_CACHE_LEASES: dict[str, int] = {} _MATRIX_DISK_CACHE_PENDING_DELETE: set[str] = set() @@ -679,8 +690,10 @@ def load_market_data_matrix_from_parquet( cache_max_bytes: int = _MATRIX_DISK_CACHE_DEFAULT_MAX_BYTES, profile_generation: str = "default", source_generation: str | None = None, + cancel_event: threading.Event | None = None, ) -> MarketDataMatrix: """Load a daily market matrix, reusing a covering read-only mmap when possible.""" + _raise_if_matrix_cancelled(cancel_event) if start > end: raise ValueError("matrix parquet range start must not exceed end") root = Path(parquet_root) @@ -729,6 +742,7 @@ def load_market_data_matrix_from_parquet( instruments, batch_size=batch_size, cache_status="disabled", + cancel_event=cancel_event, ) cache_dir = Path(cache_root) @@ -807,7 +821,9 @@ def load_market_data_matrix_from_parquet( source_generation, batch_size=batch_size, axis_cache_root=cache_dir, + cancel_event=cancel_event, ) + _raise_if_matrix_cancelled(cancel_event) _prune_matrix_disk_cache( cache_dir, keep=cache_path, @@ -916,12 +932,15 @@ def _build_market_data_matrix_from_dataset( *, batch_size: int, cache_status: str, + cancel_event: threading.Event | None = None, ) -> MarketDataMatrix: + _raise_if_matrix_cancelled(cancel_event) filter_expr = _matrix_filter_expression(start, end, symbols) actual_dates, actual_symbols = _collect_parquet_axes( dataset, filter_expr, batch_size=batch_size, + cancel_event=cancel_event, ) if not actual_dates or not actual_symbols: raise ValueError("matrix parquet range contains no market data") @@ -953,7 +972,9 @@ def _build_market_data_matrix_from_dataset( parquet_fields, seen, batch_size=batch_size, + cancel_event=cancel_event, ) + _raise_if_matrix_cancelled(cancel_event) names, latest_limits = _populate_matrix_derived_arrays( actual_symbols, arrays, @@ -1037,7 +1058,9 @@ def _build_market_data_matrix_cache_from_dataset( *, batch_size: int, axis_cache_root: Path, + cancel_event: threading.Event | None = None, ) -> None: + _raise_if_matrix_cancelled(cancel_event) build_started = time.perf_counter() timing_ms: dict[str, float] = {} cache_path.parent.mkdir(parents=True, exist_ok=True) @@ -1057,7 +1080,9 @@ def _build_market_data_matrix_cache_from_dataset( filter_expr, batch_size=batch_size, cache_root=axis_cache_root, + cancel_event=cancel_event, ) + _raise_if_matrix_cancelled(cancel_event) if not actual_dates or not actual_symbols: raise ValueError("matrix parquet range contains no market data") timing_ms["axes"] = round((time.perf_counter() - stage_started) * 1000, 1) @@ -1101,7 +1126,9 @@ def _build_market_data_matrix_cache_from_dataset( parquet_fields, seen, batch_size=batch_size, + cancel_event=cancel_event, ) + _raise_if_matrix_cancelled(cancel_event) if not seen.any(): raise ValueError("matrix parquet range contains no requested market data") timing_ms["scan"] = round((time.perf_counter() - stage_started) * 1000, 1) @@ -1118,6 +1145,7 @@ def _build_market_data_matrix_cache_from_dataset( vector_fields=vector_fields, ) _mask_unseen_staging_fields(fields, seen) + _raise_if_matrix_cancelled(cancel_event) if "price_limit_pct" in fields: write_numpy_price_limit_matrix( fields["price_limit_pct"], @@ -1147,6 +1175,7 @@ def _build_market_data_matrix_cache_from_dataset( apply_latest_limits=actual_dates[-1] == _latest_partition_date(root), ) timing_ms["derived"] = round((time.perf_counter() - stage_started) * 1000, 1) + _raise_if_matrix_cancelled(cancel_event) stage_started = time.perf_counter() for values in mapped: values.flush() @@ -1181,6 +1210,7 @@ def _build_market_data_matrix_cache_from_dataset( json.dumps(manifest, ensure_ascii=False, separators=(",", ":")), encoding="utf-8", ) + _raise_if_matrix_cancelled(cancel_event) try: os.replace(temporary, cache_path) except OSError: @@ -1313,6 +1343,7 @@ def _scan_matrix_values( seen: np.ndarray, *, batch_size: int, + cancel_event: threading.Event | None = None, ) -> None: date_to_id = {value: index for index, value in enumerate(actual_dates)} symbol_to_id = {value: index for index, value in enumerate(actual_symbols)} @@ -1343,6 +1374,7 @@ def _scan_matrix_values( **{name: fields[name] for name in parquet_fields}, } for batch in scanner.to_batches(): + _raise_if_matrix_cancelled(cancel_event) time_ids = _arrow_axis_ids(_batch_column(batch, "date"), date_to_id) asset_ids = _arrow_axis_ids(_batch_column(batch, "symbol"), symbol_to_id) flat_ids = time_ids.astype(np.int64) * asset_count + asset_ids @@ -1898,7 +1930,9 @@ def _load_or_build_matrix_axes( *, batch_size: int, cache_root: Path, + cancel_event: threading.Event | None = None, ) -> tuple[list[date], list[str]]: + _raise_if_matrix_cancelled(cancel_event) path = _matrix_axis_cache_path(cache_root, parquet_root, start, end, symbols) previous: dict[str, Any] | None = None if path.exists(): @@ -1931,6 +1965,7 @@ def _load_or_build_matrix_axes( dataset, filter_expr, batch_size=batch_size, + cancel_event=cancel_event, ) changed_labels = set() retained_dates = {value.isoformat() for value in actual_dates} @@ -1956,6 +1991,7 @@ def _load_or_build_matrix_axes( ) symbols_set = set(actual_symbols) for batch in scanner.to_batches(): + _raise_if_matrix_cancelled(cancel_event) retained_dates.update( value.isoformat() for value in pc.unique(_batch_column(batch, "date")).to_pylist() @@ -1971,8 +2007,10 @@ def _load_or_build_matrix_axes( dataset, filter_expr, batch_size=batch_size, + cancel_event=cancel_event, ) + _raise_if_matrix_cancelled(cancel_event) payload = { "version": _MATRIX_AXIS_INDEX_VERSION, "source_partitions": dict(source_partitions), @@ -1993,6 +2031,7 @@ def _collect_parquet_axes( filter_expr, *, batch_size: int, + cancel_event: threading.Event | None = None, ) -> tuple[list[date], list[str]]: dates: set[date] = set() symbols: set[str] = set() @@ -2003,6 +2042,7 @@ def _collect_parquet_axes( use_threads=True, ) for batch in scanner.to_batches(): + _raise_if_matrix_cancelled(cancel_event) dates.update(pc.unique(_batch_column(batch, "date")).to_pylist()) symbols.update( str(value) @@ -2998,6 +3038,7 @@ _VALID_REDUCE_MIN = 0 _VALID_REDUCE_MAX = 1 _VALID_REDUCE_MEAN = 2 _VALID_REDUCE_STD = 3 +_VALID_REDUCE_SUM = 4 @njit(cache=True, nogil=True, parallel=True) @@ -3049,6 +3090,8 @@ def _valid_rolling_kernel( mean = total / window_value if operation == _VALID_REDUCE_MEAN: out[row, asset_id] = mean + elif operation == _VALID_REDUCE_SUM: + out[row, asset_id] = total else: squared = 0.0 for offset in range(window): @@ -3187,6 +3230,30 @@ def valid_rolling_std( ) +def valid_rolling_sum( + values: np.ndarray, + valid_mask: np.ndarray, + window: int, + *, + bar_index: ValidBarIndex | None = None, +) -> np.ndarray: + source = np.asarray(values, dtype=np.float32) + valid = np.asarray(valid_mask, dtype=bool) & np.isfinite(source) + index = _resolve_valid_bar_index(source, valid, bar_index) + return _cached_matrix_operation( + "valid_rolling_sum", + (source, valid, index.offsets, index.rows), + {"window": int(window)}, + lambda: _valid_rolling_reduce( + source, + valid, + window, + _VALID_REDUCE_SUM, + bar_index=index, + ), + ) + + def rolling_quantile(values: np.ndarray, window: int, quantile: float) -> np.ndarray: source = np.asarray(values, dtype=np.float32) q = float(quantile) @@ -3675,6 +3742,10 @@ _MATRIX_COMPUTED_FEATURES = frozenset({ "turnover_ratio_5d", "log_amount", "amount_ratio_5d", "gap_return", "intraday_return", "close_position", "distance_to_high_60d", "distance_from_low_60d", + "max_ret_20d", "ret_skew_20d", "up_days_20d", + "amihud_20d", "turnover_z_60d", "vol_price_corr_20d", + "vwap_bias", "vol_trend_5_60", + "limit_up_count_20d", "limit_up_count_60d", }) @@ -3872,9 +3943,106 @@ def _compute_matrix_feature(market: MarketDataMatrix, name: str) -> np.ndarray: return _matrix_relative(market.close, matrix_feature(market, "high_60d")) if name == "distance_from_low_60d": return _matrix_relative(market.close, matrix_feature(market, "low_60d")) + if name == "max_ret_20d": + daily = matrix_feature(market, "change_pct") + return valid_rolling_max(daily, np.isfinite(daily), 20) + if name == "ret_skew_20d": + return _matrix_rolling_skew(matrix_feature(market, "change_pct"), 20) + if name == "up_days_20d": + daily = matrix_feature(market, "change_pct") + up = np.where(daily > 0, np.float32(1.0), np.float32(0.0)).astype(np.float32) + up[~np.isfinite(daily)] = np.nan + return valid_rolling_sum(up, np.isfinite(up), 20) + if name == "amihud_20d": + daily = matrix_feature(market, "change_pct") + amount = market.field("amount") + amount_yi = amount / np.float32(1e8) + illiquidity = _matrix_ratio(np.abs(daily), amount_yi) + return valid_rolling_mean( + illiquidity, + close_valid & np.isfinite(illiquidity), + 20, + ) + if name == "turnover_z_60d": + turnover = market.field("turnover_rate") + valid = close_valid & np.isfinite(turnover) + previous = valid_shift(turnover, 1, valid) + baseline_valid = np.isfinite(previous) + mean = valid_rolling_mean(previous, baseline_valid, 60) + std = valid_rolling_std(previous, baseline_valid, 60, ddof=1) + deviation = _matrix_ratio(turnover - mean, std) + deviation[np.isfinite(std) & (std <= 0)] = np.nan + return deviation + if name == "vol_price_corr_20d": + daily = matrix_feature(market, "change_pct") + return _matrix_rolling_corr(daily, market.volume, close_valid, 20) + if name == "vwap_bias": + amount = market.field("amount") + shares = market.volume * np.float32(100.0) + valid = close_valid & np.isfinite(amount) & (market.volume > 0) & (amount > 0) + vwap = np.full(market.shape, np.nan, dtype=np.float32) + np.divide(amount, shares, out=vwap, where=valid) + return _matrix_relative(market.close, vwap) + if name == "vol_trend_5_60": + volume_valid = close_valid & np.isfinite(market.volume) + fast = valid_rolling_mean(market.volume, volume_valid, 5) + slow = valid_rolling_mean(market.volume, volume_valid, 60) + return _matrix_relative(fast, slow) + if name in {"limit_up_count_20d", "limit_up_count_60d"}: + window = 20 if name == "limit_up_count_20d" else 60 + consecutive = market.field("consecutive_limit_ups") + hits = np.where(np.isfinite(consecutive) & (consecutive > 0), np.float32(1.0), np.float32(0.0)) + hits = hits.astype(np.float32) + return valid_rolling_sum(hits, close_valid, window) raise ValueError(f"unsupported matrix feature: {name}") +def _matrix_rolling_skew(values: np.ndarray, window: int) -> np.ndarray: + valid = np.isfinite(values) + first = valid_rolling_mean(values, valid, window) + second = valid_rolling_mean(np.square(values, dtype=np.float32), valid, window) + third = valid_rolling_mean( + (values * values * values).astype(np.float32), valid, window + ) + variance = second - np.square(first, dtype=np.float32) + central_third = ( + third + - np.float32(3.0) * first * second + + np.float32(2.0) * np.power(first, 3) + ) + out = _matrix_ratio(central_third, np.sqrt(np.power(variance, 3))) + out[np.isfinite(variance) & (variance <= 0)] = np.nan + return out + + +def _matrix_rolling_corr( + left: np.ndarray, right: np.ndarray, valid_mask: np.ndarray, window: int +) -> np.ndarray: + valid = valid_mask & np.isfinite(left) & np.isfinite(right) + product = (left * right).astype(np.float32) + mean_left = valid_rolling_mean(left, valid, window) + mean_right = valid_rolling_mean(right, valid, window) + mean_product = valid_rolling_mean(product, valid, window) + mean_left_sq = valid_rolling_mean( + np.square(left, dtype=np.float32), valid, window + ) + mean_right_sq = valid_rolling_mean( + np.square(right, dtype=np.float32), valid, window + ) + covariance = mean_product - mean_left * mean_right + variance_left = mean_left_sq - np.square(mean_left, dtype=np.float32) + variance_right = mean_right_sq - np.square(mean_right, dtype=np.float32) + denominator = np.sqrt(variance_left * variance_right) + out = _matrix_ratio(covariance, denominator) + degenerate = ( + np.isfinite(variance_left) + & np.isfinite(variance_right) + & ((variance_left <= 0) | (variance_right <= 0)) + ) + out[degenerate] = np.nan + return out + + def _matrix_ema(values: np.ndarray, valid: np.ndarray, period: int) -> np.ndarray: return valid_ewm_adjust_false(values, valid, alpha=2.0 / (period + 1.0)) diff --git a/backend/app/backtest/mining.py b/backend/app/backtest/mining.py new file mode 100644 index 0000000..a4a23fb --- /dev/null +++ b/backend/app/backtest/mining.py @@ -0,0 +1,1660 @@ +"""Pure factor-mining algorithms and callback-driven nested validation.""" +from __future__ import annotations + +import json +import logging +import math +import time +from collections.abc import Callable, Mapping, Sequence +from dataclasses import asdict, dataclass, field, replace +from datetime import date +from typing import Any, Literal, Protocol + +import numpy as np +import polars as pl + +logger = logging.getLogger(__name__) + +MAX_MINING_FACTORS = 48 +MAX_EXISTING_STRATEGIES = 8 +MAX_COMBINATION_SIZE = 4 +MAX_BEAM_WIDTH = 32 +MAX_FINALISTS = 8 +MAX_REAL_TRIALS = 256 + +# Evidence-based promotion gate documented in docs/mining.md. A candidate must +# clear every threshold before it may be published as an independent strategy. +GATE_MIN_VALID_FOLDS = 2 +GATE_MIN_POSITIVE_FOLD_RATIO = 2.0 / 3.0 +GATE_MIN_OOS_SHARPE = 0.5 +GATE_MAX_DRAWDOWN = -0.25 +GATE_MIN_TRADES = 60 + +MiningProfile = Literal["exploratory", "balanced", "strict"] + + +class JsonDataclassMixin: + """Provide JSON output without coupling pure models to Pydantic.""" + + def to_json(self) -> str: + return json.dumps(asdict(self), ensure_ascii=False, allow_nan=False) + + +@dataclass(frozen=True) +class MiningBudget(JsonDataclassMixin): + max_factors: int = MAX_MINING_FACTORS + max_existing_strategies: int = MAX_EXISTING_STRATEGIES + max_combination_size: int = MAX_COMBINATION_SIZE + beam_width: int = 16 + max_proxy_trials: int = 256 + max_trials: int = 96 + + def __post_init__(self) -> None: + if not 1 <= self.max_factors <= MAX_MINING_FACTORS: + raise ValueError(f"max_factors must be between 1 and {MAX_MINING_FACTORS}") + if not 0 <= self.max_existing_strategies <= MAX_EXISTING_STRATEGIES: + raise ValueError( + "max_existing_strategies must be between 0 and " + f"{MAX_EXISTING_STRATEGIES}" + ) + if not 1 <= self.max_combination_size <= MAX_COMBINATION_SIZE: + raise ValueError( + "max_combination_size must be between 1 and " + f"{MAX_COMBINATION_SIZE}" + ) + if not 1 <= self.beam_width <= MAX_BEAM_WIDTH: + raise ValueError(f"beam_width must be between 1 and {MAX_BEAM_WIDTH}") + if self.max_proxy_trials <= 0: + raise ValueError("max_proxy_trials must be positive") + if not 1 <= self.max_trials <= MAX_REAL_TRIALS: + raise ValueError(f"max_trials must be between 1 and {MAX_REAL_TRIALS}") + + @classmethod + def exploratory(cls) -> MiningBudget: + return cls( + max_combination_size=3, + beam_width=8, + max_proxy_trials=96, + max_trials=32, + ) + + @classmethod + def balanced(cls) -> MiningBudget: + return cls() + + @classmethod + def strict(cls) -> MiningBudget: + return cls(beam_width=32, max_proxy_trials=512, max_trials=256) + + +@dataclass(frozen=True) +class NestedValidationConfig(JsonDataclassMixin): + outer_train_bars: int = 504 + outer_test_bars: int = 126 + outer_step_bars: int = 63 + inner_train_bars: int = 252 + inner_test_bars: int = 63 + inner_step_bars: int = 63 + purge_bars: int = 30 + embargo_bars: int = 5 + min_train_bars: int = 126 + + def __post_init__(self) -> None: + positive = { + "outer_train_bars": self.outer_train_bars, + "outer_test_bars": self.outer_test_bars, + "outer_step_bars": self.outer_step_bars, + "inner_train_bars": self.inner_train_bars, + "inner_test_bars": self.inner_test_bars, + "inner_step_bars": self.inner_step_bars, + "min_train_bars": self.min_train_bars, + } + invalid = [name for name, value in positive.items() if value <= 0] + if invalid: + raise ValueError(f"nested validation bars must be positive: {invalid}") + if self.purge_bars < 0 or self.embargo_bars < 0: + raise ValueError("purge_bars and embargo_bars must not be negative") + if self.outer_train_bars < self.min_train_bars: + raise ValueError("outer_train_bars is smaller than min_train_bars") + if self.inner_train_bars < self.min_train_bars: + raise ValueError("inner_train_bars is smaller than min_train_bars") + + @classmethod + def exploratory(cls) -> NestedValidationConfig: + return cls( + outer_train_bars=126, + outer_test_bars=63, + outer_step_bars=63, + inner_train_bars=63, + inner_test_bars=21, + inner_step_bars=21, + purge_bars=30, + embargo_bars=5, + min_train_bars=63, + ) + + @classmethod + def balanced(cls) -> NestedValidationConfig: + return cls() + + @classmethod + def strict(cls) -> NestedValidationConfig: + return cls( + outer_train_bars=756, + outer_test_bars=126, + outer_step_bars=126, + inner_train_bars=504, + inner_test_bars=63, + inner_step_bars=63, + purge_bars=30, + embargo_bars=5, + min_train_bars=126, + ) + + +def validation_config_for_profile(profile: str) -> NestedValidationConfig: + if profile not in {"exploratory", "balanced", "strict"}: + raise ValueError(f"unknown mining profile: {profile}") + return getattr(NestedValidationConfig, profile)() + + +def required_outer_folds(profile: str) -> int: + validation_config_for_profile(profile) + return 1 if profile == "exploratory" else 3 + + +def required_trading_bars( + config: NestedValidationConfig, + outer_folds: int, +) -> int: + if outer_folds <= 0: + raise ValueError("outer_folds must be positive") + return ( + config.outer_train_bars + + config.purge_bars + + config.outer_test_bars + + (outer_folds - 1) * config.outer_step_bars + ) + + +def nested_fold_count( + trading_bars: int, + config: NestedValidationConfig, +) -> int: + if trading_bars < 0: + raise ValueError("trading_bars must not be negative") + one_fold_bars = required_trading_bars(config, 1) + if trading_bars < one_fold_bars: + return 0 + return 1 + (trading_bars - one_fold_bars) // config.outer_step_bars + + +@dataclass(frozen=True) +class CandidateGateResult(JsonDataclassMixin): + qualified: bool + reasons: tuple[str, ...] + + +def evaluate_candidate_gate( + *, + confidence: str | None, + valid_folds: int | None, + positive_fold_ratio: float | None, + sharpe: float | None, + max_drawdown: float | None, + n_trades: int | None, +) -> CandidateGateResult: + """Check the documented promotion thresholds against real candidate evidence.""" + reasons: list[str] = [] + if confidence == "low": + reasons.append("exploratory results can only be saved as pending candidates") + if valid_folds is None or valid_folds < GATE_MIN_VALID_FOLDS: + reasons.append( + "requires at least " + f"{GATE_MIN_VALID_FOLDS} valid outer folds (got " + f"{'none' if valid_folds is None else valid_folds})" + ) + if positive_fold_ratio is None or positive_fold_ratio < GATE_MIN_POSITIVE_FOLD_RATIO: + reasons.append( + "requires a positive-return fold ratio of at least " + f"{GATE_MIN_POSITIVE_FOLD_RATIO:.2f}" + ) + if sharpe is None or sharpe < GATE_MIN_OOS_SHARPE: + reasons.append(f"requires an OOS Sharpe of at least {GATE_MIN_OOS_SHARPE}") + if max_drawdown is None or max_drawdown < GATE_MAX_DRAWDOWN: + reasons.append( + f"requires a max drawdown no worse than {abs(GATE_MAX_DRAWDOWN):.0%}" + ) + if n_trades is None or n_trades < GATE_MIN_TRADES: + reasons.append(f"requires at least {GATE_MIN_TRADES} OOS trades") + return CandidateGateResult(qualified=not reasons, reasons=tuple(reasons)) + + +@dataclass(frozen=True) +class MiningRequest(JsonDataclassMixin): + factor_names: tuple[str, ...] + existing_strategy_ids: tuple[str, ...] = () + correlation_threshold: float = 0.8 + date_column: str = "date" + target_column: str = "_next_return" + budget: MiningBudget = field(default_factory=MiningBudget.balanced) + validation: NestedValidationConfig = field( + default_factory=NestedValidationConfig.balanced + ) + profile: Literal["exploratory", "balanced", "strict"] = "balanced" + + def __post_init__(self) -> None: + if not self.factor_names: + raise ValueError("factor_names must not be empty") + if len(set(self.factor_names)) != len(self.factor_names): + raise ValueError("factor_names must not contain duplicates") + if len(self.factor_names) > self.budget.max_factors: + raise ValueError( + f"factor count {len(self.factor_names)} exceeds budget " + f"{self.budget.max_factors}" + ) + if len(set(self.existing_strategy_ids)) != len(self.existing_strategy_ids): + raise ValueError("existing_strategy_ids must not contain duplicates") + if len(self.existing_strategy_ids) > self.budget.max_existing_strategies: + raise ValueError( + f"existing strategy count {len(self.existing_strategy_ids)} exceeds " + f"budget {self.budget.max_existing_strategies}" + ) + if not 0.0 < self.correlation_threshold <= 1.0: + raise ValueError("correlation_threshold must be in (0, 1]") + if not self.date_column or not self.target_column: + raise ValueError("date_column and target_column must not be empty") + + @classmethod + def for_profile( + cls, + profile: Literal["exploratory", "balanced", "strict"], + factor_names: Sequence[str], + existing_strategy_ids: Sequence[str] = (), + **kwargs: Any, + ) -> MiningRequest: + if profile not in {"exploratory", "balanced", "strict"}: + raise ValueError(f"unknown mining profile: {profile}") + return cls( + factor_names=tuple(factor_names), + existing_strategy_ids=tuple(existing_strategy_ids), + budget=getattr(MiningBudget, profile)(), + validation=getattr(NestedValidationConfig, profile)(), + profile=profile, + **kwargs, + ) + + +@dataclass(frozen=True) +class FactorMetric(JsonDataclassMixin): + factor_id: str + composite_score: float + ir: float + coverage: float + turnover: float + rank_ic: float = 0.0 + + +@dataclass(frozen=True) +class CorrelationResult(JsonDataclassMixin): + factor_names: tuple[str, ...] + matrix: tuple[tuple[float, ...], ...] + pair_counts: tuple[tuple[int, ...], ...] + elapsed_ms: float + n_dates: int + n_rows: int + timing_ms: dict[str, float] = field(default_factory=dict) + + +@dataclass(frozen=True) +class FactorExclusion(JsonDataclassMixin): + factor_id: str + reason: str + representative: str + rho: float + + +@dataclass(frozen=True) +class PruneResult(JsonDataclassMixin): + selected: tuple[str, ...] + excluded: tuple[FactorExclusion, ...] + + +@dataclass(frozen=True) +class MiningCandidate(JsonDataclassMixin): + candidate_id: str + kind: Literal["factor_rank", "existing_strategy"] + factor_names: tuple[str, ...] = () + weights: tuple[float, ...] = () + directions: tuple[int, ...] = () + strategy_id: str | None = None + proxy_rank_ic: float = 0.0 + proxy_ir: float = 0.0 + observations: int = 0 + dates: int = 0 + + def definition(self) -> dict[str, Any]: + if self.kind == "existing_strategy": + return {"kind": self.kind, "strategy_id": self.strategy_id} + return { + "kind": self.kind, + "factor_names": list(self.factor_names), + "scoring": dict(zip(self.factor_names, self.weights, strict=True)), + "directions": { + factor_id: "high" if direction > 0 else "low" + for factor_id, direction in zip( + self.factor_names, + self.directions, + strict=True, + ) + }, + } + + +@dataclass(frozen=True) +class BeamSearchResult(JsonDataclassMixin): + candidates: tuple[MiningCandidate, ...] + trials_used: int + cancelled: bool + budget_exhausted: bool + elapsed_ms: float + + +@dataclass(frozen=True) +class ValidationFold(JsonDataclassMixin): + level: Literal["outer", "inner"] + outer_index: int + inner_index: int | None + train_labels: tuple[str, ...] + purge_labels: tuple[str, ...] + test_labels: tuple[str, ...] + embargo_labels: tuple[str, ...] + + @property + def train_start(self) -> str: + return self.train_labels[0] + + @property + def train_end(self) -> str: + return self.train_labels[-1] + + @property + def test_start(self) -> str: + return self.test_labels[0] + + @property + def test_end(self) -> str: + return self.test_labels[-1] + + +@dataclass(frozen=True) +class NestedFold(JsonDataclassMixin): + outer: ValidationFold + inner: tuple[ValidationFold, ...] + + +@dataclass(frozen=True) +class CandidateEvaluation(JsonDataclassMixin): + score: float | None + metrics: dict[str, Any] = field(default_factory=dict) + error: str | None = None + + +@dataclass(frozen=True) +class FoldMiningResult(JsonDataclassMixin): + outer_index: int + selected_factors: tuple[str, ...] + candidates: tuple[MiningCandidate, ...] + selected_candidate_id: str | None + inner_score: float | None + outer_evaluation: CandidateEvaluation | None + error: str | None = None + benchmark_evaluations: tuple[tuple[str, CandidateEvaluation], ...] = () + cross_evaluations: tuple[tuple[str, CandidateEvaluation], ...] = () + + +@dataclass(frozen=True) +class MiningResult(JsonDataclassMixin): + request: MiningRequest + folds: tuple[FoldMiningResult, ...] + proxy_trials_used: int + trials_used: int + cancelled: bool + elapsed_ms: float + + +class CandidateEvaluator(Protocol): + def evaluate_candidate( + self, + train: pl.DataFrame, + test: pl.DataFrame, + definition: Mapping[str, Any], + ) -> CandidateEvaluation | Mapping[str, Any] | float: ... + + +class FactorMetricProvider(Protocol): + def __call__( + self, + train: pl.DataFrame, + factor_names: Sequence[str], + ) -> Sequence[FactorMetric]: ... + + +CancelCheck = Callable[[], bool] | Any + + +def compute_rank_correlation( + panel: pl.DataFrame, + factor_names: Sequence[str], + start: Any | None = None, + end: Any | None = None, + *, + date_column: str = "date", +) -> CorrelationResult: + """Average pairwise daily cross-sectional rank correlations. + + One date partition is ranked and materialized at a time. Only the factor-by-factor + correlation sums and valid-day counts remain resident across dates. + """ + started = time.perf_counter() + names = _validate_factor_names(panel, factor_names) + if date_column not in panel.columns: + raise ValueError(f"panel is missing date column {date_column!r}") + + filter_started = time.perf_counter() + date_expr = pl.col(date_column).cast(pl.Utf8).str.slice(0, 10) + scoped = panel.select([ + pl.col(date_column), + *( + pl.when(pl.col(name).is_finite()) + .then(pl.col(name)) + .otherwise(None) + .alias(name) + for name in names + ), + ]) + if start is not None: + scoped = scoped.filter(date_expr >= str(start)[:10]) + if end is not None: + scoped = scoped.filter(date_expr <= str(end)[:10]) + if scoped.is_empty(): + raise ValueError("rank correlation date range contains no panel rows") + filter_ms = (time.perf_counter() - filter_started) * 1000.0 + + width = len(names) + pair_columns: dict[tuple[int, int], str] = {} + pair_expressions: list[pl.Expr] = [] + for left in range(width): + for right in range(left + 1, width): + column = f"_rho_{left}_{right}" + pair_columns[(left, right)] = column + pair_expressions.append( + pl.corr(names[left], names[right], method="spearman").alias(column) + ) + observation_columns = [f"_n_{index}" for index in range(width)] + + rank_started = time.perf_counter() + daily = scoped.group_by(date_column).agg([ + *pair_expressions, + *( + pl.col(name).count().alias(column) + for name, column in zip(names, observation_columns, strict=True) + ), + ]) + rank_ms = (time.perf_counter() - rank_started) * 1000.0 + + finish_started = time.perf_counter() + correlation = np.full((width, width), np.nan, dtype=np.float64) + counts = np.zeros((width, width), dtype=np.int32) + for (left, right), column in pair_columns.items(): + values = daily.get_column(column).to_numpy() + finite = np.isfinite(values) + count = int(np.count_nonzero(finite)) + if count: + value = float(np.mean(values[finite])) + correlation[left, right] = correlation[right, left] = value + counts[left, right] = counts[right, left] = count + for index, column in enumerate(observation_columns): + count = int(np.count_nonzero(daily.get_column(column).to_numpy() >= 2)) + if count: + correlation[index, index] = 1.0 + counts[index, index] = count + finish_ms = (time.perf_counter() - finish_started) * 1000.0 + n_dates = daily.height + elapsed_ms = (time.perf_counter() - started) * 1000.0 + timing = { + "filter": round(filter_ms, 3), + "rank_accumulate": round(rank_ms, 3), + "finalize": round(finish_ms, 3), + "total": round(elapsed_ms, 3), + } + logger.info( + "mining rank correlation factors=%d rows=%d dates=%d elapsed_ms=%.1f", + width, + scoped.height, + n_dates, + elapsed_ms, + ) + return CorrelationResult( + factor_names=names, + matrix=tuple(tuple(float(value) for value in row) for row in correlation), + pair_counts=tuple( + tuple(int(value) for value in row) + for row in counts + ), + elapsed_ms=round(elapsed_ms, 3), + n_dates=n_dates, + n_rows=scoped.height, + timing_ms=timing, + ) + + +def prune_correlated_factors( + metrics: Sequence[FactorMetric], + correlation: CorrelationResult, + threshold: float, +) -> PruneResult: + """Keep the strongest deterministic representative of correlated factors.""" + if not 0.0 < threshold <= 1.0: + raise ValueError("correlation threshold must be in (0, 1]") + by_name = {name: index for index, name in enumerate(correlation.factor_names)} + if len({metric.factor_id for metric in metrics}) != len(metrics): + raise ValueError("factor metrics must not contain duplicate factor_id values") + missing = sorted(metric.factor_id for metric in metrics if metric.factor_id not in by_name) + if missing: + raise ValueError(f"factor metrics missing from correlation result: {missing}") + + ordered = sorted( + metrics, + key=lambda metric: ( + -_finite_sort_value(metric.composite_score), + -_finite_sort_value(metric.ir), + -_finite_sort_value(metric.coverage), + _finite_sort_value(metric.turnover, worst=float("inf")), + metric.factor_id, + ), + ) + selected: list[str] = [] + excluded: list[FactorExclusion] = [] + for metric in ordered: + factor_index = by_name[metric.factor_id] + correlated = [ + (representative, correlation.matrix[factor_index][by_name[representative]]) + for representative in selected + if ( + correlation.pair_counts[factor_index][by_name[representative]] > 0 + and math.isfinite( + correlation.matrix[factor_index][by_name[representative]] + ) + and abs( + correlation.matrix[factor_index][by_name[representative]] + ) >= threshold + ) + ] + if not correlated: + selected.append(metric.factor_id) + continue + representative, rho = max( + correlated, + key=lambda item: (abs(item[1]), -selected.index(item[0])), + ) + excluded.append(FactorExclusion( + factor_id=metric.factor_id, + reason="correlation_threshold", + representative=representative, + rho=round(float(rho), 8), + )) + return PruneResult(selected=tuple(selected), excluded=tuple(excluded)) + + +def beam_search_factor_combinations( + panel: pl.DataFrame, + factor_names: Sequence[str], + *, + target_column: str = "_next_return", + date_column: str = "date", + train_start: Any | None = None, + train_end: Any | None = None, + max_combination_size: int = MAX_COMBINATION_SIZE, + beam_width: int = 16, + max_trials: int = 256, + cancel_check: CancelCheck | None = None, +) -> BeamSearchResult: + """Search equal and one-factor-double rank combinations on training data only.""" + started = time.perf_counter() + names = _validate_factor_names(panel, factor_names) + if target_column not in panel.columns: + raise ValueError(f"panel is missing target column {target_column!r}") + if date_column not in panel.columns: + raise ValueError(f"panel is missing date column {date_column!r}") + if not 1 <= max_combination_size <= MAX_COMBINATION_SIZE: + raise ValueError( + f"max_combination_size must be between 1 and {MAX_COMBINATION_SIZE}" + ) + if not 1 <= beam_width <= MAX_BEAM_WIDTH: + raise ValueError(f"beam_width must be between 1 and {MAX_BEAM_WIDTH}") + if max_trials <= 0: + raise ValueError("max_trials must be positive") + + date_expr = pl.col(date_column).cast(pl.Utf8).str.slice(0, 10) + scoped = panel.select([date_column, *names, target_column]) + if train_start is not None: + scoped = scoped.filter(date_expr >= str(train_start)[:10]) + if train_end is not None: + scoped = scoped.filter(date_expr <= str(train_end)[:10]) + if scoped.is_empty(): + raise ValueError("beam search training range contains no panel rows") + + ordered_names = tuple(sorted(names)) + name_to_column = {name: index for index, name in enumerate(ordered_names)} + if not scoped.get_column(date_column).is_sorted(): + scoped = scoped.sort(date_column) + blocks = tuple( + daily.select([*ordered_names, target_column]).to_numpy() + for daily in scoped.partition_by(date_column, maintain_order=True) + ) + trials_used = 0 + cancelled = False + + def evaluate( + factors: tuple[str, ...], + weights: tuple[float, ...], + directions: tuple[int, ...], + ) -> tuple[float, float, int, int] | None: + nonlocal trials_used, cancelled + if trials_used >= max_trials: + return None + if _cancelled(cancel_check): + cancelled = True + return None + trials_used += 1 + columns = tuple(name_to_column[name] for name in factors) + return _proxy_rank_ic(blocks, columns, weights, directions) + + directions_by_factor: dict[str, int] = {} + single_candidates: list[MiningCandidate] = [] + for factor_name in ordered_names: + proxy = evaluate((factor_name,), (1.0,), (1,)) + if proxy is None: + break + rank_ic, proxy_ir, observations, n_dates = proxy + if n_dates <= 0 or observations < 3: + continue + direction = 1 if rank_ic >= 0.0 else -1 + directions_by_factor[factor_name] = direction + single_candidates.append(_factor_candidate( + (factor_name,), + (1.0,), + (direction,), + abs(rank_ic), + abs(proxy_ir), + observations, + n_dates, + )) + + current_beam = _rank_candidates(single_candidates)[:beam_width] + retained = list(current_beam) + searchable_names = tuple(sorted(directions_by_factor)) + max_size = min(max_combination_size, len(searchable_names)) + for size in range(2, max_size + 1): + if cancelled or trials_used >= max_trials or not current_beam: + break + factor_sets: set[tuple[str, ...]] = set() + for candidate in current_beam: + for factor_name in searchable_names: + combined = tuple(sorted({*candidate.factor_names, factor_name})) + if len(combined) == size: + factor_sets.add(combined) + + expanded: list[MiningCandidate] = [] + stop = False + for factors in sorted(factor_sets): + directions = tuple(directions_by_factor[name] for name in factors) + patterns = [(1.0,) * size] + patterns.extend( + tuple(2.0 if index == doubled else 1.0 for index in range(size)) + for doubled in range(size) + ) + for weights in patterns: + proxy = evaluate(factors, weights, directions) + if proxy is None: + stop = True + break + rank_ic, proxy_ir, observations, n_dates = proxy + if n_dates <= 0 or observations < 3: + continue + expanded.append(_factor_candidate( + factors, + weights, + directions, + rank_ic, + proxy_ir, + observations, + n_dates, + )) + if stop: + break + current_beam = _rank_candidates(expanded)[:beam_width] + retained.extend(current_beam) + if stop: + break + + elapsed_ms = (time.perf_counter() - started) * 1000.0 + return BeamSearchResult( + candidates=tuple(_rank_candidates(retained)), + trials_used=trials_used, + cancelled=cancelled, + budget_exhausted=trials_used >= max_trials, + elapsed_ms=round(elapsed_ms, 3), + ) + + +def generate_nested_folds( + trading_labels: Sequence[Any], + config: NestedValidationConfig, +) -> tuple[NestedFold, ...]: + """Generate rolling nested folds from ordered trading labels, not calendar days.""" + labels = tuple(dict.fromkeys(str(label) for label in trading_labels)) + if not labels: + raise ValueError("trading labels are empty") + if tuple(sorted(labels)) != labels: + raise ValueError("trading labels must be sorted in ascending order") + outer_required = ( + config.outer_train_bars + config.purge_bars + config.outer_test_bars + ) + if len(labels) < outer_required: + raise ValueError( + "insufficient trading bars for outer validation: " + f"need at least {outer_required}, got {len(labels)}" + ) + inner_required = ( + config.inner_train_bars + config.purge_bars + config.inner_test_bars + ) + if config.outer_train_bars < inner_required: + raise ValueError( + "outer training window is too short for one inner fold: " + f"need at least {inner_required}, got {config.outer_train_bars}" + ) + + nested: list[NestedFold] = [] + outer_start = 0 + outer_index = 0 + while outer_start + outer_required <= len(labels): + outer = _make_validation_fold( + labels, + level="outer", + outer_index=outer_index, + inner_index=None, + train_start=outer_start, + train_bars=config.outer_train_bars, + test_bars=config.outer_test_bars, + purge_bars=config.purge_bars, + embargo_bars=config.embargo_bars, + ) + inner_folds: list[ValidationFold] = [] + inner_start = outer_start + inner_index = 0 + outer_train_stop = outer_start + config.outer_train_bars + while inner_start + inner_required <= outer_train_stop: + inner_folds.append(_make_validation_fold( + labels, + level="inner", + outer_index=outer_index, + inner_index=inner_index, + train_start=inner_start, + train_bars=config.inner_train_bars, + test_bars=config.inner_test_bars, + purge_bars=config.purge_bars, + embargo_bars=config.embargo_bars, + hard_stop=outer_train_stop, + )) + inner_index += 1 + inner_start += config.inner_step_bars + if not inner_folds: + raise ValueError(f"outer fold {outer_index} contains no valid inner fold") + nested.append(NestedFold(outer=outer, inner=tuple(inner_folds))) + outer_index += 1 + outer_start += config.outer_step_bars + return tuple(nested) + + +class MiningService: + """Run leakage-bounded mining and delegate real backtests to a callback.""" + + def run( + self, + panel: pl.DataFrame, + request: MiningRequest, + *, + factor_metrics: Sequence[FactorMetric] | None = None, + metric_provider: FactorMetricProvider | None = None, + evaluator: CandidateEvaluator | None = None, + cancel_check: CancelCheck | None = None, + ) -> MiningResult: + started = time.perf_counter() + _validate_factor_names(panel, request.factor_names) + required = {request.date_column, request.target_column} + missing = sorted(required - set(panel.columns)) + if missing: + raise ValueError(f"mining panel is missing required columns: {missing}") + if evaluator is not None: + if factor_metrics is not None: + raise ValueError("factor_metrics must not be supplied with evaluator") + if metric_provider is None: + raise ValueError("metric_provider is required when evaluator is supplied") + elif metric_provider is None and factor_metrics is None: + raise ValueError("factor_metrics or metric_provider is required") + + labels = panel.select( + pl.col(request.date_column).cast(pl.Utf8).str.slice(0, 10).unique().sort() + ).to_series().to_list() + nested_folds = generate_nested_folds(labels, request.validation) + if request.profile != "exploratory" and len(nested_folds) < 3: + raise ValueError( + f"{request.profile} mining requires at least 3 outer folds; " + f"got {len(nested_folds)}" + ) + fold_results: list[FoldMiningResult] = [] + proxy_trials_used = 0 + trials_used = 0 + cancelled = False + labels_evaluator = ( + getattr(evaluator, "evaluate_candidate_labels", None) + if evaluator is not None + else None + ) + + def run_benchmarks(nested_fold) -> tuple[tuple[str, CandidateEvaluation], ...]: + """Score every user-selected strategy on one outer test window. + + Benchmarks document how existing strategies would have done on the + same walk-forward windows, so they are evaluated even when the + factor track fails on this fold and never join the winner race. + """ + nonlocal trials_used, cancelled + if evaluator is None: + return () + benchmarks: list[tuple[str, CandidateEvaluation]] = [] + for strategy_id in request.existing_strategy_ids: + if _cancelled(cancel_check): + cancelled = True + break + if trials_used >= request.budget.max_trials: + benchmarks.append(( + _benchmark_signature(strategy_id), + CandidateEvaluation( + score=None, + error="real trial budget exhausted before benchmark evaluation", + ), + )) + continue + benchmark = benchmark_candidate(strategy_id) + if callable(labels_evaluator): + benchmark_evaluation = _evaluate_labels( + labels_evaluator, + nested_fold.outer.train_labels, + nested_fold.outer.test_labels, + benchmark, + ) + else: + benchmark_evaluation = _evaluate( + evaluator, + _train_panel_for_fold(panel, request.date_column, nested_fold.outer), + _panel_for_labels(panel, request.date_column, nested_fold.outer.test_labels), + benchmark, + ) + trials_used += 1 + benchmarks.append((benchmark.candidate_id, benchmark_evaluation)) + return tuple(benchmarks) + + if evaluator is None: + selection_phases_remaining = len(nested_folds) + evaluation_phases_remaining = 0 + else: + selection_phases_remaining = sum( + len(nested.inner) + 1 for nested in nested_folds + ) + evaluation_phases_remaining = selection_phases_remaining + + for nested in nested_folds: + if _cancelled(cancel_check): + cancelled = True + break + + if evaluator is None: + outer_train = _train_panel_for_fold( + panel, + request.date_column, + nested.outer, + ) + metrics = tuple( + metric_provider(outer_train, request.factor_names) + if metric_provider is not None + else factor_metrics or () + ) + correlation = compute_rank_correlation( + outer_train, + request.factor_names, + date_column=request.date_column, + ) + pruned = prune_correlated_factors( + metrics, + correlation, + request.correlation_threshold, + ) + proxy_remaining = request.budget.max_proxy_trials - proxy_trials_used + if proxy_remaining <= 0: + fold_results.append(FoldMiningResult( + outer_index=nested.outer.outer_index, + selected_factors=pruned.selected, + candidates=(), + selected_candidate_id=None, + inner_score=None, + outer_evaluation=None, + error="proxy trial budget exhausted", + )) + break + proxy_allowance = max( + 1, + proxy_remaining // selection_phases_remaining, + ) + beam = beam_search_factor_combinations( + outer_train, + _searchable_factors(pruned.selected, request.budget), + target_column=request.target_column, + date_column=request.date_column, + max_combination_size=request.budget.max_combination_size, + beam_width=request.budget.beam_width, + max_trials=proxy_allowance, + cancel_check=cancel_check, + ) + proxy_trials_used += beam.trials_used + selection_phases_remaining -= 1 + candidates = beam.candidates + fold_results.append(FoldMiningResult( + outer_index=nested.outer.outer_index, + selected_factors=pruned.selected, + candidates=tuple(candidates), + selected_candidate_id=None, + inner_score=None, + outer_evaluation=None, + )) + continue + + winners: list[tuple[float, MiningCandidate]] = [] + all_candidates: dict[str, MiningCandidate] = {} + selected_factor_union: set[str] = set() + for inner in nested.inner: + if _cancelled(cancel_check): + cancelled = True + break + inner_train = _train_panel_for_fold( + panel, + request.date_column, + inner, + ) + inner_test = _panel_for_labels( + panel, + request.date_column, + inner.test_labels, + ) + metrics = tuple( + metric_provider(inner_train, request.factor_names) + if metric_provider is not None + else factor_metrics or () + ) + correlation = compute_rank_correlation( + inner_train, + request.factor_names, + date_column=request.date_column, + ) + pruned = prune_correlated_factors( + metrics, + correlation, + request.correlation_threshold, + ) + selected_factor_union.update(pruned.selected) + + proxy_remaining = request.budget.max_proxy_trials - proxy_trials_used + if proxy_remaining <= 0: + break + proxy_allowance = max( + 1, + proxy_remaining // selection_phases_remaining, + ) + beam = beam_search_factor_combinations( + inner_train, + _searchable_factors(pruned.selected, request.budget), + target_column=request.target_column, + date_column=request.date_column, + max_combination_size=request.budget.max_combination_size, + beam_width=request.budget.beam_width, + max_trials=proxy_allowance, + cancel_check=cancel_check, + ) + proxy_trials_used += beam.trials_used + selection_phases_remaining -= 1 + candidates = beam.candidates + for candidate in candidates: + all_candidates[candidate.candidate_id] = candidate + + real_remaining = request.budget.max_trials - trials_used + if real_remaining <= 0: + break + real_allowance = min( + MAX_FINALISTS, + max(1, real_remaining // evaluation_phases_remaining), + ) + evaluated: list[tuple[float, MiningCandidate]] = [] + for candidate in candidates[:real_allowance]: + evaluation = ( + _evaluate_labels( + labels_evaluator, + inner.train_labels, + inner.test_labels, + candidate, + ) + if callable(labels_evaluator) + else _evaluate( + evaluator, + inner_train, + inner_test, + candidate, + ) + ) + trials_used += 1 + if evaluation.error is None and evaluation.score is not None: + evaluated.append((evaluation.score, candidate)) + evaluation_phases_remaining -= 1 + if evaluated: + winners.append(min( + evaluated, + key=lambda item: (-item[0], item[1].candidate_id), + )) + + if cancelled: + break + if not winners: + fold_results.append(FoldMiningResult( + outer_index=nested.outer.outer_index, + selected_factors=tuple(sorted(selected_factor_union)), + candidates=tuple(_rank_candidates(list(all_candidates.values()))), + selected_candidate_id=None, + inner_score=None, + outer_evaluation=None, + error="no candidate completed inner validation within budget", + benchmark_evaluations=run_benchmarks(nested), + )) + break + + by_candidate: dict[str, list[float]] = {} + for score, candidate in winners: + by_candidate.setdefault(candidate.candidate_id, []).append(score) + selected_id, selected_scores = min( + by_candidate.items(), + key=lambda item: (-len(item[1]), -float(np.mean(item[1])), item[0]), + ) + voted_candidate = all_candidates[selected_id] + inner_score = float(np.mean(selected_scores)) + if not callable(labels_evaluator): + del inner_train, inner_test + + outer_train = _train_panel_for_fold( + panel, + request.date_column, + nested.outer, + ) + outer_metrics = tuple( + metric_provider(outer_train, request.factor_names) + if metric_provider is not None + else factor_metrics or () + ) + outer_correlation = compute_rank_correlation( + outer_train, + request.factor_names, + date_column=request.date_column, + ) + outer_pruned = prune_correlated_factors( + outer_metrics, + outer_correlation, + request.correlation_threshold, + ) + proxy_remaining = request.budget.max_proxy_trials - proxy_trials_used + if proxy_remaining <= 0: + fold_results.append(FoldMiningResult( + outer_index=nested.outer.outer_index, + selected_factors=outer_pruned.selected, + candidates=tuple(_rank_candidates(list(all_candidates.values()))), + selected_candidate_id=None, + inner_score=round(inner_score, 8), + outer_evaluation=None, + error="proxy trial budget exhausted before outer retraining", + benchmark_evaluations=run_benchmarks(nested), + )) + break + proxy_allowance = max( + 1, + proxy_remaining // selection_phases_remaining, + ) + outer_beam = beam_search_factor_combinations( + outer_train, + _searchable_factors(outer_pruned.selected, request.budget), + target_column=request.target_column, + date_column=request.date_column, + max_combination_size=request.budget.max_combination_size, + beam_width=request.budget.beam_width, + max_trials=proxy_allowance, + cancel_check=cancel_check, + ) + proxy_trials_used += outer_beam.trials_used + selection_phases_remaining -= 1 + outer_candidates = outer_beam.candidates + by_refit_key = { + _candidate_refit_key(candidate): candidate + for candidate in outer_candidates + } + selected = by_refit_key.get(_candidate_refit_key(voted_candidate)) + if selected is None: + fold_results.append(FoldMiningResult( + outer_index=nested.outer.outer_index, + selected_factors=outer_pruned.selected, + candidates=outer_candidates, + selected_candidate_id=None, + inner_score=round(inner_score, 8), + outer_evaluation=None, + error=( + "outer retraining did not reproduce selected candidate structure" + if outer_candidates + else "outer training produced no candidate" + ), + benchmark_evaluations=run_benchmarks(nested), + )) + break + + if trials_used >= request.budget.max_trials: + fold_results.append(FoldMiningResult( + outer_index=nested.outer.outer_index, + selected_factors=outer_pruned.selected, + candidates=outer_candidates, + selected_candidate_id=selected.candidate_id, + inner_score=round(inner_score, 8), + outer_evaluation=None, + error="real trial budget exhausted before outer evaluation", + benchmark_evaluations=run_benchmarks(nested), + )) + break + outer_test = _panel_for_labels( + panel, + request.date_column, + nested.outer.test_labels, + ) + if callable(labels_evaluator): + del outer_train, outer_test + outer_evaluation = _evaluate_labels( + labels_evaluator, + nested.outer.train_labels, + nested.outer.test_labels, + selected, + ) + else: + outer_evaluation = _evaluate( + evaluator, + outer_train, + outer_test, + selected, + ) + trials_used += 1 + evaluation_phases_remaining -= 1 + fold_results.append(FoldMiningResult( + outer_index=nested.outer.outer_index, + selected_factors=outer_pruned.selected, + candidates=outer_candidates, + selected_candidate_id=selected.candidate_id, + inner_score=round(inner_score, 8), + outer_evaluation=outer_evaluation, + benchmark_evaluations=run_benchmarks(nested), + )) + if cancelled: + break + if trials_used >= request.budget.max_trials: + break + + if not cancelled and evaluator is not None: + winner_union: dict[str, MiningCandidate] = {} + for fold in fold_results: + if fold.selected_candidate_id is None: + continue + if fold.selected_candidate_id in winner_union: + continue + winner = next( + ( + candidate + for candidate in fold.candidates + if candidate.candidate_id == fold.selected_candidate_id + ), + None, + ) + if winner is not None: + winner_union[winner.candidate_id] = winner + if len(winner_union) > 1: + extended_folds: list[FoldMiningResult] = [] + for nested, fold in zip(nested_folds, fold_results, strict=False): + cross: list[tuple[str, CandidateEvaluation]] = [] + for candidate_id, candidate in winner_union.items(): + if candidate_id == fold.selected_candidate_id: + continue + if trials_used >= request.budget.max_trials: + cross.append(( + candidate_id, + CandidateEvaluation( + score=None, + error=( + "real trial budget exhausted before " + "cross-fold evaluation" + ), + ), + )) + continue + if callable(labels_evaluator): + evaluation = _evaluate_labels( + labels_evaluator, + nested.outer.train_labels, + nested.outer.test_labels, + candidate, + ) + else: + cross_train = _train_panel_for_fold( + panel, + request.date_column, + nested.outer, + ) + cross_test = _panel_for_labels( + panel, + request.date_column, + nested.outer.test_labels, + ) + evaluation = _evaluate( + evaluator, + cross_train, + cross_test, + candidate, + ) + trials_used += 1 + cross.append((candidate_id, evaluation)) + extended_folds.append(replace( + fold, + cross_evaluations=tuple(cross), + )) + fold_results = extended_folds + + return MiningResult( + request=request, + folds=tuple(fold_results), + proxy_trials_used=proxy_trials_used, + trials_used=trials_used, + cancelled=cancelled, + elapsed_ms=round((time.perf_counter() - started) * 1000.0, 3), + ) + + +def _validate_factor_names( + panel: pl.DataFrame, + factor_names: Sequence[str], +) -> tuple[str, ...]: + names = tuple(str(name) for name in factor_names) + if not names: + raise ValueError("factor_names must not be empty") + if len(names) > MAX_MINING_FACTORS: + raise ValueError(f"factor count exceeds hard limit {MAX_MINING_FACTORS}") + if len(set(names)) != len(names): + raise ValueError("factor_names must not contain duplicates") + missing = sorted(set(names) - set(panel.columns)) + if missing: + raise ValueError(f"panel is missing factor columns: {missing}") + return names + + +def _finite_sort_value(value: float, *, worst: float = float("-inf")) -> float: + try: + number = float(value) + except (TypeError, ValueError): + return worst + return number if math.isfinite(number) else worst + + +def _average_rank(values: np.ndarray) -> np.ndarray: + order = np.argsort(values, kind="stable") + ordered = values[order] + boundaries = np.concatenate(( + np.array([0]), + np.flatnonzero(ordered[1:] != ordered[:-1]) + 1, + np.array([len(ordered)]), + )) + counts = np.diff(boundaries) + average = (boundaries[:-1] + 1 + boundaries[1:]) / 2.0 + ranked = np.empty(len(values), dtype=np.float64) + ranked[order] = np.repeat(average, counts) + return ranked + + +def _proxy_rank_ic( + blocks: Sequence[np.ndarray], + columns: tuple[int, ...], + weights: tuple[float, ...], + directions: tuple[int, ...], +) -> tuple[float, float, int, int]: + daily_ics: list[float] = [] + observations = 0 + weight_values = np.asarray(weights, dtype=np.float64) + direction_values = np.asarray(directions, dtype=np.float64) + for block in blocks: + factors = block[:, columns].astype(np.float64, copy=False) + target = block[:, -1].astype(np.float64, copy=False) + valid = np.isfinite(target) & np.isfinite(factors).all(axis=1) + count = int(np.count_nonzero(valid)) + if count < 3: + continue + factor_values = factors[valid] + factor_ranks = np.column_stack([ + _average_rank(factor_values[:, index]) + for index in range(factor_values.shape[1]) + ]) + composite = (factor_ranks * direction_values) @ weight_values + composite_rank = _average_rank(composite) + target_rank = _average_rank(target[valid]) + if np.std(composite_rank) <= 0.0 or np.std(target_rank) <= 0.0: + continue + rho = float(np.corrcoef(composite_rank, target_rank)[0, 1]) + if math.isfinite(rho): + daily_ics.append(rho) + observations += count + if not daily_ics: + return 0.0, 0.0, observations, 0 + values = np.asarray(daily_ics, dtype=np.float64) + mean = float(np.mean(values)) + std = float(np.std(values)) + ir = mean / std if std > 1e-12 else 0.0 + return mean, ir, observations, len(daily_ics) + + +def compute_candidate_signature(definition: Mapping[str, Any]) -> str: + """Return the canonical artifact signature for a mining candidate definition.""" + kind = definition.get("kind") + if kind == "existing_strategy": + strategy_id = definition.get("strategy_id") + if not isinstance(strategy_id, str) or not strategy_id: + raise ValueError("existing strategy candidate requires strategy_id") + return f"strategy:{strategy_id}" + if kind != "factor_rank": + raise ValueError(f"unsupported mining candidate kind: {kind!r}") + + factor_names = definition.get("factor_names") + scoring = definition.get("scoring") + directions = definition.get("directions") + if not isinstance(factor_names, list) or not factor_names: + raise ValueError("factor candidate requires factor_names") + if not isinstance(scoring, Mapping) or set(scoring) != set(factor_names): + raise ValueError("factor candidate scoring keys must match factor_names") + if not isinstance(directions, Mapping) or set(directions) != set(factor_names): + raise ValueError("factor candidate direction keys must match factor_names") + + weights: list[str] = [] + direction_values: list[str] = [] + for factor_name in factor_names: + if not isinstance(factor_name, str) or not factor_name: + raise ValueError("factor names must be non-empty strings") + value = scoring[factor_name] + if isinstance(value, bool): + raise ValueError("factor weights must be numeric") + try: + weight = float(value) + except (TypeError, ValueError) as exc: + raise ValueError("factor weights must be numeric") from exc + if not math.isfinite(weight) or weight <= 0.0: + raise ValueError("factor weights must be finite and positive") + direction = directions[factor_name] + if direction not in {"high", "low"}: + raise ValueError("factor directions must be high or low") + weights.append(f"{weight:g}") + direction_values.append("1" if direction == "high" else "-1") + return ( + f"factor:{','.join(factor_names)}|w:{','.join(weights)}" + f"|d:{','.join(direction_values)}" + ) + + +def _factor_candidate( + factors: tuple[str, ...], + weights: tuple[float, ...], + directions: tuple[int, ...], + rank_ic: float, + proxy_ir: float, + observations: int, + dates: int, +) -> MiningCandidate: + candidate_id = compute_candidate_signature({ + "kind": "factor_rank", + "factor_names": list(factors), + "scoring": dict(zip(factors, weights, strict=True)), + "directions": { + factor_id: "high" if direction > 0 else "low" + for factor_id, direction in zip(factors, directions, strict=True) + }, + }) + return MiningCandidate( + candidate_id=candidate_id, + kind="factor_rank", + factor_names=factors, + weights=weights, + directions=directions, + proxy_rank_ic=round(float(rank_ic), 8), + proxy_ir=round(float(proxy_ir), 8), + observations=observations, + dates=dates, + ) + + +def benchmark_candidate(strategy_id: str) -> MiningCandidate: + """Build the fixed benchmark candidate for one user-selected strategy.""" + return MiningCandidate( + candidate_id=_benchmark_signature(strategy_id), + kind="existing_strategy", + strategy_id=strategy_id, + ) + + +def _benchmark_signature(strategy_id: str) -> str: + return compute_candidate_signature({ + "kind": "existing_strategy", + "strategy_id": strategy_id, + }) + + +def _searchable_factors( + selected: Sequence[str], + budget: MiningBudget, +) -> tuple[str, ...]: + """Cap beam-search inputs so singletons plus combinations fit the phase budget. + + ``selected`` arrives in training-fold metric order, so the cap keeps the + strongest factors and keeps the lexicographic singleton pass from consuming + the whole proxy allowance before any combination is scored. + """ + return tuple(selected[: max(1, budget.beam_width)]) + + +def _candidate_refit_key(candidate: MiningCandidate) -> tuple[Any, ...]: + if candidate.kind == "existing_strategy": + return (candidate.kind, candidate.strategy_id) + return (candidate.kind, candidate.factor_names, candidate.weights) + + +def _rank_candidates(candidates: Sequence[MiningCandidate]) -> list[MiningCandidate]: + return sorted( + candidates, + key=lambda candidate: ( + -candidate.proxy_rank_ic, + -candidate.proxy_ir, + candidate.candidate_id, + ), + ) + + +def _make_validation_fold( + labels: tuple[str, ...], + *, + level: Literal["outer", "inner"], + outer_index: int, + inner_index: int | None, + train_start: int, + train_bars: int, + test_bars: int, + purge_bars: int, + embargo_bars: int, + hard_stop: int | None = None, +) -> ValidationFold: + train_stop = train_start + train_bars + test_start = train_stop + purge_bars + test_stop = test_start + test_bars + embargo_stop = test_stop + embargo_bars + if hard_stop is not None: + embargo_stop = min(embargo_stop, hard_stop) + return ValidationFold( + level=level, + outer_index=outer_index, + inner_index=inner_index, + train_labels=labels[train_start:train_stop], + purge_labels=labels[train_stop:test_start], + test_labels=labels[test_start:test_stop], + embargo_labels=labels[test_stop:embargo_stop], + ) + + +def _train_panel_for_fold( + panel: pl.DataFrame, + date_column: str, + fold: ValidationFold, +) -> pl.DataFrame: + train = _panel_for_labels(panel, date_column, fold.train_labels) + if "_target_date" not in train.columns: + return train + target_date = pl.col("_target_date").cast(pl.Utf8).str.slice(0, 10) + daily = train.select(date_column, "_target_date").unique( + subset=[date_column], + maintain_order=True, + ) + allowed = daily.select( + (target_date.is_null() | (target_date <= fold.train_end)).alias("_allowed") + ).get_column("_allowed").to_list() + first_excluded = next( + (index for index, value in enumerate(allowed) if not value), + len(allowed), + ) + if not any(allowed[first_excluded:]): + return _panel_for_labels( + train, + date_column, + fold.train_labels[:first_excluded], + ) + return train.filter(target_date.is_null() | (target_date <= fold.train_end)) + + +def _panel_for_labels( + panel: pl.DataFrame, + date_column: str, + labels: Sequence[str], +) -> pl.DataFrame: + normalized = tuple(str(label)[:10] for label in labels) + if not normalized: + return panel.slice(0, 0) + values = panel.get_column(date_column) + if values.is_sorted(): + bounds: tuple[Any, Any] | None = None + if values.dtype == pl.Date: + bounds = ( + date.fromisoformat(normalized[0]), + date.fromisoformat(normalized[-1]), + ) + elif values.dtype == pl.Utf8: + bounds = (normalized[0], normalized[-1]) + if bounds is not None: + start = int(values.search_sorted(bounds[0], side="left")) + stop = int(values.search_sorted(bounds[1], side="right")) + sliced = panel.slice(start, stop - start) + actual = tuple( + str(value)[:10] + for value in sliced.get_column(date_column).unique( + maintain_order=True + ) + ) + if actual == normalized: + return sliced + date_expr = pl.col(date_column).cast(pl.Utf8).str.slice(0, 10) + return panel.filter(date_expr.is_in(normalized)) + + +def _cancelled(cancel_check: CancelCheck | None) -> bool: + if cancel_check is None: + return False + if callable(cancel_check): + return bool(cancel_check()) + is_set = getattr(cancel_check, "is_set", None) + return bool(is_set()) if callable(is_set) else False + + +def _evaluate_labels( + evaluator: Callable[ + [Sequence[str], Sequence[str], Mapping[str, Any]], + CandidateEvaluation | Mapping[str, Any] | float, + ], + train_labels: Sequence[str], + test_labels: Sequence[str], + candidate: MiningCandidate, +) -> CandidateEvaluation: + try: + raw = evaluator(train_labels, test_labels, candidate.definition()) + except Exception as exc: + return CandidateEvaluation(score=None, error=str(exc)) + return _normalize_evaluation(raw) + + +def _evaluate( + evaluator: CandidateEvaluator, + train: pl.DataFrame, + test: pl.DataFrame, + candidate: MiningCandidate, +) -> CandidateEvaluation: + try: + raw = evaluator.evaluate_candidate(train, test, candidate.definition()) + except Exception as exc: + return CandidateEvaluation(score=None, error=str(exc)) + return _normalize_evaluation(raw) + + +def _normalize_evaluation( + raw: CandidateEvaluation | Mapping[str, Any] | float, +) -> CandidateEvaluation: + if isinstance(raw, CandidateEvaluation): + return CandidateEvaluation( + score=_finite_score(raw.score), + metrics=raw.metrics, + error=raw.error, + ) + if isinstance(raw, Mapping): + score = raw.get("score") + error = raw.get("error") + metrics = raw.get("metrics", {}) + return CandidateEvaluation( + score=_finite_score(score), + metrics=dict(metrics) if isinstance(metrics, Mapping) else {}, + error=str(error) if error is not None else None, + ) + return CandidateEvaluation(score=_finite_score(raw)) + + +def _finite_score(value: Any) -> float | None: + try: + score = float(value) + except (TypeError, ValueError): + return None + return score if math.isfinite(score) else None diff --git a/backend/app/backtest/mining_runtime.py b/backend/app/backtest/mining_runtime.py new file mode 100644 index 0000000..0733d7c --- /dev/null +++ b/backend/app/backtest/mining_runtime.py @@ -0,0 +1,1489 @@ +"""Production mining runtime executed only inside a spawned worker.""" +from __future__ import annotations + +import json +import math +import os +import time +import uuid +from collections.abc import Callable, Mapping, Sequence +from dataclasses import dataclass, replace +from datetime import date, timedelta +from itertools import pairwise +from pathlib import Path +from typing import Any, Literal + +import numpy as np +import polars as pl + +from app.backtest.factor import ( + FACTOR_COLUMNS, + FACTOR_METHODOLOGY_VERSION, + FACTOR_WARMUP_DAYS, + FactorBacktestService, + FactorBatchConfig, +) +from app.backtest.fundamentals import ( + FUNDAMENTAL_FACTOR_NAMES, + attach_fundamental_factors, + load_fundamental_snapshot, +) +from app.backtest.mining import ( + MAX_FINALISTS, + CandidateEvaluation, + FactorMetric, + MiningBudget, + MiningCandidate, + MiningRequest, + MiningResult, + MiningService, + benchmark_candidate, + compute_rank_correlation, + generate_nested_folds, + required_outer_folds, + required_trading_bars, + validation_config_for_profile, +) +from app.backtest.strategy import ( + BacktestResultPolicy, + ResolvedFeaturePlan, + StrategyBacktestConfig, + StrategyBacktestService, + StrategyDependencyResolver, + _merge_resolved_feature_plans, + build_matrix_cache_profile, +) +from app.services.mining_jobs import MiningRunStore +from app.services.mining_preflight import enriched_partition_dates +from app.services.mining_schedule import MINING_ALGORITHM_VERSION +from app.strategy import config as strategy_config +from app.strategy.engine import StrategyEngine + +ProgressCallback = Callable[[dict[str, Any]], None] +CancelCheck = Callable[[], bool] | Any +_PROFILE_NAMES = frozenset({"exploratory", "balanced", "strict"}) +_FACTOR_IDS = frozenset(str(item["id"]) for item in FACTOR_COLUMNS) +_MINING_MATRIX_CACHE_BYTES = 32 * 1024 * 1024 +_RESULT_POLICY = BacktestResultPolicy( + required_stats=frozenset({"total_return", "sharpe", "max_drawdown", "n_trades"}), + include_monte_carlo=False, + include_curves=False, + include_trades=False, + include_per_symbol_stats=False, + include_return_distribution=False, + include_benchmark=False, + include_strategy_info=False, +) +_REGIME_FILTERS: dict[str, dict[str, list[str]]] = { + "strong": {"states": ["strong", "lean_strong"]}, + "range": {"states": ["range"]}, + "weak": {"states": ["lean_weak", "weak"]}, +} + + +class MiningRuntimeCancelledError(RuntimeError): + pass + + +@dataclass(frozen=True) +class RuntimeRequest: + run_id: str + factor_names: tuple[str, ...] + strategy_ids: tuple[str, ...] + symbols: list[str] | None + asset_type: Literal["stock", "etf"] + start: date + end: date + profile: Literal["exploratory", "balanced", "strict"] + forward_horizon: int + commission_pct: float + stamp_tax_pct: float + slippage_bps: float + correlation_threshold: float + max_finalists: int + require_regime: bool + mining_request: MiningRequest + + +class TrainingMetricProvider: + """Compute fold-local metrics and retain only compact call telemetry.""" + + def __init__(self, target_column: str) -> None: + self.target_column = target_column + self.calls: list[dict[str, Any]] = [] + + def __call__( + self, + train: pl.DataFrame, + factor_names: Sequence[str], + ) -> tuple[FactorMetric, ...]: + metrics = tuple( + _factor_metric(train, factor_name, self.target_column) + for factor_name in factor_names + ) + labels = _date_labels(train) + self.calls.append({ + "start": labels[0] if labels else None, + "end": labels[-1] if labels else None, + "rows": train.height, + "metrics": metrics, + }) + return metrics + + +class MatcherCandidateEvaluator: + """Evaluate one fixed definition with the production matrix matcher.""" + + def __init__( + self, + service: StrategyBacktestService, + strategy_engine: StrategyEngine, + data_dir: Path, + request: RuntimeRequest, + base_market, + cancel_check: CancelCheck | None, + ) -> None: + self.service = service + self.strategy_engine = strategy_engine + self.data_dir = data_dir + self.request = request + self.base_market = base_market + self.cancel_check = cancel_check + self.backtest_count = 0 + self.peak_compute_cache_bytes = 0 + + def evaluate_candidate( + self, + train: pl.DataFrame, + test: pl.DataFrame, + definition: Mapping[str, Any], + ) -> CandidateEvaluation: + del train + return self.evaluate_test(test, definition) + + def evaluate_candidate_labels( + self, + train_labels: Sequence[str], + test_labels: Sequence[str], + definition: Mapping[str, Any], + ) -> CandidateEvaluation: + del train_labels + return self._evaluate_labels(test_labels, definition) + + def evaluate_test( + self, + test: pl.DataFrame, + definition: Mapping[str, Any], + *, + regime_state: str = "overall", + ) -> CandidateEvaluation: + return self._evaluate_labels( + _date_labels(test), + definition, + regime_state=regime_state, + ) + + def _evaluate_labels( + self, + labels: Sequence[str], + definition: Mapping[str, Any], + *, + regime_state: str = "overall", + ) -> CandidateEvaluation: + _raise_if_cancelled(self.cancel_check) + if not labels: + return CandidateEvaluation(score=None, error="test fold contains no dates") + try: + config = self._backtest_config( + definition, + date.fromisoformat(labels[0]), + date.fromisoformat(labels[-1]), + regime_state, + ) + prepared = self.service.prepare_matrix_optimization( + [config], + matrix_cache_max_bytes=_MINING_MATRIX_CACHE_BYTES, + market_data_override=self.base_market, + ) + try: + result = self.service.run( + config, + cancel_event=self.cancel_check, + prepared=prepared, + result_policy=_RESULT_POLICY, + ) + self.peak_compute_cache_bytes = max( + self.peak_compute_cache_bytes, + prepared.compute_cache.snapshot()["peak_bytes"], + ) + finally: + prepared.compute_cache.close() + self.backtest_count += 1 + if result.error: + return CandidateEvaluation(score=None, error=result.error) + metrics = { + key: _finite_or_none(result.stats.get(key)) + for key in ("total_return", "sharpe", "max_drawdown", "n_trades") + } + score = _finite_or_none(metrics.get("sharpe")) + if score is None: + return CandidateEvaluation( + score=None, + metrics=metrics, + error="backtest did not return a finite sharpe", + ) + return CandidateEvaluation(score=score, metrics=metrics) + except (OSError, ValueError, TypeError) as exc: + return CandidateEvaluation(score=None, error=str(exc)) + + def _backtest_config( + self, + definition: Mapping[str, Any], + start: date, + end: date, + regime_state: str, + ) -> StrategyBacktestConfig: + kind = str(definition.get("kind") or "") + if kind == "existing_strategy": + strategy_id = str(definition.get("strategy_id") or "") + strategy = self.strategy_engine.get(strategy_id) + overrides = strategy_config.load_override(self.data_dir, strategy_id) + params = self.strategy_engine.resolve_params(strategy, overrides=overrides) + elif kind == "factor_rank": + strategy_id = "factor_rank_research" + scoring = definition.get("scoring") + directions = definition.get("directions") + if not isinstance(scoring, Mapping) or not scoring: + raise ValueError("factor candidate has no scoring definition") + if not isinstance(directions, Mapping): + raise ValueError("factor candidate has no direction definition") + params = { + "scoring": {str(key): float(value) for key, value in scoring.items()}, + "directions": {str(key): str(value) for key, value in directions.items()}, + "entry_score": 70.0, + "exit_score": 40.0, + "top_rank": 20, + } + overrides = {} + else: + raise ValueError(f"unsupported mining candidate kind: {kind!r}") + + regime_filter = None + if regime_state != "overall": + regime_filter = _REGIME_FILTERS.get(regime_state) + if regime_filter is None: + raise ValueError(f"unsupported regime state: {regime_state}") + return StrategyBacktestConfig( + strategy_id=strategy_id, + symbols=self.request.symbols, + start=start, + end=end, + params=params, + overrides=overrides, + matching="open_t+1", + entry_fill="open_t+1", + exit_fill="open_t+1", + fees_pct=self.request.commission_pct, + commission_pct=self.request.commission_pct, + stamp_tax_pct=self.request.stamp_tax_pct, + slippage_bps=self.request.slippage_bps, + max_positions=10, + max_exposure_pct=1.0, + initial_capital=1_000_000.0, + position_sizing="equal", + mode="position", + asset_type=self.request.asset_type, + holding_days=self.request.forward_horizon, + minute_fill=False, + regime_filter=regime_filter, + ) + + +_SYMBOL_BATCH_SIZE = 512 + + +def _load_compact_factor_panel( + factor_service: FactorBacktestService, + config: FactorBatchConfig, + factor_names: Sequence[str], + *, + expected_generation: str, + cancel_check: CancelCheck | None, +) -> pl.DataFrame: + panel_columns = [ + "symbol", + "date", + "open", + "high", + "low", + "close", + "volume", + "amount", + "turnover_rate", + ] + if any( + name in ("limit_up_count_20d", "limit_up_count_60d") + for name in factor_names + ): + panel_columns.append("consecutive_limit_ups") + load_start = ( + config.start + if all(name == "turnover_rate" for name in factor_names) + else config.start - timedelta(days=FACTOR_WARMUP_DAYS) + ) + raw = factor_service.engine.load_panel( + config.symbols, + load_start, + config.end, + columns=panel_columns, + asset_type=config.asset_type, + expected_generation=expected_generation, + ) + if raw.is_empty(): + return raw + + fundamental_names = [ + str(name) + for name in factor_names + if str(name) in FUNDAMENTAL_FACTOR_NAMES + ] + if fundamental_names: + data_dir = getattr( + getattr(getattr(factor_service.engine, "repo", None), "store", None), + "data_dir", + None, + ) + raw = attach_fundamental_factors( + raw, + load_fundamental_snapshot(data_dir), + fundamental_names, + ) + + symbol = pl.col("symbol") + day = pl.col("date") + previous_symbol = symbol.shift(1) + previous_day = day.shift(1) + invalid_key = raw.select( + ( + symbol.is_null() + | day.is_null() + | (symbol < previous_symbol).fill_null(False) + | ( + (symbol == previous_symbol) + & (day <= previous_day) + ).fill_null(False) + ).any() + ).item() + if invalid_key: + raise ValueError( + "mining factor panel requires non-null, unique symbol/date keys " + "sorted by symbol and strictly increasing date" + ) + output_by_date: dict[date, list[pl.DataFrame]] = {} + group_sizes = ( + raw.group_by("symbol", maintain_order=True) + .len() + .get_column("len") + .to_list() + ) + row_offset = 0 + for offset in range(0, len(group_sizes), _SYMBOL_BATCH_SIZE): + _raise_if_cancelled(cancel_check) + row_count = sum(group_sizes[offset:offset + _SYMBOL_BATCH_SIZE]) + batch = raw.slice(row_offset, row_count) + row_offset += row_count + missing = set(factor_names) - set(batch.columns) + if missing: + batch = factor_service._compute_missing_factors( + batch, + missing, + assume_sorted=True, + ) + projected = batch.filter( + (pl.col("date") >= config.start) + & (pl.col("date") <= config.end) + & pl.col("close").is_not_null() + & (pl.col("close") > 0) + ).select([ + "symbol", + "date", + "close", + *( + pl.col(name).cast(pl.Float32, strict=False).alias(name) + for name in factor_names + ), + ]) + for daily in projected.partition_by("date", maintain_order=True): + output_by_date.setdefault(daily.item(0, "date"), []).append(daily) + del batch, projected + return pl.concat( + [ + pl.concat(output_by_date[label], how="vertical", rechunk=False) + for label in sorted(output_by_date) + ], + how="vertical", + rechunk=False, + ) + + +def run_mining_runtime( + payload: Mapping[str, Any], + *, + data_dir: Path, + service: StrategyBacktestService, + strategy_engine: StrategyEngine, + progress_cb: ProgressCallback | None = None, + cancel_check: CancelCheck | None = None, + rss_sampler: Any | None = None, +) -> dict[str, Any]: + """Run one persistent mining job and return only a compact IPC summary.""" + started = time.perf_counter() + emit = progress_cb or (lambda _message: None) + request = _decode_runtime_request(payload, data_dir, strategy_engine) + fingerprint = payload.get("data_fingerprint") + expected_generation = ( + fingerprint.get("generation") + if isinstance(fingerprint, Mapping) + else None + ) + if not isinstance(expected_generation, str) or not expected_generation: + raise ValueError("mining worker payload is missing its data generation") + store = MiningRunStore(data_dir) + phase_peak_rss_bytes: dict[str, int] = {} + + def start_phase() -> None: + if rss_sampler is not None: + rss_sampler.reset_phase() + + def finish_phase(name: str) -> None: + if rss_sampler is not None: + phase_peak_rss_bytes[name] = rss_sampler.phase_peak_rss_bytes() + + emit({"phase": "panel", "label": "加载因子面板", "done": 0, "total": 1}) + start_phase() + _raise_if_cancelled(cancel_check) + panel_started = time.perf_counter() + factor_service = FactorBacktestService(service.engine) + factor_config = FactorBatchConfig( + factor_names=list(request.factor_names), + symbols=request.symbols, + start=request.start, + end=request.end, + asset_type=request.asset_type, + commission_pct=request.commission_pct, + stamp_tax_pct=request.stamp_tax_pct, + slippage_bps=request.slippage_bps, + ) + generation = factor_service._data_generation(request.asset_type) + if generation != expected_generation: + raise ValueError( + "mining data generation changed after the run was queued" + ) + source_panel = _load_compact_factor_panel( + factor_service, + factor_config, + request.factor_names, + expected_generation=generation, + cancel_check=cancel_check, + ) + if source_panel.is_empty(): + raise ValueError("mining date range contains no enriched data") + service.engine.clear_panel_cache() + trading_dates = enriched_partition_dates( + data_dir, + request.asset_type, + request.start, + request.end, + ) + factor_service._assert_data_generation(request.asset_type, generation) + panel = attach_single_forward_return( + source_panel, + start=request.start, + end=request.end, + horizon=request.forward_horizon, + trading_dates=trading_dates, + factor_names=request.factor_names, + target_column=request.mining_request.target_column, + assume_unique_symbol_date=True, + ) + del source_panel + if panel.is_empty(): + raise ValueError("mining panel contains no valid price rows") + phase_ms: dict[str, float] = { + "panel": round((time.perf_counter() - panel_started) * 1000.0, 3) + } + finish_phase("panel") + emit({ + "phase": "panel", + "label": "因子面板已准备", + "done": 1, + "total": 1, + "rows": panel.height, + "factors": len(request.factor_names), + }) + + _raise_if_cancelled(cancel_check) + start_phase() + matrix_started = time.perf_counter() + emit({"phase": "matrix", "label": "准备共享撮合矩阵", "done": 0, "total": 1}) + base_market = _prepare_base_market( + service, + strategy_engine, + data_dir, + request, + expected_generation=generation, + cancel_check=cancel_check, + ) + factor_service._assert_data_generation(request.asset_type, generation) + phase_ms["matrix"] = round((time.perf_counter() - matrix_started) * 1000.0, 3) + finish_phase("matrix") + emit({ + "phase": "matrix", + "label": "共享撮合矩阵已准备", + "done": 1, + "total": 1, + "matrix_bytes": base_market.nbytes, + }) + + metric_provider = TrainingMetricProvider(request.mining_request.target_column) + evaluator = MatcherCandidateEvaluator( + service, + strategy_engine, + data_dir, + request, + base_market, + cancel_check, + ) + emit({"phase": "search", "label": "嵌套样本外搜索", "done": 0, "total": 1}) + start_phase() + search_started = time.perf_counter() + result = MiningService().run( + panel, + request.mining_request, + metric_provider=metric_provider, + evaluator=evaluator, + cancel_check=cancel_check, + ) + phase_ms["search"] = round((time.perf_counter() - search_started) * 1000.0, 3) + finish_phase("search") + if result.cancelled: + raise MiningRuntimeCancelledError("mining cancelled") + emit({ + "phase": "search", + "label": "候选搜索完成", + "done": 1, + "total": 1, + "proxy_trials": result.proxy_trials_used, + "real_trials": result.trials_used, + }) + + _raise_if_cancelled(cancel_check) + start_phase() + artifact_started = time.perf_counter() + emit({"phase": "artifacts", "label": "写入研究结果", "done": 0, "total": 4}) + artifact_frames = _build_artifacts( + panel, + request, + result, + metric_provider, + evaluator, + cancel_check, + ) + for done, (name, frame) in enumerate(artifact_frames.items(), start=1): + _raise_if_cancelled(cancel_check) + path = store.artifact_path(request.run_id, name) # type: ignore[arg-type] + _atomic_write_parquet(frame, path) + store.register_artifact(request.run_id, name) # type: ignore[arg-type] + emit({ + "phase": "artifacts", + "label": f"已写入 {name}", + "done": done, + "total": 4, + }) + phase_ms["artifacts"] = round((time.perf_counter() - artifact_started) * 1000.0, 3) + finish_phase("artifacts") + + folds = artifact_frames["folds"] + candidates = artifact_frames["candidates"] + factors = artifact_frames["factors"] + selected_overall = folds.filter( + (pl.col("regime_state") == "overall") + & ( + (pl.col("evaluation_kind") == "selected") + | pl.col("candidate_signature").is_null() + ) + ) + valid_folds = selected_overall.filter(~pl.col("skipped")).height + skipped_folds = selected_overall.filter(pl.col("skipped")).height + budget_exhausted = _budget_exhausted(result) + elapsed_ms = round((time.perf_counter() - started) * 1000.0, 3) + phase_ms["total"] = elapsed_ms + confidence = _confidence(request.profile) + return { + "status": ( + "succeeded_with_budget_exhausted" if budget_exhausted else "succeeded" + ), + "factor_count": len(request.factor_names), + "selected_factor_count": int(factors.filter(pl.col("selected")).height), + "candidate_count": candidates.height, + "valid_fold_count": valid_folds, + "skipped_fold_count": skipped_folds, + "confidence": confidence, + "budget_exhausted": budget_exhausted, + "elapsed_ms": elapsed_ms, + "data_as_of": request.end.isoformat(), + "algorithm_version": MINING_ALGORITHM_VERSION, + "methodology_version": FACTOR_METHODOLOGY_VERSION, + "proxy_trials_used": result.proxy_trials_used, + "trials_used": result.trials_used + max(0, evaluator.backtest_count - result.trials_used), + "panel_rows": panel.height, + "panel_scans": 1, + "matrix_bytes": base_market.nbytes, + "matrix_compute_cache_peak_bytes": evaluator.peak_compute_cache_bytes, + "phase_ms": phase_ms, + "phase_peak_rss_bytes": phase_peak_rss_bytes, + "artifacts": list(artifact_frames), + } + + +def attach_single_forward_return( + panel: pl.DataFrame, + *, + start: date, + end: date, + horizon: int, + trading_dates: Sequence[date], + factor_names: Sequence[str], + target_column: str = "_next_return", + assume_unique_symbol_date: bool = False, +) -> pl.DataFrame: + """Materialize exactly one global-axis forward label and its endpoint date.""" + if horizon <= 0: + raise ValueError("forward horizon must be positive") + names = tuple(str(name) for name in factor_names) + required = {"symbol", "date", "close", *names} + missing = sorted(required - set(panel.columns)) + if missing: + raise ValueError(f"factor panel is missing required columns: {missing}") + dates = tuple(sorted(dict.fromkeys( + value for value in trading_dates if start <= value <= end + ))) + if not dates: + raise ValueError("mining date range has no trading dates") + + valid_rows = ( + (pl.col("date") >= start) + & (pl.col("date") <= end) + & pl.col("close").is_not_null() + & (pl.col("close") > 0) + ) + if assume_unique_symbol_date: + invalid_count = panel.select((~valid_rows).sum()).item() + if invalid_count: + raise ValueError("prevalidated mining panel contains invalid price rows") + scoped = panel.select([ + "symbol", + "date", + "close", + *( + pl.col(name).cast(pl.Float32, strict=False).alias(name) + for name in names + ), + ]) + else: + scoped = ( + panel.filter(valid_rows) + .select([ + "symbol", + "date", + "close", + *( + pl.col(name).cast(pl.Float32, strict=False).alias(name) + for name in names + ), + ]) + .unique(subset=["symbol", "date"], keep="last") + ) + date_dtype = scoped.schema["date"] + target_date_column = "_target_date" + if len(dates) > horizon: + date_map = pl.DataFrame({ + "date": dates[:-horizon], + target_date_column: dates[horizon:], + }).with_columns( + pl.col("date").cast(date_dtype), + pl.col(target_date_column).cast(date_dtype), + ) + else: + date_map = pl.DataFrame( + schema={"date": date_dtype, target_date_column: date_dtype} + ) + prices = scoped.select("symbol", "date", "close") + lookup = prices.select( + "symbol", + pl.col("date").alias(target_date_column), + pl.col("close").alias("_target_close"), + ) + labels = ( + prices.join(date_map, on="date", how="left") + .join(lookup, on=["symbol", target_date_column], how="left") + .select( + "symbol", + "date", + pl.when(pl.col("_target_close").is_not_null()) + .then(pl.col("_target_close") / pl.col("close") - 1.0) + .otherwise(None) + .cast(pl.Float32) + .alias(target_column), + target_date_column, + ) + ) + if assume_unique_symbol_date: + labels = labels.sort(["date", "symbol"]) + if ( + not labels.get_column("symbol").equals(scoped.get_column("symbol")) + or not labels.get_column("date").equals(scoped.get_column("date")) + ): + raise ValueError("prevalidated mining panel is not sorted by date and symbol") + return scoped.select(["symbol", "date", *names]).hstack([ + labels.get_column(target_column), + labels.get_column(target_date_column), + ]) + return ( + scoped.select(["symbol", "date", *names]) + .join(labels, on=["symbol", "date"], how="left") + .sort(["date", "symbol"]) + ) + + +def _decode_runtime_request( + payload: Mapping[str, Any], + data_dir: Path, + strategy_engine: StrategyEngine, +) -> RuntimeRequest: + run_id = str(payload.get("run_id") or "") + request = payload.get("request") + if not run_id or not isinstance(request, Mapping): + raise ValueError("mining worker payload is missing run_id or request") + + factor_names = tuple(str(value) for value in request.get("factor_names") or ()) + if not factor_names or len(set(factor_names)) != len(factor_names): + raise ValueError("factor_names must be non-empty and unique") + unknown_factors = sorted(set(factor_names) - _FACTOR_IDS) + if unknown_factors: + raise ValueError(f"unknown mining factors: {unknown_factors}") + if len(factor_names) > 48: + raise ValueError("mining supports at most 48 factors") + + strategy_ids = tuple(str(value) for value in request.get("strategy_ids") or ()) + if len(set(strategy_ids)) != len(strategy_ids) or len(strategy_ids) > 8: + raise ValueError("strategy_ids must be unique and contain at most 8 strategies") + asset_type = str(request.get("asset_type") or "stock") + if asset_type not in {"stock", "etf"}: + raise ValueError("mining asset_type must be stock or etf") + for strategy_id in strategy_ids: + strategy = strategy_engine.get(strategy_id) + if strategy.meta.get("research_only"): + raise ValueError(f"research template cannot be selected as existing strategy: {strategy_id}") + if strategy.execution_backend != "matrix_native": + raise ValueError(f"mining strategy is not matrix-native: {strategy_id}") + if asset_type not in strategy.meta.get("asset_types", ["stock"]): + raise ValueError(f"mining strategy does not support {asset_type}: {strategy_id}") + + all_dates = enriched_partition_dates(data_dir, asset_type) + if not all_dates: + raise ValueError(f"no enriched {asset_type} trading dates are available") + requested_start = _optional_date(request.get("start")) + requested_end = _optional_date(request.get("end")) + if ( + requested_start is not None + and requested_end is not None + and requested_start > requested_end + ): + raise ValueError("mining start must not be after end") + start = max(requested_start or all_dates[0], all_dates[0]) + end = min(requested_end or all_dates[-1], all_dates[-1]) + if start > end: + raise ValueError("mining date range contains no enriched data") + + profile = str(request.get("budget_profile") or "balanced") + if profile not in _PROFILE_NAMES: + raise ValueError(f"unsupported mining profile: {profile}") + validation = validation_config_for_profile(profile) + forward_horizon = int(request.get("forward_horizon") or 5) + if forward_horizon not in {1, 3, 5}: + raise ValueError("forward_horizon must be 1, 3, or 5 trading days") + if validation.purge_bars < forward_horizon: + raise ValueError("validation purge must cover the forward horizon") + + budget = getattr(MiningBudget, profile)() + max_combination = int( + request.get("max_combination_factors") or budget.max_combination_size + ) + beam_width = int(request.get("beam_width") or budget.beam_width) + max_finalists = int(request.get("max_finalists") or MAX_FINALISTS) + if not 1 <= max_finalists <= MAX_FINALISTS: + raise ValueError(f"max_finalists must be between 1 and {MAX_FINALISTS}") + scoped_dates = [value for value in all_dates if start <= value <= end] + required_folds = required_outer_folds(profile) + required_bars = required_trading_bars(validation, required_folds) + if len(scoped_dates) < required_bars: + fold_label = "outer fold" if required_folds == 1 else "outer folds" + raise ValueError( + f"{profile} mining requires at least {required_bars} enriched trading " + f"bars for {required_folds} {fold_label}; effective range " + f"{start.isoformat()} to {end.isoformat()} has {len(scoped_dates)}" + ) + nested = generate_nested_folds( + [value.isoformat() for value in scoped_dates], + validation, + ) + reserved_regime_trials = 3 * len(nested) if request.get("require_regime", True) else 0 + real_trials = max(len(nested) + 1, budget.max_trials - reserved_regime_trials) + real_trials = min(real_trials, budget.max_trials) + budget = replace( + budget, + max_combination_size=max_combination, + beam_width=beam_width, + max_trials=real_trials, + ) + correlation_threshold = _bounded_float( + request.get("correlation_threshold", 0.75), + "correlation_threshold", + 0.0, + 1.0, + exclusive_min=True, + ) + commission_pct = _bounded_float( + request.get("commission_pct", 0.0002), "commission_pct", 0.0, 0.05 + ) + stamp_tax_pct = _bounded_float( + request.get("stamp_tax_pct", 0.0005), "stamp_tax_pct", 0.0, 0.05 + ) + slippage_bps = _bounded_float( + request.get("slippage_bps", 5.0), "slippage_bps", 0.0, 1000.0 + ) + symbols_value = request.get("symbols") + symbols = None + if symbols_value is not None: + if not isinstance(symbols_value, list): + raise ValueError("symbols must be a list or null") + symbols = list(dict.fromkeys(str(value) for value in symbols_value if value)) + if not symbols: + symbols = None + + mining_request = MiningRequest( + factor_names=factor_names, + existing_strategy_ids=strategy_ids, + correlation_threshold=correlation_threshold, + target_column="_next_return", + budget=budget, + validation=validation, + profile=profile, # type: ignore[arg-type] + ) + return RuntimeRequest( + run_id=run_id, + factor_names=factor_names, + strategy_ids=strategy_ids, + symbols=symbols, + asset_type=asset_type, # type: ignore[arg-type] + start=start, + end=end, + profile=profile, # type: ignore[arg-type] + forward_horizon=forward_horizon, + commission_pct=commission_pct, + stamp_tax_pct=stamp_tax_pct, + slippage_bps=slippage_bps, + correlation_threshold=correlation_threshold, + max_finalists=max_finalists, + require_regime=bool(request.get("require_regime", True)), + mining_request=mining_request, + ) + + +def _prepare_base_market( + service: StrategyBacktestService, + strategy_engine: StrategyEngine, + data_dir: Path, + request: RuntimeRequest, + *, + expected_generation: str | None = None, + cancel_check: CancelCheck | None = None, +): + resolver = StrategyDependencyResolver() + plans: list[ResolvedFeaturePlan] = [] + research = strategy_engine.get("factor_rank_research") + for offset in range(0, len(request.factor_names), 4): + factor_chunk = request.factor_names[offset:offset + 4] + research_params = { + "scoring": {factor_name: 1.0 for factor_name in factor_chunk}, + "directions": {factor_name: "high" for factor_name in factor_chunk}, + } + plans.append(resolver.resolve( + research, + params=research_params, + basic_filter=service._effective_basic_filter(research, {}), + entry_signals=research.entry_signals, + exit_signals=research.exit_signals, + overrides={}, + )) + for strategy_id in request.strategy_ids: + strategy = strategy_engine.get(strategy_id) + overrides = strategy_config.load_override(data_dir, strategy_id) + params = strategy_engine.resolve_params(strategy, overrides=overrides) + plans.append(resolver.resolve( + strategy, + params=params, + basic_filter=service._effective_basic_filter(strategy, overrides), + entry_signals=service._effective_signals( + overrides, "entry_signals", strategy.entry_signals + ), + exit_signals=service._effective_signals( + overrides, "exit_signals", strategy.exit_signals + ), + overrides=overrides, + )) + merged = _merge_resolved_feature_plans(plans) + profile = build_matrix_cache_profile( + strategy_engine, + request.asset_type, + requested_plan=merged, + requested_forward_bars=request.forward_horizon, + ) + warmup_days = max(120, int(max(merged.warmup_bars, 1) * 1.6)) + load_start = request.start - timedelta(days=warmup_days) + return service.engine.load_market_data_matrix_for_backtest( + request.symbols, + load_start, + request.end, + merged, + asset_type=request.asset_type, + cache_profile=profile, + coverage_start=load_start, + coverage_end=request.end, + expected_generation=expected_generation, + cancel_event=cancel_check, + ) + + +def _build_artifacts( + panel: pl.DataFrame, + request: RuntimeRequest, + result: MiningResult, + metric_provider: TrainingMetricProvider, + evaluator: MatcherCandidateEvaluator, + cancel_check: CancelCheck | None, +) -> dict[str, pl.DataFrame]: + nested = generate_nested_folds(_date_labels(panel), request.mining_request.validation) + last_train = _panel_for_dates(panel, nested[-1].outer.train_labels) + if "_target_date" in last_train.columns: + last_train = last_train.filter( + pl.col("_target_date").is_not_null() + & (pl.col("_target_date") <= date.fromisoformat(nested[-1].outer.train_end)) + ) + latest_metrics = { + metric.factor_id: metric + for metric in metric_provider(last_train, request.factor_names) + } + selected_factors = { + factor_name + for fold in result.folds + for factor_name in fold.selected_factors + } + direction_by_factor: dict[str, int] = {} + for fold in result.folds: + for candidate in fold.candidates: + for factor_name, direction in zip( + candidate.factor_names, candidate.directions, strict=True + ): + direction_by_factor.setdefault(factor_name, int(direction)) + metadata = {str(item["id"]): item for item in FACTOR_COLUMNS} + factor_rows = [] + for factor_name in request.factor_names: + metric = latest_metrics[factor_name] + factor_rows.append({ + "factor_name": factor_name, + "label": str(metadata.get(factor_name, {}).get("label", factor_name)), + "direction": direction_by_factor.get( + factor_name, 1 if metric.rank_ic >= 0 else -1 + ), + "score": _finite_or_none(metric.composite_score), + "ic_mean": _finite_or_none(metric.rank_ic), + "ir": _finite_or_none(metric.ir), + "coverage": _finite_or_none(metric.coverage), + "turnover": _finite_or_none(metric.turnover), + "spread_return": None, + "spread_sharpe": None, + "selected": factor_name in selected_factors, + "excluded_reason": None if factor_name in selected_factors else "not_selected", + }) + factors = pl.DataFrame(factor_rows) + + correlation = compute_rank_correlation(last_train, request.factor_names) + correlation_rows = [] + for row_id, left in enumerate(correlation.factor_names): + for column_id, right in enumerate(correlation.factor_names): + count = int(correlation.pair_counts[row_id][column_id]) + correlation_rows.append({ + "factor_x": left, + "factor_y": right, + "rho": ( + float(correlation.matrix[row_id][column_id]) if count > 0 else None + ), + "pair_count": count, + }) + correlation_frame = pl.DataFrame(correlation_rows) + + benchmark_by_id = { + benchmark_candidate(strategy_id).candidate_id: benchmark_candidate(strategy_id) + for strategy_id in request.strategy_ids + } + candidate_by_id: dict[str, MiningCandidate] = {} + for fold in result.folds: + for candidate in fold.candidates: + candidate_by_id.setdefault(candidate.candidate_id, candidate) + fold_rows: list[dict[str, Any]] = [] + for fold, nested_fold in zip(result.folds, nested, strict=False): + selected = ( + candidate_by_id.get(fold.selected_candidate_id) + if fold.selected_candidate_id is not None + else None + ) + evaluation = fold.outer_evaluation + fold_rows.append(_fold_row( + fold.outer_index, + selected, + nested_fold.outer, + evaluation, + regime_state="overall", + n_dates=len(nested_fold.outer.test_labels), + reason=fold.error, + )) + for candidate_id, cross_evaluation in fold.cross_evaluations: + fold_rows.append(_fold_row( + fold.outer_index, + candidate_by_id.get(candidate_id), + nested_fold.outer, + cross_evaluation, + regime_state="overall", + n_dates=len(nested_fold.outer.test_labels), + reason=None, + evaluation_kind="cross", + )) + for candidate_id, benchmark_evaluation in fold.benchmark_evaluations: + fold_rows.append(_fold_row( + fold.outer_index, + benchmark_by_id.get(candidate_id), + nested_fold.outer, + benchmark_evaluation, + regime_state="overall", + n_dates=len(nested_fold.outer.test_labels), + reason=None, + evaluation_kind="benchmark", + )) + if ( + selected is None + or evaluation is None + or evaluation.error is not None + or not request.require_regime + ): + continue + test = _panel_for_dates(panel, nested_fold.outer.test_labels) + for state in ("strong", "range", "weak"): + _raise_if_cancelled(cancel_check) + regime_evaluation = evaluator.evaluate_test( + test, + selected.definition(), + regime_state=state, + ) + n_dates = _regime_date_count( + panel, + nested_fold.outer, + state, + evaluator.data_dir, + ) + fold_rows.append(_fold_row( + fold.outer_index, + selected, + nested_fold.outer, + regime_evaluation, + regime_state=state, + n_dates=n_dates, + reason=None, + )) + folds = pl.DataFrame(fold_rows, schema_overrides={ + "total_return": pl.Float64, + "sharpe": pl.Float64, + "max_drawdown": pl.Float64, + "n_trades": pl.Int64, + }) + + candidate_rows = [] + overall_rows = [row for row in fold_rows if row["regime_state"] == "overall"] + winner_by_id = { + fold.selected_candidate_id: candidate_by_id[fold.selected_candidate_id] + for fold in result.folds + if fold.selected_candidate_id is not None + and fold.selected_candidate_id in candidate_by_id + } + ranked_candidates = _rank_artifact_candidates( + winner_by_id.values(), + overall_rows, + limit=request.max_finalists, + ) + [benchmark_by_id[cid] for cid in sorted(benchmark_by_id)] + for candidate in ranked_candidates: + rows = [row for row in overall_rows if row["candidate_signature"] == candidate.candidate_id] + successful = [row for row in rows if not row["skipped"]] + returns = [row["total_return"] for row in successful if row["total_return"] is not None] + sharpes = [row["sharpe"] for row in successful if row["sharpe"] is not None] + drawdowns = [row["max_drawdown"] for row in successful if row["max_drawdown"] is not None] + trades = [row["n_trades"] for row in successful if row["n_trades"] is not None] + definition = candidate.definition() + candidate_rows.append({ + "signature": candidate.candidate_id, + "name": _candidate_name(candidate), + "kind": ( + "existing_strategy" + if candidate.kind == "existing_strategy" + else "factor_combination" + ), + "factor_names_json": json.dumps( + list(candidate.factor_names), ensure_ascii=False, separators=(",", ":") + ), + "strategy_id": candidate.strategy_id, + "definition_json": json.dumps( + definition, + ensure_ascii=False, + allow_nan=False, + sort_keys=True, + separators=(",", ":"), + ), + "regime_state": "overall", + "score": _mean_or_none(sharpes), + "oos_return": _mean_or_none(returns), + "oos_sharpe": _mean_or_none(sharpes), + "oos_max_drawdown": min(drawdowns) if drawdowns else None, + "oos_positive_fold_ratio": ( + sum(value > 0 for value in returns) / len(returns) if returns else None + ), + "oos_n_trades": sum(int(value) for value in trades) if trades else None, + "confidence": _confidence(request.profile), + "valid_folds": len(successful), + "skipped_folds": len(rows) - len(successful), + "promoted_candidate_id": None, + "published_strategy_id": None, + }) + candidates = pl.DataFrame(candidate_rows, schema_overrides={ + "score": pl.Float64, + "oos_return": pl.Float64, + "oos_sharpe": pl.Float64, + "oos_max_drawdown": pl.Float64, + "oos_positive_fold_ratio": pl.Float64, + "oos_n_trades": pl.Int64, + "strategy_id": pl.Utf8, + "promoted_candidate_id": pl.Utf8, + "published_strategy_id": pl.Utf8, + }) if candidate_rows else _empty_candidates_frame() + return { + "factors": factors, + "correlation": correlation_frame, + "candidates": candidates, + "folds": folds, + } + + +def _factor_metric( + train: pl.DataFrame, + factor_name: str, + target_column: str, +) -> FactorMetric: + scoped = train.select("date", "symbol", factor_name, target_column) + finite_factor = pl.col(factor_name).is_not_null() & pl.col(factor_name).is_finite() + eligible = scoped.filter( + finite_factor + & pl.col(target_column).is_not_null() + & pl.col(target_column).is_finite() + ) + coverage = ( + scoped.select(finite_factor.mean()).item() if scoped.height else 0.0 + ) + daily = ( + eligible.group_by("date") + .agg( + pl.corr( + pl.col(factor_name).rank(method="average"), + pl.col(target_column).rank(method="average"), + ).alias("ic") + ) + .filter(pl.col("ic").is_not_null() & pl.col("ic").is_finite()) + .sort("date") + ) + values = daily["ic"].to_numpy() if not daily.is_empty() else np.array([]) + mean = float(np.mean(values)) if values.size else 0.0 + std = float(np.std(values)) if values.size else 0.0 + ir = mean / std if std > 1e-12 else 0.0 + turnover = _top_quintile_turnover(eligible, factor_name, direction=1 if mean >= 0 else -1) + score = abs(ir) * float(coverage or 0.0) / (1.0 + turnover) + return FactorMetric( + factor_id=factor_name, + composite_score=round(score, 8), + ir=round(abs(ir), 8), + coverage=round(float(coverage or 0.0), 8), + turnover=round(turnover, 8), + rank_ic=round(mean, 8), + ) + + +def _top_quintile_turnover( + panel: pl.DataFrame, + factor_name: str, + *, + direction: int, +) -> float: + if panel.is_empty(): + return 1.0 + ranked = ( + panel.select("date", "symbol", factor_name) + .sort(["date", factor_name, "symbol"], descending=[False, direction < 0, False]) + .with_columns( + pl.col(factor_name).rank(method="average").over("date").alias("_rank"), + pl.len().over("date").alias("_count"), + ) + .filter( + pl.col("_rank") + > pl.col("_count") * (0.8 if direction > 0 else 0.0) + ) + ) + if direction < 0: + ranked = ranked.filter(pl.col("_rank") <= pl.col("_count") * 0.2) + holdings = [ + set(str(value) for value in daily["symbol"].to_list()) + for daily in ranked.partition_by("date", maintain_order=True) + ] + if len(holdings) < 2: + return 0.0 + values = [] + for previous, current in pairwise(holdings): + denominator = max(len(previous), len(current), 1) + values.append(1.0 - len(previous & current) / denominator) + return float(np.mean(values)) if values else 0.0 + + +def _fold_row( + fold_index: int, + candidate: MiningCandidate | None, + validation_fold, + evaluation: CandidateEvaluation | None, + *, + regime_state: str, + n_dates: int, + reason: str | None, + evaluation_kind: str = "selected", +) -> dict[str, Any]: + error = reason or (evaluation.error if evaluation is not None else None) + metrics = evaluation.metrics if evaluation is not None else {} + return { + "candidate_signature": candidate.candidate_id if candidate is not None else None, + "evaluation_kind": evaluation_kind, + "fold": fold_index, + "label": f"OOS {fold_index + 1}", + "regime_state": regime_state, + "n_dates": n_dates, + "train_start": validation_fold.train_start, + "train_end": validation_fold.train_end, + "test_start": validation_fold.test_start, + "test_end": validation_fold.test_end, + "selected_factors_json": json.dumps( + list(candidate.factor_names) if candidate is not None else [], + ensure_ascii=False, + separators=(",", ":"), + ), + "total_return": _finite_or_none(metrics.get("total_return")), + "sharpe": _finite_or_none(metrics.get("sharpe")), + "max_drawdown": _finite_or_none(metrics.get("max_drawdown")), + "n_trades": _int_or_none(metrics.get("n_trades")), + "skipped": evaluation is None or error is not None, + "reason": error, + } + + +def _regime_date_count( + panel: pl.DataFrame, + validation_fold, + regime_state: str, + data_dir: Path, +) -> int: + labels = tuple( + label + for label in _date_labels(panel) + if label <= validation_fold.test_end + ) + mask = StrategyBacktestService._build_regime_mask( + labels, + _REGIME_FILTERS[regime_state], + data_dir, + required_start=date.fromisoformat(validation_fold.test_start), + required_end=date.fromisoformat(validation_fold.test_end), + ) + if mask is None: + return 0 + return sum( + bool(allowed) + for label, allowed in zip(labels, mask, strict=True) + if validation_fold.test_start <= label <= validation_fold.test_end + ) + + +def _rank_artifact_candidates( + candidates: Sequence[MiningCandidate], + overall_rows: Sequence[Mapping[str, Any]], + *, + limit: int, +) -> list[MiningCandidate]: + return sorted( + candidates, + key=lambda candidate: _candidate_artifact_rank(candidate, overall_rows), + )[:limit] + + +def _candidate_artifact_rank( + candidate: MiningCandidate, + overall_rows: Sequence[Mapping[str, Any]], +) -> tuple[float, str]: + sharpes = [ + row.get("sharpe") + for row in overall_rows + if row.get("candidate_signature") == candidate.candidate_id + and not row.get("skipped") + and row.get("sharpe") is not None + ] + mean_sharpe = _mean_or_none(sharpes) + return ( + -(mean_sharpe if mean_sharpe is not None else float("-inf")), + candidate.candidate_id, + ) + + +def _candidate_name(candidate: MiningCandidate) -> str: + if candidate.kind == "existing_strategy": + return f"已有策略 · {candidate.strategy_id}" + return "因子组合 · " + " + ".join(candidate.factor_names) + + +def _empty_candidates_frame() -> pl.DataFrame: + return pl.DataFrame(schema={ + "signature": pl.Utf8, + "name": pl.Utf8, + "kind": pl.Utf8, + "factor_names_json": pl.Utf8, + "strategy_id": pl.Utf8, + "definition_json": pl.Utf8, + "regime_state": pl.Utf8, + "score": pl.Float64, + "oos_return": pl.Float64, + "oos_sharpe": pl.Float64, + "oos_max_drawdown": pl.Float64, + "oos_positive_fold_ratio": pl.Float64, + "oos_n_trades": pl.Int64, + "confidence": pl.Utf8, + "valid_folds": pl.Int64, + "skipped_folds": pl.Int64, + "promoted_candidate_id": pl.Utf8, + "published_strategy_id": pl.Utf8, + }) + + +def _atomic_write_parquet(frame: pl.DataFrame, path: Path) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_name(f".{path.name}.{uuid.uuid4().hex}.tmp") + try: + frame.write_parquet(temporary) + with temporary.open("r+b") as stream: + os.fsync(stream.fileno()) + os.replace(temporary, path) + except OSError: + temporary.unlink(missing_ok=True) + raise + + +def _panel_for_dates(panel: pl.DataFrame, labels: Sequence[str]) -> pl.DataFrame: + return panel.filter( + pl.col("date").cast(pl.Utf8).str.slice(0, 10).is_in(list(labels)) + ) + + +def _date_labels(panel: pl.DataFrame) -> tuple[str, ...]: + if panel.is_empty(): + return () + return tuple( + panel.select(pl.col("date").cast(pl.Utf8).str.slice(0, 10).unique().sort()) + .to_series() + .to_list() + ) + + +def _raise_if_cancelled(cancel_check: CancelCheck | None) -> None: + if cancel_check is None: + return + cancelled = cancel_check() if callable(cancel_check) else cancel_check.is_set() + if cancelled: + raise MiningRuntimeCancelledError("mining cancelled") + + +def _optional_date(value: Any) -> date | None: + if value in (None, ""): + return None + if isinstance(value, date): + return value + try: + return date.fromisoformat(str(value)) + except ValueError as exc: + raise ValueError(f"invalid ISO date: {value!r}") from exc + + +def _bounded_float( + value: Any, + name: str, + minimum: float, + maximum: float, + *, + exclusive_min: bool = False, +) -> float: + try: + number = float(value) + except (TypeError, ValueError) as exc: + raise ValueError(f"{name} must be numeric") from exc + valid_min = number > minimum if exclusive_min else number >= minimum + if not math.isfinite(number) or not valid_min or number > maximum: + left = "(" if exclusive_min else "[" + raise ValueError(f"{name} must be in {left}{minimum}, {maximum}]") + return number + + +def _finite_or_none(value: Any) -> float | None: + try: + number = float(value) + except (TypeError, ValueError): + return None + return number if math.isfinite(number) else None + + +def _int_or_none(value: Any) -> int | None: + number = _finite_or_none(value) + return int(number) if number is not None else None + + +def _mean_or_none(values: Sequence[float]) -> float | None: + return float(np.mean(values)) if values else None + + +def _confidence(profile: str) -> str: + return {"exploratory": "low", "balanced": "standard", "strict": "high"}[profile] + + +def _budget_exhausted(result: MiningResult) -> bool: + if result.proxy_trials_used >= result.request.budget.max_proxy_trials: + return True + if result.trials_used >= result.request.budget.max_trials: + return True + return any("budget exhausted" in (fold.error or "") for fold in result.folds) diff --git a/backend/app/backtest/regime_alignment.py b/backend/app/backtest/regime_alignment.py new file mode 100644 index 0000000..3f0fe5f --- /dev/null +++ b/backend/app/backtest/regime_alignment.py @@ -0,0 +1,129 @@ +from __future__ import annotations + +from collections.abc import Mapping, Sequence +from datetime import date +from typing import Any + +import numpy as np + +RegimePoint = tuple[str, float] + +REGIME_THREE_LEVEL_MAP = { + "strong": "strong", + "lean_strong": "strong", + "range": "range", + "lean_weak": "weak", + "weak": "weak", +} + + +def three_level_regime(state: str) -> str: + return REGIME_THREE_LEVEL_MAP.get(state, state) + + +def _date_text(value: object) -> str: + return str(value)[:10] + + +def _normalize_regime_point(value: Any) -> RegimePoint: + if isinstance(value, Mapping): + state = str(value.get("state", "")) + score = float(value.get("score", 0) or 0) + return state, score + if isinstance(value, (tuple, list)) and len(value) >= 2: + return str(value[0]), float(value[1] or 0) + raise ValueError("市场环境数据格式无效") + + +def align_regime_t_minus_one( + labels: Sequence[str], + regime_by_date: Mapping[object, Any], + required_start: date | None, + required_end: date | None, +) -> list[RegimePoint | None]: + """Align each label with the preceding label's regime without any I/O.""" + regime_map = { + _date_text(key): _normalize_regime_point(value) + for key, value in regime_by_date.items() + } + if not regime_map: + raise ValueError("市场环境数据为空, 请先在数据页完成市场环境计算后再回测") + + aligned: list[RegimePoint | None] = [None] * len(labels) + required_start_text = str(required_start) if required_start is not None else None + required_end_text = str(required_end) if required_end is not None else None + missing_dates: list[str] = [] + if labels and required_start_text is not None: + first_label = _date_text(labels[0]) + if first_label >= required_start_text and ( + required_end_text is None or first_label <= required_end_text + ): + raise ValueError( + f"市场环境数据覆盖不完整: 正式首日 {first_label} 缺少前一交易日环境, " + "请把前一交易日行情包含在预热区间" + ) + for index in range(1, len(labels)): + current_label = _date_text(labels[index]) + previous_label = _date_text(labels[index - 1]) + point = regime_map.get(previous_label) + if point is not None: + aligned[index] = point + continue + required = ( + (required_start_text is None or current_label >= required_start_text) + and (required_end_text is None or current_label <= required_end_text) + ) + if required: + missing_dates.append(previous_label) + + if missing_dates: + first_missing = missing_dates[0] + suffix = f" 等 {len(missing_dates)} 天" if len(missing_dates) > 1 else "" + raise ValueError( + f"市场环境数据覆盖不完整: 缺少前一交易日环境 {first_missing}{suffix}, " + "请先补算对应区间" + ) + return aligned + + +def build_regime_filter_mask( + labels: Sequence[str], + regime_filter: Mapping[str, Any] | None, + regime_by_date: Mapping[object, Any], + *, + required_start: date | None = None, + required_end: date | None = None, +) -> np.ndarray | None: + """Build a T-1 regime filter mask from caller-supplied regime data. + + States are matched against the raw five-level labels, so each regime + level can be filtered on its own. Callers that want the aggregated + three-level view must list the raw states explicitly, e.g. + ``["strong", "lean_strong"]`` for the strong bucket. + """ + if not regime_filter: + return None + allowed_states = { + str(state) + for state in (regime_filter.get("states") or []) + } + min_score = regime_filter.get("min_score") + if not allowed_states and min_score is None: + return None + + aligned = align_regime_t_minus_one( + labels, + regime_by_date, + required_start, + required_end, + ) + mask = np.ones(len(labels), dtype=bool) + for index, point in enumerate(aligned): + if point is None: + continue + state, score = point + mask[index] = ( + (not allowed_states or state in allowed_states) + and (min_score is None or score >= float(min_score)) + ) + return mask diff --git a/backend/app/backtest/strategy.py b/backend/app/backtest/strategy.py index 811b70c..2981a5f 100644 --- a/backend/app/backtest/strategy.py +++ b/backend/app/backtest/strategy.py @@ -20,11 +20,13 @@ import numpy as np import polars as pl from app.backtest.engine import BacktestEngine, MatcherConfig, SimResult, SimulationOptions +from app.backtest.fundamentals import FUNDAMENTAL_FACTOR_NAMES from app.backtest.matrix import ( MarketDataMatrix, MatrixCacheProfile, MatrixComputeCache, MatrixPipelineConfig, + MatrixPrewarmCancelledError, MatrixStrategyPipeline, apply_time_masks, build_market_matrix, @@ -59,7 +61,7 @@ _EXECUTION_COLUMNS = frozenset({ "symbol", "date", "open", "high", "low", "close", "volume", "name", "score", "signal_limit_up", "signal_limit_down", }) -_LIMIT_BASE_COLUMNS = frozenset({"raw_close", "raw_high"}) +_LIMIT_BASE_COLUMNS = frozenset({"raw_close", "raw_high", "raw_low"}) _INSTRUMENT_COLUMNS = frozenset({"name", "total_shares", "float_shares"}) @@ -81,6 +83,8 @@ class ResolvedFeaturePlan: warmup_bars: int full_feature_fallback: bool = False execution_backend: str = "polars_expr" + # 财务因子列不落 enriched 存储, 由 engine 在加载口按公告日门控附加。 + fundamental_columns: frozenset[str] = frozenset() def _merge_resolved_feature_plans( @@ -108,6 +112,7 @@ def _merge_resolved_feature_plans( warmup_bars=max(plan.warmup_bars for plan in plans), full_feature_fallback=any(plan.full_feature_fallback for plan in plans), execution_backend="matrix_native", + fundamental_columns=_union("fundamental_columns"), ) @@ -206,6 +211,9 @@ class StrategyDependencyResolver: warmup_bars=plan.warmup_bars, full_feature_fallback=full_fallback, execution_backend=strategy.execution_backend, + fundamental_columns=frozenset( + required_features & FUNDAMENTAL_FACTOR_NAMES + ), ) @staticmethod @@ -224,6 +232,18 @@ class StrategyDependencyResolver: required_features = set(strategy.required_features) required_features.update(strategy.matrix_strategy.required_fields()) + parameter_fields = getattr( + strategy.matrix_strategy, + "required_fields_for_params", + None, + ) + parameter_scoring: dict[str, float] = {} + if callable(parameter_fields): + parameter_scoring = { + str(name): 1.0 + for name in parameter_fields(params) + } + required_features.update(scoring_dependencies(parameter_scoring)) required_features.update(_basic_filter_dependencies(basic_filter)) scoring = effective_scoring(strategy.meta.get("scoring"), overrides) required_features.update(scoring_dependencies(scoring)) @@ -239,6 +259,7 @@ class StrategyDependencyResolver: 60, int(strategy.matrix_strategy.required_warmup_bars(params)), scoring_warmup_bars(scoring), + scoring_warmup_bars(parameter_scoring), ) matrix_columns = set(base_columns) | set(instrument_columns) | { "signal_limit_up", @@ -254,6 +275,9 @@ class StrategyDependencyResolver: warmup_bars=warmup_bars, full_feature_fallback=False, execution_backend="matrix_native", + fundamental_columns=frozenset( + required_features & FUNDAMENTAL_FACTOR_NAMES + ), ) @@ -346,10 +370,13 @@ def prewarm_matrix_cache( asset_type: str, latest_date: date, years: int = 5, + cancel_event: threading.Event | None = None, ) -> dict[str, object]: """Build the shared full-universe mmap outside a user backtest request.""" if years <= 0: raise ValueError("matrix cache prewarm years must be positive") + if cancel_event is not None and cancel_event.is_set(): + raise MatrixPrewarmCancelledError("matrix cache prewarm cancelled") profile = build_matrix_cache_profile( strategy_engine, asset_type, @@ -390,6 +417,7 @@ def prewarm_matrix_cache( cache_profile=profile, coverage_start=coverage_start, coverage_end=latest_date, + cancel_event=cancel_event, ) result = { "asset_type": asset_type, @@ -1696,14 +1724,7 @@ class StrategyBacktestService: required_start: date | None = None, required_end: date | None = None, ) -> np.ndarray | None: - """构造逐日 regime mask。强制 T-1 防未来函数: regime[T-1] 决定 entry[T]。 - - timestamp_labels[i] 的入场资格 = 它的"前一交易日"的 regime 是否满足条件。 - "前一交易日"用 timestamp_labels 自身的顺序确定(回测时间轴上的前一天)。 - 边界: 首日无前一日环境 → 默认允许(不阻断)。 - regime_filter 为 None 时返回 None(不过滤)。启用过滤后缺少正式区间所需的 - 环境数据则 fail-closed, 避免界面显示已过滤但实际静默放行。 - """ + """构造逐日 T-1 regime mask, 保留历史静态入口兼容调用方。""" if not regime_filter: return None allowed_states = set(regime_filter.get("states") or []) @@ -1713,52 +1734,25 @@ class StrategyBacktestService: if data_dir is None: raise ValueError("市场环境过滤不可用: 未找到环境数据目录") + from app.backtest.regime_alignment import build_regime_filter_mask from app.services import regime_builder + regime_df = regime_builder.load_regime_history(data_dir) - if regime_df.is_empty(): - raise ValueError("市场环境数据为空, 请先在数据页完成市场环境计算后再回测") - - # 构建 date(ISO) → (state, score) 映射 - regime_map: dict[str, tuple[str, int]] = {} - for r in regime_df.iter_rows(named=True): - d = r.get("date") - ds = str(d)[:10] if d is not None else None - if ds: - regime_map[ds] = (str(r.get("state", "")), int(r.get("score", 0) or 0)) - - # 对每个 label, 找它的前一交易日的 regime(timestamp_labels 顺序里的前一天) - n = len(timestamp_labels) - mask = np.ones(n, dtype=bool) # 默认允许 - required_start_text = str(required_start) if required_start is not None else None - required_end_text = str(required_end) if required_end is not None else None - missing_dates: list[str] = [] - for i in range(1, n): - current_label = timestamp_labels[i][:10] - prev_label = timestamp_labels[i - 1][:10] - entry = regime_map.get(prev_label) - if entry is None: - required = ( - (required_start_text is None or current_label >= required_start_text) - and (required_end_text is None or current_label <= required_end_text) - ) - if required: - missing_dates.append(prev_label) - continue - state, score = entry - ok = True - if allowed_states and state not in allowed_states: - ok = False - if min_score is not None and score < min_score: - ok = False - mask[i] = ok - if missing_dates: - first_missing = missing_dates[0] - suffix = f" 等 {len(missing_dates)} 天" if len(missing_dates) > 1 else "" - raise ValueError( - f"市场环境数据覆盖不完整: 缺少前一交易日环境 {first_missing}{suffix}, " - "请先补算对应区间" - ) - return mask + regime_by_date = { + row["date"]: { + "state": row.get("state", ""), + "score": row.get("score", 0), + } + for row in regime_df.iter_rows(named=True) + if row.get("date") is not None + } + return build_regime_filter_mask( + timestamp_labels, + regime_filter, + regime_by_date, + required_start=required_start, + required_end=required_end, + ) def _build_candidate_filter_mask( self, diff --git a/backend/app/backtest/worker.py b/backend/app/backtest/worker.py index 1da69c6..f4fb102 100644 --- a/backend/app/backtest/worker.py +++ b/backend/app/backtest/worker.py @@ -22,6 +22,9 @@ class BacktestWorkerError(RuntimeError): """Raised when a spawned worker fails before returning a task result.""" +_CANCEL_GRACE_SECONDS = 5.0 + + class _PeakRssSampler: """Track whole-task and resettable phase RSS peaks with one sampling thread.""" @@ -136,6 +139,10 @@ def make_worker_task(kind: str, data_dir: Path, config) -> dict[str, Any]: encoded = asdict(config) encoded["start"] = config.start.isoformat() encoded["end"] = config.end.isoformat() + elif kind == "mining": + if not isinstance(config, dict): + raise TypeError("mining worker config must be a dict") + encoded = dict(config) else: raise ValueError(f"unsupported worker task kind: {kind}") return { @@ -165,8 +172,8 @@ def _worker_entry(task: dict[str, Any], event_queue, cancel_event) -> None: from app.backtest.engine import BacktestEngine from app.backtest.optimizer import StrategyOptimizer from app.backtest.strategy import StrategyBacktestService - from app.strategy.engine import StrategyEngine from app.strategy import config as strategy_config + from app.strategy.engine import StrategyEngine from app.tickflow.repository import DataStore, KlineRepository data_dir = Path(task["data_dir"]) @@ -201,6 +208,18 @@ def _worker_entry(task: dict[str, Any], event_queue, cancel_event) -> None: optimizer = StrategyOptimizer(service, strategy_engine) walkforward = WalkForwardService(optimizer, service, strategy_engine) result = walkforward.run(config, _progress, cancel_event) + elif kind == "mining": + from app.backtest.mining_runtime import run_mining_runtime + + result = run_mining_runtime( + task["config"], + data_dir=data_dir, + service=service, + strategy_engine=strategy_engine, + progress_cb=_progress, + cancel_check=cancel_event, + rss_sampler=sampler, + ) else: raise ValueError(f"unsupported worker task kind: {kind}") @@ -261,11 +280,20 @@ def run_worker_task( result: dict[str, Any] | None = None failure: dict[str, Any] | None = None ipc_started = time.perf_counter() + cancel_started: float | None = None try: while result is None and failure is None: if cancel_event is not None and cancel_event.is_set(): process_cancel.set() + if cancel_started is None: + cancel_started = time.monotonic() + elif time.monotonic() - cancel_started >= _CANCEL_GRACE_SECONDS: + process.terminate() + process.join(timeout=5.0) + raise BacktestWorkerError( + "backtest worker did not stop within 5 seconds after cancellation" + ) try: message = events.get(timeout=0.1) except queue.Empty: diff --git a/backend/app/enriched_generation.py b/backend/app/enriched_generation.py new file mode 100644 index 0000000..87fa81c --- /dev/null +++ b/backend/app/enriched_generation.py @@ -0,0 +1,319 @@ +from __future__ import annotations + +import json +import os +import threading +import time +import uuid +import weakref +from collections.abc import Iterator +from contextlib import contextmanager +from pathlib import Path +from typing import Any, BinaryIO + +import polars as pl + + +class EnrichedGenerationUnavailableError(RuntimeError): + """The enriched dataset has no stable generation available for readers.""" + + +_WRITER_LOCKS_GUARD = threading.Lock() +_WRITER_LOCKS: dict[tuple[str, str], threading.RLock] = {} +_ACTIVE_PUBLICATIONS: weakref.WeakValueDictionary[str, EnrichedPublication] = ( + weakref.WeakValueDictionary() +) + + +def _marker_path(data_dir: Path, asset_type: str) -> Path: + return Path(data_dir) / f".matrix_generation_{asset_type}.json" + + +def _writer_lock(data_dir: Path, asset_type: str) -> threading.RLock: + key = (str(Path(data_dir).resolve()), asset_type) + with _WRITER_LOCKS_GUARD: + return _WRITER_LOCKS.setdefault(key, threading.RLock()) + + +def _read_marker(path: Path) -> dict[str, Any] | None: + try: + payload = json.loads(path.read_text(encoding="utf-8")) + except FileNotFoundError: + return None + except (OSError, TypeError, ValueError, json.JSONDecodeError) as exc: + raise EnrichedGenerationUnavailableError( + "enriched data generation marker is invalid" + ) from exc + if not isinstance(payload, dict): + raise EnrichedGenerationUnavailableError( + "enriched data generation marker is invalid" + ) + return payload + + +def _fsync_directory(path: Path) -> None: + if os.name == "nt": + return + descriptor = os.open(path, os.O_RDONLY) + try: + os.fsync(descriptor) + finally: + os.close(descriptor) + + +def _write_marker(path: Path, payload: dict[str, Any]) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_name(f".{path.name}.{uuid.uuid4().hex}.tmp") + try: + with temporary.open("x", encoding="utf-8", newline="\n") as stream: + json.dump(payload, stream, separators=(",", ":")) + stream.flush() + os.fsync(stream.fileno()) + os.replace(temporary, path) + _fsync_directory(path.parent) + finally: + temporary.unlink(missing_ok=True) + + +def _unlock_file(stream: BinaryIO) -> None: + if os.name == "nt": + import msvcrt + + stream.seek(0) + msvcrt.locking(stream.fileno(), msvcrt.LK_UNLCK, 1) + return + import fcntl + + fcntl.flock(stream.fileno(), fcntl.LOCK_UN) + + +def _try_lock_file(stream: BinaryIO) -> None: + if os.name == "nt": + import msvcrt + + stream.seek(0) + try: + msvcrt.locking(stream.fileno(), msvcrt.LK_NBLCK, 1) + except OSError as exc: + raise EnrichedGenerationUnavailableError( + "another enriched publication is active" + ) from exc + return + import fcntl + + try: + fcntl.flock(stream.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB) + except OSError as exc: + raise EnrichedGenerationUnavailableError( + "another enriched publication is active" + ) from exc + + +@contextmanager +def _exclusive_generation_lock(data_dir: Path, asset_type: str) -> Iterator[None]: + lock_path = Path(data_dir) / f".matrix_generation_{asset_type}.lock" + lock_path.parent.mkdir(parents=True, exist_ok=True) + with ( + _writer_lock(data_dir, asset_type), + lock_path.open("a+b") as stream, + ): + stream.seek(0, os.SEEK_END) + if stream.tell() == 0: + stream.write(b"0") + stream.flush() + _try_lock_file(stream) + try: + yield + finally: + _unlock_file(stream) + + +def _process_is_alive(pid: Any) -> bool: + if not isinstance(pid, int) or pid <= 0: + return False + if pid == os.getpid(): + return True + try: + os.kill(pid, 0) + except ProcessLookupError: + return False + except (OSError, PermissionError): + return True + return True + + +def _ready_payload(generation: str) -> dict[str, Any]: + return { + "state": "ready", + "generation": generation, + "updated_at_ns": time.time_ns(), + } + + +def get_enriched_generation( + data_dir: Path, + asset_type: str = "stock", + *, + initialize: bool = True, +) -> str: + path = _marker_path(data_dir, asset_type) + payload = _read_marker(path) + if payload is None: + if not initialize: + raise EnrichedGenerationUnavailableError( + "enriched data generation marker is unavailable" + ) + with _exclusive_generation_lock(data_dir, asset_type): + payload = _read_marker(path) + if payload is None: + generation = uuid.uuid4().hex + _write_marker(path, _ready_payload(generation)) + return generation + state = payload.get("state", "ready") + generation = payload.get("generation") + if state != "ready" or not isinstance(generation, str) or not generation: + raise EnrichedGenerationUnavailableError( + "enriched data is being published; retry after the update finishes" + ) + return generation + + +def enriched_publication_incomplete( + data_dir: Path, + asset_type: str = "stock", +) -> bool: + try: + payload = _read_marker(_marker_path(data_dir, asset_type)) + except EnrichedGenerationUnavailableError: + return True + if payload is None: + return False + return ( + payload.get("state", "ready") != "ready" + or not isinstance(payload.get("generation"), str) + or not payload["generation"] + ) + + +def bump_enriched_generation(data_dir: Path, asset_type: str = "stock") -> str: + path = _marker_path(data_dir, asset_type) + with _exclusive_generation_lock(data_dir, asset_type): + current = _read_marker(path) + if current is not None and current.get("state", "ready") != "ready": + raise EnrichedGenerationUnavailableError( + "cannot bump an incomplete enriched publication" + ) + generation = uuid.uuid4().hex + _write_marker(path, _ready_payload(generation)) + return generation + + +class EnrichedPublication: + """Publish one logical enriched write batch under a stable generation token.""" + + def __init__( + self, + data_dir: Path, + asset_type: str = "stock", + *, + recover: bool = False, + ) -> None: + self.data_dir = Path(data_dir) + self.asset_type = asset_type + self.recover = recover + self._publishing = False + self._changed = False + self._base_generation: str | None = None + self._publication_id = uuid.uuid4().hex + + def begin(self) -> None: + with _exclusive_generation_lock(self.data_dir, self.asset_type): + self._claim_or_verify() + + def mark_changed(self) -> None: + if not self._publishing: + raise RuntimeError("enriched publication has not started") + self._changed = True + + def abandon(self) -> None: + if not self._publishing or self._changed: + return + path = _marker_path(self.data_dir, self.asset_type) + with _exclusive_generation_lock(self.data_dir, self.asset_type): + current = _read_marker(path) + if current is not None and current.get("publication_id") == self._publication_id: + _write_marker(path, _ready_payload(str(self._base_generation))) + self._publishing = False + + def write_parquet(self, df: pl.DataFrame, out: Path) -> None: + out.parent.mkdir(parents=True, exist_ok=True) + temporary = out.with_name(f".{out.name}.{uuid.uuid4().hex}.tmp") + try: + df.write_parquet(temporary) + with temporary.open("r+b") as stream: + stream.flush() + os.fsync(stream.fileno()) + with _exclusive_generation_lock(self.data_dir, self.asset_type): + self._claim_or_verify() + os.replace(temporary, out) + _fsync_directory(out.parent) + self._changed = True + finally: + temporary.unlink(missing_ok=True) + + def commit(self) -> str | None: + if not self._changed: + return None + path = _marker_path(self.data_dir, self.asset_type) + with _exclusive_generation_lock(self.data_dir, self.asset_type): + current = _read_marker(path) + if current is None or current.get("publication_id") != self._publication_id: + raise EnrichedGenerationUnavailableError( + "enriched publication ownership was lost" + ) + generation = uuid.uuid4().hex + _write_marker(path, _ready_payload(generation)) + self._publishing = False + return generation + + def _claim_or_verify(self) -> None: + path = _marker_path(self.data_dir, self.asset_type) + try: + current = _read_marker(path) + except EnrichedGenerationUnavailableError: + if not self.recover: + raise + current = None + if self._publishing: + if current is None or current.get("publication_id") != self._publication_id: + raise EnrichedGenerationUnavailableError( + "enriched publication ownership was lost" + ) + return + _ACTIVE_PUBLICATIONS[self._publication_id] = self + if current is not None and current.get("state", "ready") != "ready": + current_id = current.get("publication_id") + current_owner = _ACTIVE_PUBLICATIONS.get(str(current_id)) + owner_pid = current.get("owner_pid") + if current_owner is not None or ( + owner_pid != os.getpid() and _process_is_alive(owner_pid) + ): + raise EnrichedGenerationUnavailableError( + "another enriched publication is active" + ) + if not self.recover: + raise EnrichedGenerationUnavailableError( + "another enriched publication is incomplete" + ) + generation = None if current is None else current.get("generation") + if not isinstance(generation, str) or not generation: + generation = uuid.uuid4().hex + self._base_generation = generation + _write_marker(path, { + "state": "publishing", + "generation": generation, + "publication_id": self._publication_id, + "owner_pid": os.getpid(), + "updated_at_ns": time.time_ns(), + }) + self._publishing = True diff --git a/backend/app/indicators/pipeline.py b/backend/app/indicators/pipeline.py index 24ade27..99ea33f 100644 --- a/backend/app/indicators/pipeline.py +++ b/backend/app/indicators/pipeline.py @@ -22,6 +22,10 @@ from pathlib import Path import polars as pl from app.config import settings +from app.enriched_generation import ( + EnrichedPublication, + enriched_publication_incomplete, +) from app.market_time import cn_today from app.parquet import scan_daily_parquet, scan_enriched_parquet, scan_parquet_compat from app.price_limits import ( @@ -350,7 +354,12 @@ def _resolve_needed(needed: set[str] | None) -> set[str]: return want -def compute_indicators(df: pl.DataFrame, needed: set[str] | None = None) -> pl.DataFrame: +def compute_indicators( + df: pl.DataFrame, + needed: set[str] | None = None, + *, + assume_sorted: bool = False, +) -> pl.DataFrame: """从 OHLCV 数据计算全套技术指标。 输入必须包含: symbol, date, open, high, low, close, volume @@ -370,7 +379,7 @@ def compute_indicators(df: pl.DataFrame, needed: set[str] | None = None) -> pl.D want = _resolve_needed(needed) - df = df.sort(["symbol", "date"]) + df = df if assume_sorted else df.sort(["symbol", "date"]) # Pass 1: 均线 + EMA + MACD 基础 + BOLL 基础 + KDJ 基础 + ATR 基础 + 量价 + 极值 prev_close = pl.col("close").shift(1).over("symbol") @@ -670,7 +679,7 @@ def compute_limit_signals( signal_limit_down_recovery (跌停翘板) signal_broken_limit_up (炸板: 最高价触及涨停价但收盘未封住) - 输入必须包含: symbol, date, raw_close, raw_high, open, high, low, close, + 输入必须包含: symbol, date, raw_close, raw_high, raw_low, open, high, low, close, change_pct, vol_ratio_5d。 """ if df.is_empty(): @@ -879,9 +888,10 @@ def compute_limit_signals( pl.when( pl.col("_prev_raw_close").is_not_null() & (pl.col("_prev_raw_close") > 0) + & (pl.col("raw_low") > 0) ).then( (~pl.col("signal_limit_down").fill_null(False)) # 最终没跌停 - & (pl.col("low") <= pl.col("_effective_limit_down") + 0.005) # 曾触及跌停 + & (pl.col("raw_low") <= pl.col("_effective_limit_down") + 0.005) # 曾触及跌停(原始价口径, 跌停价为原始价基准) & (pl.col("close") > pl.col("open")) # 收阳 ).otherwise(None).cast(pl.Boolean) .alias("signal_limit_down_recovery") @@ -1045,6 +1055,11 @@ def run_pipeline(data_dir: Path | None = None, t0 = _t.perf_counter() d = Path(data_dir or settings.data_dir) + if enriched_publication_incomplete(d, "stock"): + logger.warning("检测到未完成的 enriched 发布,改为全量重建") + symbols = None + new_dates_only = False + publication = EnrichedPublication(d, "stock", recover=True) daily_dir = d / "kline_daily" enriched_base = d / "kline_daily_enriched" factor_path = d / "adj_factor" / "all.parquet" @@ -1134,7 +1149,7 @@ def run_pipeline(data_dir: Path | None = None, out = enriched_base / f"date={ds}" / "part.parquet" out.parent.mkdir(parents=True, exist_ok=True) date_df = _select_storage_cols(date_df).sort(["symbol"]) - date_df.write_parquet(out) + publication.write_parquet(date_df, out) written += date_df.height t_write_new = _t.perf_counter() logger.info("增量写入: %.2fs, %d 行", t_write_new - t_new, written) @@ -1166,10 +1181,11 @@ def run_pipeline(data_dir: Path | None = None, existing = existing.filter(~pl.col("symbol").is_in(list(sym_set))) date_df_storage = pl.concat([existing, date_df_storage], how="diagonal_relaxed") date_df_storage = date_df_storage.sort(["symbol"]) - date_df_storage.write_parquet(out) + publication.write_parquet(date_df_storage, out) written += date_df.height logger.info("除权重算: %d 只, 共写入 %d 行", len(sym_set), written) + publication.commit() t_done = _t.perf_counter() logger.info("增量管道完成: %.2fs, %d 行", t_done - t0, written) return written @@ -1267,7 +1283,7 @@ def run_pipeline(data_dir: Path | None = None, existing = existing.filter(~pl.col("symbol").is_in(batch_syms)) date_df_storage = pl.concat([existing, date_df_storage], how="diagonal_relaxed") date_df_storage = date_df_storage.sort(["symbol"]) - date_df_storage.write_parquet(out) + publication.write_parquet(date_df_storage, out) written += date_df_storage.height else: # 全量模式: 缓冲到 date_buffers, 最后一次性写入 @@ -1308,11 +1324,12 @@ def run_pipeline(data_dir: Path | None = None, out = base / f"date={ds}" / "part.parquet" out.parent.mkdir(parents=True, exist_ok=True) merged = pl.concat(dfs, how="diagonal_relaxed").sort(["symbol"]) - merged.write_parquet(out) + publication.write_parquet(merged, out) date_buffers.clear() gc.collect() + publication.commit() t_done = _t.perf_counter() adj_label = "含复权" if not factors.is_empty() else "无复权" logger.info("enriched 完成 [%s]: %.2fs, 共 %d 行, %s", @@ -1339,9 +1356,13 @@ def _load_recent_history(enriched_base: Path, symbols: list[str], days: int) -> from datetime import date, timedelta cutoff = date.today() - timedelta(days=days + 30) # 多读 30 天余量 + cast_options = pl.ScanCastOptions(integer_cast="allow-float") try: lf = ( - scan_enriched_parquet(str(enriched_base / "**" / "*.parquet"), cast_options=_cast) + scan_enriched_parquet( + str(enriched_base / "**" / "*.parquet"), + cast_options=cast_options, + ) .filter( (pl.col("symbol").is_in(symbols)) & (pl.col("date") >= cutoff) @@ -1814,10 +1835,10 @@ def _compute_limit_signals_today(df: pl.DataFrame, instruments: pl.DataFrame) -> # 跌停翘板 pl.when(no_price_limit) .then(False) - .when(valid_prev_raw | has_authoritative_down) + .when((valid_prev_raw | has_authoritative_down) & (pl.col("raw_low") > 0)) .then( (~is_limit_down.fill_null(True)) - & (pl.col("low") <= effective_limit_down + 0.005) + & (pl.col("raw_low") <= effective_limit_down + 0.005) & (pl.col("close") > pl.col("open")) ).otherwise(None).cast(pl.Boolean) .alias("signal_limit_down_recovery"), diff --git a/backend/app/jobs/daily_pipeline.py b/backend/app/jobs/daily_pipeline.py index 6a70541..34f2698 100644 --- a/backend/app/jobs/daily_pipeline.py +++ b/backend/app/jobs/daily_pipeline.py @@ -542,6 +542,28 @@ def run_now( stage_errors.append(f"compute_regime: {e}") skipped.append("regime") + # Step 2.7: 市场主线(概念/行业涨停梯队聚合) 增量计算 — regime 同开关。 + # 只窄扫连板 >=1 的行, 增量通常 1 天, 开销可忽略。软失败: 不阻断主管道。 + mainline_rows = 0 + if not _prefs_regime.get_pipeline_regime_enabled(): + skipped.append("mainline") + else: + try: + emit("compute_mainline", 93, "计算市场主线…") + from app.services import market_mainline + for _kind in ("concept", "industry"): + rows = market_mainline.compute_mainline_incremental( + repo, repo.store.data_dir, kind=_kind + ) + mainline_rows += rows.height if not rows.is_empty() else 0 + if mainline_rows: + logger.info("compute_mainline: %d rows", mainline_rows) + emit("compute_mainline", 94, f"市场主线 {mainline_rows} 行") + except Exception as e: + logger.warning("compute_mainline failed (soft): %s", e) + stage_errors.append(f"compute_mainline: {e}") + skipped.append("mainline") + # Step 3: 刷新视图 emit("refresh_views", 95, "刷新 DuckDB 视图…") _refresh_views(repo) @@ -561,6 +583,7 @@ def run_now( "etf_adj_factor_symbols": etf_adj_symbols, "minute_rows": written_minute, "regime_days": regime_days, + "mainline_rows": mainline_rows, "lagging_symbols": len(lagging_symbols), "skipped_stages": skipped, "stage_errors": stage_errors, @@ -626,37 +649,54 @@ def _refresh_instruments_view(repo: KlineRepository) -> None: logger.warning("refresh instruments view failed: %s", e) -def _run_tracked(fn, job_label: str) -> None: +def _run_tracked(fn, job_label: str) -> bool: """调度触发时包装 JobStore 跟踪，确保同步历史有记录。 单飞: 若已有活跃(pending∨running)任务(手动同步中), 本次调度直接跳过, 不并发。 重任务执行槽: 再挡一层僵尸并发(reap 后线程仍活时不得并行写 parquet)。 + 返回 True 仅表示任务已成功并且执行槽已释放。 """ from app.services.pipeline_jobs import job_store, release_run_slot, try_acquire_run_slot job_id, is_new = job_store.create() if not is_new: logger.info("scheduled %s 跳过: 已有活跃任务在运行 (job_id=%s)", job_label, job_id) - return + return False if not try_acquire_run_slot(): logger.warning("scheduled %s 跳过: 重任务执行槽被占用(疑似上次任务卡死)", job_label) job_store.fail(job_id, f"scheduled {job_label} skipped: 已有数据任务在运行") - return + return False def progress(stage: str, pct: int, msg: str, stage_pct: int | None = None, skip_log: bool = False) -> None: job_store.progress(job_id, stage, pct, msg, stage_pct=stage_pct, skip_log=skip_log) + succeeded = False try: job_store.start(job_id) result = fn(on_progress=progress) job_store.succeed(job_id, result) + succeeded = True logger.info("scheduled %s completed: job_id=%s", job_label, job_id) except Exception: logger.exception("scheduled %s failed: job_id=%s", job_label, job_id) job_store.fail(job_id, f"scheduled {job_label} failed") finally: release_run_slot() + return succeeded + + +def _scheduled_pipeline_task(pipeline_fn) -> None: + """Run weekly mining only after the tracked daily pipeline has fully succeeded.""" + if not _run_tracked(pipeline_fn, "daily_pipeline"): + return + try: + from app.services.mining_schedule import run_weekly_mining + + result = run_weekly_mining(_get_app_state()) + logger.info("scheduled mining result: %s", result) + except Exception: + logger.exception("scheduled mining enqueue failed; daily pipeline remains succeeded") # ================================================================ @@ -916,7 +956,7 @@ def start_scheduler(repo: KlineRepository, capset: CapabilitySet) -> AsyncIOSche return result scheduler.add_job( - lambda: _run_tracked(_pipeline_then_refresh, "daily_pipeline"), + lambda: _scheduled_pipeline_task(_pipeline_then_refresh), trigger=CronTrigger(day_of_week="mon-fri", hour=sched["hour"], minute=sched["minute"], timezone="Asia/Shanghai"), diff --git a/backend/app/main.py b/backend/app/main.py index 09ea0f2..2beb09f 100644 --- a/backend/app/main.py +++ b/backend/app/main.py @@ -3,7 +3,6 @@ from __future__ import annotations import logging import sys -import threading from contextlib import asynccontextmanager from pathlib import Path @@ -13,15 +12,42 @@ from fastapi.responses import FileResponse, JSONResponse from fastapi.staticfiles import StaticFiles from app import __version__ -from app.api import analysis, auth as auth_api, backtest, data, ext_data, financials, indices, intraday, kline, market_recap, monitor_rules, alerts, overview, pipeline, regime, rps, screener, settings as settings_api, signals, stock_analysis, strategy, watchlist +from app.api import ( + alerts, + analysis, + backtest, + data, + ext_data, + financials, + indices, + intraday, + kline, + market_recap, + mining, + monitor_rules, + overview, + pipeline, + regime, + rps, + screener, + signals, + stock_analysis, + strategy, + watchlist, +) +from app.api import auth as auth_api +from app.api import settings as settings_api from app.api.routes import router as core_router from app.config import settings +from app.enriched_generation import EnrichedGenerationUnavailableError from app.extensions.loader import ( configure_backend_extensions, current_extension_context, start_backend_extensions, ) from app.jobs import daily_pipeline +from app.services.matrix_prewarm_owner import MatrixCachePrewarmOwner +from app.services.mining_process_lock import MiningProcessLock from app.services.quote_service import QuoteService from app.tickflow import client as tf_client from app.tickflow.policy import detect_capabilities @@ -57,7 +83,7 @@ if not getattr(sys, "frozen", False): @asynccontextmanager -async def lifespan(app: FastAPI): +async def _application_lifespan(app: FastAPI): logger.info( "Tick Stock Panel v%s starting (mode=%s)", __version__, tf_client.current_mode(), @@ -76,9 +102,19 @@ async def lifespan(app: FastAPI): repo = KlineRepository(store) app.state.datastore = store app.state.repo = repo + from app.services.mining_manager import MiningJobManager + + mining_manager = MiningJobManager(store.data_dir) + recovered_mining_runs = mining_manager.recover_interrupted() + app.state.mining_manager = mining_manager + if recovered_mining_runs: + logger.warning("recovered %d interrupted mining runs", recovered_mining_runs) # 在接受回测请求前固定 managed generation，避免首批并发 worker 各自创建版本。 if settings.backtest_matrix_disk_cache_enabled: - repo.get_matrix_data_generation("stock") + try: + repo.get_matrix_data_generation("stock") + except EnrichedGenerationUnavailableError as exc: + logger.warning("enriched generation requires a full rebuild: %s", exc) # 指标异步预热标志: enriched 缓存在后台线程构建, 完成后置 True app.state.indicators_ready = False repo._on_warmup_done = lambda: setattr(app.state, "indicators_ready", True) # noqa: SLF001 @@ -188,51 +224,50 @@ async def lifespan(app: FastAPI): app.state.strategy_engine = strategy_engine logger.info("strategy engine loaded: %d strategies", len(strategy_engine.list_strategies())) - matrix_prewarm_lock = threading.Lock() - matrix_prewarm_running = False + matrix_prewarm_owner = MatrixCachePrewarmOwner() def _schedule_matrix_cache_prewarm() -> None: - nonlocal matrix_prewarm_running if ( not settings.backtest_matrix_disk_cache_enabled or not settings.backtest_matrix_cache_prewarm ): return - with matrix_prewarm_lock: - if matrix_prewarm_running: - logger.info("matrix cache prewarm already in progress, skip") - return - matrix_prewarm_running = True def _prewarm() -> None: - nonlocal matrix_prewarm_running + from app.backtest.engine import BacktestEngine + from app.backtest.matrix import MatrixPrewarmCancelledError + from app.backtest.strategy import prewarm_matrix_cache + from app.services.heavy_job_limiter import ( + HeavyJobCancelledError, + shared_heavy_job_limiter, + ) + try: latest = repo.latest_enriched_date("stock") if latest is None: logger.info("matrix cache prewarm skipped: no stock enriched data") return - from app.backtest.engine import BacktestEngine - from app.backtest.strategy import prewarm_matrix_cache - result = prewarm_matrix_cache( - BacktestEngine(repo), - strategy_engine, - asset_type="stock", - latest_date=latest, - years=settings.backtest_matrix_cache_prewarm_years, - ) + with shared_heavy_job_limiter.slot( + "normal", + cancel_event=matrix_prewarm_owner.cancel_event, + ): + result = prewarm_matrix_cache( + BacktestEngine(repo), + strategy_engine, + asset_type="stock", + latest_date=latest, + years=settings.backtest_matrix_cache_prewarm_years, + cancel_event=matrix_prewarm_owner.cancel_event, + ) logger.info("matrix cache prewarm done: %s", result) + except (HeavyJobCancelledError, MatrixPrewarmCancelledError): + logger.info("matrix cache prewarm cancelled") except Exception: # noqa: BLE001 logger.exception("matrix cache prewarm failed") - finally: - with matrix_prewarm_lock: - matrix_prewarm_running = False - threading.Thread( - target=_prewarm, - name="matrix-cache-prewarm", - daemon=True, - ).start() + if not matrix_prewarm_owner.schedule(_prewarm): + logger.info("matrix cache prewarm already running or shutting down, skip") repo._on_refresh_done = _schedule_matrix_cache_prewarm # noqa: SLF001 if repo.enriched_ready: @@ -281,26 +316,44 @@ async def lifespan(app: FastAPI): extension_registry, ) - yield + try: + yield + finally: + repo._on_refresh_done = None # noqa: SLF001 + if not matrix_prewarm_owner.shutdown(timeout=5.0): + logger.warning("matrix cache prewarm did not stop within 5 seconds") + mmanager = getattr(app.state, "mining_manager", None) + if mmanager: + mmanager.shutdown() + if app.state.scheduler: + app.state.scheduler.shutdown(wait=False) + ps = getattr(app.state, "pull_scheduler", None) + if ps: + ps.stop() + fsc = getattr(app.state, "financial_scheduler", None) + if fsc: + fsc.stop() + qs = getattr(app.state, "quote_service", None) + if qs: + qs.stop() + dsvc = getattr(app.state, "depth_service", None) + if dsvc: + dsvc.stop_polling() + wbot = getattr(app.state, "wecom_bot_service", None) + if wbot: + wbot.stop() + logger.info("shutdown") - if app.state.scheduler: - app.state.scheduler.shutdown(wait=False) - ps = getattr(app.state, "pull_scheduler", None) - if ps: - ps.stop() - fsc = getattr(app.state, "financial_scheduler", None) - if fsc: - fsc.stop() - qs = getattr(app.state, "quote_service", None) - if qs: - qs.stop() - dsvc = getattr(app.state, "depth_service", None) - if dsvc: - dsvc.stop_polling() - wbot = getattr(app.state, "wecom_bot_service", None) - if wbot: - wbot.stop() - logger.info("shutdown") + +@asynccontextmanager +async def lifespan(app: FastAPI): + mining_process_lock = MiningProcessLock(settings.data_dir) + mining_process_lock.acquire() + try: + async with _application_lifespan(app): + yield + finally: + mining_process_lock.release() app = FastAPI( @@ -374,6 +427,7 @@ app.include_router(kline.router) app.include_router(watchlist.router) app.include_router(screener.router) app.include_router(backtest.router) +app.include_router(mining.router) app.include_router(intraday.router) app.include_router(indices.router) app.include_router(overview.router) diff --git a/backend/app/services/ext_data.py b/backend/app/services/ext_data.py index 9129541..8a6ff27 100644 --- a/backend/app/services/ext_data.py +++ b/backend/app/services/ext_data.py @@ -1,6 +1,7 @@ """扩展数据服务 — 配置管理 + 文件解析 + Parquet 存储。""" from __future__ import annotations +import copy import json import logging import re @@ -187,17 +188,48 @@ class ExtConfig: # 配置持久化 # --------------------------------------------------------------------------- +# load_all 进程内缓存: kline/screener/watchlist 等热路径每请求调用, 每次都 +# iterdir + 逐 config.json read_text+parse 纯重复; 以配置目录的 +# (目录名, mtime_ns, size) 签名失效 (新增/编辑/删除配置都会改变签名)。 +_load_all_cache: dict[str, tuple[tuple, list[ExtConfig]]] = {} + + +def _ext_config_dir_signature(base: Path) -> tuple | None: + """配置目录下所有 config.json 的 (目录名, mtime_ns, size) 签名; 出错返回 None (禁用缓存)。""" + try: + sig = [] + for d in sorted(base.iterdir()): + cp = d / "config.json" + if d.is_dir() and cp.exists(): + st = cp.stat() + sig.append((d.name, st.st_mtime_ns, st.st_size)) + return tuple(sig) + except Exception: # noqa: BLE001 + return None + + class ExtConfigStore: """扩展数据配置文件读写 — 每个表独立目录 data/ext/{config_id}/config.json。""" + # 与创建端点 CreateExtReq.id 的 pattern 一致; load_all 之外的 config_id + # 来自 URL path 参数, 必须先过白名单再拼路径, 防止 ../ 穿越删除。 + _VALID_ID = re.compile(r"^[a-zA-Z0-9_]+$") + def __init__(self, data_dir: Path) -> None: self._base = data_dir / "ext_data" def _config_path(self, config_id: str) -> Path: + if not self._VALID_ID.match(config_id): + raise ValueError(f"非法 config_id: {config_id!r}") return self._base / config_id / "config.json" def load_all(self) -> list[ExtConfig]: # 兼容旧版: 如果目录为空且旧配置文件存在则迁移 + sig = _ext_config_dir_signature(self._base) + if sig is not None: + cached = _load_all_cache.get(str(self._base)) + if cached is not None and cached[0] == sig: + return copy.deepcopy(cached[1]) if not self._base.exists() or not any(self._base.iterdir()): old = self._base.parent / "ext_configs.json" if not old.exists(): @@ -215,10 +247,16 @@ class ExtConfigStore: configs.append(ExtConfig.from_dict(raw)) except Exception as e: logger.warning("扩展表配置解析失败 %s: %s", cp, e) + if sig is not None and configs: + # 缓存存私有副本, 命中时返回深拷贝, 调用方改配置对象不会污染缓存。 + _load_all_cache[str(self._base)] = (sig, copy.deepcopy(configs)) return configs def get(self, config_id: str) -> ExtConfig | None: - cp = self._config_path(config_id) + try: + cp = self._config_path(config_id) + except ValueError: + return None if not cp.exists(): return None try: @@ -238,7 +276,10 @@ class ExtConfigStore: def delete(self, config_id: str) -> bool: import shutil - cp = self._config_path(config_id) + try: + cp = self._config_path(config_id) + except ValueError: + return False if not cp.exists(): return False shutil.rmtree(cp.parent, ignore_errors=True) diff --git a/backend/app/services/financial_sync.py b/backend/app/services/financial_sync.py index fe0b5a3..7b857eb 100644 --- a/backend/app/services/financial_sync.py +++ b/backend/app/services/financial_sync.py @@ -154,7 +154,7 @@ def _sync_table( ) -def _merge_share_history(*frames: pl.DataFrame) -> pl.DataFrame: +def _merge_report_history(*frames: pl.DataFrame) -> pl.DataFrame: valid = [ frame for frame in frames @@ -162,65 +162,74 @@ def _merge_share_history(*frames: pl.DataFrame) -> pl.DataFrame: ] if not valid: return pl.DataFrame() - return ( + merged = ( pl.concat(valid, how="diagonal_relaxed") .filter(pl.col("symbol").is_not_null() & pl.col("period_end").is_not_null()) - .unique(subset=["symbol", "period_end"], keep="last") - .sort(["symbol", "period_end"]) + ) + # 同一 (symbol, period_end) 多条时保留 announce_date 最新一条 (业绩修正以最新公告为准)。 + if "announce_date" in merged.columns: + merged = merged.sort(["symbol", "period_end", "announce_date"], nulls_last=True) + return merged.unique(subset=["symbol", "period_end"], keep="last").sort( + ["symbol", "period_end"] ) -def _sync_shares_for_symbols( +def _sync_history_table_for_symbols( + table: str, symbols: list[str], data_dir: Path, capset: CapabilitySet, ) -> int: - """首次拉全量股本历史，后续更新最新记录并补齐新增标的历史。""" - existing = get_financial_df(data_dir, "shares") + """历史累积同步: 保留已有各期记录, 仅拉最新期 + 为新标的补全量历史。 + + 与 shares 同一模式。若改为 latest_only 全量覆盖, 历史各期会在每次同步时 + 被冲掉, 财务因子将永远只有单期快照, 任何回测都是未来函数。 + """ + existing = get_financial_df(data_dir, table) if existing.is_empty() or not {"symbol", "period_end"} <= set(existing.columns): - return _sync_table("shares", symbols, data_dir, capset, latest_only=False) + return _sync_table(table, symbols, data_dir, capset, latest_only=False) existing_symbols = set(existing["symbol"].drop_nulls().to_list()) missing_symbols = [symbol for symbol in symbols if symbol not in existing_symbols] missing_history = ( - _fetch_table("shares", missing_symbols, capset, latest_only=False) + _fetch_table(table, missing_symbols, capset, latest_only=False) if missing_symbols else pl.DataFrame() ) current_symbols = [symbol for symbol in symbols if symbol in existing_symbols] - latest = _fetch_table("shares", current_symbols, capset, latest_only=True) - merged = _merge_share_history(existing, missing_history, latest) - return _write_table("shares", merged, data_dir) + latest = _fetch_table(table, current_symbols, capset, latest_only=True) + merged = _merge_report_history(existing, missing_history, latest) + return _write_table(table, merged, data_dir) def sync_metrics(data_dir: Path, capset: CapabilitySet) -> int: - """同步核心财务指标 (metrics)。""" + """同步核心财务指标 (metrics), 历史各期累积保留。""" symbols = _get_symbols(data_dir) - return _sync_table("metrics", symbols, data_dir, capset, latest_only=True) + return _sync_history_table_for_symbols("metrics", symbols, data_dir, capset) def sync_income(data_dir: Path, capset: CapabilitySet) -> int: - """同步利润表。""" + """同步利润表, 历史各期累积保留。""" symbols = _get_symbols(data_dir) - return _sync_table("income", symbols, data_dir, capset, latest_only=True) + return _sync_history_table_for_symbols("income", symbols, data_dir, capset) def sync_balance_sheet(data_dir: Path, capset: CapabilitySet) -> int: - """同步资产负债表。""" + """同步资产负债表, 历史各期累积保留。""" symbols = _get_symbols(data_dir) - return _sync_table("balance_sheet", symbols, data_dir, capset, latest_only=True) + return _sync_history_table_for_symbols("balance_sheet", symbols, data_dir, capset) def sync_cash_flow(data_dir: Path, capset: CapabilitySet) -> int: - """同步现金流量表。""" + """同步现金流量表, 历史各期累积保留。""" symbols = _get_symbols(data_dir) - return _sync_table("cash_flow", symbols, data_dir, capset, latest_only=True) + return _sync_history_table_for_symbols("cash_flow", symbols, data_dir, capset) def sync_shares(data_dir: Path, capset: CapabilitySet) -> int: """同步历史股本表。""" symbols = _get_symbols(data_dir) - return _sync_shares_for_symbols(symbols, data_dir, capset) + return _sync_history_table_for_symbols("shares", symbols, data_dir, capset) def sync_all(data_dir: Path, capset: CapabilitySet) -> dict[str, int]: @@ -232,10 +241,8 @@ def sync_all(data_dir: Path, capset: CapabilitySet) -> dict[str, int]: symbols = _get_symbols(data_dir) results: dict[str, int] = {} for table in FINANCIAL_TABLES: - results[table] = ( - _sync_shares_for_symbols(symbols, data_dir, capset) - if table == "shares" - else _sync_table(table, symbols, data_dir, capset, latest_only=True) + results[table] = _sync_history_table_for_symbols( + table, symbols, data_dir, capset ) # 同步完成后注册 DuckDB 视图 @@ -428,10 +435,8 @@ class FinancialScheduler: symbols = _get_symbols(self._data_dir) result: dict[str, int] = {} for t in FINANCIAL_TABLES: - result[t] = ( - _sync_shares_for_symbols(symbols, self._data_dir, self._capset) - if t == "shares" - else _sync_table(t, symbols, self._data_dir, self._capset, latest_only=True) + result[t] = _sync_history_table_for_symbols( + t, symbols, self._data_dir, self._capset ) self._record_sync(t) _refresh_financials_views(self._data_dir) diff --git a/backend/app/services/heavy_job_limiter.py b/backend/app/services/heavy_job_limiter.py new file mode 100644 index 0000000..65c7e88 --- /dev/null +++ b/backend/app/services/heavy_job_limiter.py @@ -0,0 +1,121 @@ +"""Weighted process-local limiter for memory-heavy jobs.""" + +from __future__ import annotations + +import threading +import time +from collections.abc import Iterator +from contextlib import contextmanager +from typing import ClassVar, Literal + +HeavyJobKind = Literal["normal", "mining"] + + +class HeavyJobLimitTimeoutError(TimeoutError): + """Raised when a heavy-job slot cannot be acquired before its deadline.""" + + +class HeavyJobCancelledError(RuntimeError): + """Raised when slot acquisition is cancelled while waiting.""" + + +class HeavyJobLimiter: + """A weighted limiter where normal jobs cost one slot and mining costs two.""" + + _WEIGHTS: ClassVar[dict[HeavyJobKind, int]] = {"normal": 1, "mining": 2} + + def __init__(self, capacity: int = 2, *, cancel_poll_interval: float = 0.05) -> None: + if capacity <= 0: + raise ValueError("capacity must be positive") + if cancel_poll_interval <= 0: + raise ValueError("cancel_poll_interval must be positive") + self.capacity = capacity + self._cancel_poll_interval = cancel_poll_interval + self._used = 0 + self._acquired = {"normal": 0, "mining": 0} + self._condition = threading.Condition() + + @property + def in_use(self) -> int: + with self._condition: + return self._used + + @property + def available(self) -> int: + with self._condition: + return self.capacity - self._used + + def acquire( + self, + kind: HeavyJobKind = "normal", + *, + timeout: float | None = None, + cancel_event: threading.Event | None = None, + ) -> bool: + """Wait for capacity and return ``False`` on cancellation or timeout.""" + weight = self._weight(kind) + if weight > self.capacity: + raise ValueError(f"{kind} requires {weight} slots, capacity is {self.capacity}") + if timeout is not None and timeout < 0: + raise ValueError("timeout must be non-negative") + + deadline = None if timeout is None else time.monotonic() + timeout + with self._condition: + while True: + if cancel_event is not None and cancel_event.is_set(): + return False + if self._used + weight <= self.capacity: + self._used += weight + self._acquired[kind] += 1 + return True + + remaining = None if deadline is None else deadline - time.monotonic() + if remaining is not None and remaining <= 0: + return False + wait_for = remaining + if cancel_event is not None: + wait_for = self._cancel_poll_interval + if remaining is not None: + wait_for = min(wait_for, remaining) + self._condition.wait(wait_for) + + def release(self, kind: HeavyJobKind = "normal") -> None: + """Return capacity previously acquired for ``kind``.""" + weight = self._weight(kind) + with self._condition: + if self._acquired[kind] == 0: + raise RuntimeError(f"cannot release unacquired {kind} capacity") + self._acquired[kind] -= 1 + self._used -= weight + self._condition.notify_all() + + @contextmanager + def slot( + self, + kind: HeavyJobKind = "normal", + *, + timeout: float | None = None, + cancel_event: threading.Event | None = None, + ) -> Iterator[HeavyJobLimiter]: + """Acquire weighted capacity for the duration of a ``with`` block.""" + acquired = self.acquire(kind, timeout=timeout, cancel_event=cancel_event) + if not acquired: + if cancel_event is not None and cancel_event.is_set(): + raise HeavyJobCancelledError(f"{kind} job was cancelled while waiting") + raise HeavyJobLimitTimeoutError(f"timed out waiting for {kind} job capacity") + try: + yield self + finally: + self.release(kind) + + @classmethod + def _weight(cls, kind: HeavyJobKind) -> int: + try: + return cls._WEIGHTS[kind] + except KeyError as exc: + raise ValueError(f"unsupported heavy job kind: {kind!r}") from exc + + +shared_heavy_job_limiter = HeavyJobLimiter(capacity=2) +# Short alias for entry points that prefer the existing module-singleton naming style. +heavy_job_limiter = shared_heavy_job_limiter diff --git a/backend/app/services/kline_sync.py b/backend/app/services/kline_sync.py index 3aa00ca..46789c1 100644 --- a/backend/app/services/kline_sync.py +++ b/backend/app/services/kline_sync.py @@ -15,7 +15,7 @@ import polars as pl from app.data_providers.base import AssetType from app.indicators.pipeline import filter_halt_days -from app.market_time import cn_now +from app.market_time import CN_TZ, cn_now, cn_today from app.services import preferences from app.tickflow.capabilities import Cap, CapabilitySet from app.tickflow.client import get_client @@ -266,7 +266,9 @@ def sync_daily_by_quotes(repo: KlineRepository) -> int: if df.is_empty(): return 0 - today = _date.today() + # 分区日期用北京交易日 (与 quote_service._build_daily 的 cn_today 一致), + # 避免 UTC 服务器在盘中把日分区写成服务器本地日期。 + today = cn_today() daily_df = df.with_columns(pl.lit(today).cast(pl.Date).alias("date")) # 过滤停牌 (open/high 为 0; close 可能被填充为前收盘价, 不能用全零判断) @@ -833,8 +835,10 @@ def fetch_minute_single( ) -> pl.DataFrame: """实时拉取单股单日分钟 K(不写入本地)。优先自定义分钟源, 回退 TickFlow。""" from datetime import datetime - start_time = datetime(trade_date.year, trade_date.month, trade_date.day, 9, 25, 0) - end_time = datetime(trade_date.year, trade_date.month, trade_date.day, 15, 5, 0) + # 北京时间窗口必须带时区: naive datetime 会被 .timestamp() 按服务器本地时区解释, + # UTC 容器上窗口整体偏移 8 小时, 分时补拉必然为空。 + start_time = datetime(trade_date.year, trade_date.month, trade_date.day, 9, 25, 0, tzinfo=CN_TZ) + end_time = datetime(trade_date.year, trade_date.month, trade_date.day, 15, 5, 0, tzinfo=CN_TZ) # 自定义数据源分流: 与 sync_minute_batch 一致, 配了自定义分钟源时走 custom provider, # 避免无 TickFlow Pro+ 权限的用户分时图首次打开(本地无数据)时补拉失败返回空。 diff --git a/backend/app/services/market_mainline.py b/backend/app/services/market_mainline.py new file mode 100644 index 0000000..2344957 --- /dev/null +++ b/backend/app/services/market_mainline.py @@ -0,0 +1,248 @@ +"""市场主线(板块/概念)识别 — 基于涨停梯队的历史聚合。 + +用户判据的量化: 主升阶段的主线 = 同一概念内涨停家数多、最高连板高、 +梯队档位填得满(2 板到最高板之间不断层)。对每个交易日按概念聚合涨停梯队, +截面 rank 归一后加权成主线分, 持久化为日频时序, 供市场环境页展示 +"什么阶段走什么主升"。 + +口径限制(重要): 概念成分来自 ext_gn_ths 快照(本地自 2026-07 起留存, 无历史 +版本)。历史主线是把"今天的成分"回看历史 — 早年存在归属漂移(新概念不会 +出现在旧时段、成分调整会错归属)。MEMBERSHIP_NOTE 随 API 返回给前端展示。 + +性能: 全量回填只窄扫 enriched 的 4 列并先过滤连板 >=1(全历史 ~10 万行), +join 概念映射后 group_by, 峰值内存 <100MB。 +""" +from __future__ import annotations + +import logging +from datetime import date +from pathlib import Path + +import polars as pl + +from app.services.rps_rotation import _load_concept_map_df + +logger = logging.getLogger(__name__) + +MEMBERSHIP_NOTE = ( + "概念成分为当前快照回看历史(本地自 2026-07 起留存, 无历史版本), " + "早年主线存在归属漂移, 越近越准" +) + +MAINLINE_DIR = "mainline_history" +_TOP_PER_DAY = 30 # 每日持久化的主线数(按分数截断) +_INDUSTRY_LEVEL = 2 # 行业主线取前两级(如 计算机-软件开发) +_MIN_LIMIT_UP = 3 # 单概念当日最少涨停家数(低于此不参与排名) + +# 主线分权重: 概念内涨停家数 / 最高连板 / 梯队档位数 / 二板以上家数 +_SCORE_WEIGHTS = { + "limit_up_count": 0.35, + "max_boards": 0.25, + "rungs_filled": 0.25, + "ge2_count": 0.15, +} + + +def _resolve_filter_config(filter_cfg: dict | None) -> dict: + """解析过滤配置; None 时读用户偏好(宽基/风格标签过滤, 见 preferences 文档)。""" + if filter_cfg is not None: + return { + "min_members": int(filter_cfg.get("min_members", 4)), + "max_members": int(filter_cfg.get("max_members", 600)), + "blacklist": {str(x) for x in filter_cfg.get("blacklist") or []}, + } + try: + from app.services import preferences + + cfg = preferences.get_mainline_filter_config() + return { + "min_members": int(cfg["min_members"]), + "max_members": int(cfg["max_members"]), + "blacklist": set(cfg["blacklist"]), + } + except Exception: + return {"min_members": 4, "max_members": 600, "blacklist": set()} + + +def mainline_path(data_dir: Path) -> Path: + return data_dir / MAINLINE_DIR / "part.parquet" + + +def load_mainline_history(data_dir: Path, kind: str = "concept") -> pl.DataFrame: + """读取主线时序(全部 kind), 不存在返回空 DataFrame。""" + p = mainline_path(data_dir) + if not p.exists(): + return pl.DataFrame() + try: + df = pl.read_parquet(p) + except Exception as e: + logger.warning("load_mainline_history failed: %s", e) + return pl.DataFrame() + if df.is_empty() or "kind" not in df.columns: + return df + return df.filter(pl.col("kind") == kind) + + +def _industry_member(member: str, kind: str) -> str: + """行业维度取前 _INDUSTRY_LEVEL 级; 概念原样返回。""" + if kind != "industry": + return member + return "-".join(member.split("-")[:_INDUSTRY_LEVEL]) + + +def compute_mainline_range(repo, data_dir: Path, start: date, end: date, + kind: str = "concept", + filter_cfg: dict | None = None) -> pl.DataFrame: + """计算 [start, end] 每日主线排行(按 _SCORE_WEIGHTS 加权截面分)。 + + filter_cfg: {"min_members", "max_members", "blacklist"}; None 时读用户偏好。 + 宽基/风格标签(融资融券/沪深股通等数千成分)按成员数上限过滤, + 用户黑名单按名称过滤(不论大小)。修改配置后重算主线生效。 + + 返回列: date, kind, member, limit_up_count, ge2_count, max_boards, + boards_sum, rungs_filled, leader_symbol, score, rank。空数据返回空表。 + """ + if start > end: + return pl.DataFrame() + enriched_dir = repo.store.data_dir / "kline_daily_enriched" + if not enriched_dir.exists(): + return pl.DataFrame() + + map_df, _ = _load_concept_map_df(repo, kind) + if map_df.is_empty(): + return pl.DataFrame() + + cfg = _resolve_filter_config(filter_cfg) + if cfg["min_members"] > 1 or cfg["max_members"] < 5000 or cfg["blacklist"]: + member_counts = map_df.group_by(kind).len().rename({"len": "_members"}) + member_counts = member_counts.filter( + pl.col("_members").ge(cfg["min_members"]) + & pl.col("_members").le(cfg["max_members"]) + & ~pl.col(kind).is_in(sorted(cfg["blacklist"])) + ) + allowed = member_counts.select(kind) + map_df = map_df.join(allowed, on=kind, how="semi") + if map_df.is_empty(): + return pl.DataFrame() + + limit_rows = ( + pl.scan_parquet(enriched_dir / "**" / "*.parquet") + .select(["date", "symbol", "consecutive_limit_ups", "amount"]) + .filter( + (pl.col("date") >= start) & (pl.col("date") <= end) + & (pl.col("consecutive_limit_ups") >= 1) + ) + .collect() + ) + if limit_rows.is_empty(): + return pl.DataFrame() + + limit_rows = limit_rows.with_columns(pl.col("symbol").str.to_uppercase().alias("_sym_up")) + joined = limit_rows.join(map_df, on="_sym_up", how="inner") + if joined.is_empty(): + return pl.DataFrame() + joined = joined.with_columns( + pl.col(kind).map_elements( + lambda m: _industry_member(str(m), kind), + return_dtype=pl.Utf8, + ).alias("member") + ) + + agg = ( + joined.group_by(["date", "member"]) + .agg( + pl.len().alias("limit_up_count"), + (pl.col("consecutive_limit_ups") >= 2).sum().alias("ge2_count"), + pl.col("consecutive_limit_ups").max().alias("max_boards"), + pl.col("consecutive_limit_ups").sum().alias("boards_sum"), + pl.col("consecutive_limit_ups") + .filter(pl.col("consecutive_limit_ups") >= 2) + .n_unique() + .alias("rungs_filled"), + pl.col("symbol") + .sort_by( + pl.col("consecutive_limit_ups"), pl.col("amount"), + descending=[True, True], + ) + .first() + .alias("leader_symbol"), + ) + ) + + # 截面 rank 归一(0-1) → 加权主线分(0-100)。分母 max(n-1,1) 保证单概念日不除零。 + agg = agg.filter(pl.col("limit_up_count") >= _MIN_LIMIT_UP) + norm_exprs = [] + for col in _SCORE_WEIGHTS: + norm_exprs.append( + ((pl.col(col).rank(method="average") - 1.0) + / pl.max_horizontal(pl.len().over("date") - 1, 1)).over("date").alias(f"_{col}_r") + ) + agg = agg.with_columns(norm_exprs) + agg = agg.with_columns( + ( + 100.0 * sum( + _SCORE_WEIGHTS[col] * pl.col(f"_{col}_r") for col in _SCORE_WEIGHTS + ) + ).alias("score") + ) + agg = agg.with_columns( + pl.col("score").rank(method="ordinal", descending=True).over("date").alias("rank") + ) + result = ( + agg.filter(pl.col("rank") <= _TOP_PER_DAY) + .drop([f"_{col}_r" for col in _SCORE_WEIGHTS]) + .with_columns(pl.lit(kind).alias("kind")) + .select([ + "date", "kind", "member", "limit_up_count", "ge2_count", + "max_boards", "boards_sum", "rungs_filled", "leader_symbol", + "score", "rank", + ]) + .sort(["date", "rank"]) + ) + return result + + +def upsert_mainline_history(data_dir: Path, new_rows: pl.DataFrame) -> None: + """按 (date, kind) 整日覆盖 upsert; schema 以 new_rows 为权威(同 regime 模式)。""" + if new_rows.is_empty() or "date" not in new_rows.columns: + return + p = mainline_path(data_dir) + p.parent.mkdir(parents=True, exist_ok=True) + old = pl.read_parquet(p) if p.exists() else pl.DataFrame() + if old.is_empty(): + combined = new_rows + else: + # 按 (date, kind) 整日覆盖: anti-join 掉本次重算的 (日, 维度) 组合 + kept = old.join( + new_rows.select(["date", "kind"]).unique(), + on=["date", "kind"], + how="anti", + ) + target_cols = new_rows.columns + keep_exprs = [ + pl.col(c) if c in kept.columns else pl.lit(None).alias(c) + for c in target_cols + ] + kept = kept.select(keep_exprs) + combined = pl.concat([kept, new_rows.select(target_cols)], how="vertical_relaxed") + combined = combined.sort(["date", "kind", "rank"]) + combined.write_parquet(p) + + +def compute_mainline_incremental(repo, data_dir: Path, *, today: date | None = None, + kind: str = "concept") -> pl.DataFrame: + """增量补算主线(供 daily_pipeline / 手动触发): 补 enriched 已有而主线缺失的日。""" + today = today or date.today() + from app.services.regime_builder import enriched_date_set + + enriched_dates = enriched_date_set(repo) + existing = load_mainline_history(data_dir, kind) + existing_dates = set(existing["date"].to_list()) if not existing.is_empty() else set() + missing = sorted(d for d in enriched_dates if d not in existing_dates and d <= today) + if not missing: + return pl.DataFrame() + logger.info("mainline incremental(%s): compute %d days", kind, len(missing)) + new_rows = compute_mainline_range(repo, data_dir, missing[0], missing[-1], kind=kind) + if not new_rows.is_empty(): + upsert_mainline_history(data_dir, new_rows) + return new_rows diff --git a/backend/app/services/market_phase.py b/backend/app/services/market_phase.py new file mode 100644 index 0000000..3f10703 --- /dev/null +++ b/backend/app/services/market_phase.py @@ -0,0 +1,255 @@ +"""市场情绪周期阶段(冰点/启动/主升/高潮/退潮/修复) — 纯函数模块。 + +与 regime_builder 的 5 档 state(强势/偏强/震荡/偏弱/弱势)并存: +- state: 综合情绪分(赚钱/投机/抗跌/趋势 4 维加权), 回测环境过滤与挖掘在用, 不动。 +- phase: 基于"连板梯队"的阶段(用户判据: 高度、宽度、晋级率、梯队完整度), + 刻画情绪周期位置(冰点→启动→主升→高潮→退潮), 供市场环境页分析与主线识别。 + +驱动量(全部可从已存储的 consecutive_limit_ups 派生, 2020-08 起全历史可回算): +- height 高度: 当日最高连板数 +- first_board 首板宽度: 首板(1 连板)家数 +- ge2/ge3/ge5 宽度: N 板以上家数 +- promo 晋级率: 昨日连板池今日继续封板的比例 (池 <10 家记 null) +- seal_rate 封板率: regime 已有列 +- ladder_completeness 梯队完整度: 2..height 档位中非空占比 + +阈值标定: 2020-08~2026-08 全市场 1454 个交易日的 p10/p60/p90 分位数 +(标定脚本一次性运行, 不提交); 关键异常段抽查(2024-09/10 rally→climax→ebb, +2024-01/02 微盘退潮)人工核过归属。阈值集中在下方, 调整只需改这里。 +""" +from __future__ import annotations + +import logging + +import polars as pl + +logger = logging.getLogger(__name__) + +# ───────────────────────── 阶段词汇 ───────────────────────── +PHASE_ICE = "ice" +PHASE_IGNITE = "ignite" +PHASE_RALLY = "rally" +PHASE_CLIMAX = "climax" +PHASE_EBB = "ebb" +PHASE_REPAIR = "repair" + +PHASE_LABELS = { + PHASE_ICE: "冰点", + PHASE_IGNITE: "启动", + PHASE_RALLY: "主升", + PHASE_CLIMAX: "高潮", + PHASE_EBB: "退潮", + PHASE_REPAIR: "修复", +} + +# 规则判定优先级: 高潮 > 主升 > 退潮 > 启动 > 冰点 > 修复(兜底) +_PHASE_PRIORITY = (PHASE_CLIMAX, PHASE_RALLY, PHASE_EBB, PHASE_IGNITE, PHASE_ICE) + +# ───────────────────────── 阈值(标定自 2020-08~2026-08 分位数) ───────────────────────── +# 高潮: 情绪极端宣泄 — 二板以上宽度或首板数达到 p90 的 ~2 倍以上(历史 <2% 天数) +CLIMAX_GE2 = 50 # p90(25) 的 2 倍 +CLIMAX_FIRST_BOARD = 220 # p90(88) 的 2.5 倍 +# 主升: 高度/宽度/晋级率同时高于中位 (p60), 或晋级率极强 (p85+) +RALLY_HEIGHT = 7 # p60 +RALLY_GE2 = 15 # p60 +RALLY_PROMO = 0.23 # p60 +RALLY_PROMO_ALT = 0.30 # p85+ +RALLY_GE2_ALT = 12 +RALLY_HEIGHT_ALT = 5 +# 退潮: 晋级率崩至 p20 以下且宽度自近期高位回落; 或晋级率/封板率双弱 +EBB_PROMO = 0.15 # p20 +EBB_PROMO_STRICT = 0.13 +EBB_SEAL = 0.57 # ~p10-p15 +EBB_RECENT_GE2 = 12 # 5 日前 ge2 高于此才认定"自高位退潮" +EBB_RECENT_HEIGHT = 6 +# 启动: 宽度/高度自低位扩张且晋级率恢复 +IGNITE_GE2_DELTA = 3 # ge2 较 5 日前增加量 +IGNITE_GE2 = 8 # p20-p40 +IGNITE_PROMO = 0.20 # ~p55 +IGNITE_HEIGHT_DELTA = 1 # height 较 5 日前抬升 +IGNITE_HEIGHT = 5 # p40 +IGNITE_PROMO_SOFT = 0.19 +# 冰点: 高度/宽度/首板同时贴地 (p10) +ICE_HEIGHT = 4 # p10-p20 +ICE_GE2 = 6 # p10 +ICE_FIRST_BOARD = 24 # p10 + +# 晋级率最小池(家数), 低于此记 null(小样本噪声) +PROMO_MIN_POOL = 10 +# 平滑与持续性: EMA alpha≈1/3 (约 5 日), 阶段切换需连续 CONFIRM_DAYS 日同标签 +_EMA_ALPHA = 1.0 / 3.0 +_CONFIRM_DAYS = 2 +# 大盘弱档否决: 正面阶段(主升/高潮/启动)不允许出现在 5 档 state 为弱势/偏弱的日子。 +# 涨停梯队可能与大盘背离(如 2024-01 微盘崩期间中字头涨停生态走强), 该否决 +# 保证"主升"标签在大盘层面也成立; state 列缺失时(单元测试)不启用否决。 +_POSITIVE_PHASES = frozenset({PHASE_CLIMAX, PHASE_RALLY, PHASE_IGNITE}) +_VETO_STATES = frozenset({"weak", "lean_weak"}) + + +def with_prev_consecutive(df: pl.DataFrame) -> pl.DataFrame: + """按 symbol 追加昨日连板数列 _prev_consec (供晋级率)。 + + df 需含 symbol/date/consecutive_limit_ups; 输入应覆盖前一交易日 + (调用方保证 warmup 或直接传全量), 每个符号首行 _prev_consec 为 null。 + """ + if "_prev_consec" in df.columns: + return df + return ( + df.sort(["symbol", "date"]) + .with_columns( + pl.col("consecutive_limit_ups").shift(1).over("symbol").alias("_prev_consec") + ) + ) + + +def ladder_daily_aggs() -> list[pl.Expr]: + """group_by("date").agg(...) 可直接拼接的梯队聚合表达式。 + + 要求 df 含 consecutive_limit_ups; 含 _prev_consec 时附带晋级率分子/分母。 + """ + consec = pl.col("consecutive_limit_ups") + exprs = [ + consec.eq(1).sum().alias("first_board"), + consec.ge(2).sum().alias("ge2_count"), + consec.ge(3).sum().alias("ge3_count"), + consec.ge(5).sum().alias("ge5_count"), + consec.filter(consec.ge(2)).n_unique().alias("rungs_filled"), + ] + return exprs + + +def ladder_promo_aggs() -> list[pl.Expr]: + """晋级率聚合(分子/分母); 要求 df 已含 _prev_consec 列。""" + prev = pl.col("_prev_consec") + consec = pl.col("consecutive_limit_ups") + return [ + prev.ge(1).sum().alias("promo_pool"), + (prev.ge(1) & consec.eq(prev + 1)).sum().alias("promo_ok"), + ] + + +def finalize_ladder_row(r: dict) -> dict: + """把聚合行的梯队原始值整理为持久化字段(晋级率/ladder_completeness)。""" + height = int(r.get("max_consecutive") or 0) + rungs = int(r.get("rungs_filled") or 0) + completeness = (rungs / (height - 1)) if height >= 3 else 0.0 + pool = int(r.get("promo_pool") or 0) + ok = int(r.get("promo_ok") or 0) + promo = (ok / pool) if pool >= PROMO_MIN_POOL else None + return { + "first_board": int(r.get("first_board") or 0), + "ge2_count": int(r.get("ge2_count") or 0), + "ge3_count": int(r.get("ge3_count") or 0), + "ge5_count": int(r.get("ge5_count") or 0), + "ladder_completeness": round(completeness, 4), + "promo_pool": pool, + "promo_rate": round(promo, 4) if promo is not None else None, + } + + +def _ema(values: list[float], alpha: float = _EMA_ALPHA) -> list[float]: + out: list[float] = [] + cur = None + for v in values: + if v is None or v != v: # None 或 NaN + if cur is None: + out.append(None) + continue + out.append(cur) # ffill: 缺失沿用上一平滑值 + continue + cur = v if cur is None else cur + alpha * (v - cur) + out.append(cur) + # 前向回填: 序列开头缺失用首个有效值 + first_valid = next((i for i, x in enumerate(out) if x is not None), None) + if first_valid is not None: + for i in range(first_valid): + out[i] = out[first_valid] + else: + out = [0.0] * len(values) + return out + + +def classify_phase_series(daily: pl.DataFrame) -> pl.DataFrame: + """对完整日序打阶段标签, 追加 phase 列。 + + 输入列: date, max_consecutive, first_board, ge2_count, promo_rate, seal_rate + (promo_rate 允许 null)。处理: promo 前向填充 → 各驱动 EMA 平滑 → + 逐日规则判定(按优先级) → 连续 _CONFIRM_DAYS 日同标签才切换(持续性)。 + """ + required = {"date", "max_consecutive", "first_board", "ge2_count", "promo_rate", "seal_rate"} + missing = required - set(daily.columns) + if missing: + raise ValueError(f"classify_phase_series 缺少列: {sorted(missing)}") + + rows = daily.sort("date") + n = rows.height + states = rows["state"].to_list() if "state" in rows.columns else None + height_s = _ema([float(v) if v is not None else None for v in rows["max_consecutive"].to_list()]) + first_s = _ema([float(v) if v is not None else None for v in rows["first_board"].to_list()]) + ge2_s = _ema([float(v) if v is not None else None for v in rows["ge2_count"].to_list()]) + promo_s = _ema([float(v) if v is not None else None for v in rows["promo_rate"].to_list()]) + seal_s = _ema([float(v) if v is not None else None for v in rows["seal_rate"].to_list()]) + + def raw_label(i: int) -> str: + h, fb, g2, pr, sr = height_s[i], first_s[i], ge2_s[i], promo_s[i], seal_s[i] + g2_prev = ge2_s[max(0, i - 5)] + h_prev = height_s[max(0, i - 5)] + # 高潮 + if g2 >= CLIMAX_GE2 or fb >= CLIMAX_FIRST_BOARD: + return PHASE_CLIMAX + # 主升 + if h >= RALLY_HEIGHT and g2 >= RALLY_GE2 and pr >= RALLY_PROMO: + return PHASE_RALLY + if pr >= RALLY_PROMO_ALT and g2 >= RALLY_GE2_ALT and h >= RALLY_HEIGHT_ALT: + return PHASE_RALLY + # 冰点: 高度/宽度/首板同时贴地 — 优先于退潮(持续死寂的市场是"冰点" + # 而非"自高位退潮"; 退潮的规则 B 不带 from_high 条件, 顺序反了会把 + # 长期冰点误标成退潮) + if h <= ICE_HEIGHT and g2 <= ICE_GE2 and fb <= ICE_FIRST_BOARD: + return PHASE_ICE + # 退潮: 自高位回落 + 晋级率坍塌, 或晋级/封板双弱 + from_high = g2_prev >= EBB_RECENT_GE2 or h_prev >= EBB_RECENT_HEIGHT + if from_high and (pr <= EBB_PROMO and g2 < g2_prev): + return PHASE_EBB + if pr <= EBB_PROMO_STRICT and sr <= EBB_SEAL: + return PHASE_EBB + # 启动: 自低位扩张 + if g2 - g2_prev >= IGNITE_GE2_DELTA and g2 >= IGNITE_GE2 and pr >= IGNITE_PROMO: + return PHASE_IGNITE + if h - h_prev >= IGNITE_HEIGHT_DELTA and h >= IGNITE_HEIGHT and pr >= IGNITE_PROMO_SOFT: + return PHASE_IGNITE + return PHASE_REPAIR + + labels: list[str] = [] + current = None + pending: str | None = None + pending_run = 0 + for i in range(n): + raw = raw_label(i) + if ( + states is not None + and raw in _POSITIVE_PHASES + and states[i] in _VETO_STATES + ): + raw = PHASE_REPAIR + if current is None: + current = raw + labels.append(raw) + continue + if raw == current: + labels.append(current) + pending, pending_run = None, 0 + continue + if raw == pending: + pending_run += 1 + else: + pending, pending_run = raw, 1 + if pending_run >= _CONFIRM_DAYS: + current = raw + labels.append(current) + pending, pending_run = None, 0 + else: + labels.append(current) + return daily.with_columns( + pl.Series("phase", labels, dtype=pl.Utf8).alias("phase") + ).sort("date") diff --git a/backend/app/services/matrix_prewarm_owner.py b/backend/app/services/matrix_prewarm_owner.py new file mode 100644 index 0000000..9c01cb2 --- /dev/null +++ b/backend/app/services/matrix_prewarm_owner.py @@ -0,0 +1,48 @@ +from __future__ import annotations + +import threading +from collections.abc import Callable + + +class MatrixCachePrewarmOwner: + def __init__(self) -> None: + self._lock = threading.Lock() + self._cancel_event = threading.Event() + self._thread: threading.Thread | None = None + + @property + def cancel_event(self) -> threading.Event: + return self._cancel_event + + def schedule(self, target: Callable[[], None]) -> bool: + with self._lock: + if self._cancel_event.is_set(): + return False + if self._thread is not None and self._thread.is_alive(): + return False + thread = threading.Thread( + target=self._run, + args=(target,), + name="matrix-cache-prewarm", + daemon=True, + ) + self._thread = thread + thread.start() + return True + + def shutdown(self, timeout: float = 5.0) -> bool: + self._cancel_event.set() + with self._lock: + thread = self._thread + if thread is None: + return True + thread.join(timeout=max(0.0, timeout)) + return not thread.is_alive() + + def _run(self, target: Callable[[], None]) -> None: + try: + target() + finally: + with self._lock: + if self._thread is threading.current_thread(): + self._thread = None diff --git a/backend/app/services/mining_candidates.py b/backend/app/services/mining_candidates.py new file mode 100644 index 0000000..7625862 --- /dev/null +++ b/backend/app/services/mining_candidates.py @@ -0,0 +1,793 @@ +"""Trusted promotion and explicit publication for persisted mining candidates. + +Concurrency protection is process-local; V1 remains a single-process service. +""" +from __future__ import annotations + +import hashlib +import json +import math +import os +import re +import threading +import uuid +from collections.abc import Callable, Mapping +from pathlib import Path +from typing import Any + +import polars as pl +import pyarrow.parquet as pq + +from app.backtest.candidates import CandidateStore +from app.backtest.factor import FACTOR_COLUMNS +from app.backtest.mining import compute_candidate_signature, evaluate_candidate_gate +from app.services.mining_jobs import SUCCESS_RUN_STATUSES, MiningRunStore +from app.strategy.ai_generator import AIStrategyGenerator +from app.strategy.engine import StrategyEngine + +_MAX_ARTIFACT_BYTES = 8 * 1024 * 1024 +_MAX_ARTIFACT_ROWS = 32 +_MAX_UNCOMPRESSED_BYTES = 32 * 1024 * 1024 +_MAX_DEFINITION_BYTES = 16 * 1024 +_FACTOR_IDS = frozenset(str(item["id"]) for item in FACTOR_COLUMNS) +_FACTOR_DEFINITION_FIELDS = frozenset({"kind", "factor_names", "scoring", "directions"}) +_EXISTING_DEFINITION_FIELDS = frozenset({"kind", "strategy_id"}) +_BACKLINK_FIELDS = frozenset({"promoted_candidate_id", "published_strategy_id"}) +_PUBLISHED_PREFIX = "mined_factor_" +_STRATEGY_ID_PATTERN = re.compile(r"^mined_factor_[A-Za-z0-9_-]{1,49}$") +_ARTIFACT_SCHEMA = { + "signature": pl.String, + "name": pl.String, + "kind": pl.String, + "factor_names_json": pl.String, + "strategy_id": pl.String, + "definition_json": pl.String, + "regime_state": pl.String, + "score": pl.Float64, + "oos_return": pl.Float64, + "oos_sharpe": pl.Float64, + "oos_max_drawdown": pl.Float64, + "oos_positive_fold_ratio": pl.Float64, + "oos_n_trades": pl.Int64, + "confidence": pl.String, + "valid_folds": pl.Int64, + "skipped_folds": pl.Int64, + "promoted_candidate_id": pl.String, + "published_strategy_id": pl.String, +} +_LOCK = threading.RLock() + + +class MiningCandidateService: + def __init__( + self, + data_dir: Path | str, + run_store: MiningRunStore, + candidate_store: CandidateStore, + strategy_engine: StrategyEngine, + *, + strategy_cache_invalidator: Callable[[Path], None] | None = None, + monitor_state_invalidator: Callable[[], None] | None = None, + ) -> None: + self.data_dir = Path(data_dir).resolve() + self.run_store = run_store + self.candidate_store = candidate_store + self.strategy_engine = strategy_engine + if strategy_cache_invalidator is None: + from app.services.strategy_cache import clear_cache + + strategy_cache_invalidator = clear_cache + self._strategy_cache_invalidator = strategy_cache_invalidator + self._monitor_state_invalidator = monitor_state_invalidator + + def promote(self, run_id: str, signature: str) -> dict[str, Any]: + with _LOCK: + manifest, summary, path, frame, row, definition = self._load_candidate( + run_id, signature + ) + kind, name, source_id, config = self._promotion_config( + manifest, summary, row, definition + ) + item = self.candidate_store.create_or_get_by_provenance( + origin_run_id=run_id, + candidate_signature=signature, + kind=kind, + name=name, + source_id=source_id, + config=config, + metrics=self._candidate_metrics(row), + data_as_of=_optional_string(summary.get("data_as_of")), + status="pending", + ) + if row.get("promoted_candidate_id") != item["id"]: + self._write_backlink( + path, + frame, + signature, + "promoted_candidate_id", + item["id"], + ) + return item + + def publish(self, run_id: str, signature: str) -> dict[str, Any]: + with _LOCK: + manifest, summary, path, frame, row, definition = self._load_candidate( + run_id, signature + ) + gate = evaluate_candidate_gate( + confidence=row.get("confidence"), + valid_folds=row.get("valid_folds"), + positive_fold_ratio=row.get("oos_positive_fold_ratio"), + sharpe=row.get("oos_sharpe"), + max_drawdown=row.get("oos_max_drawdown"), + n_trades=row.get("oos_n_trades"), + ) + if not gate.qualified: + raise ValueError( + "candidate does not meet the promotion gate: " + + "; ".join(gate.reasons) + ) + asset_type = self._asset_type(manifest) + if definition["kind"] == "existing_strategy": + published_id = str(definition["strategy_id"]) + self._validate_publication_backlink(row, published_id) + self._verify_public_strategy(published_id, asset_type) + if row.get("published_strategy_id") != published_id: + self._write_backlink( + path, + frame, + signature, + "published_strategy_id", + published_id, + ) + return {"ok": True, "strategy_id": published_id} + + published_id = self._validate_published_id( + _published_strategy_id(run_id, signature) + ) + self._validate_publication_backlink(row, published_id) + source = self._render_factor_strategy( + manifest, summary, row, definition, published_id + ) + + target = self._custom_strategy_path(published_id) + created = self._publish_or_verify_source( + target, + source, + published_id, + run_id, + signature, + asset_type, + ) + try: + self._strategy_cache_invalidator(self.data_dir) + if self._monitor_state_invalidator is not None: + self._monitor_state_invalidator() + except Exception as exc: + rollback_error = ( + self._rollback_created_source(target, source) if created else None + ) + message = f"strategy runtime invalidation failed: {exc}" + if rollback_error is not None: + message += f"; strategy rollback failed: {rollback_error}" + raise RuntimeError(message) from exc + if row.get("published_strategy_id") != published_id: + self._write_backlink( + path, + frame, + signature, + "published_strategy_id", + published_id, + ) + return {"ok": True, "strategy_id": published_id} + + def _load_candidate( + self, + run_id: str, + signature: str, + ) -> tuple[ + dict[str, Any], + dict[str, Any], + Path, + pl.DataFrame, + dict[str, Any], + dict[str, Any], + ]: + if not isinstance(signature, str) or not signature: + raise ValueError("candidate signature must not be empty") + manifest = self.run_store.get(run_id) + if manifest is None: + raise KeyError(run_id) + if manifest.get("status") not in SUCCESS_RUN_STATUSES: + raise ValueError("mining candidates require a successful run") + path = self._registered_candidates_path(manifest) + frame = self._read_artifact(path) + matches = frame.filter(pl.col("signature") == signature) + if matches.height == 0: + raise KeyError(signature) + if matches.height != 1: + raise ValueError("mining candidates artifact contains a duplicate signature") + row = matches.row(0, named=True) + self._asset_type(manifest) + definition = self._validate_definition(manifest, row, signature) + summary = self._validated_summary(self.run_store.read_summary(run_id)) + return manifest, summary, path, frame, row, definition + + def _registered_candidates_path(self, manifest: Mapping[str, Any]) -> Path: + artifacts = manifest.get("artifacts") + if not isinstance(artifacts, Mapping): + raise ValueError("mining candidates artifact is not registered") + raw_path = artifacts.get("candidates") + if raw_path != "candidates.parquet": + raise ValueError( + "only the registered candidates.parquet artifact can be used" + ) + path = self.run_store.artifact_path( + str(manifest["run_id"]), "candidates" + ) + if path.is_symlink() or not path.is_file(): + raise ValueError("mining candidates artifact is unavailable") + return path + + @staticmethod + def _read_artifact(path: Path) -> pl.DataFrame: + try: + size = path.stat().st_size + except OSError as exc: + raise RuntimeError("failed to read mining candidates artifact") from exc + if size <= 0 or size > _MAX_ARTIFACT_BYTES: + raise ValueError("mining candidates artifact exceeds its size limit") + try: + parquet = pq.ParquetFile(path) + metadata = parquet.metadata + schema = pl.read_parquet_schema(path) + except Exception as exc: + raise RuntimeError("failed to read mining candidates artifact") from exc + if metadata is None or metadata.num_rows > _MAX_ARTIFACT_ROWS: + raise ValueError("mining candidates artifact exceeds its row limit") + uncompressed = sum( + metadata.row_group(index).total_byte_size + for index in range(metadata.num_row_groups) + ) + if uncompressed > _MAX_UNCOMPRESSED_BYTES: + raise ValueError( + "mining candidates artifact exceeds its uncompressed size limit" + ) + missing = sorted(set(_ARTIFACT_SCHEMA) - set(schema)) + if missing: + raise ValueError(f"mining candidates artifact schema is invalid: {missing}") + invalid_types = [ + name for name, dtype in _ARTIFACT_SCHEMA.items() + if schema[name] != dtype + ] + if invalid_types: + raise ValueError( + "mining candidates artifact column types are invalid: " + f"{invalid_types}" + ) + try: + return pl.read_parquet(path, columns=list(_ARTIFACT_SCHEMA)) + except Exception as exc: + raise RuntimeError("failed to read mining candidates artifact") from exc + + def _validate_definition( + self, + manifest: Mapping[str, Any], + row: Mapping[str, Any], + signature: str, + ) -> dict[str, Any]: + raw_definition = row.get("definition_json") + if ( + not isinstance(raw_definition, str) + or len(raw_definition.encode("utf-8")) > _MAX_DEFINITION_BYTES + ): + raise ValueError("mining candidate definition is unavailable") + try: + definition = json.loads(raw_definition) + except json.JSONDecodeError as exc: + raise ValueError("mining candidate definition is invalid") from exc + if not isinstance(definition, dict): + raise ValueError("mining candidate definition must be an object") + kind = definition.get("kind") + if kind == "factor_rank": + if set(definition) != _FACTOR_DEFINITION_FIELDS: + raise ValueError("factor candidate definition contains unsupported fields") + expected_kind = "factor_combination" + elif kind == "existing_strategy": + if set(definition) != _EXISTING_DEFINITION_FIELDS: + raise ValueError("existing candidate definition contains unsupported fields") + expected_kind = "existing_strategy" + else: + raise ValueError(f"unsupported mining candidate kind: {kind!r}") + if row.get("kind") != expected_kind: + raise ValueError("mining candidate kind does not match its definition") + if ( + not isinstance(row.get("name"), str) + or not row["name"] + or len(row["name"]) > 80 + or row.get("regime_state") != "overall" + ): + raise ValueError("mining candidate row metadata is invalid") + if kind == "factor_rank": + self._validate_factor_definition(manifest, row, definition) + else: + self._validate_existing_definition(manifest, row, definition) + computed = compute_candidate_signature(definition) + if row.get("signature") != signature or computed != signature: + raise ValueError("mining candidate signature does not match its definition") + score = row.get("score") + if ( + score is not None + and ( + isinstance(score, bool) + or not isinstance(score, (int, float)) + or not math.isfinite(float(score)) + ) + ): + raise ValueError("candidate score must be finite") + return definition + + @staticmethod + def _request(manifest: Mapping[str, Any]) -> Mapping[str, Any]: + request = manifest.get("request") + if not isinstance(request, Mapping): + raise ValueError("mining origin request is unavailable") + return request + + def _validate_factor_definition( + self, + manifest: Mapping[str, Any], + row: Mapping[str, Any], + definition: Mapping[str, Any], + ) -> None: + factor_names = definition.get("factor_names") + if ( + not isinstance(factor_names, list) + or not 1 <= len(factor_names) <= 4 + or len(set(factor_names)) != len(factor_names) + or any(not isinstance(name, str) or not name for name in factor_names) + ): + raise ValueError("factor candidate must contain 1 to 4 unique factors") + scoring = definition.get("scoring") + directions = definition.get("directions") + if not isinstance(scoring, Mapping) or set(scoring) != set(factor_names): + raise ValueError("factor scoring keys must exactly match factor names") + if not isinstance(directions, Mapping) or set(directions) != set(factor_names): + raise ValueError("factor direction keys must exactly match factor names") + for factor_name in factor_names: + weight = scoring[factor_name] + if ( + isinstance(weight, bool) + or not isinstance(weight, (int, float)) + or not math.isfinite(float(weight)) + or float(weight) <= 0.0 + ): + raise ValueError("factor weights must be finite and positive") + if directions[factor_name] not in {"high", "low"}: + raise ValueError("factor directions must be high or low") + unknown = sorted(set(factor_names) - _FACTOR_IDS) + if unknown: + raise ValueError(f"factor candidate contains unknown factors: {unknown}") + selected = self._request(manifest).get("factor_names") + if not isinstance(selected, list) or not set(factor_names) <= set(selected): + raise ValueError("factor candidate contains factors absent from its origin request") + try: + persisted_names = json.loads(str(row.get("factor_names_json"))) + except json.JSONDecodeError as exc: + raise ValueError("factor candidate factor list is invalid") from exc + if persisted_names != factor_names or row.get("strategy_id") is not None: + raise ValueError("factor candidate columns do not match its definition") + + def _validate_existing_definition( + self, + manifest: Mapping[str, Any], + row: Mapping[str, Any], + definition: Mapping[str, Any], + ) -> None: + strategy_id = definition.get("strategy_id") + if not isinstance(strategy_id, str) or not strategy_id: + raise ValueError("existing candidate strategy ID is invalid") + selected = self._request(manifest).get("strategy_ids") + if not isinstance(selected, list) or strategy_id not in selected: + raise ValueError("existing candidate was absent from its origin request") + if row.get("strategy_id") != strategy_id: + raise ValueError("existing candidate strategy ID does not match its definition") + asset_type = str(self._request(manifest).get("asset_type") or "stock") + self._verify_public_strategy(strategy_id, asset_type) + + def _promotion_config( + self, + manifest: Mapping[str, Any], + summary: Mapping[str, Any], + row: Mapping[str, Any], + definition: Mapping[str, Any], + ) -> tuple[str, str, str, dict[str, Any]]: + request = self._request(manifest) + signature = str(row["signature"]) + provenance = { + "origin_run_id": str(manifest["run_id"]), + "candidate_signature": signature, + "regime_state": str(row.get("regime_state") or "overall"), + "algorithm_version": str(summary.get("algorithm_version") or "mining-v1"), + "methodology_version": str(summary.get("methodology_version") or "factor_v2"), + } + common = { + "start": request.get("start"), + "end": request.get("end"), + "asset_type": request.get("asset_type") or "stock", + "matching": "open_t+1", + "entry_fill": "open_t+1", + "exit_fill": "open_t+1", + "commission_pct": request.get("commission_pct", 0.0002), + "stamp_tax_pct": request.get("stamp_tax_pct", 0.0005), + "slippage_bps": request.get("slippage_bps", 5.0), + "mode": "position", + "minute_fill": False, + **provenance, + } + name = str(row.get("name") or signature)[:80] + if definition["kind"] == "existing_strategy": + strategy_id = str(definition["strategy_id"]) + return "strategy", name, strategy_id, { + **common, + "strategy_id": strategy_id, + } + factor_names = list(definition["factor_names"]) + source_id = _published_strategy_id(str(manifest["run_id"]), signature) + return "strategy", name, source_id, { + **common, + "strategy_id": source_id, + "factor_names": factor_names, + "directions": [definition["directions"][name] for name in factor_names], + "weights": [float(definition["scoring"][name]) for name in factor_names], + } + + @staticmethod + def _candidate_metrics(row: Mapping[str, Any]) -> dict[str, Any]: + fields = ( + "oos_sharpe", + "oos_return", + "oos_max_drawdown", + "oos_positive_fold_ratio", + "oos_n_trades", + "valid_folds", + "skipped_folds", + "confidence", + ) + result: dict[str, Any] = {} + for field in fields: + value = row.get(field) + if value is None: + continue + if field == "confidence": + if not isinstance(value, str) or not value or len(value) > 32: + raise ValueError("candidate confidence is invalid") + elif ( + isinstance(value, bool) + or not isinstance(value, (int, float)) + or not math.isfinite(float(value)) + ): + raise ValueError(f"candidate metric {field} must be finite") + result[field] = value + return result + + @staticmethod + def _validated_summary(summary: Mapping[str, Any]) -> dict[str, str]: + result: dict[str, str] = {} + for field in ("data_as_of", "algorithm_version", "methodology_version"): + value = summary.get(field) + if not isinstance(value, str) or not value or len(value) > 120: + raise ValueError(f"mining summary {field} is invalid") + result[field] = value + return result + + @staticmethod + def _asset_type(manifest: Mapping[str, Any]) -> str: + asset_type = MiningCandidateService._request(manifest).get("asset_type") + if asset_type not in {"stock", "etf"}: + raise ValueError("mining origin asset_type is invalid") + return str(asset_type) + + def _verify_public_strategy( + self, + strategy_id: str, + asset_type: str, + *, + path: Path | None = None, + run_id: str | None = None, + signature: str | None = None, + ) -> None: + strategy = self.strategy_engine.get(strategy_id) + if strategy.meta.get("research_only"): + raise ValueError("research-only strategy cannot be published") + if strategy.execution_backend != "matrix_native": + raise ValueError("published strategy must be matrix-native") + if "1d" not in strategy.meta.get("timeframes", []): + raise ValueError("published strategy must support 1d") + if asset_type not in strategy.meta.get("asset_types", []): + raise ValueError("published strategy does not support the run asset type") + public_ids = { + str(meta.get("id")) for meta in self.strategy_engine.list_strategies() + } + if strategy_id not in public_ids: + raise ValueError("published strategy is not publicly discoverable") + if path is not None and ( + strategy.source != "custom" + or strategy.file_path is None + or strategy.file_path.resolve() != path.resolve() + or strategy.meta.get("origin_run_id") != run_id + or strategy.meta.get("candidate_signature") != signature + ): + raise ValueError("published strategy provenance is invalid") + + @staticmethod + def _validate_published_id(strategy_id: str) -> str: + if not _STRATEGY_ID_PATTERN.fullmatch(strategy_id): + raise ValueError( + f"strategy_id must use {_PUBLISHED_PREFIX!r} and safe characters" + ) + return strategy_id + + @staticmethod + def _validate_publication_backlink( + row: Mapping[str, Any], + strategy_id: str, + ) -> None: + existing = _optional_string(row.get("published_strategy_id")) + if existing is not None and existing != strategy_id: + raise ValueError("candidate publication backlink is inconsistent") + + def _custom_strategy_path(self, strategy_id: str) -> Path: + unresolved_root = self.data_dir / "strategies" / "custom" + unresolved_root.mkdir(parents=True, exist_ok=True) + if unresolved_root.is_symlink(): + raise ValueError("custom strategy directory must not be a symlink") + root = unresolved_root.resolve() + if not root.is_relative_to(self.data_dir): + raise ValueError("custom strategy directory escapes data_dir") + path = (root / f"{strategy_id}.py").resolve(strict=False) + if path.parent != root: + raise ValueError("strategy publication path escapes custom directory") + return path + + def _render_factor_strategy( + self, + manifest: Mapping[str, Any], + summary: Mapping[str, Any], + row: Mapping[str, Any], + definition: Mapping[str, Any], + strategy_id: str, + ) -> str: + asset_type = self._asset_type(manifest) + factor_names = list(definition["factor_names"]) + scoring = { + name: float(definition["scoring"][name]) for name in factor_names + } + directions = {name: definition["directions"][name] for name in factor_names} + meta = { + "id": strategy_id, + "name": row["name"], + "description": "Published mining factor-rank candidate", + "tags": ["mining", "factor-rank"], + "asset_types": [asset_type], + "timeframes": ["1d"], + "research_only": False, + "origin_run_id": manifest["run_id"], + "candidate_signature": row["signature"], + "mining_algorithm_version": summary["algorithm_version"], + "factor_methodology_version": summary["methodology_version"], + "params": [ + { + "id": "entry_score", + "label": "Entry minimum score", + "type": "float", + "default": 70.0, + "min": 0.0, + "max": 100.0, + "step": 5.0, + }, + { + "id": "exit_score", + "label": "Exit maximum score", + "type": "float", + "default": 40.0, + "min": 0.0, + "max": 100.0, + "step": 5.0, + }, + { + "id": "top_rank", + "label": "Daily selection limit", + "type": "int", + "default": 20, + "min": 1, + "max": 100, + "step": 1, + }, + ], + "scoring": {}, + "order_by": "score", + "descending": True, + "limit": 100, + } + return ( + '"""Trusted factor-rank strategy published from a mining run."""\n' + "from app.strategy.builtin.factor_rank_research import " + "FactorRankResearchMatrixStrategy\n\n" + f"META = {meta!r}\n\n" + 'EXECUTION_BACKEND = "matrix_native"\n' + 'ENTRY_SIGNALS = ["signal_factor_rank_entry"]\n' + 'EXIT_SIGNALS = ["signal_factor_rank_exit"]\n' + "STOP_LOSS = -0.08\n" + "MAX_HOLD_DAYS = 30\n\n" + f"SCORING = {scoring!r}\n" + f"DIRECTIONS = {directions!r}\n" + "MATRIX_STRATEGY = FactorRankResearchMatrixStrategy(SCORING, DIRECTIONS)\n" + ) + + def _publish_or_verify_source( + self, + path: Path, + source: str, + strategy_id: str, + run_id: str, + signature: str, + asset_type: str, + ) -> bool: + validation = AIStrategyGenerator().validate_code(source) + if not validation.get("valid"): + raise ValueError( + f"rendered strategy failed validation: {validation.get('error')}" + ) + if validation.get("meta", {}).get("id") != strategy_id: + raise ValueError("rendered strategy META id is invalid") + if path.exists() or path.is_symlink(): + self._verify_existing_source( + path, source, strategy_id, run_id, signature, asset_type + ) + return False + if self.strategy_engine.has(strategy_id): + raise ValueError(f"strategy ID already exists: {strategy_id}") + + temporary = path.with_name(f".{path.name}.{uuid.uuid4().hex}.tmp") + linked = False + try: + with temporary.open("x", encoding="utf-8", newline="\n") as stream: + stream.write(source) + stream.flush() + os.fsync(stream.fileno()) + try: + os.link(temporary, path) + except FileExistsError as exc: + raise ValueError(f"strategy path already exists: {strategy_id}") from exc + except OSError as exc: + raise RuntimeError("failed to create strategy source") from exc + linked = True + self._fsync_directory(path.parent) + try: + self.strategy_engine.reload() + self._verify_public_strategy( + strategy_id, + asset_type, + path=path, + run_id=run_id, + signature=signature, + ) + except Exception as exc: + rollback_error = self._rollback_publication(path, temporary) + message = f"strategy publication failed: {exc}" + if rollback_error is not None: + message += f"; registry rollback failed: {rollback_error}" + raise RuntimeError(message) from exc + finally: + temporary.unlink(missing_ok=True) + if linked: + self._fsync_directory(path.parent) + return True + + def _verify_existing_source( + self, + path: Path, + source: str, + strategy_id: str, + run_id: str, + signature: str, + asset_type: str, + ) -> None: + if path.is_symlink() or not path.is_file(): + raise ValueError("strategy publication target is not a regular file") + try: + existing_source = path.read_text(encoding="utf-8") + except (OSError, UnicodeError) as exc: + raise ValueError("existing strategy source is unreadable") from exc + if existing_source != source: + raise ValueError(f"strategy ID collision: {strategy_id}") + try: + self._verify_public_strategy( + strategy_id, + asset_type, + path=path, + run_id=run_id, + signature=signature, + ) + except ValueError: + self.strategy_engine.reload() + self._verify_public_strategy( + strategy_id, + asset_type, + path=path, + run_id=run_id, + signature=signature, + ) + + def _rollback_publication(self, path: Path, temporary: Path) -> Exception | None: + try: + if path.exists() and temporary.exists() and os.path.samefile(path, temporary): + path.unlink() + self._fsync_directory(path.parent) + self.strategy_engine.reload() + except Exception as exc: + return exc + return None + + def _rollback_created_source(self, path: Path, source: str) -> Exception | None: + try: + if path.is_file() and not path.is_symlink(): + if path.read_text(encoding="utf-8") != source: + return RuntimeError("published strategy source changed before rollback") + path.unlink() + self._fsync_directory(path.parent) + self.strategy_engine.reload() + except Exception as exc: + return exc + return None + + @staticmethod + def _fsync_directory(path: Path) -> None: + if os.name == "nt": + return + descriptor = os.open(path, os.O_RDONLY) + try: + os.fsync(descriptor) + finally: + os.close(descriptor) + + @staticmethod + def _write_backlink( + path: Path, + frame: pl.DataFrame, + signature: str, + field: str, + value: str, + ) -> None: + if field not in _BACKLINK_FIELDS: + raise ValueError("unsupported mining candidate backlink") + matches = frame.filter(pl.col("signature") == signature) + if matches.height != 1: + raise ValueError("mining candidate backlink target is no longer unique") + updated = frame.with_columns( + pl.when(pl.col("signature") == signature) + .then(pl.lit(value)) + .otherwise(pl.col(field)) + .alias(field) + ) + temporary = path.with_name(f".{path.name}.{uuid.uuid4().hex}.tmp") + try: + updated.write_parquet(temporary) + with temporary.open("r+b") as stream: + stream.flush() + os.fsync(stream.fileno()) + os.replace(temporary, path) + except Exception as exc: + temporary.unlink(missing_ok=True) + raise RuntimeError("failed to update mining candidate artifact") from exc + + +def _published_strategy_id(run_id: str, signature: str) -> str: + payload = f"{run_id}\0{signature}".encode() + digest = hashlib.blake2b(payload, digest_size=10).hexdigest() + return f"{_PUBLISHED_PREFIX}{digest}" + + +def _optional_string(value: Any) -> str | None: + return value if isinstance(value, str) and value else None diff --git a/backend/app/services/mining_jobs.py b/backend/app/services/mining_jobs.py new file mode 100644 index 0000000..343ab8a --- /dev/null +++ b/backend/app/services/mining_jobs.py @@ -0,0 +1,620 @@ +"""Persistent metadata and bounded event storage for mining runs.""" + +from __future__ import annotations + +import json +import math +import os +import re +import threading +import uuid +from collections.abc import Collection, Mapping +from datetime import UTC, date, datetime +from enum import Enum +from pathlib import Path +from typing import Any, Literal, cast + +MiningRunStatus = Literal[ + "queued", + "running", + "cancelling", + "succeeded", + "succeeded_with_budget_exhausted", + "failed", + "cancelled", + "interrupted", + "skipped_prerequisite", +] +ArtifactName = Literal["factors", "correlation", "candidates", "folds"] + +RUN_STATUSES: frozenset[str] = frozenset( + { + "queued", + "running", + "cancelling", + "succeeded", + "succeeded_with_budget_exhausted", + "failed", + "cancelled", + "interrupted", + "skipped_prerequisite", + } +) +ACTIVE_RUN_STATUSES: frozenset[str] = frozenset({"queued", "running", "cancelling"}) +SUCCESS_RUN_STATUSES: frozenset[str] = frozenset({"succeeded", "succeeded_with_budget_exhausted"}) +TERMINAL_RUN_STATUSES: frozenset[str] = RUN_STATUSES - ACTIVE_RUN_STATUSES +ARTIFACT_NAMES: frozenset[str] = frozenset({"factors", "correlation", "candidates", "folds"}) +MAX_EVENTS = 256 +MAX_EVENT_PAYLOAD_BYTES = 16 * 1024 +_SCHEMA_VERSION = 1 +_RUN_ID_PATTERN = re.compile(r"^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$") +_STORE_LOCK = threading.RLock() + +_ALLOWED_TRANSITIONS: dict[str, frozenset[str]] = { + "queued": frozenset( + {"running", "cancelling", "cancelled", "failed", "interrupted", "skipped_prerequisite"} + ), + "running": frozenset( + { + "cancelling", + "succeeded", + "succeeded_with_budget_exhausted", + "failed", + "cancelled", + "interrupted", + "skipped_prerequisite", + } + ), + "cancelling": frozenset( + { + "succeeded", + "succeeded_with_budget_exhausted", + "failed", + "cancelled", + "interrupted", + } + ), + "succeeded": frozenset(), + "succeeded_with_budget_exhausted": frozenset(), + "failed": frozenset(), + "cancelled": frozenset(), + "interrupted": frozenset(), + "skipped_prerequisite": frozenset(), +} + + +class MiningRunStoreError(RuntimeError): + pass + + +class MiningRunValidationError(MiningRunStoreError, ValueError): + pass + + +class InvalidMiningStatusTransitionError(MiningRunStoreError): + pass + + +def canonicalize_request(request: Mapping[str, Any]) -> dict[str, Any]: + """Return a JSON-safe request whose mapping order cannot affect its signature.""" + if not isinstance(request, Mapping): + raise MiningRunValidationError("request must be a mapping") + return cast(dict[str, Any], _canonicalize_json_value(request)) + + +def compute_run_signature(request: Mapping[str, Any], data_fingerprint: Any) -> str: + """Hash every request dimension and the data fingerprint using BLAKE2b.""" + import hashlib + + signature_input = { + "request": canonicalize_request(request), + "data_fingerprint": _canonicalize_json_value(data_fingerprint), + } + payload = json.dumps( + signature_input, + ensure_ascii=False, + allow_nan=False, + sort_keys=True, + separators=(",", ":"), + ).encode("utf-8") + return hashlib.blake2b(payload, digest_size=32).hexdigest() + + +class MiningRunStore: + """Store one manifest, summary, artifact registry, and bounded event log per run.""" + + def __init__(self, data_dir: Path | str | None = None) -> None: + if data_dir is None: + from app.config import settings + + data_dir = settings.data_dir + self.runs_root = (Path(data_dir).resolve() / "research" / "mining" / "runs").resolve() + self.runs_root.mkdir(parents=True, exist_ok=True) + + def create( + self, + request: Mapping[str, Any], + data_fingerprint: Any, + *, + run_id: str | None = None, + ) -> dict[str, Any]: + """Create a queued run and its initial on-disk files.""" + safe_run_id = self._validate_run_id(uuid.uuid4().hex if run_id is None else run_id) + canonical_request = canonicalize_request(request) + canonical_fingerprint = _canonicalize_json_value(data_fingerprint) + now = _now_iso() + manifest = { + "schema_version": _SCHEMA_VERSION, + "run_id": safe_run_id, + "status": "queued", + "request": canonical_request, + "data_fingerprint": canonical_fingerprint, + "run_signature": compute_run_signature(canonical_request, canonical_fingerprint), + "artifacts": {}, + "created_at": now, + "updated_at": now, + "started_at": None, + "finished_at": None, + "cancellation_requested_at": None, + "error": None, + } + run_dir = self._run_dir(safe_run_id) + with _STORE_LOCK: + if run_dir.exists(): + raise MiningRunValidationError(f"run already exists: {safe_run_id}") + run_dir.mkdir(parents=False) + _atomic_write_json(run_dir / "summary.json", {}) + _atomic_write_text(run_dir / "events.jsonl", "") + _atomic_write_json(run_dir / "manifest.json", manifest) + return manifest + + def get(self, run_id: str) -> dict[str, Any] | None: + """Read a manifest, filling defaults for manifests written by older versions.""" + safe_run_id = self._validate_run_id(run_id) + with _STORE_LOCK: + return self._read_manifest_path( + self._run_dir(safe_run_id) / "manifest.json", safe_run_id + ) + + def transition_status( + self, + run_id: str, + status: MiningRunStatus, + *, + error: str | None = None, + ) -> dict[str, Any]: + """Apply a validated state transition and atomically replace the manifest.""" + if status not in RUN_STATUSES: + raise MiningRunValidationError(f"unsupported mining run status: {status!r}") + safe_run_id = self._validate_run_id(run_id) + with _STORE_LOCK: + manifest = self._required_manifest(safe_run_id) + return self._transition_locked(manifest, status, error=error) + + def write_summary(self, run_id: str, summary: Mapping[str, Any]) -> dict[str, Any]: + """Atomically replace a run's scalar or compact aggregate summary.""" + if not isinstance(summary, Mapping): + raise MiningRunValidationError("summary must be a mapping") + safe_run_id = self._validate_run_id(run_id) + clean_summary = cast(dict[str, Any], _canonicalize_json_value(summary)) + with _STORE_LOCK: + self._required_manifest(safe_run_id) + _atomic_write_json(self._run_dir(safe_run_id) / "summary.json", clean_summary) + return clean_summary + + def read_summary(self, run_id: str) -> dict[str, Any]: + safe_run_id = self._validate_run_id(run_id) + with _STORE_LOCK: + self._required_manifest(safe_run_id) + path = self._run_dir(safe_run_id) / "summary.json" + if not path.exists(): + return {} + value = _read_json(path) + if not isinstance(value, dict): + raise MiningRunStoreError(f"invalid summary for run {safe_run_id}") + return value + + def artifact_path(self, run_id: str, name: ArtifactName) -> Path: + """Return the safe default Parquet path for an artifact.""" + safe_run_id = self._validate_run_id(run_id) + self._validate_artifact_name(name) + return self._safe_artifact_path(safe_run_id, Path(f"{name}.parquet")) + + def register_artifact( + self, + run_id: str, + name: ArtifactName, + path: Path | str | None = None, + ) -> dict[str, Any]: + """Record a Parquet artifact path relative to its owning run directory.""" + safe_run_id = self._validate_run_id(run_id) + self._validate_artifact_name(name) + artifact_path = self._safe_artifact_path( + safe_run_id, + Path(path) if path is not None else Path(f"{name}.parquet"), + ) + if artifact_path.suffix.lower() != ".parquet": + raise MiningRunValidationError("mining artifacts must use the .parquet suffix") + run_dir = self._run_dir(safe_run_id) + relative_path = artifact_path.relative_to(run_dir).as_posix() + with _STORE_LOCK: + manifest = self._required_manifest(safe_run_id) + artifacts = dict(manifest.get("artifacts") or {}) + artifacts[name] = relative_path + manifest["artifacts"] = artifacts + manifest["updated_at"] = _now_iso() + _atomic_write_json(run_dir / "manifest.json", manifest) + return manifest + + def append_event( + self, + run_id: str, + event_type: str, + payload: Mapping[str, Any] | None = None, + ) -> dict[str, Any]: + """Append a compact event, retaining only the most recent ``MAX_EVENTS`` entries.""" + safe_run_id = self._validate_run_id(run_id) + if not isinstance(event_type, str): + raise MiningRunValidationError("event_type must be a string") + clean_event_type = event_type.strip() + if not clean_event_type or len(clean_event_type) > 64: + raise MiningRunValidationError("event_type must contain 1 to 64 characters") + raw_payload: Mapping[str, Any] | Any = {} if payload is None else payload + if not isinstance(raw_payload, Mapping): + raise MiningRunValidationError("event payload must be a mapping") + clean_payload = cast(dict[str, Any], _canonicalize_json_value(raw_payload)) + encoded_payload = json.dumps( + clean_payload, + ensure_ascii=False, + allow_nan=False, + sort_keys=True, + separators=(",", ":"), + ).encode("utf-8") + if len(encoded_payload) > MAX_EVENT_PAYLOAD_BYTES: + raise MiningRunValidationError( + f"event payload exceeds {MAX_EVENT_PAYLOAD_BYTES} byte limit" + ) + + with _STORE_LOCK: + self._required_manifest(safe_run_id) + path = self._run_dir(safe_run_id) / "events.jsonl" + events = self._read_events_path(path) + next_id = max((event["id"] for event in events), default=0) + 1 + event = { + "id": next_id, + "timestamp": _now_iso(), + "type": clean_event_type, + "payload": clean_payload, + } + events.append(event) + events = events[-MAX_EVENTS:] + text = "".join( + json.dumps(item, ensure_ascii=False, allow_nan=False, separators=(",", ":")) + "\n" + for item in events + ) + _atomic_write_text(path, text) + return event + + def read_events(self, run_id: str, *, after_id: int = 0) -> list[dict[str, Any]]: + """Read retained events whose monotonically increasing ID is greater than ``after_id``.""" + if isinstance(after_id, bool) or not isinstance(after_id, int) or after_id < 0: + raise MiningRunValidationError("after_id must be a non-negative integer") + safe_run_id = self._validate_run_id(run_id) + with _STORE_LOCK: + self._required_manifest(safe_run_id) + events = self._read_events_path(self._run_dir(safe_run_id) / "events.jsonl") + return [event for event in events if event["id"] > after_id] + + def list_runs( + self, + *, + limit: int = 50, + statuses: Collection[MiningRunStatus] | None = None, + ) -> list[dict[str, Any]]: + """Return recent valid manifests without exposing store paths to API callers.""" + if isinstance(limit, bool) or not isinstance(limit, int) or not 1 <= limit <= 200: + raise MiningRunValidationError("limit must be between 1 and 200") + allowed_statuses = None if statuses is None else set(statuses) + if allowed_statuses is not None and not allowed_statuses <= RUN_STATUSES: + raise MiningRunValidationError("statuses contains an unsupported mining run status") + + try: + paths = list(self.runs_root.glob("*/manifest.json")) + except OSError as exc: + raise MiningRunStoreError("failed to scan mining run manifests") from exc + manifests: list[dict[str, Any]] = [] + for path in paths: + run_id = path.parent.name + if not _RUN_ID_PATTERN.fullmatch(run_id): + continue + try: + manifest = self._read_manifest_path( + self._run_dir(run_id) / "manifest.json", + run_id, + ) + except MiningRunStoreError: + continue + if manifest is None: + continue + if allowed_statuses is not None and manifest.get("status") not in allowed_statuses: + continue + manifests.append(manifest) + manifests.sort(key=_manifest_sort_key, reverse=True) + return manifests[:limit] + + def find_by_signature( + self, + run_signature: str, + *, + statuses: Collection[MiningRunStatus] | None = None, + ) -> dict[str, Any] | None: + """Find the newest run with a signature, optionally restricted to selected statuses.""" + if not isinstance(run_signature, str) or not run_signature: + raise MiningRunValidationError("run_signature must not be empty") + allowed_statuses = None if statuses is None else set(statuses) + if allowed_statuses is not None and not allowed_statuses <= RUN_STATUSES: + raise MiningRunValidationError("statuses contains an unsupported mining run status") + + # Directory enumeration and manifest reads stay outside the write lock. Atomic replacements + # make each individual read coherent while avoiding a lock around a potentially slow scan. + try: + paths = list(self.runs_root.glob("*/manifest.json")) + except OSError as exc: + raise MiningRunStoreError("failed to scan mining run manifests") from exc + matches: list[dict[str, Any]] = [] + for path in paths: + run_id = path.parent.name + if not _RUN_ID_PATTERN.fullmatch(run_id): + continue + try: + manifest_path = self._run_dir(run_id) / "manifest.json" + manifest = self._read_manifest_path(manifest_path, run_id) + except MiningRunStoreError: + continue + if manifest is None or manifest.get("run_signature") != run_signature: + continue + if allowed_statuses is not None and manifest.get("status") not in allowed_statuses: + continue + matches.append(manifest) + return max(matches, key=_manifest_sort_key, default=None) + + def recover_interrupted(self) -> int: + """Mark runs without a live in-process worker as interrupted at startup.""" + try: + paths = list(self.runs_root.glob("*/manifest.json")) + except OSError as exc: + raise MiningRunStoreError("failed to scan mining run manifests") from exc + + candidates: list[str] = [] + for path in paths: + run_id = path.parent.name + if not _RUN_ID_PATTERN.fullmatch(run_id): + continue + try: + manifest_path = self._run_dir(run_id) / "manifest.json" + manifest = self._read_manifest_path(manifest_path, run_id) + except MiningRunStoreError: + continue + if manifest is not None and manifest.get("status") in ACTIVE_RUN_STATUSES: + candidates.append(run_id) + + recovered = 0 + for run_id in candidates: + with _STORE_LOCK: + manifest = self._required_manifest(run_id) + if manifest["status"] not in ACTIVE_RUN_STATUSES: + continue + self._transition_locked(manifest, "interrupted", error=None) + recovered += 1 + return recovered + + def _transition_locked( + self, + manifest: dict[str, Any], + status: MiningRunStatus, + *, + error: str | None, + ) -> dict[str, Any]: + previous = manifest["status"] + if previous == status: + return manifest + if status not in _ALLOWED_TRANSITIONS[previous]: + raise InvalidMiningStatusTransitionError( + f"cannot transition from {previous} to {status}" + ) + + now = _now_iso() + manifest["status"] = status + manifest["updated_at"] = now + if status == "running" and not manifest.get("started_at"): + manifest["started_at"] = now + if status == "cancelling": + manifest["cancellation_requested_at"] = now + if status in TERMINAL_RUN_STATUSES: + manifest["finished_at"] = now + if error is not None: + manifest["error"] = str(error) + _atomic_write_json(self._run_dir(manifest["run_id"]) / "manifest.json", manifest) + return manifest + + def _required_manifest(self, run_id: str) -> dict[str, Any]: + manifest = self._read_manifest_path(self._run_dir(run_id) / "manifest.json", run_id) + if manifest is None: + raise KeyError(run_id) + return manifest + + def _read_manifest_path(self, path: Path, run_id: str) -> dict[str, Any] | None: + if not path.exists(): + return None + value = _read_json(path) + if not isinstance(value, dict): + raise MiningRunStoreError(f"invalid manifest for run {run_id}") + return self._normalize_manifest(value, run_id) + + def _normalize_manifest(self, value: dict[str, Any], run_id: str) -> dict[str, Any]: + status = value.get("status", "queued") + if status not in RUN_STATUSES: + raise MiningRunStoreError(f"invalid status in manifest for run {run_id}") + raw_request = value.get("request") if isinstance(value.get("request"), dict) else {} + data_fingerprint = value.get("data_fingerprint") + signature = value.get("run_signature") + if not isinstance(signature, str) or not signature: + signature = compute_run_signature(raw_request, data_fingerprint) + raw_artifacts = value.get("artifacts") if isinstance(value.get("artifacts"), dict) else {} + artifacts: dict[str, str] = {} + run_dir = self._run_dir(run_id) + for name, raw_path in raw_artifacts.items(): + if name not in ARTIFACT_NAMES or not isinstance(raw_path, str): + continue + try: + safe_path = self._safe_artifact_path(run_id, Path(raw_path)) + except MiningRunValidationError: + continue + if safe_path.suffix.lower() == ".parquet": + artifacts[name] = safe_path.relative_to(run_dir).as_posix() + normalized = dict(value) + normalized.update( + { + "schema_version": value.get("schema_version", 0), + "run_id": run_id, + "status": status, + "request": raw_request, + "data_fingerprint": data_fingerprint, + "run_signature": signature, + "artifacts": artifacts, + "created_at": value.get("created_at"), + "updated_at": value.get("updated_at") or value.get("created_at"), + "started_at": value.get("started_at"), + "finished_at": value.get("finished_at"), + "cancellation_requested_at": value.get("cancellation_requested_at"), + "error": value.get("error"), + } + ) + return normalized + + @staticmethod + def _read_events_path(path: Path) -> list[dict[str, Any]]: + if not path.exists(): + return [] + try: + lines = path.read_text(encoding="utf-8").splitlines() + except (OSError, UnicodeError) as exc: + raise MiningRunStoreError(f"failed to read events file: {path}") from exc + events: list[dict[str, Any]] = [] + for line in lines: + if not line.strip(): + continue + try: + event = json.loads(line) + except json.JSONDecodeError as exc: + raise MiningRunStoreError(f"invalid events file: {path}") from exc + if ( + not isinstance(event, dict) + or isinstance(event.get("id"), bool) + or not isinstance(event.get("id"), int) + or event["id"] <= 0 + ): + raise MiningRunStoreError(f"invalid event record: {path}") + if events and event["id"] <= events[-1]["id"]: + raise MiningRunStoreError(f"non-monotonic event IDs: {path}") + events.append(event) + return events[-MAX_EVENTS:] + + def _run_dir(self, run_id: str) -> Path: + safe_run_id = self._validate_run_id(run_id) + candidate = (self.runs_root / safe_run_id).resolve() + if not candidate.is_relative_to(self.runs_root): + raise MiningRunValidationError("run path escapes mining runs root") + return candidate + + def _safe_artifact_path(self, run_id: str, path: Path) -> Path: + run_dir = self._run_dir(run_id) + candidate = path if path.is_absolute() else run_dir / path + resolved = candidate.resolve() + if not resolved.is_relative_to(run_dir): + raise MiningRunValidationError("artifact path escapes its mining run directory") + return resolved + + @staticmethod + def _validate_run_id(run_id: str) -> str: + if not isinstance(run_id, str) or not _RUN_ID_PATTERN.fullmatch(run_id): + raise MiningRunValidationError("run_id contains unsafe characters") + return run_id + + @staticmethod + def _validate_artifact_name(name: str) -> None: + if name not in ARTIFACT_NAMES: + raise MiningRunValidationError(f"unsupported artifact name: {name!r}") + + +def _canonicalize_json_value(value: Any) -> Any: + if value is None or isinstance(value, (str, bool, int)): + return value + if isinstance(value, float): + if not math.isfinite(value): + raise MiningRunValidationError("non-finite numbers are not supported") + return value + if isinstance(value, Enum): + return _canonicalize_json_value(value.value) + if isinstance(value, (datetime, date)): + return value.isoformat() + if isinstance(value, Path): + return str(value) + if isinstance(value, Mapping): + result: dict[str, Any] = {} + for key, item in value.items(): + if not isinstance(key, str): + raise MiningRunValidationError("JSON mapping keys must be strings") + result[key] = _canonicalize_json_value(item) + return {key: result[key] for key in sorted(result)} + if isinstance(value, (list, tuple)): + return [_canonicalize_json_value(item) for item in value] + if isinstance(value, (set, frozenset)): + items = [_canonicalize_json_value(item) for item in value] + return sorted( + items, + key=lambda item: json.dumps( + item, ensure_ascii=False, allow_nan=False, sort_keys=True, separators=(",", ":") + ), + ) + raise MiningRunValidationError(f"value is not JSON serializable: {type(value).__name__}") + + +def _read_json(path: Path) -> Any: + try: + return json.loads(path.read_text(encoding="utf-8")) + except (OSError, UnicodeError, json.JSONDecodeError) as exc: + raise MiningRunStoreError(f"failed to read JSON file: {path}") from exc + + +def _atomic_write_json(path: Path, value: Any) -> None: + try: + text = json.dumps(value, ensure_ascii=False, allow_nan=False, indent=2) + "\n" + except (TypeError, ValueError) as exc: + raise MiningRunValidationError("value is not JSON serializable") from exc + _atomic_write_text(path, text) + + +def _atomic_write_text(path: Path, text: str) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_name(f".{path.name}.{uuid.uuid4().hex}.tmp") + try: + with temporary.open("w", encoding="utf-8", newline="\n") as stream: + stream.write(text) + stream.flush() + os.fsync(stream.fileno()) + os.replace(temporary, path) + except OSError as exc: + temporary.unlink(missing_ok=True) + raise MiningRunStoreError(f"failed to write file: {path}") from exc + + +def _now_iso() -> str: + return datetime.now(UTC).isoformat() + + +def _manifest_sort_key(manifest: dict[str, Any]) -> tuple[str, str]: + return ( + str(manifest.get("updated_at") or manifest.get("created_at") or ""), + str(manifest.get("run_id") or ""), + ) diff --git a/backend/app/services/mining_manager.py b/backend/app/services/mining_manager.py new file mode 100644 index 0000000..0422ac3 --- /dev/null +++ b/backend/app/services/mining_manager.py @@ -0,0 +1,263 @@ +"""Threaded orchestration for persistent mining jobs.""" + +from __future__ import annotations + +import threading +import time +from collections.abc import Callable +from pathlib import Path +from typing import Any + +from app.backtest.worker import make_worker_task, run_worker_task +from app.services.heavy_job_limiter import ( + HeavyJobCancelledError, + shared_heavy_job_limiter, +) +from app.services.mining_jobs import ( + ACTIVE_RUN_STATUSES, + SUCCESS_RUN_STATUSES, + TERMINAL_RUN_STATUSES, + MiningRunStore, + MiningRunValidationError, + compute_run_signature, +) + +WorkerRunner = Callable[ + [dict[str, Any], Callable[[dict[str, Any]], None], threading.Event], + dict[str, Any], +] +TaskFactory = Callable[[str, Path, dict[str, Any]], dict[str, Any]] + +_SUCCESS_STATUSES = {"succeeded", "succeeded_with_budget_exhausted"} +_SHUTDOWN_JOIN_SECONDS = 1.0 + + +class MiningJobManager: + """Coordinate mining persistence, capacity, cancellation, and worker threads.""" + + def __init__( + self, + data_dir: Path | str, + worker_runner: WorkerRunner = run_worker_task, + task_factory: TaskFactory = make_worker_task, + ) -> None: + self._data_dir = Path(data_dir).resolve() + self._store = MiningRunStore(self._data_dir) + self._worker_runner = worker_runner + self._task_factory = task_factory + self._lock = threading.RLock() + self._threads: dict[str, threading.Thread] = {} + self._cancel_events: dict[str, threading.Event] = {} + self._shutdown = False + + @property + def store(self) -> MiningRunStore: + return self._store + + def start( + self, + request: dict[str, Any], + data_fingerprint: Any, + force: bool = False, + source: str = "manual", + run_id: str | None = None, + ) -> dict[str, Any]: + signature = compute_run_signature(request, data_fingerprint) + with self._lock: + if self._shutdown: + raise RuntimeError("mining job manager is shut down") + if not force: + active = self._store.find_by_signature( + signature, + statuses=ACTIVE_RUN_STATUSES, + ) + if active is not None: + return active + succeeded = self._store.find_by_signature( + signature, + statuses=SUCCESS_RUN_STATUSES, + ) + if succeeded is not None: + return succeeded + + try: + manifest = self._store.create( + request, + data_fingerprint, + run_id=run_id, + ) + except MiningRunValidationError: + if run_id is None: + raise + existing = self._store.get(run_id) + if existing is None: + raise + return existing + run_id = manifest["run_id"] + self._store.append_event( + run_id, + "queued", + {"status": "queued", "source": source}, + ) + self._start_thread_locked(run_id, source) + return manifest + + def cancel(self, run_id: str) -> dict[str, Any]: + with self._lock: + manifest = self._store.get(run_id) + if manifest is None: + raise KeyError(run_id) + if manifest["status"] in TERMINAL_RUN_STATUSES: + return manifest + + cancel_event = self._cancel_events.get(run_id) + if cancel_event is None: + cancelled = self._store.transition_status(run_id, "cancelled") + self._store.append_event(run_id, "cancelled", {"status": "cancelled"}) + return cancelled + + cancel_event.set() + if manifest["status"] != "cancelling": + manifest = self._store.transition_status(run_id, "cancelling") + self._store.append_event(run_id, "cancelling", {"status": "cancelling"}) + return manifest + + def shutdown(self) -> None: + with self._lock: + self._shutdown = True + run_ids = list(self._threads) + for run_id in run_ids: + self.cancel(run_id) + + deadline = time.monotonic() + _SHUTDOWN_JOIN_SECONDS + current = threading.current_thread() + for run_id in run_ids: + with self._lock: + thread = self._threads.get(run_id) + if thread is None or thread is current: + continue + remaining = deadline - time.monotonic() + if remaining <= 0: + break + thread.join(timeout=remaining) + + def recover_interrupted(self) -> int: + return self._store.recover_interrupted() + + def _start_thread_locked(self, run_id: str, source: str) -> None: + if run_id in self._threads: + return + cancel_event = threading.Event() + thread = threading.Thread( + target=self._run_job, + args=(run_id, source, cancel_event), + name=f"mining-{run_id}", + daemon=True, + ) + self._cancel_events[run_id] = cancel_event + self._threads[run_id] = thread + thread.start() + + def _run_job( + self, + run_id: str, + source: str, + cancel_event: threading.Event, + ) -> None: + try: + with shared_heavy_job_limiter.slot("mining", cancel_event=cancel_event): + if not self._mark_running(run_id, cancel_event): + return + manifest = self._store.get(run_id) + if manifest is None: + raise KeyError(run_id) + payload = { + "run_id": run_id, + "request": manifest["request"], + "data_fingerprint": manifest["data_fingerprint"], + "source": source, + } + task = self._task_factory("mining", self._data_dir, payload) + result = self._worker_runner( + task, + lambda progress: self._record_progress(run_id, progress, cancel_event), + cancel_event, + ) + if not isinstance(result, dict): + raise TypeError("mining worker result must be a compact dict") + self._finish_success(run_id, result, cancel_event) + except HeavyJobCancelledError: + self._finish_cancelled(run_id) + except Exception as exc: + if cancel_event.is_set(): + self._finish_cancelled(run_id) + else: + self._finish_failed(run_id, exc) + finally: + with self._lock: + self._threads.pop(run_id, None) + self._cancel_events.pop(run_id, None) + + def _mark_running(self, run_id: str, cancel_event: threading.Event) -> bool: + with self._lock: + if cancel_event.is_set(): + self._finish_cancelled_locked(run_id) + return False + self._store.transition_status(run_id, "running") + self._store.append_event(run_id, "running", {"status": "running"}) + return True + + def _record_progress( + self, + run_id: str, + progress: dict[str, Any], + cancel_event: threading.Event, + ) -> None: + if not isinstance(progress, dict): + raise TypeError("mining progress must be a compact dict") + with self._lock: + if cancel_event.is_set(): + return + self._store.append_event(run_id, "progress", progress) + self._store.write_summary(run_id, {"progress": progress}) + + def _finish_success( + self, + run_id: str, + result: dict[str, Any], + cancel_event: threading.Event, + ) -> None: + status = result.get("status", "succeeded") + if status not in _SUCCESS_STATUSES: + raise ValueError(f"unsupported mining worker status: {status!r}") + with self._lock: + if cancel_event.is_set(): + self._finish_cancelled_locked(run_id) + return + self._store.write_summary(run_id, result) + self._store.transition_status(run_id, status) + self._store.append_event(run_id, status, {"status": status}) + + def _finish_cancelled(self, run_id: str) -> None: + with self._lock: + self._finish_cancelled_locked(run_id) + + def _finish_cancelled_locked(self, run_id: str) -> None: + manifest = self._store.get(run_id) + if manifest is None or manifest["status"] in TERMINAL_RUN_STATUSES: + return + self._store.transition_status(run_id, "cancelled") + self._store.append_event(run_id, "cancelled", {"status": "cancelled"}) + + def _finish_failed(self, run_id: str, exc: Exception) -> None: + message = str(exc)[:2000] + with self._lock: + manifest = self._store.get(run_id) + if manifest is None or manifest["status"] in TERMINAL_RUN_STATUSES: + return + self._store.transition_status(run_id, "failed", error=message) + self._store.append_event( + run_id, + "error", + {"status": "failed", "message": message}, + ) diff --git a/backend/app/services/mining_preflight.py b/backend/app/services/mining_preflight.py new file mode 100644 index 0000000..6f234ee --- /dev/null +++ b/backend/app/services/mining_preflight.py @@ -0,0 +1,139 @@ +"""Lightweight mining date availability checks shared by API and workers.""" +from __future__ import annotations + +from dataclasses import asdict, dataclass +from datetime import date +from pathlib import Path +from typing import Any + +from app.backtest.mining import ( + nested_fold_count, + required_outer_folds, + required_trading_bars, + validation_config_for_profile, +) +from app.tickflow.repository import enriched_dirname + + +@dataclass(frozen=True) +class MiningAvailability: + asset_type: str + budget_profile: str + trading_bars: int + required_bars: int + outer_folds: int + required_outer_folds: int + eligible: bool + available_start: date | None + available_end: date | None + effective_start: date | None + effective_end: date | None + suggested_start: date | None + + def to_dict(self) -> dict[str, Any]: + return { + key: value.isoformat() if isinstance(value, date) else value + for key, value in asdict(self).items() + } + + +def enriched_partition_dates( + data_dir: Path, + asset_type: str, + start: date | None = None, + end: date | None = None, +) -> list[date]: + root = data_dir / enriched_dirname(asset_type) + values: set[date] = set() + for partition in root.glob("date=*"): + try: + value = date.fromisoformat(partition.name.removeprefix("date=")) + except ValueError: + continue + if start is not None and value < start: + continue + if end is not None and value > end: + continue + if (partition / "part.parquet").is_file(): + values.add(value) + return sorted(values) + + +def mining_availability( + data_dir: Path, + *, + asset_type: str, + budget_profile: str, + start: date | None = None, + end: date | None = None, +) -> MiningAvailability: + if asset_type not in {"stock", "etf"}: + raise ValueError(f"unsupported mining asset type: {asset_type}") + if start is not None and end is not None and start > end: + raise ValueError("mining start must not be after end") + + config = validation_config_for_profile(budget_profile) + required_folds = required_outer_folds(budget_profile) + required_bars = required_trading_bars(config, required_folds) + all_dates = enriched_partition_dates(data_dir, asset_type) + scoped = [ + value + for value in all_dates + if (start is None or value >= start) and (end is None or value <= end) + ] + dates_through_end = [ + value for value in all_dates if end is None or value <= end + ] + suggested_start = ( + dates_through_end[-required_bars] + if len(dates_through_end) >= required_bars + else None + ) + trading_bars = len(scoped) + return MiningAvailability( + asset_type=asset_type, + budget_profile=budget_profile, + trading_bars=trading_bars, + required_bars=required_bars, + outer_folds=nested_fold_count(trading_bars, config), + required_outer_folds=required_folds, + eligible=trading_bars >= required_bars, + available_start=all_dates[0] if all_dates else None, + available_end=all_dates[-1] if all_dates else None, + effective_start=scoped[0] if scoped else None, + effective_end=scoped[-1] if scoped else None, + suggested_start=suggested_start, + ) + + +def require_mining_availability( + data_dir: Path, + *, + asset_type: str, + budget_profile: str, + start: date | None = None, + end: date | None = None, +) -> MiningAvailability: + availability = mining_availability( + data_dir, + asset_type=asset_type, + budget_profile=budget_profile, + start=start, + end=end, + ) + if availability.eligible: + return availability + + if availability.effective_start is None: + effective_range = "contains no enriched data" + else: + effective_range = ( + f"{availability.effective_start.isoformat()} to " + f"{availability.effective_end.isoformat()}" + ) + fold_label = "outer fold" if availability.required_outer_folds == 1 else "outer folds" + raise ValueError( + f"{budget_profile} mining requires at least {availability.required_bars} " + f"enriched trading bars for {availability.required_outer_folds} {fold_label}; " + f"effective range {effective_range} has {availability.trading_bars}" + ) diff --git a/backend/app/services/mining_process_lock.py b/backend/app/services/mining_process_lock.py new file mode 100644 index 0000000..f0323b0 --- /dev/null +++ b/backend/app/services/mining_process_lock.py @@ -0,0 +1,78 @@ +from __future__ import annotations + +import os +from pathlib import Path +from typing import BinaryIO + + +class MiningProcessLockError(RuntimeError): + """Another application process owns mining for this data directory.""" + + +class MiningProcessLock: + def __init__(self, data_dir: Path) -> None: + self._path = Path(data_dir) / ".mining_process.lock" + self._stream: BinaryIO | None = None + + def acquire(self) -> None: + if self._stream is not None: + return + self._path.parent.mkdir(parents=True, exist_ok=True) + stream = self._path.open("a+b") + try: + stream.seek(0, os.SEEK_END) + if stream.tell() == 0: + stream.write(b"0") + stream.flush() + os.set_inheritable(stream.fileno(), False) + _try_lock_file(stream) + except BaseException: + stream.close() + raise + self._stream = stream + + def release(self) -> None: + stream = self._stream + if stream is None: + return + self._stream = None + try: + _unlock_file(stream) + finally: + stream.close() + + +def _try_lock_file(stream: BinaryIO) -> None: + if os.name == "nt": + import msvcrt + + stream.seek(0) + try: + msvcrt.locking(stream.fileno(), msvcrt.LK_NBLCK, 1) + except OSError as exc: + raise MiningProcessLockError( + "another application process already owns mining for this data directory" + ) from exc + return + + import fcntl + + try: + fcntl.flock(stream.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB) + except OSError as exc: + raise MiningProcessLockError( + "another application process already owns mining for this data directory" + ) from exc + + +def _unlock_file(stream: BinaryIO) -> None: + if os.name == "nt": + import msvcrt + + stream.seek(0) + msvcrt.locking(stream.fileno(), msvcrt.LK_UNLCK, 1) + return + + import fcntl + + fcntl.flock(stream.fileno(), fcntl.LOCK_UN) diff --git a/backend/app/services/mining_schedule.py b/backend/app/services/mining_schedule.py new file mode 100644 index 0000000..6a6475d --- /dev/null +++ b/backend/app/services/mining_schedule.py @@ -0,0 +1,391 @@ +"""Weekly scheduled mining orchestration and deterministic data claims.""" + +from __future__ import annotations + +import hashlib +import json +import logging +import threading +from datetime import date, datetime +from pathlib import Path +from typing import Any +from zoneinfo import ZoneInfo + +import polars as pl + +from app.backtest.factor import FACTOR_COLUMNS, FACTOR_METHODOLOGY_VERSION +from app.backtest.mining import ( + required_outer_folds, + required_trading_bars, + validation_config_for_profile, +) +from app.services import preferences +from app.services.mining_preflight import enriched_partition_dates +from app.services.regime_builder import load_regime_history, regime_path + +logger = logging.getLogger(__name__) + +BEIJING_TZ = ZoneInfo("Asia/Shanghai") +MINING_ALGORITHM_VERSION = "mining-v2" +FINGERPRINT_VERSION = "weekly-mining-data-v2" +_PROFILES = frozenset({"balanced", "strict"}) +_CLAIM_LOCK = threading.Lock() + + +def beijing_now(now: datetime | None = None) -> datetime: + """Return an aware Beijing datetime without depending on the server timezone.""" + if now is None: + return datetime.now(BEIJING_TZ) + if now.tzinfo is None: + return now.replace(tzinfo=BEIJING_TZ) + return now.astimezone(BEIJING_TZ) + + +def beijing_date(now: datetime | None = None) -> date: + return beijing_now(now).date() + + +def iso_week(value: date) -> tuple[int, int]: + iso_year, week, _ = value.isocalendar() + return iso_year, week + + +def build_default_request(repo: Any, profile: str) -> dict[str, Any]: + """Build the bounded V1 stock/full-market request used by the scheduler.""" + if profile not in _PROFILES: + raise ValueError(f"unsupported mining profile: {profile}") + latest = repo.latest_enriched_date("stock") + end = latest.isoformat() if latest is not None else None + return { + "factor_names": [item["id"] for item in FACTOR_COLUMNS[:48]], + "strategy_ids": [], + "symbols": None, + "asset_type": "stock", + "start": None, + "end": end, + "budget_profile": profile, + "require_regime": True, + } + + +def build_data_fingerprint( + repo: Any, + app_state: Any, + request: dict[str, Any], +) -> dict[str, Any]: + """Hash one stable managed generation plus source metadata.""" + for _attempt in range(2): + fingerprint = _build_data_fingerprint_once(repo, app_state, request) + if repo.get_matrix_data_generation(fingerprint["asset_type"]) == fingerprint["generation"]: + return fingerprint + raise ValueError("enriched data changed while building the mining fingerprint") + + +def _build_data_fingerprint_once( + repo: Any, + app_state: Any, + request: dict[str, Any], +) -> dict[str, Any]: + data_dir = Path(repo.store.data_dir) + asset_type = str(request.get("asset_type") or "stock") + enriched_root = ( + data_dir / "kline_daily_enriched" + if asset_type == "stock" + else data_dir / f"kline_{asset_type}_enriched" + ) + module_root = Path(__file__).resolve().parents[1] + components = { + "version": FINGERPRINT_VERSION, + "asset_type": asset_type, + "generation": repo.get_matrix_data_generation(asset_type), + "latest_enriched_date": _iso_or_none(repo.latest_enriched_date(asset_type)), + "enriched": _enriched_metadata(enriched_root), + "instruments": _instrument_metadata(repo, asset_type), + "regime": _path_metadata(regime_path(data_dir), root=data_dir), + "algorithm_version": MINING_ALGORITHM_VERSION, + "methodology_version": FACTOR_METHODOLOGY_VERSION, + "implementation": _implementation_metadata(module_root), + "strategies": _selected_strategy_metadata( + app_state, + request.get("strategy_ids") or [], + data_dir, + ), + } + payload = _canonical_json(components) + return { + **components, + "digest": hashlib.sha256(payload.encode("utf-8")).hexdigest(), + } + + +def schedule_claim(day: date) -> str: + iso_year, week = iso_week(day) + return f"weekly-{iso_year}-W{week:02d}" + + +def run_weekly_mining(app_state: Any, *, now: datetime | None = None) -> dict[str, Any]: + """Check the weekly gate and enqueue mining; never perform mining synchronously.""" + config = preferences.get_mining_schedule() + day = beijing_date(now) + if not config["mining_schedule_enabled"]: + return {"status": "disabled"} + weekday = day.weekday() + if weekday > 4 or weekday < config["mining_schedule_weekday"]: + return {"status": "weekday_mismatch"} + + manager = getattr(app_state, "mining_manager", None) + repo = getattr(app_state, "repo", None) + if manager is None or repo is None: + raise RuntimeError("scheduled mining dependencies are not initialized") + store = getattr(manager, "store", None) + if store is None: + raise RuntimeError("scheduled mining manager has no run store") + + request = build_default_request(repo, config["mining_budget_profile"]) + fingerprint = build_data_fingerprint(repo, app_state, request) + claim = schedule_claim(day) + fingerprint = {**fingerprint, "source": "scheduled", "source_claim": claim} + + with _CLAIM_LOCK: + existing = store.get(claim) + if existing is not None: + return {"status": "already_claimed", "run_id": claim} + + prerequisite_error = _prerequisite_error(repo, request) + if prerequisite_error is not None: + _record_skipped_prerequisite(store, claim, request, fingerprint, prerequisite_error) + return { + "status": "skipped_prerequisite", + "run_id": claim, + "error": prerequisite_error, + } + + run = manager.start( + request, + fingerprint, + force=False, + source="scheduled", + run_id=claim, + ) + run_id = run.get("run_id") if isinstance(run, dict) else getattr(run, "run_id", None) + return {"status": "enqueued", "run_id": run_id or claim} + + +def _prerequisite_error(repo: Any, request: dict[str, Any]) -> str | None: + data_dir = Path(repo.store.data_dir) + end = request.get("end") + if end is None: + return "stock enriched data is unavailable" + regime = regime_path(data_dir) + try: + if not regime.is_file() or regime.stat().st_size <= 0: + return "regime data is unavailable" + except OSError: + return "regime data is unavailable" + + start = request.get("start") + start_date = date.fromisoformat(start) if start is not None else None + end_date = date.fromisoformat(end) + partitions = enriched_partition_dates( + data_dir, + "stock", + start_date, + end_date, + ) + covered = [value.isoformat() for value in partitions] + profile = request["budget_profile"] + validation = validation_config_for_profile(profile) + required = required_trading_bars( + validation, + required_outer_folds(profile), + ) + if len(covered) < required: + return ( + "insufficient enriched trading dates: " + f"need {required}, got {len(covered)}" + ) + + regime_history = load_regime_history(data_dir) + if regime_history.is_empty() or "date" not in regime_history.columns: + return "regime data is unavailable" + regime_dates = set( + regime_history.select( + pl.col("date").cast(pl.Utf8).str.slice(0, 10) + ).to_series().to_list() + ) + required_predecessors = set(covered[:-1]) + missing_regime = required_predecessors - regime_dates + if missing_regime: + return ( + "regime coverage is incomplete for T-1 alignment: " + f"missing {len(missing_regime)} trading dates" + ) + return None + + +def _record_skipped_prerequisite( + store: Any, + claim: str, + request: dict[str, Any], + fingerprint: dict[str, Any], + error: str, +) -> None: + try: + store.create(request, fingerprint, run_id=claim) + except Exception: + if store.get(claim) is not None: + return + raise + store.append_event( + claim, + "skipped_prerequisite", + {"source": "scheduled", "reason": error}, + ) + store.transition_status(claim, "skipped_prerequisite", error=error) + + +def _instrument_metadata(repo: Any, asset_type: str) -> dict[str, Any]: + instruments = repo.get_instruments_asset(asset_type) + if instruments is None or instruments.is_empty() or "symbol" not in instruments.columns: + return {"rows": 0, "digest": "no-instruments"} + columns = [ + name + for name in ( + "symbol", + "name", + "total_shares", + "float_shares", + "limit_up", + "limit_down", + ) + if name in instruments.columns + ] + payload = instruments.select(columns).sort("symbol").to_dicts() + digest = hashlib.blake2b( + json.dumps(payload, ensure_ascii=False, default=str).encode("utf-8"), + digest_size=20, + ).hexdigest() + return {"rows": instruments.height, "columns": columns, "digest": digest} + + +def _enriched_metadata(root: Path) -> dict[str, Any]: + records: list[dict[str, Any]] = [] + for partition in sorted(root.glob("date=*"), key=lambda item: item.name): + try: + date.fromisoformat(partition.name.removeprefix("date=")) + except ValueError: + continue + records.append( + { + "partition": partition.name, + "file": _path_metadata(partition / "part.parquet", root=root), + } + ) + return { + "partition_count": len(records), + "first_partition": records[0]["partition"] if records else None, + "last_partition": records[-1]["partition"] if records else None, + "metadata_digest": hashlib.sha256(_canonical_json(records).encode("utf-8")).hexdigest(), + } + + +def _selected_strategy_metadata( + app_state: Any, + strategy_ids: list[str], + data_dir: Path, +) -> list[dict[str, Any]]: + if not strategy_ids: + return [] + engine = getattr(app_state, "strategy_engine", None) + if engine is None: + raise RuntimeError("strategy engine is unavailable for scheduled mining fingerprint") + metadata: list[dict[str, Any]] = [] + for strategy_id in sorted(strategy_ids): + strategy = engine.get(strategy_id) + if strategy.execution_backend != "matrix_native": + raise ValueError(f"scheduled mining strategy is not matrix-native: {strategy_id}") + source_path = Path(strategy.file_path) if strategy.file_path is not None else None + override_path = data_dir / "user_data" / "strategy_overrides" / f"{strategy_id}.json" + metadata.append( + { + "strategy_id": strategy_id, + "source": _content_metadata( + source_path, root=source_path.parent if source_path else data_dir + ), + "source_tree": ( + _implementation_metadata(source_path.parent) + if source_path is not None + else None + ), + "override": _content_metadata(override_path, root=data_dir), + } + ) + return metadata + + +def _path_metadata(path: Path | None, *, root: Path) -> dict[str, Any] | None: + if path is None: + return None + try: + stat = path.stat() + except OSError: + return {"path": _relative_path(path, root), "exists": False} + return { + "path": _relative_path(path, root), + "exists": True, + "size": stat.st_size, + "mtime_ns": stat.st_mtime_ns, + } + + +def _content_metadata(path: Path | None, *, root: Path) -> dict[str, Any] | None: + if path is None: + return None + try: + content = path.read_bytes() + except OSError: + return {"path": _relative_path(path, root), "exists": False} + return { + "path": _relative_path(path, root), + "exists": True, + "size": len(content), + "sha256": hashlib.sha256(content).hexdigest(), + } + + +def _implementation_metadata(module_root: Path) -> dict[str, Any]: + records = [] + for path in sorted(module_root.rglob("*.py"), key=lambda item: item.as_posix()): + try: + content = path.read_bytes() + except OSError: + continue + records.append({ + "path": path.relative_to(module_root).as_posix(), + "sha256": hashlib.sha256(content).hexdigest(), + }) + return { + "file_count": len(records), + "digest": hashlib.sha256(_canonical_json(records).encode("utf-8")).hexdigest(), + } + + +def _relative_path(path: Path, root: Path) -> str: + try: + return path.resolve().relative_to(root.resolve()).as_posix() + except ValueError: + return path.name + + +def _iso_or_none(value: date | None) -> str | None: + return value.isoformat() if value is not None else None + + +def _canonical_json(value: Any) -> str: + return json.dumps( + value, + ensure_ascii=False, + allow_nan=False, + sort_keys=True, + separators=(",", ":"), + ) diff --git a/backend/app/services/preferences.py b/backend/app/services/preferences.py index 8bb2fb2..43fc60e 100644 --- a/backend/app/services/preferences.py +++ b/backend/app/services/preferences.py @@ -5,12 +5,19 @@ """ from __future__ import annotations +import copy import json import logging +import re from pathlib import Path logger = logging.getLogger(__name__) +# 进程内缓存: 行情轮询线程一轮会调用 8~12 次 getter, 每次读盘+parse 是纯重复; +# 文件仅在用户改设置时变化, 以 (mtime_ns, size) 签名判断是否重读。 +_cache: dict | None = None +_cache_sig: tuple[int, int] | None = None + def _path() -> Path: from app.config import settings @@ -19,14 +26,32 @@ def _path() -> Path: return p +def _invalidate_cache() -> None: + global _cache, _cache_sig + _cache = None + _cache_sig = None + + def load() -> dict: + """读取 preferences.json (带 mtime 签名缓存)。返回深拷贝, 调用方可自由修改。""" + global _cache, _cache_sig p = _path() - if p.exists(): - try: - return json.loads(p.read_text(encoding="utf-8")) - except Exception as e: # noqa: BLE001 - logger.warning("preferences.json malformed: %s", e) - return {} + try: + sig = (p.stat().st_mtime_ns, p.stat().st_size) + except OSError: + return {} + if _cache is not None and sig == _cache_sig: + return copy.deepcopy(_cache) + try: + data = json.loads(p.read_text(encoding="utf-8")) + except FileNotFoundError: + return {} + except Exception as e: + logger.warning("preferences.json malformed: %s", e) + return {} + _cache = data + _cache_sig = sig + return copy.deepcopy(_cache) def save(updates: dict) -> dict: @@ -36,6 +61,7 @@ def save(updates: dict) -> dict: _path().write_text( json.dumps(current, indent=2, ensure_ascii=False), encoding="utf-8", ) + _invalidate_cache() return current @@ -88,6 +114,7 @@ def set_realtime_quote_interval(interval: float) -> float: _path().write_text( json.dumps(current, indent=2, ensure_ascii=False), encoding="utf-8", ) + _invalidate_cache() return interval @@ -316,6 +343,74 @@ def get_regime_warmup_days() -> int: return 40 +# ── 市场主线(概念/行业涨停梯队)过滤 ── +# 宽基/风格标签(融资融券 ~7700 成分、深股通/沪股通 ~3300-3700、国企改革 ~2900) +# 会按"家数"霸占主线榜首, 但它们不是可操作的题材主线。默认按成分股数上限过滤。 +# 标定(2026-08 THS 概念): 成员 >600 的 55 个概念几乎全是此类风格标签, +# 真实题材(华为概念 2006/人工智能 2166/固态电池等)均在 600 以下或可自行调整。 +_MAINLINE_MAX_MEMBERS_MIN = 50 +_MAINLINE_MAX_MEMBERS_MAX = 5000 +_MAINLINE_MIN_MEMBERS_MIN = 1 +_MAINLINE_MIN_MEMBERS_MAX = 200 + + +def get_mainline_max_members() -> int: + """主线维度成员数上限, 超过视为宽基/风格标签被过滤。默认 600。""" + v = load().get("mainline_max_members", 600) + try: + return max(_MAINLINE_MAX_MEMBERS_MIN, min(_MAINLINE_MAX_MEMBERS_MAX, int(v))) + except (TypeError, ValueError): + return 600 + + +def get_mainline_min_members() -> int: + """主线维度成员数下限, 过滤微型标签。默认 4。""" + v = load().get("mainline_min_members", 4) + try: + return max(_MAINLINE_MIN_MEMBERS_MIN, min(_MAINLINE_MIN_MEMBERS_MAX, int(v))) + except (TypeError, ValueError): + return 4 + + +def get_mainline_blacklist() -> list[str]: + """用户自定义屏蔽的维度成员名(不论成员数大小)。默认空。 + + 保存时接受 list 或逗号/顿号/分号/空白分隔的字符串。 + """ + v = load().get("mainline_blacklist", []) + if isinstance(v, str): + v = [part for part in re.split(r"[,，、;；\s]+", v) if part] # noqa: RUF001 + if not isinstance(v, list): + return [] + return [str(x).strip() for x in v if str(x).strip()] + + +def get_mainline_filter_config() -> dict: + """主线过滤配置汇总(供 API 返回与计算读取)。""" + return { + "min_members": get_mainline_min_members(), + "max_members": get_mainline_max_members(), + "blacklist": get_mainline_blacklist(), + } + + +def set_mainline_filter_config(cfg: dict) -> dict: + """保存主线过滤配置(白名单字段, 部分更新)。修改后需重算主线生效。""" + updates: dict = {} + if "min_members" in cfg and cfg["min_members"] is not None: + updates["mainline_min_members"] = cfg["min_members"] + if "max_members" in cfg and cfg["max_members"] is not None: + updates["mainline_max_members"] = cfg["max_members"] + if "blacklist" in cfg and cfg["blacklist"] is not None: + raw = cfg["blacklist"] + if isinstance(raw, str): + raw = [part for part in re.split(r"[,，、;；\s]+", raw) if part] # noqa: RUF001 + updates["mainline_blacklist"] = [str(x).strip() for x in (raw or []) if str(x).strip()] + if updates: + save(updates) + return get_mainline_filter_config() + + _PIPELINE_PULL_KEYS = ("pipeline_pull_etf", "pipeline_pull_index") @@ -475,6 +570,43 @@ def set_review_schedule(enabled: bool, hour: int, minute: int) -> dict: return {"enabled": bool(enabled), "hour": h, "minute": m} +MINING_BUDGET_PROFILES = frozenset({"balanced", "strict"}) + + +def get_mining_schedule() -> dict: + """返回周度自动 mining 配置。历史配置缺字段时默认关闭。""" + data = load() + weekday = data.get("mining_schedule_weekday", 4) + if isinstance(weekday, bool) or not isinstance(weekday, int) or not 0 <= weekday <= 4: + weekday = 4 + profile = data.get("mining_budget_profile", "balanced") + if not isinstance(profile, str) or profile not in MINING_BUDGET_PROFILES: + profile = "balanced" + enabled = data.get("mining_schedule_enabled", False) + if not isinstance(enabled, bool): + enabled = False + return { + "mining_schedule_enabled": enabled, + "mining_schedule_weekday": weekday, + "mining_budget_profile": profile, + } + + +def set_mining_schedule(enabled: bool, weekday: int, profile: str) -> dict: + """校验并一次写入周度自动 mining 的整组配置。""" + if isinstance(weekday, bool) or not isinstance(weekday, int) or not 0 <= weekday <= 4: + raise ValueError("mining schedule weekday must be between 0 and 4") + if profile not in MINING_BUDGET_PROFILES: + raise ValueError("mining budget profile must be balanced or strict") + result = { + "mining_schedule_enabled": bool(enabled), + "mining_schedule_weekday": weekday, + "mining_budget_profile": profile, + } + save(result) + return result + + def get_review_push_channels() -> list[str]: """复盘推送渠道(多选) — 选定的外部工具列表, 复盘归档后逐个推送。 diff --git a/backend/app/services/quote_service.py b/backend/app/services/quote_service.py index a8fe985..38f2232 100644 --- a/backend/app/services/quote_service.py +++ b/backend/app/services/quote_service.py @@ -130,18 +130,38 @@ class QuoteSubscriber: self._event.set() +# 落盘节流间隔: last_fetch_ms 仅在进程重启后用于显示"最后获取时间"(运行中读内存值), +# 每 30s 持久化一次足够, 避免 expert 档每秒一轮的全量 preferences 重写磁盘。 +_LAST_FETCH_WRITE_INTERVAL_MS = 30_000.0 +_last_fetch_written_at_ms: float = 0.0 + + def _persist_last_fetch(fetched_at_ms: float) -> None: """把"最后获取"时间戳持久化到 preferences, 使进程重启后仍可显示。 放在锁外调用 (IO); 失败不影响主流程 (内存值已更新, 下次 fetch 再写)。 + 距上次成功落盘不足 30s 时跳过 (节流只影响落盘频率, 内存值不受影响)。 """ + global _last_fetch_written_at_ms + if (fetched_at_ms - _last_fetch_written_at_ms) < _LAST_FETCH_WRITE_INTERVAL_MS: + return try: from app.services import preferences preferences.save({"last_fetch_ms": round(fetched_at_ms, 0)}) + _last_fetch_written_at_ms = fetched_at_ms except Exception as e: # noqa: BLE001 logger.debug("last_fetch_ms 持久化失败 (不影响行情): %s", e) +def _monitor_name_map(repo) -> dict[str, str]: + """监控回填用的 symbol → name 映射 (股票 + ETF + 指数, 股票优先)。 + + 走 repo.get_name_map() 的进程内 memo (三份 instruments 维表刷新时失效), + 避免每轮监控对 ~7000 行维表 iter_rows 重建。过滤空名称与旧行为一致。 + """ + return {s: n for s, n in repo.get_name_map().items() if n} + + class QuoteService: """全局实时行情服务 — 单例。""" @@ -1081,28 +1101,10 @@ class QuoteService: engine = getattr(self._app_state, "monitor_engine", None) if engine and engine.rule_count > 0: # 预构建 symbol → name 映射 (enriched 已 drop name 列, 引擎触发时回填用)。 - # 含股票 + ETF 维表, 保证 ETF 监控告警也能回填名称。 + # 股票 + ETF + 指数三表合并走 _monitor_name_map -> repo.get_name_map() + # 的进程内 memo, 避免每轮监控对 ~7000 行维表 iter_rows 重建。 try: - name_map: dict[str, str] = {} - inst_df = self._app_state.repo.get_instruments() - if not inst_df.is_empty() and "symbol" in inst_df.columns and "name" in inst_df.columns: - for row in inst_df.select(["symbol", "name"]).iter_rows(named=True): - if row.get("name"): - name_map[row["symbol"]] = row["name"] - # 仅当存在 ETF 规则时补 ETF 维表 (股票名优先, setdefault 不覆盖股票) - if engine.has_asset_rules("etf"): - etf_inst = self._app_state.repo.get_etf_instruments() - if not etf_inst.is_empty() and "symbol" in etf_inst.columns and "name" in etf_inst.columns: - for row in etf_inst.select(["symbol", "name"]).iter_rows(named=True): - if row.get("name"): - name_map.setdefault(row["symbol"], row["name"]) - # 仅当存在指数规则时补指数维表 (setdefault 不覆盖股票/ETF) - if engine.has_asset_rules("index"): - idx_inst = self._app_state.repo.get_instruments_asset("index") - if not idx_inst.is_empty() and "symbol" in idx_inst.columns and "name" in idx_inst.columns: - for row in idx_inst.select(["symbol", "name"]).iter_rows(named=True): - if row.get("name"): - name_map.setdefault(row["symbol"], row["name"]) + name_map = _monitor_name_map(self._app_state.repo) if name_map: engine.set_name_map(name_map) except Exception as e: # noqa: BLE001 diff --git a/backend/app/services/regime_builder.py b/backend/app/services/regime_builder.py index 3143779..b78f429 100644 --- a/backend/app/services/regime_builder.py +++ b/backend/app/services/regime_builder.py @@ -150,7 +150,16 @@ def _aggregate_daily(df: pl.DataFrame, index_pct_map: dict | None = None) -> pl. 纯 polars 聚合, 不重算指标(假设 df 已含 signal_*/change_pct/ma20 等列)。 index_pct_map: {date: 指数涨幅} 可选, 由调用方从指数数据预先算好。 + 梯队指标(首板/N板宽度/晋级率)由 market_phase 提供; phase 列不在此算 + (需要完整日序做平滑), 由 refresh_phase_labels 在 upsert 后统一重标。 """ + from app.services.market_phase import ( + finalize_ladder_row, + ladder_daily_aggs, + ladder_promo_aggs, + with_prev_consecutive, + ) + needed = ["date", "change_pct", "amount", "signal_limit_up", "signal_limit_down", "signal_broken_limit_up", "consecutive_limit_ups", "close", "ma20"] @@ -158,6 +167,9 @@ def _aggregate_daily(df: pl.DataFrame, index_pct_map: dict | None = None) -> pl. if "date" not in avail or "change_pct" not in avail: return pl.DataFrame() + if "consecutive_limit_ups" in avail and "symbol" in df.columns: + df = with_prev_consecutive(df) + # 基础聚合 — 全部用 group_by 一次性向量化算出, 避免逐日 filter 扫全表(OOM/超时元凶)。 has_ma20 = "close" in avail and "ma20" in avail grouped = df.group_by("date").agg( @@ -216,6 +228,15 @@ def _aggregate_daily(df: pl.DataFrame, index_pct_map: dict | None = None) -> pl. ] if has_ma20 else [] ), + # 梯队指标(阶段判定所需): 首板/N板宽度/非空档位数; 晋级率需 _prev_consec + *( + ladder_daily_aggs() + if "consecutive_limit_ups" in avail else [] + ), + *( + ladder_promo_aggs() + if "consecutive_limit_ups" in avail and "_prev_consec" in df.columns else [] + ), ).sort("date") # 转成 dict 列表做分类(规则引擎需逐日算, 但只扫 grouped 行数=天数, 不再回扫全表) @@ -289,6 +310,8 @@ def _aggregate_daily(df: pl.DataFrame, index_pct_map: dict | None = None) -> pl. "speculation_score": round(sub["speculation"]), "resilience_score": round(sub["resilience"]), "trend_score": round(sub["trend"]), + # 梯队指标(阶段判定所需); phase 由 refresh_phase_labels 统一重标 + **finalize_ladder_row(r), }) return pl.DataFrame(rows) if rows else pl.DataFrame() @@ -325,6 +348,10 @@ def _compute_batch(repo, enriched_dir, instruments, historical_shares, needed={"signal_limit_up", "signal_limit_down", "signal_broken_limit_up"}, historical_shares=historical_shares, ) + # 晋级率需要昨日连板数: 在裁掉 warmup 之前先按 symbol 平移, + # 保证每批首日的 _prev_consec 来自 warmup 的最后一个交易日而非 null。 + from app.services.market_phase import with_prev_consecutive + df = with_prev_consecutive(df) # 丢弃 warmup 行, 只留目标区间 return df.filter((pl.col("date") >= batch_start) & (pl.col("date") <= batch_end)) @@ -446,6 +473,28 @@ def load_regime_history(data_dir: Path) -> pl.DataFrame: return pl.DataFrame() +def refresh_phase_labels(data_dir: Path) -> int: + """对全量 regime 时序重标情绪周期阶段(冰点/启动/主升/高潮/退潮/修复)。 + + 阶段判定需要完整日序(EMA 平滑 + 持续性确认), 不能在单批内完成, + 因此每次 upsert 后调用本函数整体重标并写回。行数为天数(千级), 开销可忽略。 + 返回标注的天数; 阶段列缺失所需指标(旧 schema 未重算)时返回 0。 + """ + from app.services.market_phase import classify_phase_series + + df = load_regime_history(data_dir) + required = {"date", "max_consecutive", "first_board", "ge2_count", "promo_rate", "seal_rate"} + if df.is_empty() or not required.issubset(df.columns): + return 0 + try: + labeled = classify_phase_series(df) + except Exception as e: + logger.warning("refresh_phase_labels failed: %s", e) + return 0 + labeled.write_parquet(regime_path(data_dir)) + return labeled.height + + def upsert_regime_history(data_dir: Path, new_rows: pl.DataFrame) -> None: """按 date 覆盖(upsert): 重算的天覆盖旧行, 新天追加。 @@ -553,6 +602,7 @@ def compute_regime_incremental(repo, data_dir: Path, *, today: date | None = Non new_rows = run_regime_batch(repo, start=to_compute[0], end=to_compute[-1]) if not new_rows.is_empty(): upsert_regime_history(data_dir, new_rows) + refresh_phase_labels(data_dir) return new_rows diff --git a/backend/app/strategy/ai_generator.py b/backend/app/strategy/ai_generator.py index 648cb69..0e3dba9 100644 --- a/backend/app/strategy/ai_generator.py +++ b/backend/app/strategy/ai_generator.py @@ -343,6 +343,7 @@ META = {{...}}，{entrypoint_requirement}。只输出完整 Python 代码。 "polars", "numpy", "app.backtest.matrix", + "app.strategy.builtin.factor_rank_research", "datetime", "__future__", }) diff --git a/backend/app/strategy/builtin/factor_rank_research.py b/backend/app/strategy/builtin/factor_rank_research.py new file mode 100644 index 0000000..bfe1ae3 --- /dev/null +++ b/backend/app/strategy/builtin/factor_rank_research.py @@ -0,0 +1,209 @@ +"""Fixed matrix-native strategy for controlled factor-rank research.""" +from __future__ import annotations + +import numpy as np + +from app.backtest.matrix import ( + MarketDataMatrix, + SignalMatrix, + build_matrix_score, + make_signal_matrix, +) + +META = { + "id": "factor_rank_research", + "name": "因子排名研究", + "description": "受控多因子截面评分、阈值与排名选股策略", + "tags": ["因子", "研究", "截面排名"], + "asset_types": ["stock", "etf"], + "timeframes": ["1d"], + "research_only": True, + "params": [ + { + "id": "entry_score", + "label": "入场最低分", + "type": "float", + "default": 70.0, + "min": 0.0, + "max": 100.0, + "step": 5.0, + }, + { + "id": "exit_score", + "label": "离场最高分", + "type": "float", + "default": 40.0, + "min": 0.0, + "max": 100.0, + "step": 5.0, + }, + { + "id": "top_rank", + "label": "每日最多入选", + "type": "int", + "default": 20, + "min": 1, + "max": 100, + "step": 1, + }, + ], + # Research-generated scoring is supplied in params. Keeping META scoring + # empty prevents the framework pipeline from replacing the strategy score. + "scoring": {}, + "order_by": "score", + "descending": True, + "limit": 100, +} + +EXECUTION_BACKEND = "matrix_native" +ENTRY_SIGNALS = ["signal_factor_rank_entry"] +EXIT_SIGNALS = ["signal_factor_rank_exit"] +STOP_LOSS = -0.08 +MAX_HOLD_DAYS = 30 + +_MAX_FACTORS = 4 +_VALID_DIRECTIONS = {"high", "low"} + + +class FactorRankResearchMatrixStrategy: + def __init__( + self, + scoring: dict[str, float] | None = None, + directions: dict[str, str] | None = None, + ) -> None: + self._scoring = _validated_scoring(scoring) if scoring is not None else None + self._directions = ( + _validated_directions(directions, self._scoring) + if directions is not None and self._scoring is not None + else None + ) + + def required_fields(self) -> frozenset[str]: + return frozenset({ + "open", + "high", + "low", + "close", + "volume", + "amount", + "turnover_rate", + }) + + def required_warmup_bars(self, params: dict) -> int: + del params + return 60 + + def required_fields_for_params(self, params: dict) -> frozenset[str]: + if self._scoring is not None: + return frozenset(self._scoring) + raw = params.get("scoring") + if raw is None: + return frozenset() + return frozenset(_validated_scoring(raw)) + + def compute_signals(self, market: MarketDataMatrix, params: dict) -> SignalMatrix: + scoring = self._scoring or _validated_scoring(params.get("scoring")) + directions = self._directions or _validated_directions( + params.get("directions"), scoring + ) + entry_score = _bounded_float(params.get("entry_score", 70.0), "entry_score") + exit_score = _bounded_float(params.get("exit_score", 40.0), "exit_score") + top_rank = int(params.get("top_rank", 20)) + if not 1 <= top_rank <= 100: + raise ValueError("top_rank must be between 1 and 100") + if exit_score > entry_score: + raise ValueError("exit_score must not exceed entry_score") + + universe = np.isfinite(market.close) + score = build_matrix_score( + market, + universe, + scoring, + "score", + True, + fallback=np.zeros(market.shape, dtype=np.float32), + directions=directions, + ) + entry = universe & (score >= np.float32(entry_score)) + entry = _limit_top_rank(entry, score, top_rank) + exit_ = universe & (score <= np.float32(exit_score)) + return make_signal_matrix( + market.shape, + entry=entry.astype(np.uint8), + exit=exit_.astype(np.uint8), + score=score, + entry_signal_code=np.where(entry, 0, -1).astype(np.int16), + exit_signal_code=np.where(exit_, 0, -1).astype(np.int16), + entry_signal_ids=("signal_factor_rank_entry",), + exit_signal_ids=("signal_factor_rank_exit",), + ) + + +def _validated_scoring(raw: object) -> dict[str, float]: + if not isinstance(raw, dict) or not raw: + raise ValueError("factor-rank research requires a non-empty scoring mapping") + if len(raw) > _MAX_FACTORS: + raise ValueError(f"factor-rank research supports at most {_MAX_FACTORS} factors") + scoring: dict[str, float] = {} + for name, value in raw.items(): + if not isinstance(name, str) or not name: + raise ValueError("scoring factor names must be non-empty strings") + try: + weight = float(value) + except (TypeError, ValueError) as exc: + raise ValueError(f"scoring weight for {name!r} must be numeric") from exc + if not np.isfinite(weight) or weight <= 0.0: + raise ValueError(f"scoring weight for {name!r} must be finite and positive") + scoring[name] = weight + return scoring + + +def _validated_directions( + raw: object, + scoring: dict[str, float], +) -> dict[str, str]: + if raw is None: + return {} + if not isinstance(raw, dict): + raise ValueError("directions must be a mapping") + unknown = sorted(set(raw) - set(scoring)) + if unknown: + raise ValueError(f"directions contain factors absent from scoring: {unknown}") + directions: dict[str, str] = {} + for name, value in raw.items(): + if value not in _VALID_DIRECTIONS: + raise ValueError( + f"direction for {name!r} must be one of {sorted(_VALID_DIRECTIONS)}" + ) + directions[str(name)] = str(value) + return directions + + +def _bounded_float(value: object, name: str) -> float: + try: + number = float(value) + except (TypeError, ValueError) as exc: + raise ValueError(f"{name} must be numeric") from exc + if not np.isfinite(number) or not 0.0 <= number <= 100.0: + raise ValueError(f"{name} must be between 0 and 100") + return number + + +def _limit_top_rank( + eligible: np.ndarray, + score: np.ndarray, + top_rank: int, +) -> np.ndarray: + result = np.zeros(eligible.shape, dtype=bool) + for time_id in range(eligible.shape[0]): + asset_ids = np.flatnonzero(eligible[time_id]) + if asset_ids.size <= top_rank: + result[time_id, asset_ids] = True + continue + # mergesort preserves asset-axis order for equal scores. + order = np.argsort(-score[time_id, asset_ids], kind="stable")[:top_rank] + result[time_id, asset_ids[order]] = True + return result + + +MATRIX_STRATEGY = FactorRankResearchMatrixStrategy() diff --git a/backend/app/strategy/config.py b/backend/app/strategy/config.py index 3c594f7..a22e2c5 100644 --- a/backend/app/strategy/config.py +++ b/backend/app/strategy/config.py @@ -6,12 +6,25 @@ """ from __future__ import annotations +import copy import json import logging from pathlib import Path logger = logging.getLogger(__name__) +# 进程内缓存: 监控引擎每轮对每条策略规则调用 load_override, 每次读盘+parse 纯重复; +# override 仅在用户编辑时变化, 以 (mtime_ns, size) 签名判断是否重读。 +# 键为 override 文件路径 (进程内可能有多个 data_dir, 如测试)。 +_override_cache: dict[str, dict] = {} +_override_cache_sig: dict[str, tuple[int, int]] = {} + + +def _invalidate_override_cache(path: Path) -> None: + key = str(path) + _override_cache.pop(key, None) + _override_cache_sig.pop(key, None) + def _overrides_dir(data_dir: Path) -> Path: d = data_dir / "user_data" / "strategy_overrides" @@ -19,15 +32,29 @@ def _overrides_dir(data_dir: Path) -> Path: return d -def _path(data_dir: Path, strategy_id: str) -> Path: - return _overrides_dir(data_dir) / f"{strategy_id}.json" +def _path(data_dir: Path, strategy_id: str, *, ensure_dir: bool = True) -> Path: + # ensure_dir=False 供热路径读取: mkdir 系统调用在 Windows 上 ~0.07ms, + # 读缓存命中时跳过它 (目录由写路径保证存在)。 + if ensure_dir: + d = _overrides_dir(data_dir) + else: + d = data_dir / "user_data" / "strategy_overrides" + return d / f"{strategy_id}.json" def load_override(data_dir: Path, strategy_id: str) -> dict: - """读取策略的用户覆盖配置，不存在返回空 dict""" - p = _path(data_dir, strategy_id) - if not p.exists(): + """读取策略的用户覆盖配置，不存在返回空 dict (带 mtime 签名缓存, 返回深拷贝)""" + p = _path(data_dir, strategy_id, ensure_dir=False) + key = str(p) + try: + st = p.stat() + sig = (st.st_mtime_ns, st.st_size) + except OSError: + _invalidate_override_cache(p) return {} + cached = _override_cache.get(key) + if cached is not None and sig == _override_cache_sig.get(key): + return copy.deepcopy(cached) try: data = json.loads(p.read_text(encoding="utf-8")) # 清理 basic_filter 中值为 None/空的键（避免固化无意义的空值） @@ -38,7 +65,9 @@ def load_override(data_dir: Path, strategy_id: str) -> dict: data["basic_filter"] = cleaned else: del data["basic_filter"] - return data + _override_cache[key] = data + _override_cache_sig[key] = sig + return copy.deepcopy(data) except Exception as e: logger.warning("load override %s failed: %s", strategy_id, e) return {} @@ -49,11 +78,13 @@ def save_override(data_dir: Path, strategy_id: str, overrides: dict) -> None: p = _path(data_dir, strategy_id) p.parent.mkdir(parents=True, exist_ok=True) p.write_text(json.dumps(overrides, ensure_ascii=False, indent=2), encoding="utf-8") + _invalidate_override_cache(p) def delete_override(data_dir: Path, strategy_id: str) -> None: """删除策略的用户覆盖配置（重置为默认值）""" p = _path(data_dir, strategy_id) + _invalidate_override_cache(p) if p.exists(): p.unlink() diff --git a/backend/app/strategy/engine.py b/backend/app/strategy/engine.py index fca60e7..5ee42d0 100644 --- a/backend/app/strategy/engine.py +++ b/backend/app/strategy/engine.py @@ -554,10 +554,12 @@ class StrategyEngine: # 查询 # ================================================================ - def list_strategies(self) -> list[dict]: - """返回所有策略的元信息""" + def list_strategies(self, *, include_research: bool = False) -> list[dict]: + """Return public strategy metadata unless research templates are requested.""" result = [] for s in self._strategies.values(): + if s.meta.get("research_only") and not include_research: + continue result.append({ **s.meta, "source": s.source, @@ -732,7 +734,11 @@ class StrategyEngine: ), ) field_columns.update( - self._matrix_field_columns(strategy, overrides_map.get(strategy_id)) + self._matrix_field_columns( + strategy, + overrides_map.get(strategy_id), + params, + ) ) if not matrix_ids: return None @@ -1027,7 +1033,11 @@ class StrategyEngine: field_columns: set[str] = set() for sid, strategy in matrix_strats: field_columns.update( - self._matrix_field_columns(strategy, overrides_map.get(sid)) + self._matrix_field_columns( + strategy, + overrides_map.get(sid), + params_map.get(sid), + ) ) shared_matrix = build_market_data_matrix( shared_history, @@ -1052,8 +1062,26 @@ class StrategyEngine: return results @staticmethod - def _matrix_field_columns(strategy: StrategyDef, overrides: dict | None = None) -> set[str]: + def _matrix_field_columns( + strategy: StrategyDef, + overrides: dict | None = None, + params: dict | None = None, + ) -> set[str]: fields = set(strategy.matrix_strategy.required_fields()) + # 参数评分字段 (如挖掘策略的因子组合) 需展开为实际数据依赖, + # 与 backtest._resolve_matrix_native 保持同一语义, 否则虚拟因子 + # (limit_up_count_* -> consecutive_limit_ups) 在矩阵里缺字段。 + parameter_fields = getattr( + strategy.matrix_strategy, + "required_fields_for_params", + None, + ) + if callable(parameter_fields): + fields.update( + scoring_dependencies( + {str(name): 1.0 for name in parameter_fields(params or {})} + ) + ) basic_filter = dict(strategy.basic_filter or {}) if (overrides or {}).get("basic_filter"): basic_filter.update(overrides["basic_filter"]) @@ -1102,7 +1130,7 @@ class StrategyEngine: return StrategyResult(as_of=as_of, strategy_id=strategy_id) market = build_market_data_matrix( source_panel, - field_columns=self._matrix_field_columns(strategy, overrides), + field_columns=self._matrix_field_columns(strategy, overrides, params), ) if source_panel is None or source_panel.is_empty(): diff --git a/backend/app/strategy/scoring.py b/backend/app/strategy/scoring.py index 4456983..dca28ca 100644 --- a/backend/app/strategy/scoring.py +++ b/backend/app/strategy/scoring.py @@ -35,12 +35,31 @@ VIRTUAL_SCORING_DEPENDENCIES: dict[str, frozenset[str]] = { "close_position": frozenset({"high", "low", "close"}), "distance_to_high_60d": frozenset({"close", "high_60d"}), "distance_from_low_60d": frozenset({"close", "low_60d"}), + "max_ret_20d": frozenset({"close"}), + "ret_skew_20d": frozenset({"close"}), + "up_days_20d": frozenset({"close"}), + "amihud_20d": frozenset({"close", "amount"}), + "turnover_z_60d": frozenset({"turnover_rate"}), + "vol_price_corr_20d": frozenset({"close", "volume"}), + "vwap_bias": frozenset({"close", "volume", "amount"}), + "vol_trend_5_60": frozenset({"volume"}), + "limit_up_count_20d": frozenset({"consecutive_limit_ups"}), + "limit_up_count_60d": frozenset({"consecutive_limit_ups"}), } _ROLLING_SCORING_WARMUP: dict[str, int] = { "vol_ratio_10d": 11, "turnover_ratio_5d": 6, "amount_ratio_5d": 6, + "max_ret_20d": 21, + "ret_skew_20d": 21, + "up_days_20d": 21, + "amihud_20d": 21, + "turnover_z_60d": 61, + "vol_price_corr_20d": 21, + "vol_trend_5_60": 60, + "limit_up_count_20d": 21, + "limit_up_count_60d": 61, } @@ -143,9 +162,73 @@ def scoring_value_expr(columns: Collection[str], name: str) -> pl.Expr | None: return _relative(pl.col("close"), pl.col("high_60d")) if name == "distance_from_low_60d": return _relative(pl.col("close"), pl.col("low_60d")) + if name in { + "max_ret_20d", "ret_skew_20d", "up_days_20d", + "amihud_20d", "vol_price_corr_20d", + }: + change = _daily_change_expr() + if name == "max_ret_20d": + return change.rolling_max(20, min_samples=20).over("symbol") + if name == "ret_skew_20d": + return change.rolling_skew(20, bias=True).over("symbol") + if name == "up_days_20d": + return ( + (change > 0).cast(pl.Float64) + .rolling_sum(20, min_samples=20).over("symbol") + ) + if name == "amihud_20d": + illiquidity = _ratio(change.abs(), pl.col("amount") / 1e8) + return illiquidity.rolling_mean(20, min_samples=20).over("symbol") + volume = pl.col("volume") + product = change * volume + return _rolling_corr_expr(change, volume, product, 20).over("symbol") + if name == "turnover_z_60d": + baseline = pl.col("turnover_rate").shift(1) + mean = baseline.rolling_mean(60, min_samples=60) + std = baseline.rolling_std(60, min_samples=60) + return ( + pl.when(std > 0).then((pl.col("turnover_rate") - mean) / std) + .otherwise(None) + .over("symbol") + ) + if name == "vwap_bias": + vwap = _ratio(pl.col("amount"), pl.col("volume") * 100.0) + return _relative(pl.col("close"), vwap) + if name == "vol_trend_5_60": + fast = pl.col("volume").rolling_mean(5) + slow = pl.col("volume").rolling_mean(60) + return _relative(fast, slow).over("symbol") + if name in {"limit_up_count_20d", "limit_up_count_60d"}: + window = 20 if name == "limit_up_count_20d" else 60 + hit = (pl.col("consecutive_limit_ups").fill_null(0) > 0).cast(pl.Float64) + return hit.rolling_sum(window, min_samples=window).over("symbol") return None +def _daily_change_expr() -> pl.Expr: + previous = pl.col("close").shift(1) + return _ratio(pl.col("close"), previous) - 1.0 + + +def _rolling_corr_expr( + left: pl.Expr, right: pl.Expr, product: pl.Expr, window: int +) -> pl.Expr: + """Pearson correlation over a rolling window, matching the matrix kernel formula.""" + mean_left = left.rolling_mean(window, min_samples=window) + mean_right = right.rolling_mean(window, min_samples=window) + mean_product = product.rolling_mean(window, min_samples=window) + mean_left_sq = (left * left).rolling_mean(window, min_samples=window) + mean_right_sq = (right * right).rolling_mean(window, min_samples=window) + covariance = mean_product - mean_left * mean_right + variance_left = mean_left_sq - mean_left * mean_left + variance_right = mean_right_sq - mean_right * mean_right + return pl.when( + (variance_left > 0) & (variance_right > 0) + ).then( + covariance / (variance_left * variance_right).sqrt() + ).otherwise(None) + + def materialize_scoring_columns( frame: pl.DataFrame, names: Collection[str], diff --git a/backend/app/tickflow/repository.py b/backend/app/tickflow/repository.py index 10c874f..7f6705c 100644 --- a/backend/app/tickflow/repository.py +++ b/backend/app/tickflow/repository.py @@ -26,6 +26,13 @@ import duckdb import polars as pl from app.config import settings +from app.enriched_generation import ( + EnrichedGenerationUnavailableError, + EnrichedPublication, + bump_enriched_generation, + get_enriched_generation, +) +from app.market_time import cn_today from app.parquet import scan_enriched_parquet logger = logging.getLogger(__name__) @@ -318,6 +325,7 @@ class KlineRepository: # 完整 enriched 历史 (含所有指标, 供 filter_history 策略使用) self._enriched_history_cache: pl.DataFrame | None = None # ~100万行 self._enriched_history_start: date | None = None + self._enriched_history_generation: str | None = None self._index_instruments_cache: pl.DataFrame | None = None self._etf_enriched_cache: pl.DataFrame | None = None self._etf_enriched_cache_date: date | None = None @@ -485,6 +493,7 @@ class KlineRepository: self._enriched_cache_date = None self._enriched_history_cache = None self._enriched_history_start = None + self._enriched_history_generation = None self._live_agg_cache = None self._live_agg_cache_date = None self._live_agg_check_date = None @@ -497,6 +506,7 @@ class KlineRepository: self._etf_instruments_cache = None self._index_symbol_set_cache = None self._etf_symbol_set_cache = None + self._name_map_cache = None self._index_enriched_cache = None self._index_enriched_cache_date = None @@ -510,6 +520,7 @@ class KlineRepository: """ try: started = time.perf_counter() + refresh_generation = self.get_matrix_data_generation("stock") logger.info("enriched refresh start") step = time.perf_counter() @@ -596,8 +607,13 @@ class KlineRepository: logger.info("enriched refresh step done: join instruments (%.2fs)", time.perf_counter() - step) # 缓存完整历史 (含指标+必要基础信息) 供 filter_history/backtest 直接复用 + if self.get_matrix_data_generation("stock") != refresh_generation: + raise EnrichedGenerationUnavailableError( + "enriched data changed while refreshing its history cache" + ) self._enriched_history_cache = df_full self._enriched_history_start = df_full["date"].min() + self._enriched_history_generation = refresh_generation logger.info("enriched 历史缓存: %d rows, %s ~ %s", len(df_full), self._enriched_history_start, latest) @@ -626,6 +642,8 @@ class KlineRepository: logger.info("enriched 缓存已计算: %d 只, 日期 %s (即时计算)", len(df_today), latest) logger.info("enriched refresh done (%.2fs)", time.perf_counter() - started) return + except EnrichedGenerationUnavailableError: + raise except Exception as e: # noqa: BLE001 logger.warning("enriched 即时计算失败, 使用原始 14 列缓存: %s", e) @@ -908,7 +926,7 @@ class KlineRepository: def _live_agg_baseline_date(self, latest: date) -> date: """盘中递推基准日期。当天实时分区存在时使用上一可用交易日。""" - if latest != date.today(): + if latest != cn_today(): return latest try: row = self.execute_one( @@ -1051,6 +1069,7 @@ class KlineRepository: df = pl.scan_parquet(self._inst_glob).collect() if not df.is_empty(): self._instruments_cache = df + self._name_map_cache = None logger.info("instruments 缓存已加载: %d 只", len(df)) except Exception as e: # noqa: BLE001 logger.warning("instruments 缓存刷新失败: %s", e) @@ -1062,6 +1081,7 @@ class KlineRepository: if not df.is_empty(): self._index_instruments_cache = df self._index_symbol_set_cache = None + self._name_map_cache = None logger.info("index instruments 缓存已加载: %d 只", len(df)) except Exception as e: # noqa: BLE001 logger.debug("index instruments 缓存刷新跳过: %s", e) @@ -1087,6 +1107,7 @@ class KlineRepository: df_all = pl.concat(parts, how="diagonal_relaxed").unique(subset=["symbol"], keep="last").sort("symbol") self._etf_instruments_cache = df_all self._etf_symbol_set_cache = None + self._name_map_cache = None logger.info("ETF instruments 缓存已加载: %d 只", len(df_all)) def get_enriched_latest(self) -> tuple[pl.DataFrame, date | None]: @@ -1164,8 +1185,21 @@ class KlineRepository: ) -> pl.DataFrame | None: """从预计算 enriched 历史缓存返回完整区间；缓存不覆盖时返回 None。""" if self._enriched_history_cache is None: + if self._enriched_warming: + # 后台预热中: 返回 None (缓存不覆盖), 调用方各自走慢路径; + # 否则请求线程会与预热线程并发重复 300 天全量重算 + # (同 get_enriched_latest 的守卫语义)。 + return None self._refresh_enriched() cache = self._enriched_history_cache + data_dir = getattr(getattr(self, "store", None), "data_dir", None) + if data_dir is not None: + try: + current_generation = self.get_matrix_data_generation("stock") + except EnrichedGenerationUnavailableError: + return None + if self._enriched_history_generation != current_generation: + return None if cache is None or cache.is_empty() or "date" not in cache.columns: return None @@ -1204,9 +1238,9 @@ class KlineRepository: # 后台预热中: 返回空表, 不触发同步重算 (同 get_enriched_latest 守卫) return pl.DataFrame() self._refresh_enriched() - self._live_agg_check_date = date.today() # 刚建过, 当天不必再查磁盘 + self._live_agg_check_date = cn_today() # 刚建过, 当天不必再查磁盘 else: - today = date.today() + today = cn_today() if self._live_agg_check_date != today: # today 翻天了 (次日开盘首次轮询): 校验基准日是否需要前移重建。 # 同一天内多次调用直接跳过, 避免每轮都扫 parquet。 @@ -1306,16 +1340,28 @@ class KlineRepository: 自选列表/名称批查等场景的统一名称解析入口, 避免各调用方自行合并两份缓存。 symbols 非 None 时只返回命中的条目。 + 全量结果缓存在 _name_map_cache (随三份 instruments 维表刷新失效), + 避免每请求对 ~7000 行维表做 iter_rows 重建。 """ + if self._name_map_cache is not None: + if symbols is None: + return dict(self._name_map_cache) + wanted = set(symbols) + return {s: n for s, n in self._name_map_cache.items() if s in wanted} + # 只构建并缓存全量映射; symbols 过滤只作用于返回值。 + # 若把过滤后的结果写入缓存, 后续不同 symbols 的查询会命中残缺缓存, + # 导致新加入自选的标的查不到名称。 name_map: dict[str, str] = {} for df in (self.get_instruments(), self.get_etf_instruments(), self.get_instruments_asset("index")): if df.is_empty() or "symbol" not in df.columns or "name" not in df.columns: continue - if symbols is not None: - df = df.filter(pl.col("symbol").is_in(symbols)) for symbol, name in df.select(["symbol", "name"]).iter_rows(): name_map.setdefault(symbol, name) - return name_map + self._name_map_cache = name_map + if symbols is None: + return dict(name_map) + wanted = set(symbols) + return {s: n for s, n in name_map.items() if s in wanted} def enriched_latest_date(self) -> date | None: """返回缓存中的 enriched 最新日期。""" @@ -1355,10 +1401,26 @@ class KlineRepository: # 扩展范围用于指标预热 (MA60 需要 ~60 交易日 ≈ 120 日历日) warmup_start = start - timedelta(days=150) - # 扫描14列 parquet - df = self._scan_daily_symbol(symbol, warmup_start, end, None) - if not df.is_empty(): - df = self._compute_enriched_range(df) + # 优先复用预计算 enriched 历史缓存 (300 天全指标, 与回测引擎同源): + # 个股对话框打开时本接口每个行情 tick 被调一次, 逐请求 150 天扫描 + 全套 + # 指标重算是热路径上最大的重复计算。缓存最新日可能不含当日实时行, + # 由下方 get_enriched_latest 覆盖逻辑补齐; 覆盖不足时回退单股计算路径。 + df = pl.DataFrame() + hist = self._enriched_history_cache + if hist is not None and not hist.is_empty() and "date" in hist.columns: + hist_min = self._enriched_history_start + hist_max = hist["date"].max() + if hist_min is not None and hist_min <= start and hist_max >= start: + df = hist.filter( + (pl.col("symbol") == symbol) + & (pl.col("date") >= start) + & (pl.col("date") <= end) + ) + if df.is_empty(): + # 扫描14列 parquet + df = self._scan_daily_symbol(symbol, warmup_start, end, None) + if not df.is_empty(): + df = self._compute_enriched_range(df) # 尝试用缓存数据覆盖最新日 (盘中更准确) cached, cache_date = self.get_enriched_latest() @@ -1829,30 +1891,11 @@ class KlineRepository: return latest def get_matrix_data_generation(self, asset_type: str = "stock") -> str: - """Return a persistent generation bumped by every managed enriched write.""" - path = self.store.data_dir / f".matrix_generation_{asset_type}.json" - try: - payload = json.loads(path.read_text(encoding="utf-8")) - generation = str(payload.get("generation") or "") - if generation: - return generation - except (OSError, TypeError, ValueError, json.JSONDecodeError): - pass - return self._bump_matrix_data_generation(asset_type) + """Return the stable generation for managed enriched readers.""" + return get_enriched_generation(self.store.data_dir, asset_type) def _bump_matrix_data_generation(self, asset_type: str) -> str: - generation = uuid.uuid4().hex - path = self.store.data_dir / f".matrix_generation_{asset_type}.json" - temporary = path.with_name(f".{path.name}.{uuid.uuid4().hex}.tmp") - temporary.write_text( - json.dumps({ - "generation": generation, - "updated_at_ns": time.time_ns(), - }, separators=(",", ":")), - encoding="utf-8", - ) - temporary.replace(path) - return generation + return bump_enriched_generation(self.store.data_dir, asset_type) def symbols_lagging(self, reference_date: date, min_gap_days: int = 3) -> list[str]: """返回日K覆盖落后的标的: 其最新 bar 早于 reference_date - min_gap_days。 @@ -1962,6 +2005,7 @@ class KlineRepository: self._atomic_write_parquet(df.unique(subset=["symbol"], keep="last").sort("symbol"), out) self._index_instruments_cache = None self._etf_instruments_cache = None + self._name_map_cache = None self._refresh_index_instruments() def save_etf_instruments(self, df: pl.DataFrame) -> None: @@ -1974,6 +2018,7 @@ class KlineRepository: out.parent.mkdir(parents=True, exist_ok=True) self._atomic_write_parquet(df.unique(subset=["symbol"], keep="last").sort("symbol"), out) self._etf_instruments_cache = None + self._name_map_cache = None self._refresh_etf_instruments() def refresh_index_views(self) -> None: @@ -2052,25 +2097,36 @@ class KlineRepository: def _write_daily_partition(self, df: pl.DataFrame, table: str) -> None: """按 date 分区写入 parquet，每个日期一个文件，支持 merge-upsert。""" base = self.store.data_dir / table + generation_asset = { + "kline_daily_enriched": "stock", + "kline_etf_enriched": "etf", + }.get(table) + publication = ( + EnrichedPublication(self.store.data_dir, generation_asset) + if generation_asset is not None + else None + ) with self._write_lock: for date_df in df.partition_by("date"): dt = date_df["date"][0] ds = dt.isoformat() if hasattr(dt, "isoformat") else str(dt) out = base / f"date={ds}" / "part.parquet" out.parent.mkdir(parents=True, exist_ok=True) + existing = pl.DataFrame() if out.exists(): existing = pl.read_parquet(out) date_df = pl.concat([existing, date_df], how="diagonal_relaxed").unique( subset=["symbol", "date"], keep="last" ) date_df = date_df.sort(["symbol", "date"]) - self._atomic_write_parquet(date_df, out) - generation_asset = { - "kline_daily_enriched": "stock", - "kline_etf_enriched": "etf", - }.get(table) - if generation_asset is not None: - self._bump_matrix_data_generation(generation_asset) + if not existing.is_empty() and existing.equals(date_df): + continue + if publication is None: + self._atomic_write_parquet(date_df, out) + else: + publication.write_parquet(date_df, out) + if publication is not None: + publication.commit() def merge_live_daily_asset(self, asset_type: str, df: pl.DataFrame) -> None: """按 symbol 合并当天指定资产日K分区。用于少量自选实时，不覆盖全市场。""" @@ -2139,6 +2195,35 @@ class KlineRepository: subset=["symbol", "date"], keep="last" ) merged_cache = merged_cache.sort(["symbol"]) + + from app.indicators.pipeline import ENRICHED_STORAGE_COLS + storage_cols = [c for c in ENRICHED_STORAGE_COLS if c in df.columns] + df_storage = df.select(storage_cols).sort(["symbol"]) + base = self.store.data_dir / table + ds = dt.isoformat() if hasattr(dt, "isoformat") else str(dt) + out = base / f"date={ds}" / "part.parquet" + out.parent.mkdir(parents=True, exist_ok=True) + publication = ( + EnrichedPublication(self.store.data_dir, asset_type) + if asset_type in {"stock", "etf"} + else None + ) + with self._write_lock: + existing = pl.DataFrame() + if out.exists(): + existing = pl.read_parquet(out) + df_storage = pl.concat([existing, df_storage], how="diagonal_relaxed").unique( + subset=["symbol", "date"], keep="last" + ) + df_storage = df_storage.sort(["symbol"]) + if existing.is_empty() or not existing.equals(df_storage): + if publication is None: + self._atomic_write_parquet(df_storage, out) + else: + publication.write_parquet(df_storage, out) + if publication is not None: + publication.commit() + if asset_type == "stock": self._enriched_cache = merged_cache self._enriched_cache_date = dt @@ -2149,23 +2234,6 @@ class KlineRepository: self._index_enriched_cache = merged_cache self._index_enriched_cache_date = dt - from app.indicators.pipeline import ENRICHED_STORAGE_COLS - storage_cols = [c for c in ENRICHED_STORAGE_COLS if c in df.columns] - df_storage = df.select(storage_cols).sort(["symbol"]) - base = self.store.data_dir / table - ds = dt.isoformat() if hasattr(dt, "isoformat") else str(dt) - out = base / f"date={ds}" / "part.parquet" - out.parent.mkdir(parents=True, exist_ok=True) - with self._write_lock: - if out.exists(): - existing = pl.read_parquet(out) - df_storage = pl.concat([existing, df_storage], how="diagonal_relaxed").unique( - subset=["symbol", "date"], keep="last" - ) - self._atomic_write_parquet(df_storage.sort(["symbol"]), out) - if asset_type in {"stock", "etf"}: - self._bump_matrix_data_generation(asset_type) - def flush_live_daily(self, df: pl.DataFrame) -> None: """覆写当天 kline_daily 分区 (实时行情落盘, 非merge)。""" if df.is_empty() or "date" not in df.columns: @@ -2205,16 +2273,10 @@ class KlineRepository: dt = df["date"][0] cache_df = self._with_instrument_metadata(asset_type, df).sort(["symbol"]) if asset_type == "stock": - self._enriched_cache = cache_df - self._enriched_cache_date = dt table = "kline_daily_enriched" elif asset_type == "etf": - self._etf_enriched_cache = cache_df - self._etf_enriched_cache_date = dt table = "kline_etf_enriched" elif asset_type == "index": - self._index_enriched_cache = cache_df - self._index_enriched_cache_date = dt table = "kline_index_enriched" else: return @@ -2226,7 +2288,27 @@ class KlineRepository: ds = dt.isoformat() if hasattr(dt, "isoformat") else str(dt) out = base / f"date={ds}" / "part.parquet" out.parent.mkdir(parents=True, exist_ok=True) + publication = ( + EnrichedPublication(self.store.data_dir, asset_type) + if asset_type in {"stock", "etf"} + else None + ) with self._write_lock: - self._atomic_write_parquet(df_storage, out) - if asset_type in {"stock", "etf"}: - self._bump_matrix_data_generation(asset_type) + existing = pl.read_parquet(out) if out.exists() else pl.DataFrame() + if existing.is_empty() or not existing.equals(df_storage): + if publication is None: + self._atomic_write_parquet(df_storage, out) + else: + publication.write_parquet(df_storage, out) + if publication is not None: + publication.commit() + + if asset_type == "stock": + self._enriched_cache = cache_df + self._enriched_cache_date = dt + elif asset_type == "etf": + self._etf_enriched_cache = cache_df + self._etf_enriched_cache_date = dt + elif asset_type == "index": + self._index_enriched_cache = cache_df + self._index_enriched_cache_date = dt diff --git a/backend/tests/backtest/test_dependencies.py b/backend/tests/backtest/test_dependencies.py index d5d44ee..5983d69 100644 --- a/backend/tests/backtest/test_dependencies.py +++ b/backend/tests/backtest/test_dependencies.py @@ -1,5 +1,8 @@ from __future__ import annotations +import types +from datetime import date, timedelta + import polars as pl from app.backtest.strategy import StrategyDependencyResolver @@ -38,11 +41,79 @@ def test_resolver_merges_signals_scoring_filter_and_execution_columns(): assert {"macd_dif", "macd_dea", "ma20", "momentum_20d", "rsi_14"} <= set(plan.indicator_columns) assert {"signal_macd_golden", "signal_ma20_breakdown", "signal_limit_up", "signal_limit_down"} <= set(plan.signal_columns) assert {"symbol", "date", "open", "high", "low", "close", "volume", "raw_close", "raw_high"} <= set(plan.base_columns) - assert "raw_low" not in plan.base_columns + # 涨跌停信号族统一加载不复权三价 (翘板用 raw_low 判定"曾触及跌停") + assert "raw_low" in plan.base_columns assert "rsi_6" not in plan.indicator_columns assert plan.full_feature_fallback is False +def test_resolver_includes_raw_low_for_limit_signal_family(): + """回归: 翘板信号 (signal_limit_down_recovery) 依赖不复权 raw_low。 + + 旧 bug: 涨跌停基础列只声明 raw_close/raw_high, panel 加载缺 raw_low, + 因子用到翘板信号时 compute_limit_signals 抛 + "unable to find column raw_low" → 回测特征准备失败。 + """ + plan = StrategyDependencyResolver().resolve( + _strategy(), + params={"rsi_max": 30}, + basic_filter={"enabled": False}, + entry_signals=["signal_limit_down_recovery"], + exit_signals=[], + ) + + assert "signal_limit_down_recovery" in plan.signal_columns + assert {"raw_close", "raw_high", "raw_low"} <= set(plan.base_columns) + + +def test_load_panel_for_backtest_supplies_raw_low_for_recovery(monkeypatch, tmp_path): + """回归 (端到端): resolver → load_panel_for_backtest → compute_limit_signals 全链路。 + + 旧 bug: 涨跌停基础列漏 raw_low, 因子用到翘板信号时回测特征准备抛 + "unable to find column raw_low"。 + """ + from app.backtest.engine import BacktestEngine + + n_days = 40 + start = date(2024, 1, 1) + dates = [start + timedelta(days=i) for i in range(n_days)] + px = [10.0 + 0.01 * i for i in range(n_days)] + panel_lf = pl.LazyFrame({ + "symbol": ["600001.SH"] * n_days, + "date": dates, + "open": px, "high": px, "low": px, "close": px, + "volume": [100_000.0] * n_days, + "amount": [1_000_000.0] * n_days, + "raw_close": px, "raw_high": px, "raw_low": px, + }) + monkeypatch.setattr("app.backtest.engine.pl.scan_parquet", lambda path, *a, **k: panel_lf) + + instruments = pl.DataFrame({ + "symbol": ["600001.SH"], "name": ["普通股"], + "limit_up": [11.0], "limit_down": [9.0], + }) + repo = types.SimpleNamespace( + store=types.SimpleNamespace(data_dir=tmp_path), + get_enriched_range=lambda *a, **k: None, + get_instruments_asset=lambda at: instruments, + get_historical_shares=lambda: pl.DataFrame(), + ) + plan = StrategyDependencyResolver().resolve( + _strategy(), + params={"rsi_max": 30}, + basic_filter={"enabled": False}, + entry_signals=["signal_limit_down_recovery"], + exit_signals=[], + ) + + df = BacktestEngine(repo).load_panel_for_backtest( + ["600001.SH"], start, dates[-1], plan, asset_type="stock", + ) + + assert "raw_low" in df.columns + assert "signal_limit_down_recovery" in df.columns + + def test_resolver_expands_virtual_scoring_dependencies(): strategy = _strategy(meta={ "id": "deps", diff --git a/backend/tests/backtest/test_factor_batch.py b/backend/tests/backtest/test_factor_batch.py index debdb4f..f945d78 100644 --- a/backend/tests/backtest/test_factor_batch.py +++ b/backend/tests/backtest/test_factor_batch.py @@ -79,10 +79,10 @@ def test_batch_isolates_a_single_factor_failure(monkeypatch): service = FactorBacktestService(engine) original = service._evaluate_panel - def evaluate(panel, config, run_id, started_at): + def evaluate(panel, config, run_id, started_at, **kwargs): if config.factor_name == "turnover_rate": raise ValueError("broken factor") - return original(panel, config, run_id, started_at) + return original(panel, config, run_id, started_at, **kwargs) monkeypatch.setattr(service, "_evaluate_panel", evaluate) result = service.run_batch(_batch_config(["change_pct", "turnover_rate"])) @@ -135,6 +135,20 @@ def test_factor_catalog_covers_normalized_indicator_families(): "log_amount", "gap_return", "distance_to_high_60d", + "max_ret_20d", + "ret_skew_20d", + "up_days_20d", + "amihud_20d", + "turnover_z_60d", + "vol_price_corr_20d", + "vwap_bias", + "vol_trend_5_60", + "limit_up_count_20d", + "limit_up_count_60d", + "pb_latest", + "roe_latest", + "revenue_yoy_latest", + "debt_ratio_latest", } <= set(factor_ids) assert set(DERIVED_FACTOR_DEPENDENCIES) <= set(factor_ids) diff --git a/backend/tests/backtest/test_factor_metrics.py b/backend/tests/backtest/test_factor_metrics.py new file mode 100644 index 0000000..4607a48 --- /dev/null +++ b/backend/tests/backtest/test_factor_metrics.py @@ -0,0 +1,391 @@ +from __future__ import annotations + +from datetime import date, timedelta +from types import SimpleNamespace + +import polars as pl +import pytest + +from app.backtest.factor import ( + FactorBacktestService, + FactorBatchConfig, + FactorBatchItem, + FactorConfig, + FactorResult, +) +from app.backtest.regime_alignment import ( + align_regime_t_minus_one, + build_regime_filter_mask, +) + + +class _Engine: + def __init__(self, panel: pl.DataFrame, data_dir=None) -> None: + self.panel = panel + self.calls = 0 + self.repo = ( + SimpleNamespace(store=SimpleNamespace(data_dir=data_dir)) + if data_dir is not None + else None + ) + + def load_panel(self, symbols, start, end, columns, asset_type): + self.calls += 1 + selected = [column for column in columns if column in self.panel.columns] + return self.panel.select(selected) + + +def _config( + factor_name: str = "turnover_rate", + **overrides, +) -> FactorConfig: + values = { + "factor_name": factor_name, + "symbols": None, + "start": date(2026, 1, 5), + "end": date(2026, 1, 12), + "n_groups": 2, + "rebalance": "daily", + "fees_pct": 0.0, + "slippage_bps": 0.0, + } + values.update(overrides) + return FactorConfig(**values) + + +def _batch_config(**overrides) -> FactorBatchConfig: + values = { + "factor_names": ["turnover_rate"], + "symbols": None, + "start": date(2026, 1, 5), + "end": date(2026, 1, 12), + "n_groups": 2, + "rebalance": "daily", + "fees_pct": 0.0, + "slippage_bps": 0.0, + } + values.update(overrides) + return FactorBatchConfig(**values) + + +def _daily_panel(days: int = 8, symbols: int = 4) -> pl.DataFrame: + rows = [] + start = date(2026, 1, 5) + for day in range(days): + for index in range(symbols): + rows.append({ + "symbol": f"S{index}", + "date": start + timedelta(days=day), + "open": 10.0 + index, + "high": 10.5 + index, + "low": 9.5 + index, + "close": (10.0 + index) * (1.0 + (index - 1) * day * 0.01), + "volume": 1_000.0, + "amount": 10_000.0, + "turnover_rate": float(index + 1), + }) + return pl.DataFrame(rows) + + +def test_single_and_batch_use_same_full_price_axis_with_internal_factor_null(): + panel = _daily_panel(days=5, symbols=3).with_columns( + pl.when((pl.col("symbol") == "S2") & (pl.col("date") == date(2026, 1, 6))) + .then(None) + .otherwise(pl.col("turnover_rate")) + .alias("turnover_rate") + ) + engine = _Engine(panel) + service = FactorBacktestService(engine) + + single = service.run(_config(end=date(2026, 1, 9))) + batch = service.run_batch(_batch_config(end=date(2026, 1, 9))) + + assert single.error is None + assert batch.results[0].error is None + assert single.ic_mean == batch.results[0].ic_mean + assert single.ir == batch.results[0].ir + assert single.long_short_stats["total_return"] == batch.results[0].long_short_return + + +def test_daily_forward_returns_join_exact_global_trading_dates_on_suspension(): + dates = [date(2026, 1, 5) + timedelta(days=offset) for offset in range(6)] + rows = [ + {"symbol": "B", "date": current, "close": 20.0 + index} + for index, current in enumerate(dates) + ] + rows.extend( + {"symbol": "A", "date": current, "close": 10.0 + index} + for index, current in enumerate(dates) + if index != 3 + ) + panel = pl.DataFrame(rows) + + prepared = FactorBacktestService._attach_shared_next_return( + panel, + _batch_config(end=dates[-1]), + ) + first = prepared.filter( + (pl.col("symbol") == "A") & (pl.col("date") == dates[0]) + ).row(0, named=True) + second = prepared.filter( + (pl.col("symbol") == "A") & (pl.col("date") == dates[1]) + ).row(0, named=True) + + assert first["_forward_return_1d"] == pytest.approx(11.0 / 10.0 - 1.0) + assert first["_forward_return_3d"] is None + assert first["_forward_return_5d"] == pytest.approx(15.0 / 10.0 - 1.0) + assert second["_forward_return_3d"] == pytest.approx(14.0 / 11.0 - 1.0) + + +def test_service_forward_axis_uses_market_partitions_when_selected_universe_has_gap( + tmp_path, +): + dates = [date(2026, 1, 5) + timedelta(days=offset) for offset in range(3)] + panel = pl.DataFrame({ + "symbol": ["A", "A"], + "date": [dates[0], dates[2]], + "open": [10.0, 12.0], + "high": [10.0, 12.0], + "low": [10.0, 12.0], + "close": [10.0, 12.0], + "volume": [1_000.0, 1_000.0], + "amount": [10_000.0, 12_000.0], + "turnover_rate": [1.0, 2.0], + }) + for current in dates: + partition = tmp_path / "kline_daily_enriched" / f"date={current.isoformat()}" + partition.mkdir(parents=True) + pl.DataFrame({"date": [current]}).write_parquet(partition / "part.parquet") + service = FactorBacktestService(_Engine(panel, tmp_path)) + config = _batch_config(start=dates[0], end=dates[-1]) + + loaded = service._load_factor_panel(config, ["turnover_rate"]) + prepared = service._attach_shared_next_return( + loaded, + config, + trading_dates=service._global_trading_dates(config), + ) + + first = prepared.filter(pl.col("date") == dates[0]).row(0, named=True) + assert first["_forward_return_1d"] is None + assert first["_forward_return_3d"] is None + + +def test_tie_aware_groups_do_not_split_constant_factor_by_symbol_order(): + panel = pl.DataFrame({ + "symbol": ["C", "A", "D", "B"], + "date": [date(2026, 1, 5)] * 4, + "factor": [7.0] * 4, + }) + + first = FactorBacktestService._add_groups(panel, "factor", 5).sort("symbol") + second = FactorBacktestService._add_groups( + panel.reverse(), "factor", 5 + ).sort("symbol") + + assert first["_group"].n_unique() == 1 + assert first["_group"].to_list() == second["_group"].to_list() + assert first["_factor_strength"].to_list() == second["_factor_strength"].to_list() + + +def test_weekly_uses_first_actual_trading_day_not_monday(): + panel = pl.DataFrame({ + "symbol": ["A", "A", "A", "A"], + "date": [ + date(2026, 1, 6), + date(2026, 1, 7), + date(2026, 1, 13), + date(2026, 1, 14), + ], + "close": [10.0, 11.0, 12.0, 13.0], + }) + + result = FactorBacktestService._calc_period_return(panel, "weekly") + + assert result.filter(pl.col("date") == date(2026, 1, 6))["_next_return"][0] == pytest.approx(0.2) + assert result.filter(pl.col("date") == date(2026, 1, 7))["_next_return"][0] is None + + +def test_monthly_uses_first_actual_trading_day(): + panel = pl.DataFrame({ + "symbol": ["A", "A", "A", "A"], + "date": [ + date(2026, 1, 6), + date(2026, 1, 7), + date(2026, 2, 3), + date(2026, 2, 4), + ], + "close": [10.0, 11.0, 12.0, 13.0], + }) + + result = FactorBacktestService._calc_period_return(panel, "monthly") + + assert result.filter(pl.col("date") == date(2026, 1, 6))["_next_return"][0] == pytest.approx(0.2) + assert result.filter(pl.col("date") == date(2026, 1, 7))["_next_return"][0] is None + + +def test_factor_weight_and_decomposed_costs_change_group_results(): + panel = _daily_panel(days=2, symbols=4).with_columns( + pl.when(pl.col("date") == date(2026, 1, 6)) + .then( + pl.when(pl.col("symbol") == "S0").then(9.0) + .when(pl.col("symbol") == "S1").then(10.0) + .when(pl.col("symbol") == "S2").then(14.3) + .otherwise(16.9) + ) + .otherwise(pl.col("close")) + .alias("close") + ) + service = FactorBacktestService(_Engine(panel)) + + equal = service.run(_config(end=date(2026, 1, 6), weight="equal")) + weighted = service.run(_config(end=date(2026, 1, 6), weight="factor_weight")) + costly = service.run(_config( + end=date(2026, 1, 6), + weight="factor_weight", + fees_pct=0.009, + commission_pct=0.001, + stamp_tax_pct=0.002, + slippage_bps=10.0, + )) + + equal_q2 = next(item for item in equal.group_stats if item["label"] == "Q2") + weighted_q2 = next(item for item in weighted.group_stats if item["label"] == "Q2") + costly_q2 = next(item for item in costly.group_stats if item["label"] == "Q2") + assert weighted_q2["total_return"] != equal_q2["total_return"] + assert weighted_q2["total_return"] - costly_q2["total_return"] == pytest.approx(0.006) + assert costly.long_short_stats["total_return"] < weighted.long_short_stats["total_return"] + assert costly.config["commission_pct"] == 0.001 + assert costly.config["stamp_tax_pct"] == 0.002 + + +def test_factor_v2_metrics_and_defaults_are_backward_compatible(): + default_result = FactorResult(run_id="r", config={}) + default_item = FactorBatchItem(factor_name="f", label="F", group="G") + + assert default_result.methodology_version == "factor_v2" + assert default_result.yearly_ic == [] + assert default_result.ic_decay == [] + assert default_result.regime_stats == [] + assert default_item.methodology_version == "factor_v2" + assert default_item.yearly_ic == [] + + result = FactorBacktestService(_Engine(_daily_panel())).run(_config()) + assert result.methodology_version == "factor_v2" + assert result.coverage == 1.0 + assert result.turnover is not None + assert result.long_short_sharpe is not None + assert [item["horizon"] for item in result.ic_decay] == [1, 3, 5] + assert result.yearly_ic[0]["year"] == 2026 + assert result.long_short_stats["portfolio_type"] == "theoretical_factor_spread" + assert result.long_short_stats["executable_short"] is False + + +def test_factor_regime_stats_accept_injected_t_minus_one_mapping(tmp_path): + panel = _daily_panel(days=5) + market_dates = [date(2026, 1, 2), *panel["date"].unique().sort().to_list()] + for current in market_dates: + partition = tmp_path / "kline_daily_enriched" / f"date={current.isoformat()}" + partition.mkdir(parents=True) + pl.DataFrame({"date": [current]}).write_parquet(partition / "part.parquet") + regimes = { + date(2026, 1, 2): {"state": "range", "score": 50}, + date(2026, 1, 5): {"state": "weak", "score": 20}, + date(2026, 1, 6): {"state": "strong", "score": 80}, + date(2026, 1, 7): {"state": "strong", "score": 85}, + date(2026, 1, 8): {"state": "range", "score": 50}, + } + + result = FactorBacktestService(_Engine(panel, tmp_path)).run( + _config(end=date(2026, 1, 9)), + regime_by_date=regimes, + ) + + assert result.error is None + assert {item["state"] for item in result.regime_stats} == {"range", "strong", "weak"} + + +def test_factor_regime_stats_reject_missing_actual_market_predecessor(tmp_path): + panel = _daily_panel(days=3) + market_dates = [date(2026, 1, 2), *panel["date"].unique().sort().to_list()] + for current in market_dates: + partition = tmp_path / "kline_daily_enriched" / f"date={current.isoformat()}" + partition.mkdir(parents=True) + pl.DataFrame({"date": [current]}).write_parquet(partition / "part.parquet") + regimes = { + date(2026, 1, 1): {"state": "range", "score": 50}, + date(2026, 1, 5): {"state": "weak", "score": 20}, + date(2026, 1, 6): {"state": "strong", "score": 80}, + } + + with pytest.raises(ValueError, match="2026-01-02"): + FactorBacktestService(_Engine(panel, tmp_path)).run( + _config(end=date(2026, 1, 7)), + regime_by_date=regimes, + ) + + +def test_align_regime_t_minus_one_is_pure_and_fail_closed_in_required_range(): + labels = ("2026-01-05", "2026-01-06", "2026-01-07") + regimes = { + "2026-01-05": ("weak", 20), + "2026-01-06": {"state": "strong", "score": 80}, + } + + aligned = align_regime_t_minus_one( + labels, + regimes, + required_start=date(2026, 1, 6), + required_end=date(2026, 1, 7), + ) + mask = build_regime_filter_mask( + labels, + {"states": ["strong"], "min_score": 60}, + regimes, + required_start=date(2026, 1, 6), + required_end=date(2026, 1, 7), + ) + + assert aligned == [None, ("weak", 20.0), ("strong", 80.0)] + assert mask is not None + assert mask.tolist() == [True, False, True] + + with pytest.raises(ValueError, match="正式首日"): + align_regime_t_minus_one( + labels, + regimes, + required_start=date(2026, 1, 5), + required_end=date(2026, 1, 7), + ) + + lean_regimes = { + "2026-01-05": ("lean_strong", 60), + "2026-01-06": ("range", 50), + } + strong_only_mask = build_regime_filter_mask( + labels, + {"states": ["strong"]}, + lean_regimes, + required_start=date(2026, 1, 6), + required_end=date(2026, 1, 7), + ) + assert strong_only_mask is not None + assert strong_only_mask.tolist() == [True, False, False] + + aggregated_mask = build_regime_filter_mask( + labels, + {"states": ["strong", "lean_strong"]}, + lean_regimes, + required_start=date(2026, 1, 6), + required_end=date(2026, 1, 7), + ) + assert aggregated_mask is not None + assert aggregated_mask.tolist() == [True, True, False] + + with pytest.raises(ValueError, match="缺少前一交易日环境"): + align_regime_t_minus_one( + labels, + {"2026-01-05": ("weak", 20)}, + required_start=date(2026, 1, 6), + required_end=date(2026, 1, 7), + ) diff --git a/backend/tests/backtest/test_factor_rank_research.py b/backend/tests/backtest/test_factor_rank_research.py new file mode 100644 index 0000000..26379b8 --- /dev/null +++ b/backend/tests/backtest/test_factor_rank_research.py @@ -0,0 +1,218 @@ +from __future__ import annotations + +from datetime import date +from pathlib import Path +from types import SimpleNamespace + +import numpy as np +import polars as pl +import pytest +from fastapi import HTTPException + +from app.api import screener as screener_api +from app.api import strategy as strategy_api +from app.backtest.matrix import build_market_data_matrix, validate_signal_matrix +from app.backtest.optimizer import expand_param_grid +from app.backtest.strategy import StrategyDependencyResolver +from app.strategy.engine import StrategyEngine + +STRATEGY_PATH = ( + Path(__file__).resolve().parents[2] + / "app" + / "strategy" + / "builtin" + / "factor_rank_research.py" +) + + +def _market(): + panel = pl.DataFrame({ + "symbol": ["000001.SZ", "000002.SZ", "000003.SZ", "000004.SZ"] * 2, + "date": [date(2024, 1, 2)] * 4 + [date(2024, 1, 3)] * 4, + "open": [10.0] * 8, + "high": [10.5] * 8, + "low": [9.5] * 8, + "close": [10.0] * 8, + "volume": [1_000.0] * 8, + "amount": [1.0, 2.0, 3.0, 4.0, 4.0, 3.0, 2.0, 1.0], + "turnover_rate": [4.0, 3.0, 2.0, 1.0, 1.0, 2.0, 3.0, 4.0], + }) + return build_market_data_matrix( + panel, + field_columns={"amount", "turnover_rate"}, + ) + + +def test_strategy_loads_as_builtin_matrix_native_and_grid_params_validate(): + strategy = StrategyEngine._load_file(STRATEGY_PATH) + + assert strategy.meta["id"] == "factor_rank_research" + assert strategy.meta["research_only"] is True + assert strategy.execution_backend == "matrix_native" + assert strategy.matrix_strategy is not None + assert strategy.meta["scoring"] == {} + combos = expand_param_grid( + strategy.meta["params"], + { + "entry_score": [50.0, 75.0], + "exit_score": [20.0], + "top_rank": [1, 2], + }, + ) + assert len(combos) == 4 + assert strategy.matrix_strategy.required_warmup_bars({}) == 60 + assert {"amount", "turnover_rate", "close"}.issubset( + strategy.matrix_strategy.required_fields() + ) + + +def test_research_template_is_hidden_from_ordinary_strategy_apis(tmp_path): + engine = StrategyEngine(strategy_dirs=[STRATEGY_PATH.parent]) + repo = SimpleNamespace(store=SimpleNamespace(data_dir=tmp_path)) + request = SimpleNamespace( + app=SimpleNamespace(state=SimpleNamespace(strategy_engine=engine, repo=repo)) + ) + + screener_payload = screener_api.strategies(request) + strategy_payload = strategy_api.list_strategies(request) + + assert engine.has("factor_rank_research") + assert "factor_rank_research" in { + item["id"] for item in engine.list_strategies(include_research=True) + } + assert "factor_rank_research" not in { + item["id"] for item in screener_payload["presets"] + } + assert "factor_rank_research" not in { + item["id"] for item in strategy_payload["strategies"] + } + + with pytest.raises(HTTPException) as screener_error: + screener_api.run_preset( + screener_api.PresetRequest( + strategy_id="factor_rank_research", + as_of=date(2024, 1, 2), + ), + request, + ) + assert screener_error.value.status_code == 404 + + with pytest.raises(HTTPException) as strategy_error: + strategy_api.run_strategy( + strategy_api.RunRequest( + strategy_id="factor_rank_research", + as_of=date(2024, 1, 2), + ), + request, + ) + assert strategy_error.value.status_code == 404 + + +def test_dependency_resolver_includes_parameter_scoring_fields(): + strategy = StrategyEngine._load_file(STRATEGY_PATH) + + plan = StrategyDependencyResolver().resolve( + strategy, + params={"scoring": {"amount": 1.0, "ma20_bias": 1.0}}, + basic_filter={"enabled": False}, + entry_signals=strategy.entry_signals, + exit_signals=strategy.exit_signals, + ) + + assert {"amount", "close"}.issubset(plan.base_columns) + assert plan.indicator_columns == frozenset() + assert {"amount", "close"}.issubset(plan.matrix_columns) + + +def test_strategy_uses_controlled_scoring_directions_thresholds_and_top_rank(): + strategy = StrategyEngine._load_file(STRATEGY_PATH).matrix_strategy + market = _market() + + signals = strategy.compute_signals( + market, + { + "scoring": {"amount": 1.0, "turnover_rate": 1.0}, + "directions": {"amount": "high", "turnover_rate": "low"}, + "entry_score": 60.0, + "exit_score": 25.0, + "top_rank": 1, + }, + ) + + validate_signal_matrix(signals, market.shape) + assert signals.entry.sum(axis=1).tolist() == [1, 1] + assert signals.entry.tolist() == [[0, 0, 0, 1], [1, 0, 0, 0]] + assert signals.exit.tolist() == [[1, 0, 0, 0], [0, 0, 0, 1]] + assert signals.entry_signal_ids == ("signal_factor_rank_entry",) + assert signals.exit_signal_ids == ("signal_factor_rank_exit",) + assert not signals.score.flags.writeable + + +def test_strategy_direction_changes_score_without_dynamic_formula_execution(): + strategy = StrategyEngine._load_file(STRATEGY_PATH).matrix_strategy + market = _market() + + high = strategy.compute_signals( + market, + { + "scoring": {"amount": 1.0}, + "directions": {"amount": "high"}, + "entry_score": 0.0, + "exit_score": 0.0, + "top_rank": 4, + }, + ) + low = strategy.compute_signals( + market, + { + "scoring": {"amount": 1.0}, + "directions": {"amount": "low"}, + "entry_score": 0.0, + "exit_score": 0.0, + "top_rank": 4, + }, + ) + + np.testing.assert_allclose(high.score + low.score, 100.0) + with pytest.raises(ValueError, match="unsupported matrix feature"): + strategy.compute_signals( + market, + { + "scoring": {"__import__('os').system('bad')": 1.0}, + "entry_score": 50.0, + "exit_score": 20.0, + "top_rank": 1, + }, + ) + + +@pytest.mark.parametrize( + ("params", "message"), + [ + ({"scoring": {}}, "non-empty scoring"), + ( + {"scoring": {f"factor_{index}": 1.0 for index in range(5)}}, + "at most 4 factors", + ), + ( + { + "scoring": {"amount": 1.0}, + "directions": {"turnover_rate": "low"}, + }, + "absent from scoring", + ), + ( + { + "scoring": {"amount": 1.0}, + "entry_score": 20.0, + "exit_score": 30.0, + }, + "exit_score must not exceed", + ), + ], +) +def test_strategy_rejects_uncontrolled_or_invalid_research_params(params, message): + strategy = StrategyEngine._load_file(STRATEGY_PATH).matrix_strategy + + with pytest.raises(ValueError, match=message): + strategy.compute_signals(_market(), params) diff --git a/backend/tests/backtest/test_matrix_strategy.py b/backend/tests/backtest/test_matrix_strategy.py index 91c3519..c1db050 100644 --- a/backend/tests/backtest/test_matrix_strategy.py +++ b/backend/tests/backtest/test_matrix_strategy.py @@ -1,6 +1,7 @@ from __future__ import annotations import gc +import threading from dataclasses import replace from datetime import date, timedelta from pathlib import Path @@ -87,6 +88,7 @@ def test_research_factor_catalog_matches_matrix_features(): for offset in range(120): for asset_id, symbol in enumerate(("000001.SZ", "600000.SH")): close = 10.0 + asset_id * 5.0 + offset * (0.02 + asset_id * 0.01) + np.sin(offset / 5.0) + volume = 1000.0 + asset_id * 250.0 + (offset % 9) * 80.0 rows.append({ "symbol": symbol, "date": start + timedelta(days=offset), @@ -94,14 +96,35 @@ def test_research_factor_catalog_matches_matrix_features(): "high": close + 0.35 + asset_id * 0.03, "low": close - 0.3, "close": close, - "volume": 1000.0 + asset_id * 250.0 + (offset % 9) * 80.0, - "amount": (1000.0 + asset_id * 250.0 + (offset % 9) * 80.0) * close, + "volume": volume, + "amount": volume * close, "turnover_rate": 1.0 + asset_id * 0.2 + (offset % 7) * 0.05, + "consecutive_limit_ups": ( + (offset % 17) + 1 if (asset_id == 0 and offset % 17 == 0) + else (2 if (asset_id == 1 and offset % 23 == 0) else 0) + ), }) panel = pl.DataFrame(rows) factor_names = {item["id"] for item in FACTOR_COLUMNS} expected = FactorBacktestService._compute_missing_factors(panel, factor_names) - market = build_market_data_matrix(panel, field_columns={"amount", "turnover_rate"}) + from app.backtest.fundamentals import ( + FUNDAMENTAL_FACTOR_NAMES, + attach_matrix_fundamental_fields, + ) + + fundamental_names = sorted(factor_names & FUNDAMENTAL_FACTOR_NAMES) + if fundamental_names: + # 夹具无财务数据: 两条路径都应得到全 null/NaN 列, 而不是报错。 + expected = expected.with_columns([ + pl.lit(None, dtype=pl.Float64).alias(name) + for name in fundamental_names + if name not in expected.columns + ]) + market = build_market_data_matrix( + panel, + field_columns={"amount", "turnover_rate", "consecutive_limit_ups"}, + ) + market = attach_matrix_fundamental_fields(market, None, fundamental_names) for name in sorted(factor_names): expected_values = expected.sort(["date", "symbol"])[name].to_numpy().reshape(market.shape) @@ -296,7 +319,7 @@ def test_builtin_matrix_strategies_use_their_declared_formula_modules(): path for path in strategy_dir.glob("*.py") if path.name != "__init__.py" ) - assert len(strategy_files) == 18 + assert len(strategy_files) == 19 for strategy_path in strategy_files: strategy = StrategyEngine._load_file(strategy_path) assert strategy.execution_backend == "matrix_native" @@ -603,6 +626,61 @@ def test_matrix_cache_can_be_disabled(tmp_path): assert not isinstance(market.close, np.memmap) +def test_matrix_cache_cancellation_removes_staging_output(tmp_path, monkeypatch): + market_root = tmp_path / "kline_daily_enriched" + current = date(2024, 3, 2) + partition = market_root / f"date={current.isoformat()}" + partition.mkdir(parents=True) + pl.DataFrame({ + "symbol": ["000001.SZ"], + "date": [current], + "open": [10.0], + "high": [10.0], + "low": [10.0], + "close": [10.0], + "volume": [1_000.0], + }).write_parquet(partition / "part.parquet") + cache_root = tmp_path / "matrix_cache" + cancel_event = threading.Event() + original_scan = matrix_module._scan_matrix_values + + def cancel_after_scan(*args, **kwargs): + original_scan(*args, **kwargs) + cancel_event.set() + + monkeypatch.setattr(matrix_module, "_scan_matrix_values", cancel_after_scan) + + with pytest.raises( + matrix_module.MatrixPrewarmCancelledError, + match="prewarm cancelled", + ): + load_market_data_matrix_from_parquet( + market_root, + current, + current, + field_columns=set(), + cache_root=cache_root, + cancel_event=cancel_event, + ) + + assert list(cache_root.glob("v*-*")) == [] + assert list(cache_root.glob(".*.tmp")) == [] + + +def test_matrix_cache_can_be_cancelled_before_scan(tmp_path): + cancel_event = threading.Event() + cancel_event.set() + + with pytest.raises(matrix_module.MatrixPrewarmCancelledError): + load_market_data_matrix_from_parquet( + tmp_path / "missing", + date(2024, 3, 1), + date(2024, 3, 1), + field_columns=set(), + cancel_event=cancel_event, + ) + + def test_matrix_cache_prunes_by_bytes_and_leaves_no_staging_directory(tmp_path): market_root = tmp_path / "kline_daily_enriched" current = date(2024, 3, 4) @@ -708,7 +786,7 @@ def test_registered_builtin_matrix_strategies_share_one_cache_profile(): profile = build_matrix_cache_profile(engine, "stock") strategies = engine.strategy_definitions() - assert len(strategies) == 18 + assert len(strategies) == 19 assert all(strategy.execution_backend == "matrix_native" for strategy in strategies) assert profile.warmup_bars > 0 assert profile.forward_bars == max(int(strategy.max_hold_days or 0) for strategy in strategies) diff --git a/backend/tests/backtest/test_mining.py b/backend/tests/backtest/test_mining.py new file mode 100644 index 0000000..5c73e23 --- /dev/null +++ b/backend/tests/backtest/test_mining.py @@ -0,0 +1,941 @@ +from __future__ import annotations + +import json +from dataclasses import asdict, replace +from datetime import date, timedelta + +import numpy as np +import polars as pl +import pytest + +import app.backtest.mining as mining_module +from app.backtest.mining import ( + CandidateEvaluation, + CorrelationResult, + FactorMetric, + MiningBudget, + MiningRequest, + MiningService, + NestedValidationConfig, + _searchable_factors, + beam_search_factor_combinations, + compute_rank_correlation, + generate_nested_folds, + nested_fold_count, + prune_correlated_factors, + required_outer_folds, + required_trading_bars, + validation_config_for_profile, +) + + +def _panel(days: int = 12, assets: int = 6) -> pl.DataFrame: + rows = [] + start = date(2024, 1, 2) + for day_id in range(days): + current = start + timedelta(days=day_id * 2) + for asset_id in range(assets): + target = float(asset_id + (day_id % 2) * 0.1) + rows.append({ + "symbol": f"{asset_id:06d}.SZ", + "date": current, + "good": target, + "inverse": -target, + "copy": target * 10.0, + "noise": float((asset_id * 7 + day_id * 3) % assets), + "_next_return": target, + }) + return pl.DataFrame(rows) + + +def _metrics() -> tuple[FactorMetric, ...]: + return ( + FactorMetric("good", 1.0, 1.0, 1.0, 0.2, 1.0), + FactorMetric("copy", 0.9, 0.9, 1.0, 0.1, 1.0), + FactorMetric("inverse", 0.8, 0.8, 1.0, 0.1, -1.0), + FactorMetric("noise", 0.2, 0.1, 0.9, 0.5, 0.0), + ) + + +def test_profiles_enforce_hard_limits_and_are_json_serializable(): + request = MiningRequest.for_profile("exploratory", ["good", "noise"]) + + assert request.budget.beam_width == 8 + assert request.validation.outer_train_bars == 126 + assert request.validation.outer_test_bars == 63 + assert NestedValidationConfig.balanced().outer_train_bars == 504 + assert NestedValidationConfig.strict().outer_train_bars == 756 + assert json.loads(request.to_json())["factor_names"] == ["good", "noise"] + assert asdict(request)["validation"]["purge_bars"] == 30 + with pytest.raises(ValueError, match="max_factors"): + MiningBudget(max_factors=49) + with pytest.raises(ValueError, match="beam_width"): + MiningBudget(beam_width=33) + with pytest.raises(ValueError, match="max_trials"): + MiningBudget(max_trials=257) + with pytest.raises(ValueError, match="existing strategy count"): + MiningRequest( + factor_names=("good",), + existing_strategy_ids=tuple(str(index) for index in range(9)), + ) + + +@pytest.mark.parametrize( + ("profile", "required_bars", "folds"), + [ + ("exploratory", 219, 1), + ("balanced", 786, 3), + ("strict", 1164, 3), + ], +) +def test_profile_trading_bar_requirements(profile, required_bars, folds): + config = validation_config_for_profile(profile) + + assert required_outer_folds(profile) == folds + assert required_trading_bars(config, folds) == required_bars + assert nested_fold_count(required_bars - 1, config) == folds - 1 + assert nested_fold_count(required_bars, config) == folds + + +def test_rank_correlation_is_pairwise_finite_symmetric_and_average_ranked(): + panel = pl.DataFrame({ + "date": [date(2024, 1, 2)] * 5 + [date(2024, 1, 3)] * 5, + "a": [1.0, 1.0, 3.0, np.nan, 5.0, 5.0, 4.0, 3.0, 2.0, 1.0], + "b": [2.0, 2.0, 6.0, 8.0, np.inf, 1.0, 2.0, 3.0, 4.0, 5.0], + "c": [1.0, None, 2.0, 3.0, 4.0, None, None, None, None, None], + "constant": [7.0] * 10, + }) + + result = compute_rank_correlation( + panel, + ["a", "b", "c", "constant"], + date(2024, 1, 2), + date(2024, 1, 3), + ) + + matrix = np.asarray(result.matrix) + counts = np.asarray(result.pair_counts) + np.testing.assert_allclose(matrix, matrix.T) + np.testing.assert_array_equal(np.diag(matrix), np.ones(4)) + assert counts[0, 1] == 2 + assert counts[0, 2] == 1 + assert counts[2, 2] == 1 + assert counts[3, 3] == 2 + assert counts[0, 3] == 0 + assert np.isnan(matrix[0, 3]) + assert result.n_dates == 2 + assert set(result.timing_ms) == {"filter", "rank_accumulate", "finalize", "total"} + + daily_correlations = [] + for daily in panel.partition_by("date"): + valid = daily.filter(pl.col("a").is_finite() & pl.col("b").is_finite()) + daily_correlations.append(np.corrcoef( + valid["a"].rank(method="average").to_numpy(), + valid["b"].rank(method="average").to_numpy(), + )[0, 1]) + assert daily_correlations == pytest.approx([1.0, -1.0]) + assert matrix[0, 1] == pytest.approx(np.mean(daily_correlations)) + + +def test_rank_correlation_reranks_after_pairwise_finite_intersection(): + panel = pl.DataFrame({ + "date": [date(2024, 1, 2)] * 4, + "a": [1.0, 2.0, 3.0, 4.0], + "b": [10.0, None, 20.0, 30.0], + "c": [None, 10.0, 20.0, 30.0], + }) + + result = compute_rank_correlation(panel, ["a", "b", "c"]) + matrix = np.asarray(result.matrix) + + assert matrix[0, 1] == pytest.approx(1.0) + assert matrix[0, 2] == pytest.approx(1.0) + assert matrix[1, 2] == pytest.approx(1.0) + + +def test_pruning_uses_deterministic_metric_order_and_reports_representative(): + correlation = CorrelationResult( + factor_names=("a", "b", "c"), + matrix=((1.0, 0.9, 0.1), (0.9, 1.0, 0.2), (0.1, 0.2, 1.0)), + pair_counts=((10, 10, 10), (10, 10, 10), (10, 10, 10)), + elapsed_ms=1.0, + n_dates=2, + n_rows=10, + ) + metrics = ( + FactorMetric("b", 1.0, 2.0, 0.8, 0.1), + FactorMetric("c", 0.5, 1.0, 1.0, 0.1), + FactorMetric("a", 1.0, 2.0, 0.8, 0.2), + ) + + result = prune_correlated_factors(metrics, correlation, 0.8) + + assert result.selected == ("b", "c") + assert result.excluded[0].factor_id == "a" + assert result.excluded[0].representative == "b" + assert result.excluded[0].rho == pytest.approx(0.9) + + +def test_pruning_ignores_unestimable_factor_pairs(): + correlation = CorrelationResult( + factor_names=("a", "b"), + matrix=((1.0, float("nan")), (float("nan"), 1.0)), + pair_counts=((10, 0), (0, 10)), + elapsed_ms=1.0, + n_dates=2, + n_rows=10, + ) + metrics = ( + FactorMetric("a", 1.0, 1.0, 1.0, 0.1), + FactorMetric("b", 0.9, 0.9, 1.0, 0.1), + ) + + result = prune_correlated_factors(metrics, correlation, 0.8) + + assert result.selected == ("a", "b") + assert result.excluded == () + + +def test_beam_search_learns_direction_from_train_and_honors_real_proxy_budget(): + panel = _panel() + + first = beam_search_factor_combinations( + panel, + ["noise", "inverse", "good"], + max_combination_size=4, + beam_width=32, + max_trials=7, + ) + second = beam_search_factor_combinations( + panel, + ["good", "noise", "inverse"], + max_combination_size=4, + beam_width=32, + max_trials=7, + ) + reversed_rows = beam_search_factor_combinations( + panel.reverse(), + ["good", "noise", "inverse"], + max_combination_size=4, + beam_width=32, + max_trials=7, + ) + + assert first.trials_used == 7 + assert first.budget_exhausted is True + assert first.candidates == second.candidates == reversed_rows.candidates + inverse = next( + candidate + for candidate in first.candidates + if candidate.factor_names == ("inverse",) + ) + assert inverse.directions == (-1,) + assert all(len(candidate.factor_names) <= 4 for candidate in first.candidates) + assert all( + set(candidate.weights) <= {1.0, 2.0} + and sum(weight == 2.0 for weight in candidate.weights) <= 1 + for candidate in first.candidates + ) + + +def test_beam_search_does_not_access_rows_outside_explicit_train_range(): + panel = _panel(days=10) + train_end = sorted(panel["date"].unique().to_list())[5] + changed = panel.with_columns( + pl.when(pl.col("date") > train_end) + .then(-pl.col("_next_return") * 1_000.0) + .otherwise(pl.col("_next_return")) + .alias("_next_return") + ) + + original_result = beam_search_factor_combinations( + panel, + ["good", "inverse", "noise"], + train_end=train_end, + max_trials=30, + ) + changed_result = beam_search_factor_combinations( + changed, + ["good", "inverse", "noise"], + train_end=train_end, + max_trials=30, + ) + + assert original_result.candidates == changed_result.candidates + + +def test_nested_folds_use_trading_labels_with_explicit_purge_and_embargo(): + labels = [f"T{index:02d}" for index in range(22)] + config = NestedValidationConfig( + outer_train_bars=12, + outer_test_bars=4, + outer_step_bars=4, + inner_train_bars=5, + inner_test_bars=2, + inner_step_bars=2, + purge_bars=1, + embargo_bars=2, + min_train_bars=5, + ) + + folds = generate_nested_folds(labels, config) + + assert folds[0].outer.train_labels == tuple(labels[:12]) + assert folds[0].outer.purge_labels == ("T12",) + assert folds[0].outer.test_labels == tuple(labels[13:17]) + assert folds[0].outer.embargo_labels == ("T17", "T18") + assert folds[0].inner[0].train_labels == tuple(labels[:5]) + assert folds[0].inner[0].purge_labels == ("T05",) + assert folds[0].inner[0].test_labels == ("T06", "T07") + assert set(folds[0].inner[-1].test_labels).issubset(folds[0].outer.train_labels) + with pytest.raises(ValueError, match="insufficient trading bars"): + generate_nested_folds(labels[:10], config) + + +def _frame_labels(frame) -> tuple[str, ...]: + return tuple( + frame.select(pl.col("date").cast(pl.Utf8).str.slice(0, 10).unique().sort()) + .to_series() + .to_list() + ) + + +class _Evaluator: + def __init__(self) -> None: + self.calls: list[tuple[tuple[str, ...], tuple[str, ...], dict]] = [] + + def evaluate_candidate(self, train, test, definition): + train_labels = _frame_labels(train) + test_labels = _frame_labels(test) + self.calls.append((train_labels, test_labels, dict(definition))) + return {"score": len(definition.get("factor_names", ())) or 0.1} + + +class _AlternatingWinnerEvaluator(_Evaluator): + """Prefer the good factor only in windows before 2024-01-25; every later window prefers the runner-up. + + With a 20-day panel (dates spaced two calendar days apart) and a + non-overlapping outer step, every inner and outer window of the first + fold falls in January while every window of the second fold falls after + the boundary, so the per-fold winner flips and cross-fold evaluation + has two distinct definitions to score. + """ + + def evaluate_candidate(self, train, test, definition): + self.calls.append((_frame_labels(train), _frame_labels(test), dict(definition))) + prefer_good = _frame_labels(test)[0] < "2024-01-25" + names = definition.get("factor_names") or () + is_good = bool(names) and names[0] == "good" + return {"score": 2.0 if is_good == prefer_good else 1.0} + + +class _LabelEvaluator(_Evaluator): + def __init__(self) -> None: + super().__init__() + self.label_calls: list[tuple[tuple[str, ...], tuple[str, ...], dict]] = [] + + def evaluate_candidate(self, train, test, definition): + raise AssertionError("label evaluator must not receive fold DataFrames") + + def evaluate_candidate_labels(self, train_labels, test_labels, definition): + self.label_calls.append(( + tuple(train_labels), + tuple(test_labels), + dict(definition), + )) + return {"score": len(definition.get("factor_names", ())) or 0.1} + + +@pytest.mark.parametrize("evaluator_type", [_Evaluator, _LabelEvaluator]) +def test_mining_service_reselects_per_inner_fold_and_keeps_tests_out_of_selection( + evaluator_type, +): + panel = _panel(days=10) + validation = NestedValidationConfig( + outer_train_bars=8, + outer_test_bars=2, + outer_step_bars=2, + inner_train_bars=4, + inner_test_bars=2, + inner_step_bars=2, + purge_bars=0, + embargo_bars=0, + min_train_bars=4, + ) + request = MiningRequest( + factor_names=("good", "copy", "inverse", "noise"), + correlation_threshold=0.95, + budget=MiningBudget( + max_combination_size=2, + beam_width=4, + max_proxy_trials=18, + max_trials=3, + ), + validation=validation, + profile="exploratory", + ) + folds = generate_nested_folds( + sorted(str(value) for value in panel["date"].unique().to_list()), + validation, + ) + assert len(folds) == 1 + metric_calls: list[tuple[str, ...]] = [] + + def metric_provider(train, factor_names): + assert tuple(factor_names) == request.factor_names + labels = tuple( + train.select(pl.col("date").cast(pl.Utf8).str.slice(0, 10).unique().sort()) + .to_series() + .to_list() + ) + metric_calls.append(labels) + return _metrics() + + evaluator = evaluator_type() + result = MiningService().run( + panel, + request, + metric_provider=metric_provider, + evaluator=evaluator, + ) + + nested = folds[0] + expected_selection_labels = [ + *(inner.train_labels for inner in nested.inner), + nested.outer.train_labels, + ] + assert metric_calls == expected_selection_labels + assert result.trials_used == request.budget.max_trials + assert result.proxy_trials_used <= request.budget.max_proxy_trials + evaluator_calls = ( + evaluator.label_calls + if isinstance(evaluator, _LabelEvaluator) + else evaluator.calls + ) + assert len(evaluator_calls) == len(nested.inner) + 1 + for call, inner in zip(evaluator_calls[:-1], nested.inner, strict=True): + train_labels, test_labels, _ = call + assert train_labels == inner.train_labels + assert test_labels == inner.test_labels + assert not set(nested.outer.test_labels).intersection(train_labels + test_labels) + outer_train, outer_test, outer_definition = evaluator_calls[-1] + assert outer_train == nested.outer.train_labels + assert outer_test == nested.outer.test_labels + assert result.folds[0].selected_candidate_id is not None + selected = next( + candidate + for candidate in result.folds[0].candidates + if candidate.candidate_id == result.folds[0].selected_candidate_id + ) + assert outer_definition == selected.definition() + + changed = panel.with_columns( + pl.when( + pl.col("date") + .cast(pl.Utf8) + .str.slice(0, 10) + .is_in(nested.outer.test_labels) + ) + .then(-pl.col("good") * 999.0) + .otherwise(pl.col("good")) + .alias("good") + ) + without_evaluation = MiningService().run( + panel, + request, + factor_metrics=_metrics(), + ) + changed_result = MiningService().run( + changed, + request, + factor_metrics=_metrics(), + ) + assert without_evaluation.folds[0].selected_factors == ( + changed_result.folds[0].selected_factors + ) + assert without_evaluation.folds[0].candidates == changed_result.folds[0].candidates + + with pytest.raises(ValueError, match="requires at least 3 outer folds"): + MiningService().run( + panel, + replace(request, profile="balanced"), + factor_metrics=_metrics(), + ) + + +def test_mining_service_requires_fold_local_metrics_with_evaluator(): + panel = _panel(days=10) + request = MiningRequest( + factor_names=("good",), + budget=MiningBudget(max_combination_size=1, max_proxy_trials=12, max_trials=3), + validation=NestedValidationConfig( + outer_train_bars=8, + outer_test_bars=2, + outer_step_bars=2, + inner_train_bars=4, + inner_test_bars=2, + inner_step_bars=2, + purge_bars=0, + embargo_bars=0, + min_train_bars=4, + ), + profile="exploratory", + ) + + with pytest.raises(ValueError, match="metric_provider is required"): + MiningService().run(panel, request, evaluator=_Evaluator()) + with pytest.raises(ValueError, match="factor_metrics must not be supplied"): + MiningService().run( + panel, + request, + factor_metrics=(FactorMetric("good", 1.0, 1.0, 1.0, 0.1),), + metric_provider=lambda _train, _names: ( + FactorMetric("good", 1.0, 1.0, 1.0, 0.1), + ), + evaluator=_Evaluator(), + ) + + +def test_target_endpoint_is_removed_from_every_train_phase_but_not_tests(monkeypatch): + panel = _panel(days=10) + labels = sorted(panel["date"].unique().to_list()) + target_dates = pl.DataFrame({ + "date": labels, + "_target_date": [*labels[1:], labels[-1] + timedelta(days=2)], + }) + panel = panel.join(target_dates, on="date", how="left") + validation = NestedValidationConfig( + outer_train_bars=8, + outer_test_bars=2, + outer_step_bars=2, + inner_train_bars=4, + inner_test_bars=2, + inner_step_bars=2, + purge_bars=0, + embargo_bars=0, + min_train_bars=4, + ) + request = MiningRequest( + factor_names=("good",), + budget=MiningBudget(max_combination_size=1, max_proxy_trials=12, max_trials=3), + validation=validation, + profile="exploratory", + ) + nested = generate_nested_folds([str(label) for label in labels], validation)[0] + train_ends = [*(inner.train_end for inner in nested.inner), nested.outer.train_end] + metric_frames = [] + correlation_frames = [] + beam_frames = [] + + def assert_target_bounded(frame, train_end): + assert frame.filter( + pl.col("_target_date").cast(pl.Utf8).str.slice(0, 10) > train_end + ).is_empty() + + def metric_provider(train, factor_names): + train_end = train_ends[len(metric_frames)] + assert tuple(factor_names) == request.factor_names + assert_target_bounded(train, train_end) + metric_frames.append(train) + return (FactorMetric("good", 1.0, 1.0, 1.0, 0.1),) + + original_correlation = mining_module.compute_rank_correlation + original_beam = mining_module.beam_search_factor_combinations + + def checked_correlation(frame, *args, **kwargs): + train_end = train_ends[len(correlation_frames)] + assert_target_bounded(frame, train_end) + correlation_frames.append(frame) + return original_correlation(frame, *args, **kwargs) + + def checked_beam(frame, *args, **kwargs): + train_end = train_ends[len(beam_frames)] + assert_target_bounded(frame, train_end) + beam_frames.append(frame) + return original_beam(frame, *args, **kwargs) + + class EndpointEvaluator(_Evaluator): + def __init__(self): + super().__init__() + self.test_frames = [] + + def evaluate_candidate(self, train, test, definition): + self.test_frames.append(test) + return super().evaluate_candidate(train, test, definition) + + monkeypatch.setattr(mining_module, "compute_rank_correlation", checked_correlation) + monkeypatch.setattr(mining_module, "beam_search_factor_combinations", checked_beam) + evaluator = EndpointEvaluator() + + result = MiningService().run( + panel, + request, + metric_provider=metric_provider, + evaluator=evaluator, + ) + + assert result.folds[0].error is None + assert len(metric_frames) == len(correlation_frames) == len(beam_frames) == 3 + evaluation_folds = [*nested.inner, nested.outer] + assert len(evaluator.calls) == len(evaluation_folds) + for (train_labels, test_labels, _), test_frame, fold in zip( + evaluator.calls, + evaluator.test_frames, + evaluation_folds, + strict=True, + ): + assert train_labels == fold.train_labels[:-1] + assert test_labels == fold.test_labels + assert test_frame.height == len(fold.test_labels) * 6 + assert not test_frame.filter( + pl.col("_target_date").cast(pl.Utf8).str.slice(0, 10) > fold.test_end + ).is_empty() + + +def test_outer_refit_fails_when_selected_factor_structure_is_missing(): + panel = _panel(days=10) + request = MiningRequest( + factor_names=("good", "copy"), + correlation_threshold=0.8, + budget=MiningBudget(max_combination_size=1, max_proxy_trials=24, max_trials=8), + validation=NestedValidationConfig( + outer_train_bars=8, + outer_test_bars=2, + outer_step_bars=2, + inner_train_bars=4, + inner_test_bars=2, + inner_step_bars=2, + purge_bars=0, + embargo_bars=0, + min_train_bars=4, + ), + profile="exploratory", + ) + + def metric_provider(train, _factor_names): + if train["date"].n_unique() < 8: + return ( + FactorMetric("good", 1.0, 1.0, 1.0, 0.1), + FactorMetric("copy", 0.5, 0.5, 1.0, 0.1), + ) + return ( + FactorMetric("good", 0.5, 0.5, 1.0, 0.1), + FactorMetric("copy", 1.0, 1.0, 1.0, 0.1), + ) + + evaluator = _Evaluator() + result = MiningService().run( + panel, + request, + metric_provider=metric_provider, + evaluator=evaluator, + ) + + fold = result.folds[0] + assert len(evaluator.calls) == 2 + assert fold.selected_candidate_id is None + assert fold.outer_evaluation is None + assert fold.error == "outer retraining did not reproduce selected candidate structure" + assert {candidate.factor_names for candidate in fold.candidates} == {("copy",)} + + +def test_candidate_evaluation_dataclass_score_must_be_finite(): + panel = _panel(days=10) + request = MiningRequest( + factor_names=("good",), + budget=MiningBudget(max_combination_size=1, max_proxy_trials=12, max_trials=8), + validation=NestedValidationConfig( + outer_train_bars=8, + outer_test_bars=2, + outer_step_bars=2, + inner_train_bars=4, + inner_test_bars=2, + inner_step_bars=2, + purge_bars=0, + embargo_bars=0, + min_train_bars=4, + ), + profile="exploratory", + ) + + class NonFiniteEvaluator: + def evaluate_candidate(self, train, test, definition): + return CandidateEvaluation(score=float("nan"), metrics={"source": "test"}) + + result = MiningService().run( + panel, + request, + metric_provider=lambda _train, _names: ( + FactorMetric("good", 1.0, 1.0, 1.0, 0.1), + ), + evaluator=NonFiniteEvaluator(), + ) + + assert result.folds[0].selected_candidate_id is None + assert result.folds[0].error == "no candidate completed inner validation within budget" + + +def test_beam_search_skips_factors_without_sufficient_valid_observations(): + panel = _panel().with_columns( + pl.lit(None).cast(pl.Float64).alias("all_null"), + pl.lit(7.0).alias("constant"), + pl.col("inverse").alias("valid_inverse"), + pl.when(pl.col("symbol").is_in(["000000.SZ", "000001.SZ"])) + .then(pl.col("good")) + .otherwise(None) + .alias("sparse"), + ) + + result = beam_search_factor_combinations( + panel, + ["all_null", "constant", "good", "sparse", "valid_inverse"], + max_combination_size=2, + max_trials=30, + ) + invalid_only = beam_search_factor_combinations( + panel, + ["all_null", "constant", "sparse"], + max_combination_size=2, + max_trials=30, + ) + + assert result.candidates + assert all( + set(candidate.factor_names) <= {"good", "valid_inverse"} + for candidate in result.candidates + ) + assert {candidate.factor_names for candidate in result.candidates} >= { + ("good",), + ("valid_inverse",), + ("good", "valid_inverse"), + } + assert all(candidate.dates > 0 and candidate.observations >= 3 for candidate in result.candidates) + assert invalid_only.candidates == () + + +def test_small_real_allowance_evaluates_factor_and_finalists_stay_capped(): + panel = _panel(days=10) + request = MiningRequest( + factor_names=("good", "noise"), + existing_strategy_ids=tuple(f"existing-{index}" for index in range(8)), + budget=MiningBudget(max_combination_size=1, max_proxy_trials=12, max_trials=1), + validation=NestedValidationConfig( + outer_train_bars=8, + outer_test_bars=2, + outer_step_bars=2, + inner_train_bars=4, + inner_test_bars=2, + inner_step_bars=2, + purge_bars=0, + embargo_bars=0, + min_train_bars=4, + ), + profile="exploratory", + ) + evaluator = _Evaluator() + + result = MiningService().run( + panel, + request, + metric_provider=lambda _train, _names: ( + FactorMetric("good", 1.0, 1.0, 1.0, 0.1), + FactorMetric("noise", 0.5, 0.5, 1.0, 0.1), + ), + evaluator=evaluator, + ) + + assert len(evaluator.calls) == 1 + assert evaluator.calls[0][2]["kind"] == "factor_rank" + finalists = result.folds[0].candidates + assert all(candidate.kind == "factor_rank" for candidate in finalists) + assert len(finalists) == 2 + assert result.folds[0].selected_candidate_id is not None + + +def test_existing_strategies_are_benchmarked_on_every_outer_fold(): + panel = _panel(days=18) + request = MiningRequest( + factor_names=("good",), + existing_strategy_ids=("alpha", "beta"), + budget=MiningBudget(max_combination_size=1, max_proxy_trials=24, max_trials=64), + validation=NestedValidationConfig( + outer_train_bars=8, + outer_test_bars=2, + outer_step_bars=4, + inner_train_bars=4, + inner_test_bars=2, + inner_step_bars=2, + purge_bars=0, + embargo_bars=0, + min_train_bars=4, + ), + profile="exploratory", + ) + evaluator = _Evaluator() + + result = MiningService().run( + panel, + request, + metric_provider=lambda _train, _names: (FactorMetric("good", 1.0, 1.0, 1.0, 0.1),), + evaluator=evaluator, + ) + + assert len(result.folds) == 3 + for fold in result.folds: + assert all(candidate.kind == "factor_rank" for candidate in fold.candidates) + signatures = [candidate_id for candidate_id, _ in fold.benchmark_evaluations] + assert signatures == ["strategy:alpha", "strategy:beta"] + for _, evaluation in fold.benchmark_evaluations: + assert evaluation.error is None + evaluated_strategy_kinds = [ + definition["kind"] + for *_, definition in evaluator.calls + if definition["kind"] == "existing_strategy" + ] + assert len(evaluated_strategy_kinds) == 6 + + +def test_winner_definitions_are_cross_evaluated_on_all_outer_folds(): + panel = _panel(days=20) + request = MiningRequest( + factor_names=("good", "noise"), + budget=MiningBudget(max_combination_size=1, max_proxy_trials=24, max_trials=64), + validation=NestedValidationConfig( + outer_train_bars=8, + outer_test_bars=2, + outer_step_bars=10, + inner_train_bars=4, + inner_test_bars=2, + inner_step_bars=2, + purge_bars=0, + embargo_bars=0, + min_train_bars=4, + ), + profile="exploratory", + ) + evaluator = _AlternatingWinnerEvaluator() + + result = MiningService().run( + panel, + request, + metric_provider=lambda _train, _names: ( + FactorMetric("good", 1.0, 1.0, 1.0, 0.1), + FactorMetric("noise", 0.9, 0.9, 1.0, 0.1), + ), + evaluator=evaluator, + ) + + assert len(result.folds) == 2 + winners = {fold.selected_candidate_id for fold in result.folds} + assert len(winners) == 2 + for fold in result.folds: + cross_ids = [candidate_id for candidate_id, _ in fold.cross_evaluations] + assert cross_ids == sorted(winners - {fold.selected_candidate_id}) + for _, evaluation in fold.cross_evaluations: + assert evaluation.error is None + + +def test_benchmarks_run_even_when_factor_track_fails_on_a_fold(): + panel = _panel(days=18) + request = MiningRequest( + factor_names=("good",), + existing_strategy_ids=("alpha",), + budget=MiningBudget(max_combination_size=1, max_proxy_trials=24, max_trials=64), + validation=NestedValidationConfig( + outer_train_bars=8, + outer_test_bars=2, + outer_step_bars=4, + inner_train_bars=4, + inner_test_bars=2, + inner_step_bars=2, + purge_bars=0, + embargo_bars=0, + min_train_bars=4, + ), + profile="exploratory", + ) + + class _FailingEvaluator(_Evaluator): + def evaluate_candidate(self, train, test, definition): + raise RuntimeError("backtest exploded") + + result = MiningService().run( + panel, + request, + metric_provider=lambda _train, _names: (FactorMetric("good", 1.0, 1.0, 1.0, 0.1),), + evaluator=_FailingEvaluator(), + ) + + assert len(result.folds) == 1 + fold = result.folds[0] + assert fold.error == "no candidate completed inner validation within budget" + assert fold.selected_candidate_id is None + assert [candidate_id for candidate_id, _ in fold.benchmark_evaluations] == [ + "strategy:alpha" + ] + benchmark = fold.benchmark_evaluations[0][1] + assert benchmark.error == "backtest exploded" + + +def test_searchable_factors_are_capped_by_beam_width(): + budget = MiningBudget(beam_width=3) + assert _searchable_factors(("a", "b", "c", "d", "e"), budget) == ("a", "b", "c") + assert _searchable_factors(("a",), MiningBudget(beam_width=8)) == ("a",) + + +def test_beam_search_only_receives_capped_factor_inputs(): + names = tuple(f"factor_{index:02d}" for index in range(20)) + rows = [] + start = date(2024, 1, 2) + for day_id in range(12): + for asset_id in range(6): + row = { + "symbol": f"{asset_id:06d}.SZ", + "date": start + timedelta(days=day_id), + "_next_return": float(asset_id), + } + for factor_id, name in enumerate(names): + row[name] = float((asset_id * (factor_id + 1)) % 7) + factor_id * 0.5 + rows.append(row) + panel = pl.DataFrame(rows) + request = MiningRequest( + factor_names=names, + correlation_threshold=1.0, + budget=MiningBudget( + max_combination_size=2, + beam_width=4, + max_proxy_trials=96, + max_trials=8, + ), + validation=NestedValidationConfig( + outer_train_bars=8, + outer_test_bars=2, + outer_step_bars=4, + inner_train_bars=4, + inner_test_bars=2, + inner_step_bars=2, + purge_bars=0, + embargo_bars=0, + min_train_bars=4, + ), + profile="exploratory", + ) + evaluator = _Evaluator() + + result = MiningService().run( + panel, + request, + metric_provider=lambda _train, factor_names: tuple( + FactorMetric(name, 1.0 - index * 0.01, 1.0, 1.0, 0.1) + for index, name in enumerate(factor_names) + ), + evaluator=evaluator, + ) + + searched = { + factor_name + for candidate in result.folds[0].candidates + for factor_name in candidate.factor_names + } + assert searched <= set(names[:4]) + assert any(len(candidate.factor_names) == 2 for candidate in result.folds[0].candidates) diff --git a/backend/tests/backtest/test_mining_runtime.py b/backend/tests/backtest/test_mining_runtime.py new file mode 100644 index 0000000..b982700 --- /dev/null +++ b/backend/tests/backtest/test_mining_runtime.py @@ -0,0 +1,314 @@ +from __future__ import annotations + +from datetime import date, timedelta +from types import SimpleNamespace + +import polars as pl +import pytest + +from app.backtest.mining import MiningCandidate +from app.backtest.mining_runtime import ( + TrainingMetricProvider, + _decode_runtime_request, + _load_compact_factor_panel, + _prepare_base_market, + _rank_artifact_candidates, + _regime_date_count, + attach_single_forward_return, +) +from app.services import regime_builder + + +def test_runtime_rejects_insufficient_balanced_range_before_loading_panel( + tmp_path, +) -> None: + first = date(2023, 10, 13) + dates = [first + timedelta(days=offset) for offset in range(690)] + for value in dates: + partition = tmp_path / "kline_daily_enriched" / f"date={value.isoformat()}" + partition.mkdir(parents=True) + (partition / "part.parquet").touch() + + payload = { + "run_id": "insufficient-balanced", + "request": { + "factor_names": ["turnover_rate"], + "strategy_ids": [], + "asset_type": "stock", + "budget_profile": "balanced", + "start": dates[0].isoformat(), + "end": dates[-1].isoformat(), + }, + } + + with pytest.raises( + ValueError, + match=( + r"balanced mining requires at least 786 enriched trading bars for " + r"3 outer folds; effective range .* has 690" + ), + ): + _decode_runtime_request(payload, tmp_path, SimpleNamespace()) + + +def test_single_forward_label_uses_global_trading_axis_without_jump() -> None: + first = date(2024, 1, 2) + missing = first + timedelta(days=1) + resumed = first + timedelta(days=2) + panel = pl.DataFrame({ + "symbol": ["000001.SZ", "000001.SZ"], + "date": [first, resumed], + "close": [10.0, 12.0], + "turnover_rate": [1.0, 2.0], + "unused_factor": [9.0, 10.0], + }) + + result = attach_single_forward_return( + panel, + start=first, + end=resumed, + horizon=1, + trading_dates=[first, missing, resumed], + factor_names=["turnover_rate"], + ) + + first_row = result.filter(pl.col("date") == first).row(0, named=True) + assert first_row["_target_date"] == missing + assert first_row["_next_return"] is None + assert "_forward_return_1d" not in result.columns + assert "close" not in result.columns + assert "unused_factor" not in result.columns + assert result.columns == [ + "symbol", + "date", + "turnover_rate", + "_next_return", + "_target_date", + ] + assert result.schema["_next_return"] == pl.Float32 + assert result.schema["turnover_rate"] == pl.Float32 + + fast = attach_single_forward_return( + panel.sort(["date", "symbol"]), + start=first, + end=resumed, + horizon=1, + trading_dates=[first, missing, resumed], + factor_names=["turnover_rate"], + assume_unique_symbol_date=True, + ) + assert fast.equals(result) + + +def test_compact_factor_panel_matches_full_symbol_independent_calculation( + monkeypatch, +) -> None: + first = date(2024, 1, 2) + rows = [] + for symbol, offset in (("a", 0.0), ("b", 2.0), ("c", 4.0)): + for day in range(70): + close = 10.0 + offset + day * 0.1 + rows.append({ + "symbol": symbol, + "date": first + timedelta(days=day), + "open": close - 0.1, + "high": close + 0.2, + "low": close - 0.2, + "close": close, + "volume": 1000.0 + day, + "amount": close * (1000.0 + day), + "turnover_rate": 1.0 + day / 100.0, + }) + raw = pl.DataFrame(rows).sort(["symbol", "date"]) + + class Engine: + def load_panel(self, *_args, **_kwargs): + return raw + + engine = Engine() + from app.backtest.factor import FactorBacktestService + + factor_service = FactorBacktestService(engine) + config = SimpleNamespace( + symbols=None, + start=first, + end=first + timedelta(days=69), + asset_type="stock", + ) + names = ("momentum_20d", "rsi_14", "ma20_bias") + full = factor_service._compute_missing_factors( + raw, + set(names), + assume_sorted=True, + ).select(["symbol", "date", "close", *names]).with_columns([ + pl.col(name).cast(pl.Float32) for name in names + ]).sort(["date", "symbol"]) + + monkeypatch.setattr("app.backtest.mining_runtime._SYMBOL_BATCH_SIZE", 1) + compact = _load_compact_factor_panel( + factor_service, + config, + names, + expected_generation="generation", + cancel_check=None, + ) + + assert compact.equals(full) + + +def test_compact_factor_panel_rejects_noncanonical_symbol_date_keys() -> None: + first = date(2024, 1, 2) + canonical = pl.DataFrame({ + "symbol": ["a", "a", "b"], + "date": [first, first + timedelta(days=1), first], + "open": [1.0, 1.0, 1.0], + "high": [1.0, 1.0, 1.0], + "low": [1.0, 1.0, 1.0], + "close": [1.0, 1.0, 1.0], + "volume": [1.0, 1.0, 1.0], + "amount": [1.0, 1.0, 1.0], + "turnover_rate": [1.0, 1.0, 1.0], + }) + config = SimpleNamespace( + symbols=None, + start=first, + end=first + timedelta(days=1), + asset_type="stock", + ) + + class Engine: + def __init__(self, panel): + self.panel = panel + + def load_panel(self, *_args, **_kwargs): + return self.panel + + from app.backtest.factor import FactorBacktestService + + for invalid in ( + canonical.with_columns(pl.Series( + "date", + [first + timedelta(days=1), first, first], + )), + pl.concat([canonical.slice(0, 1), canonical]), + ): + with pytest.raises(ValueError, match="unique symbol/date"): + _load_compact_factor_panel( + FactorBacktestService(Engine(invalid)), + config, + ("turnover_rate",), + expected_generation="generation", + cancel_check=None, + ) + + +def test_artifact_finalists_are_truncated_by_oos_sharpe_before_signature() -> None: + low = MiningCandidate(candidate_id="a-low", kind="existing_strategy", strategy_id="low") + high = MiningCandidate(candidate_id="z-high", kind="existing_strategy", strategy_id="high") + rows = [ + {"candidate_signature": "a-low", "sharpe": 0.2, "skipped": False}, + {"candidate_signature": "z-high", "sharpe": 1.4, "skipped": False}, + ] + + assert _rank_artifact_candidates([low, high], rows, limit=1) == [high] + + +def test_prepare_base_market_forwards_cancel_event(monkeypatch, tmp_path) -> None: + cancel_event = object() + captured = {} + plan = SimpleNamespace( + base_columns=frozenset(), + intermediate_columns=frozenset(), + indicator_columns=frozenset(), + signal_columns=frozenset(), + matrix_columns=frozenset(), + instrument_columns=frozenset(), + warmup_bars=1, + full_feature_fallback=False, + execution_backend="matrix_native", + fundamental_columns=frozenset(), + ) + research = SimpleNamespace(entry_signals=[], exit_signals=[]) + strategy_engine = SimpleNamespace(get=lambda _strategy_id: research) + service = SimpleNamespace( + _effective_basic_filter=lambda *_args: {}, + engine=SimpleNamespace(), + ) + request = SimpleNamespace( + factor_names=("turnover_rate",), + strategy_ids=(), + asset_type="stock", + forward_horizon=1, + start=date(2024, 1, 2), + end=date(2024, 1, 3), + symbols=None, + ) + + monkeypatch.setattr( + "app.backtest.mining_runtime.StrategyDependencyResolver.resolve", + lambda *_args, **_kwargs: plan, + ) + monkeypatch.setattr( + "app.backtest.mining_runtime.build_matrix_cache_profile", + lambda *_args, **_kwargs: SimpleNamespace(), + ) + + def load_matrix(*_args, **kwargs): + captured.update(kwargs) + return "market" + + service.engine.load_market_data_matrix_for_backtest = load_matrix + + result = _prepare_base_market( + service, + strategy_engine, + tmp_path, + request, + expected_generation="generation", + cancel_check=cancel_event, + ) + + assert result == "market" + assert captured["cancel_event"] is cancel_event + + +def test_training_metric_provider_uses_only_supplied_fold() -> None: + start = date(2024, 1, 2) + rows = [] + for day_offset in range(3): + for asset_id in range(4): + rows.append({ + "symbol": f"{asset_id:06d}.SZ", + "date": start + timedelta(days=day_offset), + "factor": float(asset_id), + "_next_return": ( + float(asset_id) if day_offset < 2 else float(-asset_id) + ), + }) + panel = pl.DataFrame(rows) + train = panel.filter(pl.col("date") < start + timedelta(days=2)) + + provider = TrainingMetricProvider("_next_return") + metric = provider(train, ["factor"])[0] + + assert metric.rank_ic == pytest.approx(1.0) + assert metric.coverage == pytest.approx(1.0) + assert provider.calls[0]["end"] == (start + timedelta(days=1)).isoformat() + assert provider.calls[0]["rows"] == 8 + + +def test_regime_date_count_uses_t_minus_one_market_labels(tmp_path) -> None: + labels = [date(2024, 1, 2) + timedelta(days=offset) for offset in range(4)] + panel = pl.DataFrame({"date": labels}) + regime_builder.upsert_regime_history(tmp_path, pl.DataFrame({ + "date": labels[:3], + "state": ["weak", "strong", "lean_strong"], + "score": [20, 80, 70], + })) + fold = SimpleNamespace( + test_start=labels[1].isoformat(), + test_end=labels[3].isoformat(), + ) + + assert _regime_date_count(panel, fold, "strong", tmp_path) == 2 + assert _regime_date_count(panel, fold, "weak", tmp_path) == 1 diff --git a/backend/tests/backtest/test_research_candidates.py b/backend/tests/backtest/test_research_candidates.py index b391e2c..d9f4d3a 100644 --- a/backend/tests/backtest/test_research_candidates.py +++ b/backend/tests/backtest/test_research_candidates.py @@ -38,6 +38,38 @@ def test_candidate_crud_and_atomic_file(tmp_path): assert store.list() == [] +def test_candidate_mining_provenance_is_idempotent_and_conflict_safe(tmp_path): + store = CandidateStore(tmp_path) + kwargs = { + "origin_run_id": "mining-run-idempotent", + "candidate_signature": "factor-signature", + "kind": "strategy", + "name": "挖掘组合候选", + "source_id": "mined_factor_example", + "config": { + "strategy_id": "mined_factor_example", + "origin_run_id": "mining-run-idempotent", + "candidate_signature": "factor-signature", + "factor_names": ["turnover_rate"], + "directions": ["high"], + "weights": [1.0], + }, + "metrics": {"oos_sharpe": 0.9}, + "data_as_of": "2026-08-11", + } + + first = store.create_or_get_by_provenance(**kwargs) + second = store.create_or_get_by_provenance(**kwargs) + + assert second == first + assert len(store.list()) == 1 + with pytest.raises(CandidateValidationError, match="冲突"): + store.create_or_get_by_provenance( + **{**kwargs, "metrics": {"oos_sharpe": 1.1}} + ) + assert store.list() == [first] + + def test_candidate_rejects_full_result_fields(tmp_path): store = CandidateStore(tmp_path) @@ -52,6 +84,111 @@ def test_candidate_rejects_full_result_fields(tmp_path): ) +def test_candidate_stores_factor_mining_summary(tmp_path): + store = CandidateStore(tmp_path) + config = { + "factor_name": "momentum_20d", + "origin_run_id": "mining-run-001", + "candidate_signature": "factor-signature", + "regime_state": "bull", + "algorithm_version": "mining-v1", + "methodology_version": "factor-v2", + } + metrics = { + "oos_sharpe": 1.24, + "oos_return": 0.18, + "oos_max_drawdown": -0.09, + "oos_positive_fold_ratio": 0.75, + "oos_n_trades": 48, + "valid_folds": 4, + "skipped_folds": 1, + "confidence": 0.9, + "coverage": 0.82, + "turnover": 0.36, + "long_short_sharpe": 1.11, + } + + created = store.create( + kind="factor", + name="挖掘因子候选", + source_id="momentum_20d", + config=config, + metrics=metrics, + data_as_of="2026-08-11", + ) + + assert created["config"] == config + assert created["metrics"] == metrics + assert store.list()[0]["metrics"] == metrics + + +def test_candidate_stores_strategy_mining_factor_combination(tmp_path): + store = CandidateStore(tmp_path) + config = { + "strategy_id": "mined-factor-combination", + "origin_run_id": "mining-run-002", + "candidate_signature": "strategy-signature", + "regime_state": "sideways", + "algorithm_version": "mining-v1", + "methodology_version": "strategy-v1", + "factor_names": ["momentum_20d", "rsi_14"], + "directions": ["high", "low"], + "weights": [0.6, 0.4], + } + metrics = { + "oos_sharpe": 0.98, + "oos_return": 0.12, + "oos_max_drawdown": -0.07, + "oos_positive_fold_ratio": 0.8, + "oos_n_trades": 31, + "valid_folds": 5, + "skipped_folds": 0, + "confidence": 0.86, + } + + created = store.create( + kind="strategy", + name="挖掘组合候选", + source_id="mined-factor-combination", + config=config, + metrics=metrics, + data_as_of="2026-08-11", + ) + + assert created["config"] == config + assert created["metrics"] == metrics + assert store.list()[0]["config"] == config + + +@pytest.mark.parametrize("nested_value", [{"fold_1": 1.2}, [1.2, 0.8]]) +def test_candidate_rejects_nested_mining_metrics(tmp_path, nested_value): + store = CandidateStore(tmp_path) + + with pytest.raises(CandidateValidationError, match="只允许保存标量"): + store.create( + kind="factor", + name="挖掘因子候选", + source_id="momentum_20d", + config={"factor_name": "momentum_20d"}, + metrics={"oos_sharpe": nested_value}, + data_as_of=None, + ) + + +def test_candidate_rejects_unknown_metric_field(tmp_path): + store = CandidateStore(tmp_path) + + with pytest.raises(CandidateValidationError, match="不允许的字段"): + store.create( + kind="factor", + name="挖掘因子候选", + source_id="momentum_20d", + config={"factor_name": "momentum_20d"}, + metrics={"fold_metrics": 1.0}, + data_as_of=None, + ) + + def test_candidate_rejects_non_json_config(tmp_path): store = CandidateStore(tmp_path) @@ -69,13 +206,20 @@ def test_candidate_rejects_non_json_config(tmp_path): def test_candidate_loads_legacy_missing_optional_fields(tmp_path): path = tmp_path / "user_data" / "research_candidates.json" path.parent.mkdir(parents=True) - path.write_text(json.dumps([{ - "id": "legacy", - "kind": "factor", - "name": "旧候选", - "config": {"factor_name": "rsi_14", "equity_curve": [1, 2]}, - "metrics": {"ic_mean": 0.03, "trades": [{"symbol": "000001.SZ"}]}, - }]), encoding="utf-8") + path.write_text( + json.dumps( + [ + { + "id": "legacy", + "kind": "factor", + "name": "旧候选", + "config": {"factor_name": "rsi_14", "equity_curve": [1, 2]}, + "metrics": {"ic_mean": 0.03, "trades": [{"symbol": "000001.SZ"}]}, + } + ] + ), + encoding="utf-8", + ) item = CandidateStore(tmp_path).list()[0] assert item["source_id"] == "rsi_14" diff --git a/backend/tests/backtest/test_strategy_backtest_correctness.py b/backend/tests/backtest/test_strategy_backtest_correctness.py index 1b941f0..4dbde70 100644 --- a/backend/tests/backtest/test_strategy_backtest_correctness.py +++ b/backend/tests/backtest/test_strategy_backtest_correctness.py @@ -181,12 +181,17 @@ def test_non_matrix_strategy_applies_regime_filter_and_reports_config(tmp_path): "signal_limit_up": False, "signal_limit_down": False, } - for offset in range(3) + for offset in range(-1, 3) ]).sort(["symbol", "date"]) regime_builder.upsert_regime_history(tmp_path, pl.DataFrame({ - "date": [start, start + timedelta(days=1)], - "state": ["weak", "strong"], - "score": [10, 85], + "date": [ + start - timedelta(days=1), + start, + start + timedelta(days=1), + start + timedelta(days=2), + ], + "state": ["weak", "weak", "strong", "strong"], + "score": [10, 10, 85, 85], })) engine = _EngineStub(panel, data_dir=tmp_path) service = StrategyBacktestService(engine=engine, strategy_engine=_StrategyEngineStub(_strategy())) @@ -204,16 +209,70 @@ def test_non_matrix_strategy_applies_regime_filter_and_reports_config(tmp_path): assert result.error is None assert engine.sim_matrix is not None - assert engine.sim_matrix.entry[:, 0].tolist() == [1, 0, 1] + assert engine.sim_matrix.entry[:, 0].tolist() == [0, 0, 1] assert result.config["regime_filter"] == regime_filter assert result.stats["selection"] == { - "strategy_matches": 2, - "entry_candidates": 2, + "strategy_matches": 1, + "entry_candidates": 1, "entry_trigger_filtered": 0, "entry_trigger_enabled": False, } +def test_regime_filter_matches_raw_five_level_states(tmp_path): + start = date(2024, 1, 1) + panel = pl.DataFrame([ + { + "symbol": "A", + "name": "A", + "date": start + timedelta(days=offset), + "open": 10.0, + "high": 10.0, + "low": 10.0, + "close": 10.0, + "volume": 1000.0, + "amount": 1000.0, + "signal_limit_up": False, + "signal_limit_down": False, + } + for offset in range(-1, 3) + ]).sort(["symbol", "date"]) + regime_builder.upsert_regime_history(tmp_path, pl.DataFrame({ + "date": [ + start - timedelta(days=1), + start, + start + timedelta(days=1), + start + timedelta(days=2), + ], + "state": ["weak", "lean_strong", "strong", "strong"], + "score": [10, 60, 85, 85], + })) + + def run_with(states: list[str]): + engine = _EngineStub(panel, data_dir=tmp_path) + service = StrategyBacktestService( + engine=engine, + strategy_engine=_StrategyEngineStub(_strategy()), + ) + result = service.run(StrategyBacktestConfig( + strategy_id="test", + symbols=None, + start=start, + end=start + timedelta(days=2), + matching="close_t", + mode="position", + regime_filter={"states": states}, + )) + assert result.error is None + assert engine.sim_matrix is not None + return engine.sim_matrix.entry[:, 0].tolist() + + # 强势与偏强是两个独立档位; 只选强势时偏强日不入场 + assert run_with(["strong"]) == [0, 0, 1] + assert run_with(["strong", "lean_strong"]) == [0, 1, 1] + assert run_with(["lean_strong"]) == [0, 1, 0] + + def test_selection_stats_explain_entry_trigger_filtering(): start = date(2024, 1, 1) panel = pl.DataFrame([ diff --git a/backend/tests/backtest/test_worker_process.py b/backend/tests/backtest/test_worker_process.py index 94c3c84..18cd68f 100644 --- a/backend/tests/backtest/test_worker_process.py +++ b/backend/tests/backtest/test_worker_process.py @@ -1,13 +1,21 @@ from __future__ import annotations +import queue +import threading from datetime import date, timedelta +from types import SimpleNamespace import polars as pl +import pytest +from app.backtest import worker as worker_module +from app.backtest.mining import benchmark_candidate from app.backtest.optimizer import OptimizeConfig from app.backtest.strategy import StrategyBacktestConfig from app.backtest.walkforward import WalkForwardConfig -from app.backtest.worker import make_worker_task, run_worker_task +from app.backtest.worker import BacktestWorkerError, make_worker_task, run_worker_task +from app.enriched_generation import bump_enriched_generation, get_enriched_generation +from app.services.mining_jobs import MiningRunStore def _write_worker_strategy(data_dir) -> None: @@ -88,6 +96,49 @@ def _write_market_data(data_dir, start: date, days: int = 3) -> None: }).write_parquet(instruments_dir / "part.parquet") +def _write_mining_market_data( + data_dir, + start: date, + *, + days: int = 219, + assets: int = 4, +) -> None: + symbols = [f"60000{asset}.SH" for asset in range(assets)] + for offset in range(days): + current = start + timedelta(days=offset) + rows = [] + for asset_id, symbol in enumerate(symbols): + close = 10.0 + asset_id + offset * (0.01 + asset_id * 0.002) + rows.append({ + "symbol": symbol, + "date": current, + "open": close, + "high": close * 1.01, + "low": close * 0.99, + "close": close, + "volume": 1000.0 + asset_id * 100.0, + "amount": close * (100000.0 + asset_id * 1000.0), + "raw_close": close, + "raw_high": close * 1.01, + "raw_low": close * 0.99, + "turnover_rate": 1.0 + asset_id * 0.5 + offset * 0.001, + "consecutive_limit_ups": 0, + "consecutive_limit_downs": 0, + }) + partition = data_dir / "kline_daily_enriched" / f"date={current.isoformat()}" + partition.mkdir(parents=True) + pl.DataFrame(rows).write_parquet(partition / "part.parquet") + + instruments_dir = data_dir / "instruments" + instruments_dir.mkdir(parents=True) + pl.DataFrame({ + "symbol": symbols, + "name": [f"测试{asset}" for asset in range(assets)], + "total_shares": [1_000_000_000.0] * assets, + "float_shares": [1_000_000_000.0] * assets, + }).write_parquet(instruments_dir / "part.parquet") + + def test_spawn_worker_returns_compact_result_and_memory_metrics(tmp_path): start = date(2024, 1, 1) data_dir = tmp_path / "data" @@ -187,6 +238,216 @@ def test_spawn_walkforward_reuses_shared_matrix_across_folds(tmp_path): assert result["worker"]["worker_exitcode"] == 0 +def test_spawn_mining_writes_four_artifacts_and_returns_compact_summary(tmp_path): + start = date(2023, 1, 2) + data_dir = tmp_path / "data" + _write_mining_market_data(data_dir, start) + store = MiningRunStore(data_dir) + manifest = store.create( + { + "factor_names": ["turnover_rate"], + "strategy_ids": [], + "symbols": None, + "asset_type": "stock", + "start": (start - timedelta(days=7)).isoformat(), + "end": (start + timedelta(days=225)).isoformat(), + "budget_profile": "exploratory", + "forward_horizon": 1, + "commission_pct": 0.0, + "stamp_tax_pct": 0.0, + "slippage_bps": 0.0, + "correlation_threshold": 0.75, + "max_combination_factors": 1, + "beam_width": 2, + "max_finalists": 2, + "require_regime": False, + }, + {"generation": get_enriched_generation(data_dir, "stock")}, + run_id="spawn_mining", + ) + payload = { + "run_id": manifest["run_id"], + "request": manifest["request"], + "data_fingerprint": manifest["data_fingerprint"], + "source": "manual", + } + + result = run_worker_task(make_worker_task("mining", data_dir, payload)) + + assert result["status"] in {"succeeded", "succeeded_with_budget_exhausted"} + assert result["factor_count"] == 1 + assert result["data_as_of"] == (start + timedelta(days=218)).isoformat() + assert result["panel_scans"] == 1 + assert result["matrix_bytes"] > 0 + assert result["worker"]["worker_exitcode"] == 0 + assert result["worker"]["serialized_result_bytes"] < 100_000 + registered = store.get("spawn_mining")["artifacts"] # type: ignore[index] + assert set(registered) == {"factors", "correlation", "candidates", "folds"} + for name in registered: + artifact = store.artifact_path("spawn_mining", name) + assert artifact.is_file() + frame = pl.read_parquet(artifact) + assert frame.columns + if name == "folds": + assert "n_dates" in frame.columns + assert frame.filter(pl.col("regime_state") == "overall")["n_dates"].min() > 0 + +def test_spawn_mining_benchmarks_strategy_on_every_outer_fold(tmp_path): + start = date(2023, 1, 2) + data_dir = tmp_path / "data" + _write_mining_market_data(data_dir, start) + store = MiningRunStore(data_dir) + manifest = store.create( + { + "factor_names": ["turnover_rate"], + "strategy_ids": ["low_volatility_leader"], + "symbols": None, + "asset_type": "stock", + "start": (start - timedelta(days=7)).isoformat(), + "end": (start + timedelta(days=225)).isoformat(), + "budget_profile": "exploratory", + "forward_horizon": 1, + "commission_pct": 0.0, + "stamp_tax_pct": 0.0, + "slippage_bps": 0.0, + "correlation_threshold": 0.75, + "max_combination_factors": 1, + "beam_width": 2, + "max_finalists": 2, + "require_regime": False, + }, + {"generation": get_enriched_generation(data_dir, "stock")}, + run_id="spawn_mining_benchmark", + ) + payload = { + "run_id": manifest["run_id"], + "request": manifest["request"], + "data_fingerprint": manifest["data_fingerprint"], + "source": "manual", + } + + result = run_worker_task(make_worker_task("mining", data_dir, payload)) + + assert result["status"] in {"succeeded", "succeeded_with_budget_exhausted"} + folds = pl.read_parquet(store.artifact_path("spawn_mining_benchmark", "folds")) + benchmark_signature = benchmark_candidate("low_volatility_leader").candidate_id + benchmark_rows = folds.filter( + (pl.col("evaluation_kind") == "benchmark") + & (pl.col("candidate_signature") == benchmark_signature) + & (pl.col("regime_state") == "overall") + ) + outer_folds = result["valid_fold_count"] + result["skipped_fold_count"] + assert outer_folds >= 1 + assert benchmark_rows.height == outer_folds + selected_rows = folds.filter( + (pl.col("evaluation_kind") == "selected") + & (pl.col("regime_state") == "overall") + ) + assert selected_rows.height == outer_folds + candidates = pl.read_parquet(store.artifact_path("spawn_mining_benchmark", "candidates")) + assert benchmark_signature in candidates["signature"].to_list() + assert "existing_strategy" in candidates["kind"].to_list() + + +def test_spawn_mining_rejects_generation_change_after_queue(tmp_path): + start = date(2023, 1, 2) + data_dir = tmp_path / "data" + _write_mining_market_data(data_dir, start) + store = MiningRunStore(data_dir) + queued_generation = get_enriched_generation(data_dir, "stock") + manifest = store.create( + { + "factor_names": ["turnover_rate"], + "strategy_ids": [], + "symbols": None, + "asset_type": "stock", + "start": (start - timedelta(days=7)).isoformat(), + "end": (start + timedelta(days=225)).isoformat(), + "budget_profile": "exploratory", + "forward_horizon": 1, + "commission_pct": 0.0, + "stamp_tax_pct": 0.0, + "slippage_bps": 0.0, + "correlation_threshold": 0.75, + "max_combination_factors": 1, + "beam_width": 2, + "max_finalists": 2, + "require_regime": False, + }, + {"generation": queued_generation}, + run_id="stale_generation_mining", + ) + bump_enriched_generation(data_dir, "stock") + payload = { + "run_id": manifest["run_id"], + "request": manifest["request"], + "data_fingerprint": manifest["data_fingerprint"], + "source": "manual", + } + + with pytest.raises( + BacktestWorkerError, + match="changed after the run was queued", + ): + run_worker_task(make_worker_task("mining", data_dir, payload)) + + assert store.get("stale_generation_mining")["artifacts"] == {} # type: ignore[index] + + +def test_worker_terminates_child_after_cancel_grace(monkeypatch, tmp_path): + class FakeQueue: + def get(self, timeout): + raise queue.Empty + + def close(self): + pass + + def join_thread(self): + pass + + class FakeEvent: + def set(self): + pass + + class FakeProcess: + def __init__(self): + self.alive = True + self.exitcode = None + + def start(self): + pass + + def is_alive(self): + return self.alive + + def join(self, timeout=None): + pass + + def terminate(self): + self.alive = False + self.exitcode = -15 + + process = FakeProcess() + context = SimpleNamespace( + Queue=FakeQueue, + Event=FakeEvent, + Process=lambda **_kwargs: process, + ) + clock = iter([0.0, 0.0, 0.0, 6.0]) + monkeypatch.setattr(worker_module.mp, "get_context", lambda _method: context) + monkeypatch.setattr(worker_module.time, "monotonic", lambda: next(clock)) + cancel_event = threading.Event() + cancel_event.set() + + with pytest.raises(BacktestWorkerError, match="after cancellation"): + run_worker_task( + {"kind": "mining", "data_dir": str(tmp_path), "config": {}}, + cancel_event=cancel_event, + ) + + assert process.exitcode == -15 + + def test_spawn_walkforward_skips_folds_before_available_matrix_data(tmp_path): configured_start = date(2024, 1, 1) market_start = configured_start + timedelta(days=4) diff --git a/backend/tests/test_data_clear_generation.py b/backend/tests/test_data_clear_generation.py new file mode 100644 index 0000000..6d0096d --- /dev/null +++ b/backend/tests/test_data_clear_generation.py @@ -0,0 +1,154 @@ +from __future__ import annotations + +import json +from datetime import date +from pathlib import Path +from types import SimpleNamespace + +import polars as pl +import pytest + +from app.api import data as data_api +from app.backtest.engine import PanelCache +from app.enriched_generation import ( + EnrichedGenerationUnavailableError, + get_enriched_generation, +) + + +class _RepoStub: + def __init__(self, data_dir: Path) -> None: + self.store = SimpleNamespace(data_dir=data_dir) + self.calls: list[str] = [] + + def clear_cache(self) -> None: + self.calls.append("clear_cache") + + def refresh_cache(self) -> None: + self.calls.append("refresh_cache") + + def rebuild_views(self) -> None: + self.calls.append("rebuild_views") + + +def _request(repo: _RepoStub) -> SimpleNamespace: + return SimpleNamespace(app=SimpleNamespace(state=SimpleNamespace(repo=repo))) + + +def _write_parquet_placeholder(path: Path) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + path.write_bytes(b"parquet-placeholder") + + +def _stub_clear_side_effects(monkeypatch: pytest.MonkeyPatch) -> None: + from app.api import overview + from app.services import alert_store + from app.services.pipeline_jobs import job_store + from app.services.screener import ScreenerService + + monkeypatch.setattr(job_store, "clear", lambda: None) + monkeypatch.setattr(alert_store, "clear", lambda _data_dir: None) + monkeypatch.setattr(ScreenerService, "clear_history_cache", lambda: None) + monkeypatch.setattr(overview, "invalidate_overview_cache", lambda: None) + monkeypatch.setattr(data_api, "invalidate_data_cache", lambda _table=None: None) + + +def test_clear_data_bumps_enriched_generations_and_invalidates_panel_cache( + tmp_path: Path, + monkeypatch: pytest.MonkeyPatch, +) -> None: + _stub_clear_side_effects(monkeypatch) + repo = _RepoStub(tmp_path) + stock_file = tmp_path / "kline_daily_enriched" / "date=2026-08-14" / "part.parquet" + etf_file = tmp_path / "kline_etf_enriched" / "date=2026-08-14" / "part.parquet" + _write_parquet_placeholder(stock_file) + _write_parquet_placeholder(etf_file) + stock_before = get_enriched_generation(tmp_path, "stock") + etf_before = get_enriched_generation(tmp_path, "etf") + + cache = PanelCache() + cache_args = (["000001.SZ"], date(2026, 8, 14), date(2026, 8, 14), None) + computes: list[int] = [] + + def compute(*_args) -> pl.DataFrame: + computes.append(len(computes) + 1) + return pl.DataFrame({"value": [computes[-1]]}) + + cache.get_or_compute(*cache_args, compute, "stock", stock_before) + result = data_api.clear_data(_request(repo)) + stock_after = get_enriched_generation(tmp_path, "stock") + etf_after = get_enriched_generation(tmp_path, "etf") + cached_after = cache.get_or_compute(*cache_args, compute, "stock", stock_after) + + assert result == {"deleted_files": 2} + assert not stock_file.exists() + assert not etf_file.exists() + assert stock_after != stock_before + assert etf_after != etf_before + assert cached_after["value"].item() == 2 + assert cache.stats()["compute_count"] == 2 + assert repo.calls == ["clear_cache", "refresh_cache", "rebuild_views"] + + +def test_clear_data_restores_ready_generation_when_first_delete_fails( + tmp_path: Path, + monkeypatch: pytest.MonkeyPatch, +) -> None: + repo = _RepoStub(tmp_path) + target = tmp_path / "kline_daily_enriched" / "date=2026-08-14" / "part.parquet" + _write_parquet_placeholder(target) + generation_before = get_enriched_generation(tmp_path, "stock") + original_unlink = Path.unlink + + def fail_target(path: Path, *args, **kwargs) -> None: + if path == target: + raise PermissionError("injected delete failure") + original_unlink(path, *args, **kwargs) + + monkeypatch.setattr(Path, "unlink", fail_target) + + with pytest.raises(PermissionError, match="injected delete failure"): + data_api.clear_data(_request(repo)) + + assert target.is_file() + assert get_enriched_generation(tmp_path, "stock") == generation_before + marker = json.loads( + (tmp_path / ".matrix_generation_stock.json").read_text(encoding="utf-8") + ) + assert marker["state"] == "ready" + + +def test_clear_data_keeps_generation_publishing_after_partial_delete( + tmp_path: Path, + monkeypatch: pytest.MonkeyPatch, +) -> None: + repo = _RepoStub(tmp_path) + enriched_dir = tmp_path / "kline_daily_enriched" + first = enriched_dir / "date=2026-08-13" / "part.parquet" + second = enriched_dir / "date=2026-08-14" / "part.parquet" + _write_parquet_placeholder(first) + _write_parquet_placeholder(second) + get_enriched_generation(tmp_path, "stock") + original_unlink = Path.unlink + parquet_unlinks = 0 + + def fail_second_parquet(path: Path, *args, **kwargs) -> None: + nonlocal parquet_unlinks + if path.suffix == ".parquet" and enriched_dir in path.parents: + parquet_unlinks += 1 + if parquet_unlinks == 2: + raise PermissionError("injected partial delete failure") + original_unlink(path, *args, **kwargs) + + monkeypatch.setattr(Path, "unlink", fail_second_parquet) + + with pytest.raises(PermissionError, match="injected partial delete failure"): + data_api.clear_data(_request(repo)) + + assert sum(path.exists() for path in (first, second)) == 1 + marker = json.loads( + (tmp_path / ".matrix_generation_stock.json").read_text(encoding="utf-8") + ) + assert marker["state"] == "publishing" + with pytest.raises(EnrichedGenerationUnavailableError, match="being published"): + get_enriched_generation(tmp_path, "stock") diff --git a/backend/tests/test_data_status_storage.py b/backend/tests/test_data_status_storage.py new file mode 100644 index 0000000..70e95b8 --- /dev/null +++ b/backend/tests/test_data_status_storage.py @@ -0,0 +1,61 @@ +"""storage 统计求和不变量测试 — total_size_mb 必须等于各部分之和, 不得重复累加。 + +历史 bug: other_dirs 循环被复制了两遍, 且 financials 既在 other_dirs 里又有专属 +统计块 —— financials 被计入 3 次、pools/backtest_results/screener_results/ai_cache +各计入 2 次, total_size_mb 虚高。此测试用精确整 MB 文件锁定总和不变量。 +""" +from __future__ import annotations + +from pathlib import Path + +from app.api.data import _compute_storage + +MB = 1024 * 1024 + + +def _write_mb(path: Path, mb: float) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + path.write_bytes(b"\0" * int(mb * MB)) + + +def _build_tree(data_dir: Path) -> None: + _write_mb(data_dir / "kline_daily" / "part.parquet", 1.0) + _write_mb(data_dir / "financials" / "metrics" / "part.parquet", 2.0) + _write_mb(data_dir / "pools" / "p.json", 1.0) + _write_mb(data_dir / "backtest_results" / "r.json", 1.0) + _write_mb(data_dir / "screener_results" / "s.json", 1.0) + _write_mb(data_dir / "ai_cache" / "c.json", 1.0) + _write_mb(data_dir / "capabilities.json", 0.5) # 根目录散文件 + + +def test_total_equals_sum_of_parts(tmp_path): + _build_tree(tmp_path) + stats = _compute_storage(tmp_path) + + parts_mb = ( + stats["daily_size_mb"] # 1.0 (subdirs 表) + + stats["financials_size_mb"] # 2.0 (专属统计块) + + 1.0 + 1.0 + 1.0 + 1.0 # pools/backtest/screener/ai_cache (单次循环) + + 0.5 # 根目录散文件 + ) + assert stats["total_size_mb"] == parts_mb == 7.5 + + +def test_financials_counted_once_not_three_times(tmp_path): + _build_tree(tmp_path) + stats = _compute_storage(tmp_path) + + assert stats["financials_files"] == 1 + assert stats["financials_size_mb"] == 2.0 + # 旧 bug: financials 计 3 次 (6MB) + 其余 4 目录各计 2 次 (8MB) → 15.5 + assert stats["total_size_mb"] != 15.5 + + +def test_missing_dirs_contribute_zero(tmp_path): + _write_mb(tmp_path / "kline_daily" / "part.parquet", 1.0) + stats = _compute_storage(tmp_path) + + # financials 目录不存在时不含其明细键 (既有行为), 且不贡献任何体积 + assert stats.get("financials_files", 0) == 0 + assert stats.get("financials_size_mb", 0.0) == 0.0 + assert stats["total_size_mb"] == 1.0 diff --git a/backend/tests/test_enriched_generation.py b/backend/tests/test_enriched_generation.py new file mode 100644 index 0000000..a48ccfb --- /dev/null +++ b/backend/tests/test_enriched_generation.py @@ -0,0 +1,165 @@ +from __future__ import annotations + +import json +from datetime import date +from types import SimpleNamespace + +import polars as pl +import pytest + +from app.backtest.engine import BacktestEngine, PanelCache +from app.enriched_generation import ( + EnrichedGenerationUnavailableError, + EnrichedPublication, + get_enriched_generation, +) +from app.tickflow.repository import DataStore, KlineRepository + + +def _frame(value: float = 10.0) -> pl.DataFrame: + return pl.DataFrame({ + "symbol": ["000001.SZ"], + "date": [date(2026, 8, 14)], + "open": [value], + "high": [value], + "low": [value], + "close": [value], + "volume": [1_000.0], + }) + + +def test_repository_enriched_noop_does_not_bump_generation(tmp_path) -> None: + repo = KlineRepository(DataStore(tmp_path)) + frame = _frame() + + repo.append_enriched(frame) + first = repo.get_matrix_data_generation("stock") + repo.append_enriched(frame) + + assert repo.get_matrix_data_generation("stock") == first + + +def test_failed_multi_partition_publication_remains_fail_closed( + tmp_path, + monkeypatch, +) -> None: + publication = EnrichedPublication(tmp_path, recover=True) + first = tmp_path / "kline_daily_enriched" / "date=2026-08-13" / "part.parquet" + second = tmp_path / "kline_daily_enriched" / "date=2026-08-14" / "part.parquet" + publication.write_parquet(_frame(10.0), first) + + original_write = pl.DataFrame.write_parquet + + def fail_second(self, path, *args, **kwargs): + if "2026-08-14" in str(path): + raise OSError("injected write failure") + return original_write(self, path, *args, **kwargs) + + monkeypatch.setattr(pl.DataFrame, "write_parquet", fail_second) + with pytest.raises(OSError, match="injected"): + publication.write_parquet(_frame(11.0), second) + + marker = json.loads( + (tmp_path / ".matrix_generation_stock.json").read_text(encoding="utf-8") + ) + assert marker["state"] == "publishing" + assert first.is_file() + assert not second.is_file() + with pytest.raises(EnrichedGenerationUnavailableError, match="being published"): + get_enriched_generation(tmp_path, "stock") + + +def test_recovery_replaces_stale_publication_but_not_active_owner(tmp_path) -> None: + first = EnrichedPublication(tmp_path, recover=True) + out = tmp_path / "kline_daily_enriched" / "date=2026-08-14" / "part.parquet" + first.write_parquet(_frame(10.0), out) + + with pytest.raises(EnrichedGenerationUnavailableError, match="active"): + EnrichedPublication(tmp_path, recover=True).write_parquet(_frame(11.0), out) + + del first + recovered = EnrichedPublication(tmp_path, recover=True) + recovered.write_parquet(_frame(12.0), out) + recovered_generation = recovered.commit() + + assert recovered_generation == get_enriched_generation(tmp_path, "stock") + assert pl.read_parquet(out)["close"].item() == pytest.approx(12.0) + + +def test_panel_cache_generation_change_forces_recompute() -> None: + cache = PanelCache() + calls: list[int] = [] + args = (["000001.SZ"], date(2026, 8, 13), date(2026, 8, 14), None) + + def compute(*_args): + calls.append(len(calls) + 1) + return pl.DataFrame({"value": [calls[-1]]}) + + first = cache.get_or_compute(*args, compute, "stock", "generation-a") + second = cache.get_or_compute(*args, compute, "stock", "generation-b") + + assert first["value"].item() == 1 + assert second["value"].item() == 2 + assert cache.stats()["compute_count"] == 2 + + +def test_panel_reader_retries_when_generation_changes_during_scan(tmp_path) -> None: + generations = iter(["generation-a", "generation-b", "generation-b", "generation-b"]) + repo = SimpleNamespace( + store=SimpleNamespace(data_dir=tmp_path), + get_matrix_data_generation=lambda _asset_type: next(generations), + ) + engine = BacktestEngine(repo) + calls: list[str] = [] + + def load(*_args): + calls.append("scan") + return _frame(float(len(calls))) + + engine._load_panel_inner = load + panel = engine.load_panel( + None, + date(2026, 8, 14), + date(2026, 8, 14), + columns=["symbol", "date", "close"], + ) + + assert calls == ["scan", "scan"] + assert panel["close"].item() == pytest.approx(2.0) + + +def test_matrix_reader_retries_when_generation_changes_during_build( + tmp_path, + monkeypatch, +) -> None: + generations = iter(["generation-a", "generation-b", "generation-b", "generation-b"]) + repo = SimpleNamespace( + store=SimpleNamespace(data_dir=tmp_path), + get_matrix_data_generation=lambda _asset_type: next(generations), + get_instruments_asset=lambda _asset_type: pl.DataFrame(), + ) + engine = BacktestEngine(repo) + calls: list[str | None] = [] + expected = SimpleNamespace( + execution_backend="matrix_native", + base_columns={"open", "high", "low", "close", "volume"}, + instrument_columns=set(), + matrix_columns=set(), + ) + market = SimpleNamespace() + + def load_matrix(*_args, source_generation=None, **_kwargs): + calls.append(source_generation) + return market + + monkeypatch.setattr("app.backtest.engine.load_market_data_matrix_from_parquet", load_matrix) + + result = engine.load_market_data_matrix_for_backtest( + None, + date(2026, 8, 14), + date(2026, 8, 14), + expected, + ) + + assert result is market + assert calls == ["generation-a", "generation-b"] diff --git a/backend/tests/test_enriched_range_warming_guard.py b/backend/tests/test_enriched_range_warming_guard.py new file mode 100644 index 0000000..ece7f2b --- /dev/null +++ b/backend/tests/test_enriched_range_warming_guard.py @@ -0,0 +1,56 @@ +"""get_enriched_range 的预热守卫测试 — 预热期间不得触发同步全量重算。 + +启动后台预热线程正在 _refresh_enriched (300 天 scan + compute, 低配机 50s+) +时, 请求线程进入 get_enriched_range 应返回 None (缓存不覆盖语义), +不能在请求线程里并发跑第二次全量重算。与 get_enriched_latest 守卫对齐。 +""" +from __future__ import annotations + +from datetime import date + +import polars as pl + +from app.tickflow.repository import KlineRepository + + +def _bare_repo() -> KlineRepository: + """跳过 __init__ (避免 DataStore/目录依赖), 只装配守卫涉及的属性。""" + repo = KlineRepository.__new__(KlineRepository) + repo._enriched_history_cache = None + repo._enriched_warming = True + return repo + + +def test_get_enriched_range_returns_none_while_warming(): + repo = _bare_repo() + refresh_calls: list[int] = [] + + def _spy_refresh(): + refresh_calls.append(1) + + repo._refresh_enriched = _spy_refresh # type: ignore[method-assign] + + result = repo.get_enriched_range(date(2026, 1, 1), date(2026, 8, 14)) + + assert result is None + assert refresh_calls == [], "预热期间不得触发 _refresh_enriched" + + +def test_get_enriched_range_rebuilds_when_cold_and_not_warming(): + repo = _bare_repo() + repo._enriched_warming = False + built = pl.DataFrame({ + "symbol": ["600000.SH", "600000.SH"], + "date": [date(2026, 1, 1), date(2026, 8, 14)], + }) + + def _fake_refresh(): + repo._enriched_history_cache = built + + repo._refresh_enriched = _fake_refresh # type: ignore[method-assign] + + result = repo.get_enriched_range(date(2026, 1, 1), date(2026, 8, 14)) + + assert result is not None + assert result.height == 2 + assert result["symbol"].unique().to_list() == ["600000.SH"] diff --git a/backend/tests/test_ext_config_load_all_cache.py b/backend/tests/test_ext_config_load_all_cache.py new file mode 100644 index 0000000..7cbec33 --- /dev/null +++ b/backend/tests/test_ext_config_load_all_cache.py @@ -0,0 +1,99 @@ +"""ExtConfigStore.load_all 签名缓存测试 — 配置未变不重复读盘, 变更后立即可见, 返回副本。""" +from __future__ import annotations + +import json + +import pytest + +from app.services import ext_data +from app.services.ext_data import ExtConfig, ExtConfigStore, ExtField + + +@pytest.fixture(autouse=True) +def _clean_cache(): + ext_data._load_all_cache.clear() + yield + ext_data._load_all_cache.clear() + + +def _patched_loads(monkeypatch, counter: dict): + real_loads = json.loads + + def _counting(text): + counter["loads"] += 1 + return real_loads(text) + + monkeypatch.setattr(ext_data.json, "loads", _counting) + + +def _config(cid: str, label: str) -> ExtConfig: + return ExtConfig(id=cid, label=label, mode="snapshot", + fields=[ExtField(name="score", dtype="float")]) + + +def test_second_load_all_hits_cache_without_disk_parse(tmp_path, monkeypatch): + store = ExtConfigStore(tmp_path) + store.upsert(_config("cfg_a", "A")) + store.upsert(_config("cfg_b", "B")) + + counter = {"loads": 0} + _patched_loads(monkeypatch, counter) + first = store.load_all() + assert counter["loads"] == 2, "缓存为空时逐 config.json parse" + again = store.load_all() + assert counter["loads"] == 2, "签名未变时不得重复读盘+parse" + assert [c.id for c in first] == [c.id for c in again] == ["cfg_a", "cfg_b"] + + +def test_upsert_edit_invalidates_cache(tmp_path): + store = ExtConfigStore(tmp_path) + store.upsert(_config("cfg_a", "old")) + assert store.load_all()[0].label == "old" + + store.upsert(_config("cfg_a", "new")) + assert store.load_all()[0].label == "new" + + +def test_delete_invalidates_cache(tmp_path): + store = ExtConfigStore(tmp_path) + store.upsert(_config("cfg_a", "A")) + store.upsert(_config("cfg_b", "B")) + assert {c.id for c in store.load_all()} == {"cfg_a", "cfg_b"} + + assert store.delete("cfg_a") is True + assert {c.id for c in store.load_all()} == {"cfg_b"} + + +def test_external_config_change_visible(tmp_path): + import os + + store = ExtConfigStore(tmp_path) + store.upsert(_config("cfg_a", "A")) + assert store.load_all()[0].label == "A" + + cp = tmp_path / "ext_data" / "cfg_a" / "config.json" + raw = json.loads(cp.read_text(encoding="utf-8")) + raw["label"] = "externally-edited" + cp.write_text(json.dumps(raw), encoding="utf-8") + st = cp.stat() + os.utime(cp, ns=(st.st_atime_ns, st.st_mtime_ns + 1_000_000)) + + assert store.load_all()[0].label == "externally-edited" + + +def test_load_all_returns_copy_not_cached_object(tmp_path): + store = ExtConfigStore(tmp_path) + store.upsert(_config("cfg_a", "A")) + first = store.load_all() + first[0].label = "mutated" + first[0].fields.append(ExtField(name="junk", dtype="string")) + + again = store.load_all() + assert again[0].label == "A" + assert [f.name for f in again[0].fields] == ["score"] + + +def test_load_all_without_config_dir_returns_empty(tmp_path): + store = ExtConfigStore(tmp_path) + assert store.load_all() == [] + assert store.load_all() == [] diff --git a/backend/tests/test_ext_config_store_safety.py b/backend/tests/test_ext_config_store_safety.py new file mode 100644 index 0000000..1374b6b --- /dev/null +++ b/backend/tests/test_ext_config_store_safety.py @@ -0,0 +1,43 @@ +"""ExtConfigStore 的 config_id 安全校验 — 拒绝路径穿越等非法 id (fail-closed)。 + +删除端点的 config_id 来自 URL path 参数, 不经创建端点的 pattern 校验; +若直接拼接路径, `../victim` 可让 rmtree 删除 ext_data 之外的目录。 +""" +from __future__ import annotations + +import json + +from app.services.ext_data import ExtConfigStore + + +def _write_config(data_dir, config_id: str) -> None: + d = data_dir / "ext_data" / config_id + d.mkdir(parents=True, exist_ok=True) + (d / "config.json").write_text( + json.dumps({ + "id": config_id, + "label": "测试", + "mode": "snapshot", + "fields": [{"name": "score"}], + }), + encoding="utf-8", + ) + + +def test_delete_rejects_path_traversal_ids(tmp_path): + store = ExtConfigStore(tmp_path) + _write_config(tmp_path, "ok_config") + + # 穿越目标: ext_data 之外、含 config.json 的目录 (满足旧实现 rmtree 的前置条件) + victim = tmp_path / "victim" + victim.mkdir() + (victim / "config.json").write_text("{}", encoding="utf-8") + + for bad in ("../victim", "..\\victim", "a/b", "", "."): + assert store.delete(bad) is False, bad + assert store.get(bad) is None, bad + assert (victim / "config.json").exists(), "穿越删除必须被拒绝" + + # 合法 id 不受影响 + assert store.get("ok_config") is not None + assert store.delete("ok_config") is True diff --git a/backend/tests/test_factor_library_v2.py b/backend/tests/test_factor_library_v2.py new file mode 100644 index 0000000..b24462b --- /dev/null +++ b/backend/tests/test_factor_library_v2.py @@ -0,0 +1,173 @@ +"""新增因子维度的解析正确性测试 (收益形态/流动性/涨停基因/量价扩展)。 + +金标准路径一致性由 test_matrix_strategy.py::test_research_factor_catalog_matches_matrix_features +覆盖; 这里用可手算的小样本验证公式本身。 +""" +from __future__ import annotations + +import math +from datetime import date, timedelta + +import numpy as np +import polars as pl + +from app.backtest.matrix import build_market_data_matrix, matrix_feature +from app.strategy.scoring import materialize_scoring_columns + + +def _panel(rows: list[dict]) -> pl.DataFrame: + return pl.DataFrame(rows).sort(["symbol", "date"]) + + +def _single_symbol_panel(n_days: int = 70) -> pl.DataFrame: + start = date(2025, 1, 1) + rows = [] + for offset in range(n_days): + change = [0.0, 0.01, -0.02, 0.03, 0.05, -0.01, 0.02, -0.03, 0.04, 0.01][offset % 10] + close = 10.0 if offset == 0 else rows[-1]["close"] * (1 + change) + volume = 1000.0 + (offset % 5) * 200 + consecutive = 0 + if offset % 15 == 0: + consecutive = 1 + (offset // 15) % 3 if offset % 30 == 0 else 1 + rows.append({ + "symbol": "000001.SZ", + "date": start + timedelta(days=offset), + "open": close * 0.99, + "high": close * 1.02, + "low": close * 0.97, + "close": close, + "volume": volume, + "amount": volume * 100.0 * close, + "turnover_rate": 1.0 + (offset % 7) * 0.3, + "consecutive_limit_ups": consecutive, + }) + return _panel(rows) + + +def _tail_value(frame: pl.DataFrame, name: str) -> float: + return frame.tail(1).to_dicts()[0][name] + + +def test_max_ret_up_days_and_limit_up_counts(): + panel = _single_symbol_panel() + frame = materialize_scoring_columns(panel, { + "max_ret_20d", "up_days_20d", + "limit_up_count_20d", "limit_up_count_60d", + }) + + changes = [ + panel["close"][i] / panel["close"][i - 1] - 1 + for i in range(1, panel.height) + ] + window = changes[-20:] + assert math.isclose(_tail_value(frame, "max_ret_20d"), max(window), rel_tol=1e-9) + assert math.isclose( + _tail_value(frame, "up_days_20d"), + float(sum(1 for value in window if value > 0)), + rel_tol=1e-9, + ) + + hits = [ + 1 if (row["consecutive_limit_ups"] or 0) > 0 else 0 + for row in panel.iter_rows(named=True) + ] + assert math.isclose(_tail_value(frame, "limit_up_count_20d"), float(sum(hits[-20:])), rel_tol=1e-9) + assert math.isclose(_tail_value(frame, "limit_up_count_60d"), float(sum(hits[-60:])), rel_tol=1e-9) + + +def test_amihud_and_turnover_z(): + panel = _single_symbol_panel() + frame = materialize_scoring_columns(panel, {"amihud_20d", "turnover_z_60d"}) + + rows = panel.to_dicts() + illiq = [ + abs(rows[i]["close"] / rows[i - 1]["close"] - 1) / (rows[i]["amount"] / 1e8) + for i in range(1, panel.height) + ] + assert math.isclose(_tail_value(frame, "amihud_20d"), sum(illiq[-20:]) / 20, rel_tol=1e-6) + + baseline = [rows[i]["turnover_rate"] for i in range(panel.height - 61, panel.height - 1)] + mean = sum(baseline) / 60 + variance = sum((value - mean) ** 2 for value in baseline) / 59 + std = variance ** 0.5 + expected_z = (rows[-1]["turnover_rate"] - mean) / std + assert math.isclose(_tail_value(frame, "turnover_z_60d"), expected_z, rel_tol=1e-6) + + +def test_vwap_bias_and_vol_trend(): + panel = _single_symbol_panel() + frame = materialize_scoring_columns(panel, {"vwap_bias", "vol_trend_5_60"}) + + last = panel.tail(1).to_dicts()[0] + vwap = last["amount"] / (last["volume"] * 100.0) + assert math.isclose(_tail_value(frame, "vwap_bias"), last["close"] / vwap - 1, rel_tol=1e-9) + + volumes = panel["volume"].to_list() + fast = sum(volumes[-5:]) / 5 + slow = sum(volumes[-60:]) / 60 + assert math.isclose(_tail_value(frame, "vol_trend_5_60"), fast / slow - 1, rel_tol=1e-9) + + +def test_ret_skew_matches_population_skew(): + # 周期夹具的 20 日窗口恰含两个完整周期, 偏度恒为 0; 用不对称收益验证公式。 + start = date(2025, 3, 1) + changes = [0.01, -0.005, -0.004, 0.09, -0.006, 0.002, -0.003, -0.002, -0.005, 0.003] * 7 + rows = [] + close = 10.0 + for offset, change in enumerate(changes): + close = close * (1 + change) + rows.append({ + "symbol": "000001.SZ", + "date": start + timedelta(days=offset), + "open": close * 0.99, + "high": close * 1.02, + "low": close * 0.97, + "close": close, + "volume": 1000.0 + offset, + "amount": (1000.0 + offset) * close, + "turnover_rate": 1.0, + "consecutive_limit_ups": 0, + }) + panel = _panel(rows) + frame = materialize_scoring_columns(panel, {"ret_skew_20d"}) + + window = changes[-20:] + mean = sum(window) / 20 + central_second = sum((value - mean) ** 2 for value in window) / 20 + central_third = sum((value - mean) ** 3 for value in window) / 20 + expected = central_third / central_second ** 1.5 + assert abs(expected) > 0.1 + assert math.isclose(_tail_value(frame, "ret_skew_20d"), expected, rel_tol=1e-6) + + +def test_vol_price_corr_matches_pearson(): + panel = _single_symbol_panel() + frame = materialize_scoring_columns(panel, {"vol_price_corr_20d"}) + + closes = panel["close"].to_list() + changes = [closes[i] / closes[i - 1] - 1 for i in range(panel.height - 20, panel.height)] + volumes = panel["volume"].to_list()[-20:] + n = 20 + mean_x = sum(changes) / n + mean_y = sum(volumes) / n + cov = sum((x - mean_x) * (y - mean_y) for x, y in zip(changes, volumes, strict=True)) / n + var_x = sum((x - mean_x) ** 2 for x in changes) / n + var_y = sum((y - mean_y) ** 2 for y in volumes) / n + expected = cov / (var_x * var_y) ** 0.5 + assert math.isclose(_tail_value(frame, "vol_price_corr_20d"), expected, rel_tol=1e-6) + + +def test_matrix_limit_up_counts_use_consecutive_field(): + panel = _single_symbol_panel() + frame = materialize_scoring_columns(panel, {"limit_up_count_20d"}) + market = build_market_data_matrix( + panel, + field_columns={"amount", "turnover_rate", "consecutive_limit_ups"}, + ) + np.testing.assert_allclose( + matrix_feature(market, "limit_up_count_20d")[:, 0], + frame["limit_up_count_20d"].to_numpy(), + rtol=1e-6, + atol=1e-6, + equal_nan=True, + ) diff --git a/backend/tests/test_fundamental_factors.py b/backend/tests/test_fundamental_factors.py new file mode 100644 index 0000000..861a4c9 --- /dev/null +++ b/backend/tests/test_fundamental_factors.py @@ -0,0 +1,193 @@ +"""财务因子点时接入测试: 公告日门控 / 无数据 null 安全 / 双路径一致 / 历史累积同步。""" +from __future__ import annotations + +from datetime import date, timedelta +from pathlib import Path + +import numpy as np +import polars as pl + +from app.backtest.fundamentals import ( + FUNDAMENTAL_FACTOR_NAMES, + attach_fundamental_factors, + build_fundamental_matrices, + load_fundamental_snapshot, +) +from app.backtest.matrix import build_market_data_matrix + + +def _snapshot_frame(rows: list[dict]) -> pl.DataFrame: + frame = pl.DataFrame({ + "period_end": ["2026-03-31"] * len(rows), + "symbol": [r["symbol"] for r in rows], + "announce_date": [r["announce"] for r in rows], + "roe": [r.get("roe", 10.0) for r in rows], + "bps": [r.get("bps", 5.0) for r in rows], + "revenue_yoy": [r.get("revenue_yoy", 8.0) for r in rows], + }) + return ( + frame.with_columns( + pl.col("announce_date").str.slice(0, 10).str.to_date().alias("_announce") + ) + .sort(["symbol", "_announce"]) + ) + + +def _daily_panel(start: date, days: int, symbols: tuple[str, ...]) -> pl.DataFrame: + rows = [] + for offset in range(days): + for symbol in symbols: + rows.append({ + "symbol": symbol, + "date": start + timedelta(days=offset), + "open": 10.0, + "high": 10.5, + "low": 9.5, + "close": 10.0 + offset * 0.1, + "volume": 1000.0, + }) + return pl.DataFrame(rows).sort(["symbol", "date"]) + + +def test_attach_gates_on_announce_date_strictly(): + panel = _daily_panel(date(2026, 4, 1), 10, ("600000.SH", "000001.SZ")) + snapshot = _snapshot_frame([ + # 公告日 4-5: 4-5 当天不可用, 4-6 起 roe=20 + {"symbol": "600000.SH", "announce": "2026-04-05", "roe": 20.0, "bps": 4.0}, + # 无财务数据的标的 + ]) + attached = attach_fundamental_factors(panel, snapshot, ["roe_latest", "pb_latest"]) + + values = attached.filter(pl.col("symbol") == "600000.SH").sort("date") + roe = values["roe_latest"].to_list() + assert roe[:5] == [None] * 5 # 4-1 ~ 4-5 均不可用 (含公告当日) + assert roe[5:] == [20.0] * 5 # 4-6 起生效 + + # 无财务数据标的全 null, 绝不填 0 + other = attached.filter(pl.col("symbol") == "000001.SZ")["roe_latest"] + assert other.null_count() == other.len() + + # pb = close / bps, 公告前 null + pb = values["pb_latest"].to_list() + assert pb[:5] == [None] * 5 + close_6 = values.filter(pl.col("date") == date(2026, 4, 6))["close"].item() + assert abs(pb[5] - close_6 / 4.0) < 1e-12 + + +def test_attach_replaces_with_newer_announcement(): + panel = _daily_panel(date(2026, 4, 1), 20, ("600000.SH",)) + snapshot = _snapshot_frame([ + {"symbol": "600000.SH", "announce": "2026-04-05", "roe": 20.0}, + {"symbol": "600000.SH", "announce": "2026-04-15", "roe": 33.0}, + ]) + attached = attach_fundamental_factors(panel, snapshot, ["roe_latest"]).sort("date") + roe = attached["roe_latest"].to_list() + assert roe[4] is None # 4-5 公告日 + assert roe[5] == 20.0 # 4-6 起 20.0 + assert roe[13] == 20.0 # 4-14 + assert roe[14] is None # 4-15 二次公告日, 当天仍不可用 (严格大于) + assert roe[15] == 33.0 # 4-16 起新公告生效 + + +def test_attach_without_snapshot_keeps_null_columns(): + panel = _daily_panel(date(2026, 4, 1), 5, ("600000.SH",)) + attached = attach_fundamental_factors(panel, None, ["roe_latest", "pb_latest"]) + for name in ("roe_latest", "pb_latest"): + assert name in attached.columns + assert attached[name].null_count() == attached.height + + +def test_matrix_field_matches_polars_attach(): + panel = _daily_panel(date(2026, 4, 1), 12, ("600000.SH", "000001.SZ")) + snapshot = _snapshot_frame([ + {"symbol": "600000.SH", "announce": "2026-04-05", "roe": 20.0, "bps": 4.0}, + {"symbol": "000001.SZ", "announce": "2026-04-08", "roe": -5.0, "bps": -1.0}, + ]) + attached = attach_fundamental_factors(panel, snapshot, ["roe_latest", "pb_latest"]) + market = build_market_data_matrix(panel) + matrices = build_fundamental_matrices(market, snapshot, ["roe_latest", "pb_latest"]) + symbols = {s: i for i, s in enumerate(market.symbols)} + dates = {str(d): t for t, d in enumerate( + sorted({row["date"] for row in panel.iter_rows(named=True)}) + )} + for name in ("roe_latest", "pb_latest"): + matrix = matrices[name] + for row in attached.iter_rows(named=True): + expected = row[name] + actual = matrix[dates[str(row["date"])], symbols[row["symbol"]]] + if expected is None: + assert np.isnan(actual), (name, row["date"], row["symbol"], actual) + else: + np.testing.assert_allclose(actual, expected, rtol=1e-6) + + +def test_bps_nonpositive_gives_null_pb(): + panel = _daily_panel(date(2026, 4, 1), 8, ("000001.SZ",)) + snapshot = _snapshot_frame([ + {"symbol": "000001.SZ", "announce": "2026-04-02", "bps": -1.0}, + ]) + attached = attach_fundamental_factors(panel, snapshot, ["pb_latest"]) + assert attached["pb_latest"].null_count() == attached.height + + +def test_load_snapshot_from_missing_dir_returns_none(tmp_path: Path): + assert load_fundamental_snapshot(tmp_path) is None + assert load_fundamental_snapshot(None) is None + + +def test_snapshot_requires_announce_date(tmp_path: Path): + out = tmp_path / "financials" / "metrics" + out.mkdir(parents=True) + pl.DataFrame({ + "symbol": ["600000.SH"], + "announce_date": [None], + "roe": [10.0], + "gross_margin": [30.0], + "net_margin": [5.0], + "revenue_yoy": [8.0], + "net_income_yoy": [6.0], + "debt_to_asset_ratio": [40.0], + "bps": [5.0], + }).write_parquet(out / "part.parquet") + # 公告日缺失的行无法做点时门控, 视为无有效快照 + assert load_fundamental_snapshot(tmp_path) is None + + +def test_fundamental_factor_names_are_catalogued(): + from app.backtest.factor import FACTOR_COLUMNS + + catalog_ids = {item["id"] for item in FACTOR_COLUMNS} + assert catalog_ids >= FUNDAMENTAL_FACTOR_NAMES + + +def test_financial_sync_merges_history(tmp_path: Path): + from app.services import financial_sync as fs + + old = pl.DataFrame({ + "symbol": ["600000.SH", "600000.SH"], + "period_end": ["2025-09-30", "2025-12-31"], + "announce_date": ["2025-10-28", "2026-01-20"], + "roe": [8.0, 9.0], + }) + latest = pl.DataFrame({ + "symbol": ["600000.SH", "000001.SZ"], + "period_end": ["2026-03-31", "2026-03-31"], + "announce_date": ["2026-04-25", "2026-04-24"], + "roe": [10.0, 5.0], + }) + merged = fs._merge_report_history(old, latest) + assert merged.height == 4 # 旧各期保留 + 新一期并入 + # 同期修正: 旧 2025-12-31 公告 2026-01-20 vs 更晚的修正公告 + revised = pl.DataFrame({ + "symbol": ["600000.SH"], + "period_end": ["2025-12-31"], + "announce_date": ["2026-02-01"], + "roe": [9.5], + }) + merged2 = fs._merge_report_history(old, revised) + row = merged2.filter( + (pl.col("symbol") == "600000.SH") & (pl.col("period_end") == "2025-12-31") + ) + assert row.height == 1 + assert row["roe"].item() == 9.5 + assert merged2.height == 2 # 修正不增加行数 diff --git a/backend/tests/test_get_daily_cache_reuse.py b/backend/tests/test_get_daily_cache_reuse.py new file mode 100644 index 0000000..7c4d1df --- /dev/null +++ b/backend/tests/test_get_daily_cache_reuse.py @@ -0,0 +1,106 @@ +"""get_daily 复用 enriched 历史缓存的等价性测试。 + +个股对话框打开时 /api/kline/daily 每个行情 tick 调用一次; 旧路径每次 +150 天扫描 + 全套指标重算, 新路径优先从预计算历史缓存裁剪。 +本测试证明: 同一份数据下两条路径输出逐列一致, 且缓存命中时不触发扫描。 +""" +from __future__ import annotations + +from datetime import date, timedelta + +import polars as pl +from polars.testing import assert_frame_equal + +from app.tickflow.repository import KlineRepository + +SYM = "600001.SH" + + +def _raw_frame(days: int = 80) -> pl.DataFrame: + """构造 ~57 个交易日的 14 列形态数据 (复权价与原始价一致, 无除权)。""" + base = date(2026, 4, 1) + rows = [] + price = 10.0 + d = base + while len(rows) < days: + if d.weekday() < 5: + open_ = price * (1 + ((len(rows) % 7) - 3) * 0.004) + close = price * (1 + ((len(rows) % 5) - 2) * 0.006) + high = max(open_, close) * 1.01 + low = min(open_, close) * 0.99 + price = close + rows.append({ + "symbol": SYM, "date": d, + "open": round(open_, 4), "high": round(high, 4), + "low": round(low, 4), "close": round(close, 4), + "volume": 10000.0 + (len(rows) % 10) * 500.0, + "amount": 1.0e7, + "raw_close": round(close, 4), "raw_high": round(high, 4), + "raw_low": round(low, 4), + }) + d += timedelta(days=1) + return pl.DataFrame(rows).sort(["symbol", "date"]) + + +def _bare_repo(raw: pl.DataFrame) -> tuple[KlineRepository, dict]: + repo = KlineRepository.__new__(KlineRepository) + repo._enriched_history_cache = None + repo._enriched_history_start = None + repo._enriched_cache = None + repo._enriched_cache_date = None + repo.get_instruments = lambda: pl.DataFrame() # type: ignore[method-assign] + repo.get_historical_shares = lambda: pl.DataFrame() # type: ignore[method-assign] + repo.get_enriched_latest = lambda: (pl.DataFrame(), None) # type: ignore[method-assign] + calls = {"scan": 0} + + def _scan(symbol, start, end, columns): + calls["scan"] += 1 + return raw.filter((pl.col("date") >= start) & (pl.col("date") <= end)) + + repo._scan_daily_symbol = _scan # type: ignore[method-assign] + return repo, calls + + +def test_get_daily_cache_path_matches_scan_path(): + raw = _raw_frame() + dates = raw["date"].to_list() + start, end = dates[30], dates[-1] + + # 旧路径: 无历史缓存 → 扫描 + 即时计算 + repo_old, calls_old = _bare_repo(raw) + result_old = repo_old.get_daily(SYM, start, end) + assert calls_old["scan"] == 1 + + # 新路径: 预计算历史缓存 (同一真实计算栈 _compute_enriched_range 构建) + repo_new, calls_new = _bare_repo(raw) + hist = repo_new._compute_enriched_range(raw) + repo_new._enriched_history_cache = hist + repo_new._enriched_history_start = hist["date"].min() + result_new = repo_new.get_daily(SYM, start, end) + + assert calls_new["scan"] == 0, "缓存命中时不得回退到扫描路径" + assert result_new.height == result_old.height + + common = sorted(set(result_old.columns) & set(result_new.columns)) + assert {"open", "close", "ma5", "ma20", "ma60", "rsi_14"} <= set(common) + assert_frame_equal( + result_old.sort("date").select(common), + result_new.sort("date").select(common), + check_exact=False, + rel_tol=1e-9, + ) + + +def test_get_daily_falls_back_to_scan_when_cache_does_not_cover_start(): + raw = _raw_frame() + dates = raw["date"].to_list() + + repo, calls = _bare_repo(raw) + hist = repo._compute_enriched_range(raw) + repo._enriched_history_cache = hist + repo._enriched_history_start = hist["date"].min() + + # 请求起点早于缓存覆盖 → 必须回退扫描路径 + result = repo.get_daily(SYM, dates[0] - timedelta(days=5), dates[-1]) + assert calls["scan"] == 1 + assert not result.is_empty() diff --git a/backend/tests/test_heavy_job_limiter.py b/backend/tests/test_heavy_job_limiter.py new file mode 100644 index 0000000..5ebc56d --- /dev/null +++ b/backend/tests/test_heavy_job_limiter.py @@ -0,0 +1,96 @@ +from __future__ import annotations + +import threading +import time + +import pytest + +from app.services.heavy_job_limiter import ( + HeavyJobCancelledError, + HeavyJobLimiter, + HeavyJobLimitTimeoutError, + heavy_job_limiter, + shared_heavy_job_limiter, +) + + +def test_weighted_capacity_and_timeout() -> None: + limiter = HeavyJobLimiter(capacity=2) + + assert limiter.acquire("normal", timeout=0) + assert limiter.acquire("normal", timeout=0) + assert limiter.available == 0 + assert not limiter.acquire("normal", timeout=0.01) + limiter.release("normal") + assert not limiter.acquire("mining", timeout=0) + limiter.release("normal") + assert limiter.acquire("mining", timeout=0) + assert limiter.in_use == 2 + limiter.release("mining") + + +def test_waiting_acquire_can_be_cancelled() -> None: + limiter = HeavyJobLimiter(capacity=2, cancel_poll_interval=0.01) + cancel_event = threading.Event() + assert limiter.acquire("mining", timeout=0) + + result: list[bool] = [] + waiter = threading.Thread( + target=lambda: result.append( + limiter.acquire("normal", timeout=1, cancel_event=cancel_event) + ) + ) + waiter.start() + time.sleep(0.03) + cancel_event.set() + waiter.join(timeout=1) + + assert not waiter.is_alive() + assert result == [False] + assert limiter.in_use == 2 + limiter.release("mining") + + +def test_context_manager_releases_after_body_error() -> None: + limiter = HeavyJobLimiter(capacity=2) + + with pytest.raises(ValueError, match="body failed"), limiter.slot("mining", timeout=0): + raise ValueError("body failed") + + assert limiter.in_use == 0 + assert limiter.acquire("mining", timeout=0) + limiter.release("mining") + + +def test_context_manager_distinguishes_timeout_and_cancellation() -> None: + limiter = HeavyJobLimiter(capacity=2) + assert limiter.acquire("mining", timeout=0) + + with pytest.raises(HeavyJobLimitTimeoutError), limiter.slot("normal", timeout=0.01): + pytest.fail("unreachable") + + cancelled = threading.Event() + cancelled.set() + with pytest.raises(HeavyJobCancelledError), limiter.slot("normal", cancel_event=cancelled): + pytest.fail("unreachable") + + limiter.release("mining") + + +def test_invalid_release_does_not_overfill_capacity() -> None: + limiter = HeavyJobLimiter(capacity=2) + + with pytest.raises(RuntimeError): + limiter.release("normal") + assert limiter.available == 2 + + assert limiter.acquire("normal", timeout=0) + with pytest.raises(RuntimeError): + limiter.release("mining") + assert limiter.in_use == 1 + limiter.release("normal") + + +def test_module_aliases_share_the_capacity_two_singleton() -> None: + assert heavy_job_limiter is shared_heavy_job_limiter + assert shared_heavy_job_limiter.capacity == 2 diff --git a/backend/tests/test_indicator_needed.py b/backend/tests/test_indicator_needed.py index fe4d7ba..1e38b87 100644 --- a/backend/tests/test_indicator_needed.py +++ b/backend/tests/test_indicator_needed.py @@ -28,6 +28,19 @@ def _bars(n: int = 90) -> pl.DataFrame: return pl.DataFrame(rows) +def test_compute_indicators_assume_sorted_matches_default_values(): + bars = _bars().sort(["symbol", "date"]) + + default = compute_indicators(bars, needed={"macd_hist", "rsi_14", "momentum_20d"}) + fast = compute_indicators( + bars, + needed={"macd_hist", "rsi_14", "momentum_20d"}, + assume_sorted=True, + ) + + assert fast.equals(default) + + def test_compute_signals_subset_matches_full_values(): indicators = compute_indicators(_bars()) full = compute_signals(indicators) diff --git a/backend/tests/test_kline_hot_path_memory.py b/backend/tests/test_kline_hot_path_memory.py new file mode 100644 index 0000000..3f9707c --- /dev/null +++ b/backend/tests/test_kline_hot_path_memory.py @@ -0,0 +1,155 @@ +"""kline 每秒热路径测试 — _get_stock_info 走内存缓存, _attach_ext 复用签名缓存 value_map。 + +契约等值: 输出与旧的 DuckDB 扫描 / 逐配置读 parquet 路径一致。 +""" +from __future__ import annotations + +from types import SimpleNamespace + +import polars as pl + +from app.api import screener +from app.api.kline import _attach_ext, _get_stock_info +from app.services.ext_data import ExtConfig, ExtConfigStore, ExtField + + +class _FakeRepo: + """最小 repo 替身: _get_stock_info/_load_ext_value_maps 只用到这些成员。""" + + def __init__(self, instruments: pl.DataFrame, data_dir) -> None: + self._instruments = instruments + self.store = SimpleNamespace(data_dir=data_dir, db=None) + self.execute_one_calls = 0 + + def get_instruments(self) -> pl.DataFrame: + return self._instruments + + def execute_one(self, *args, **kwargs): + self.execute_one_calls += 1 + raise AssertionError("热路径不得再走 DuckDB 扫 instruments parquet") + + +def _instruments_df() -> pl.DataFrame: + return pl.DataFrame({ + "symbol": ["600000.SH", "000001.SZ", "510300.SH"], + "name": ["浦发银行", "平安银行", "沪深300ETF"], + "total_shares": [1.0e9, 2.0e9, None], + "float_shares": [5.0e8, 1.0e9, None], + }) + + +# ---------------------------------------------------------------- _get_stock_info + +def test_get_stock_info_reads_memory_cache(): + repo = _FakeRepo(_instruments_df(), None) + assert _get_stock_info(repo, "600000.SH") == { + "name": "浦发银行", "total_shares": 1.0e9, "float_shares": 5.0e8, + } + assert repo.execute_one_calls == 0 + + +def test_get_stock_info_null_shares_become_none(): + repo = _FakeRepo(_instruments_df(), None) + info = _get_stock_info(repo, "510300.SH") + assert info["name"] == "沪深300ETF" + assert info["total_shares"] is None + assert info["float_shares"] is None + + +def test_get_stock_info_missing_symbol_returns_empty(): + repo = _FakeRepo(_instruments_df(), None) + assert _get_stock_info(repo, "999999.SH") == {} + + +def test_get_stock_info_missing_columns_returns_empty_like_sql_error(): + df = pl.DataFrame({"symbol": ["600000.SH"], "name": ["浦发银行"]}) + repo = _FakeRepo(df, None) + assert _get_stock_info(repo, "600000.SH") == {} + + +def test_get_stock_info_repo_failure_returns_empty(): + repo = SimpleNamespace() + repo.get_instruments = lambda: (_ for _ in ()).throw(RuntimeError("boom")) + assert _get_stock_info(repo, "600000.SH") == {} + + +# ---------------------------------------------------------------- _attach_ext + +def test_attach_ext_empty_columns_untouched(): + resp = {"symbol": "600000.SH", "stock_info": {"name": "x"}, "rows": []} + repo = _FakeRepo(_instruments_df(), None) + out = _attach_ext(resp, repo, "600000.SH", None) + assert out is resp + assert "ext" not in out["stock_info"] + out = _attach_ext(resp, repo, "600000.SH", " ") + assert "ext" not in out["stock_info"] + + +def test_attach_ext_invalid_spec_untouched(): + resp = {"symbol": "600000.SH", "stock_info": {"name": "x"}, "rows": []} + repo = _FakeRepo(_instruments_df(), None) + out = _attach_ext(resp, repo, "600000.SH", "foo_bar") # 无 '.' 分隔 + assert out is resp + assert "ext" not in out["stock_info"] + + +def test_attach_ext_maps_values_from_loader(monkeypatch): + resp = {"symbol": "600000.SH", "stock_info": {"name": "x"}, "rows": []} + original_info = resp["stock_info"] + repo = _FakeRepo(_instruments_df(), None) + monkeypatch.setattr( + screener, "_load_ext_value_maps", + lambda r, cols: {"cfg1__score": {"600000.SH": 88.5}, "cfg1__note": {}}, + ) + out = _attach_ext(resp, repo, "600000.SH", "cfg1.score,cfg1.note") + assert out["stock_info"]["ext"] == {"cfg1__score": 88.5, "cfg1__note": None} + # 原地更新 resp 是该函数契约; 但原 stock_info 字典对象不被修改 (与旧实现一致) + assert out is resp + assert "ext" not in original_info + assert out["stock_info"] is not original_info + + +def test_attach_ext_loader_failure_yields_none_values(monkeypatch): + resp = {"symbol": "600000.SH", "stock_info": {}, "rows": []} + repo = _FakeRepo(_instruments_df(), None) + + def _boom(r, cols): + raise RuntimeError("boom") + + monkeypatch.setattr(screener, "_load_ext_value_maps", _boom) + out = _attach_ext(resp, repo, "600000.SH", "cfg1.score") + assert out["stock_info"]["ext"] == {"cfg1__score": None} + + +# ------------------------------------------- _attach_ext 与真实 _load_ext_value_maps 集成 + +def _setup_ext_snapshot(tmp_path): + store = ExtConfigStore(tmp_path) + store.upsert(ExtConfig( + id="benchx", label="基准扩展", mode="snapshot", + fields=[ExtField(name="score", dtype="float")], + )) + cfg_dir = tmp_path / "ext_data" / "benchx" + cfg_dir.mkdir(parents=True, exist_ok=True) + pl.DataFrame({ + "symbol": [f"{600000 + i}.SH" for i in range(50)], + "score": [float(i) for i in range(50)], + }).write_parquet(cfg_dir / "part.parquet") + return store + + +def test_attach_ext_real_loader_returns_parquet_values(tmp_path): + _setup_ext_snapshot(tmp_path) + repo = _FakeRepo(_instruments_df(), tmp_path) + resp = {"symbol": "600005.SH", "stock_info": {"name": "x"}, "rows": []} + out = _attach_ext(resp, repo, "600005.SH", "benchx.score") + assert out["stock_info"]["ext"] == {"benchx__score": 5.0} + assert isinstance(out["stock_info"]["ext"]["benchx__score"], float) + + +def test_attach_ext_real_loader_unknown_symbol_is_none(tmp_path): + _setup_ext_snapshot(tmp_path) + repo = _FakeRepo(_instruments_df(), tmp_path) + resp = {"symbol": "999999.SH", "stock_info": {}, "rows": []} + out = _attach_ext(resp, repo, "999999.SH", "benchx.score") + assert out["stock_info"]["ext"] == {"benchx__score": None} diff --git a/backend/tests/test_kline_sync_timezone.py b/backend/tests/test_kline_sync_timezone.py new file mode 100644 index 0000000..44d3c78 --- /dev/null +++ b/backend/tests/test_kline_sync_timezone.py @@ -0,0 +1,38 @@ +"""时区契约测试 — 分时拉取窗口必须按北京时间解释, 与服务器本地时区无关。 + +fetch_minute_single 构造的 naive datetime 会被 _datetime_to_ms 的 .timestamp() +按服务器本地时区解释: UTC 容器 (Docker 默认) 上窗口偏移 8 小时, 补拉必为空。 +""" +from __future__ import annotations + +from datetime import date, datetime + +from app.market_time import CN_TZ +from app.services import kline_sync + + +def test_fetch_minute_single_window_is_beijing_wall_clock(monkeypatch): + captured: dict[str, int] = {} + + def _fake_try_custom_minute(*args, **kwargs): + return (None, True) # 未配自定义源 → 走 TickFlow 分支 + + class _FakeKlines: + @staticmethod + def batch(symbols, period, start_time, end_time, **kwargs): + captured["start_ms"] = start_time + captured["end_ms"] = end_time + return [] + + class _FakeClient: + klines = _FakeKlines + + monkeypatch.setattr(kline_sync, "_try_custom_minute", _fake_try_custom_minute) + monkeypatch.setattr(kline_sync, "get_client", lambda: _FakeClient()) + + kline_sync.fetch_minute_single("600000.SH", date(2026, 8, 14)) + + start = datetime.fromtimestamp(captured["start_ms"] / 1000, tz=CN_TZ) + end = datetime.fromtimestamp(captured["end_ms"] / 1000, tz=CN_TZ) + assert (start.date(), start.hour, start.minute) == (date(2026, 8, 14), 9, 25) + assert (end.date(), end.hour, end.minute) == (date(2026, 8, 14), 15, 5) diff --git a/backend/tests/test_last_fetch_throttle.py b/backend/tests/test_last_fetch_throttle.py new file mode 100644 index 0000000..05d4073 --- /dev/null +++ b/backend/tests/test_last_fetch_throttle.py @@ -0,0 +1,64 @@ +"""last_fetch 落盘节流测试 — 30s 内只写一次盘, 内存值路径不受影响。""" +from __future__ import annotations + +import pytest + +from app.services import preferences, quote_service + + +@pytest.fixture(autouse=True) +def _reset_throttle_state(monkeypatch): + monkeypatch.setattr(quote_service, "_last_fetch_written_at_ms", 0.0) + yield + quote_service._last_fetch_written_at_ms = 0.0 + + +@pytest.fixture() +def save_counter(monkeypatch): + counter = {"saves": 0, "values": []} + + def _counting(updates: dict) -> dict: + counter["saves"] += 1 + counter["values"].append(updates) + return {} + + monkeypatch.setattr(preferences, "save", _counting) + return counter + + +def test_first_call_after_start_writes(save_counter): + quote_service._persist_last_fetch(1_700_000_000_000.0) + assert save_counter["saves"] == 1 + assert save_counter["values"][0] == {"last_fetch_ms": 1_700_000_000_000.0} + + +def test_writes_within_window_are_skipped(save_counter): + t0 = 1_700_000_000_000.0 + quote_service._persist_last_fetch(t0) + quote_service._persist_last_fetch(t0 + 10_000.0) # +10s: 跳过 + quote_service._persist_last_fetch(t0 + 29_999.0) # 仍不足 30s: 跳过 + assert save_counter["saves"] == 1 + + +def test_write_resumes_after_window(save_counter): + t0 = 1_700_000_000_000.0 + quote_service._persist_last_fetch(t0) + quote_service._persist_last_fetch(t0 + 30_000.0) # 恰好 30s: 恢复写盘 + assert save_counter["saves"] == 2 + assert save_counter["values"][1] == {"last_fetch_ms": 1_700_000_030_000.0} + + +def test_write_failure_does_not_propagate_and_retries(monkeypatch): + calls = {"n": 0} + + def _flaky(updates: dict) -> dict: + calls["n"] += 1 + if calls["n"] == 1: + raise OSError("disk full") + return {} + + monkeypatch.setattr(preferences, "save", _flaky) + t0 = 1_700_000_000_000.0 + quote_service._persist_last_fetch(t0) # 失败但不抛出 + quote_service._persist_last_fetch(t0 + 1_000.0) # 未成功过 -> 立即重试 + assert calls["n"] == 2 diff --git a/backend/tests/test_main_mining_lifespan.py b/backend/tests/test_main_mining_lifespan.py new file mode 100644 index 0000000..8b6e9e0 --- /dev/null +++ b/backend/tests/test_main_mining_lifespan.py @@ -0,0 +1,83 @@ +from __future__ import annotations + +import asyncio +from contextlib import asynccontextmanager +from types import SimpleNamespace + +import pytest + +import app.main as main_module + + +def test_lifespan_holds_mining_process_lock_around_application(monkeypatch) -> None: + events: list[str] = [] + + class LockStub: + def __init__(self, data_dir) -> None: + del data_dir + events.append("lock_created") + + def acquire(self) -> None: + events.append("lock_acquired") + + def release(self) -> None: + events.append("lock_released") + + @asynccontextmanager + async def application_lifespan(_app): + events.append("application_started") + try: + yield + finally: + events.append("application_stopped") + + monkeypatch.setattr(main_module, "MiningProcessLock", LockStub) + monkeypatch.setattr(main_module, "_application_lifespan", application_lifespan) + + async def exercise() -> None: + async with main_module.lifespan(SimpleNamespace()): + events.append("request_serving") + + asyncio.run(exercise()) + + assert events == [ + "lock_created", + "lock_acquired", + "application_started", + "request_serving", + "application_stopped", + "lock_released", + ] + + +def test_lifespan_releases_lock_when_application_shutdown_raises(monkeypatch) -> None: + events: list[str] = [] + + class LockStub: + def __init__(self, data_dir) -> None: + del data_dir + + def acquire(self) -> None: + events.append("acquired") + + def release(self) -> None: + events.append("released") + + @asynccontextmanager + async def application_lifespan(_app): + try: + yield + finally: + raise RuntimeError("shutdown failed") + + monkeypatch.setattr(main_module, "MiningProcessLock", LockStub) + monkeypatch.setattr(main_module, "_application_lifespan", application_lifespan) + + async def exercise() -> None: + async with main_module.lifespan(SimpleNamespace()): + pass + + with pytest.raises(RuntimeError, match="shutdown failed"): + asyncio.run(exercise()) + + assert events == ["acquired", "released"] diff --git a/backend/tests/test_market_mainline.py b/backend/tests/test_market_mainline.py new file mode 100644 index 0000000..2581d5c --- /dev/null +++ b/backend/tests/test_market_mainline.py @@ -0,0 +1,162 @@ +"""市场主线(market_mainline)与过滤配置单元测试。""" +from __future__ import annotations + +from datetime import date + +import polars as pl + +from app.services import market_mainline, preferences + + +def _write_enriched(root, rows: list[dict]) -> None: + enriched = root / "kline_daily_enriched" + by_date: dict[date, list[dict]] = {} + for r in rows: + by_date.setdefault(r["date"], []).append(r) + for d, day_rows in by_date.items(): + part = enriched / f"date={d.isoformat()}" / "part.parquet" + part.parent.mkdir(parents=True, exist_ok=True) + pl.DataFrame(day_rows).write_parquet(part) + + +def _fake_repo(tmp_path): + import types + + return types.SimpleNamespace(store=types.SimpleNamespace(data_dir=tmp_path)) + + +def _patch_map(monkeypatch, mapping: dict[str, list[str]], kind: str = "concept") -> None: + map_df = pl.DataFrame( + {"_sym_up": [s for s, ms in mapping.items() for _ in ms], + kind: [m for _, ms in mapping.items() for m in ms]}, + schema={"_sym_up": pl.Utf8, kind: pl.Utf8}, + ).unique() + + def fake_load(repo, k="concept"): + return (map_df, map_df[kind].n_unique()) if k == kind else (pl.DataFrame(), 0) + + monkeypatch.setattr(market_mainline, "_load_concept_map_df", fake_load) + + +def _mk_rows(d: date, spec: list[tuple[str, int, float]]) -> list[dict]: + return [ + {"symbol": sym, "date": d, "consecutive_limit_ups": consec, "amount": amt} + for sym, consec, amt in spec + ] + + +class TestComputeMainline: + def _setup(self, tmp_path, monkeypatch): + d1, d2 = date(2024, 1, 2), date(2024, 1, 3) + # 概念 X: d1 三个涨停(2,1,1), d2 三个涨停(3,2,1); 概念 Y: 单股 2 板 + # S5 无概念映射; 大概念 BIG 成员 700 家但只有 5 家涨停(数据里只写 5 行) + rows = _mk_rows(d1, [("S1.SH", 2, 5e8), ("S2.SH", 1, 1e8), ("S3.SH", 1, 2e8), + ("S4.SH", 2, 3e8), ("S5.SH", 1, 1e8), + ("B1.SH", 1, 1e8), ("B2.SH", 1, 1e8)]) + rows += _mk_rows(d2, [("S1.SH", 3, 6e8), ("S2.SH", 2, 2e8), ("S3.SH", 0, 1e8), + ("S4.SH", 3, 4e8), ("S5.SH", 1, 1e8), + ("B1.SH", 2, 1e8), ("B2.SH", 0, 1e8)]) + _write_enriched(tmp_path, rows) + mapping = { + "S1.SH": ["X"], "S2.SH": ["X"], "S3.SH": ["X"], + "S4.SH": ["X", "Y"], "S5.SH": [], + "B1.SH": ["BIG"], "B2.SH": ["BIG"], + **{f"F{i}.SH": ["BIG"] for i in range(700)}, # BIG 成员 702 → 超 600 上限 + } + _patch_map(monkeypatch, mapping) + return _fake_repo(tmp_path), d1, d2 + + def test_aggregation_and_big_concept_filter(self, tmp_path, monkeypatch): + repo, d1, d2 = self._setup(tmp_path, monkeypatch) + out = market_mainline.compute_mainline_range( + repo, tmp_path, d1, d2, kind="concept", + filter_cfg={"min_members": 4, "max_members": 600, "blacklist": []}, + ) + members = set(out["member"].to_list()) + assert "BIG" not in members # 成员数超上限被过滤 + assert "X" in members + x_d2 = out.filter((pl.col("date") == d2) & (pl.col("member") == "X")).to_dicts()[0] + assert x_d2["limit_up_count"] == 3 # S1,S2,S4 + assert x_d2["ge2_count"] == 3 + assert x_d2["max_boards"] == 3 + assert x_d2["rungs_filled"] == 2 # 档位 {2,3} + assert x_d2["leader_symbol"] == "S1.SH" # 最高板且成交额大 + assert x_d2["rank"] == 1 + + def test_blacklist_and_min_limit_up(self, tmp_path, monkeypatch): + repo, d1, d2 = self._setup(tmp_path, monkeypatch) + out = market_mainline.compute_mainline_range( + repo, tmp_path, d1, d2, kind="concept", + filter_cfg={"min_members": 1, "max_members": 5000, "blacklist": ["X"]}, + ) + # X 被黑名单; BIG 只有 2-3 家涨停 < _MIN_LIMIT_UP=3 也不参与 → 只剩空/无 X + assert "X" not in set(out["member"].to_list()) + + def test_upsert_replaces_same_day_kind(self, tmp_path, monkeypatch): + repo, d1, d2 = self._setup(tmp_path, monkeypatch) + cfg = {"min_members": 4, "max_members": 600, "blacklist": []} + first = market_mainline.compute_mainline_range(repo, tmp_path, d1, d1, kind="concept", filter_cfg=cfg) + market_mainline.upsert_mainline_history(tmp_path, first) + both = market_mainline.compute_mainline_range(repo, tmp_path, d1, d2, kind="concept", filter_cfg=cfg) + market_mainline.upsert_mainline_history(tmp_path, both) + stored = pl.read_parquet(market_mainline.mainline_path(tmp_path)) + assert set(stored["date"].to_list()) == {d1, d2} + # 同日重算不产生重复行 + assert stored.filter(pl.col("date") == d1).height == first.height + + def test_incremental_fills_missing_days(self, tmp_path, monkeypatch): + repo, d1, d2 = self._setup(tmp_path, monkeypatch) + cfg = {"min_members": 4, "max_members": 600, "blacklist": []} + first = market_mainline.compute_mainline_range(repo, tmp_path, d1, d1, kind="concept", filter_cfg=cfg) + market_mainline.upsert_mainline_history(tmp_path, first) + new = market_mainline.compute_mainline_incremental(repo, tmp_path, kind="concept") + assert not new.is_empty() + assert set(new["date"].to_list()) == {d2} + + def test_industry_level_truncation(self, tmp_path, monkeypatch): + d1 = date(2024, 1, 2) + rows = _mk_rows(d1, [("S1.SH", 2, 5e8), ("S2.SH", 1, 1e8), + ("S3.SH", 1, 2e8), ("S4.SH", 3, 4e8)]) + _write_enriched(tmp_path, rows) + _patch_map( + monkeypatch, + {"S1.SH": ["计算机-软件开发-垂直应用软件"], + "S2.SH": ["计算机-软件开发-垂直应用软件"], + "S3.SH": ["计算机-IT服务-IT服务Ⅲ"], + "S4.SH": ["计算机-软件开发-垂直应用软件"]}, + kind="industry", + ) + out = market_mainline.compute_mainline_range( + _fake_repo(tmp_path), tmp_path, d1, d1, kind="industry", + filter_cfg={"min_members": 1, "max_members": 5000, "blacklist": []}, + ) + members = set(out["member"].to_list()) + assert "计算机-软件开发" in members + assert all(m.count("-") <= 1 for m in members) + sw = out.filter(pl.col("member") == "计算机-软件开发").to_dicts()[0] + assert sw["limit_up_count"] == 3 + assert sw["max_boards"] == 3 + + +class TestMainlineFilterPreferences: + def test_blacklist_string_parsing_and_clamp(self, tmp_path, monkeypatch): + path = tmp_path / "preferences.json" + monkeypatch.setattr(preferences, "_path", lambda: path) + got = preferences.set_mainline_filter_config({ + "max_members": 99999, # 超上限被夹到 5000 + "min_members": 0, # 低于下限被夹到 1 + "blacklist": "融资融券, 沪股通；深股通", # noqa: RUF001 + }) + assert got["max_members"] == 5000 + assert got["min_members"] == 1 + assert set(got["blacklist"]) == {"融资融券", "沪股通", "深股通"} + # 部分更新: 只改黑名单, 其他保持 + got2 = preferences.set_mainline_filter_config({"blacklist": ["ST板块"]}) + assert got2["blacklist"] == ["ST板块"] + assert got2["max_members"] == 5000 + + def test_defaults(self, tmp_path, monkeypatch): + path = tmp_path / "preferences.json" + monkeypatch.setattr(preferences, "_path", lambda: path) + cfg = preferences.get_mainline_filter_config() + assert cfg == {"min_members": 4, "max_members": 600, "blacklist": []} diff --git a/backend/tests/test_market_phase.py b/backend/tests/test_market_phase.py new file mode 100644 index 0000000..0468b4b --- /dev/null +++ b/backend/tests/test_market_phase.py @@ -0,0 +1,200 @@ +"""市场情绪周期阶段(market_phase)单元测试 — 梯队指标与阶段规则引擎。""" +from __future__ import annotations + +from datetime import date, timedelta +from itertools import pairwise + +import polars as pl + +from app.services.market_phase import ( + CLIMAX_GE2, + EBB_PROMO, + ICE_FIRST_BOARD, + ICE_GE2, + ICE_HEIGHT, + PHASE_CLIMAX, + PHASE_EBB, + PHASE_ICE, + PHASE_IGNITE, + PHASE_RALLY, + PHASE_REPAIR, + classify_phase_series, + finalize_ladder_row, + with_prev_consecutive, +) +from app.services.regime_builder import _aggregate_daily, refresh_phase_labels, regime_path + + +def _days(n: int, start: str = "2024-01-01") -> list[date]: + d0 = date.fromisoformat(start) + out, cur = [], d0 + while len(out) < n: + if cur.weekday() < 5: + out.append(cur) + cur += timedelta(days=1) + return out + + +def _frame(rows: list[dict]) -> pl.DataFrame: + base = { + "change_pct": 0.01, "amount": 1e8, "close": 10.0, "ma20": 9.5, + "signal_limit_up": True, "signal_limit_down": False, + "signal_broken_limit_up": False, + } + return pl.DataFrame([{**base, **r} for r in rows]) + + +class TestLadderMetrics: + def test_prev_consecutive_and_counts(self): + d1, d2, d3 = _days(3) + df = _frame([ + {"symbol": "A", "date": d1, "consecutive_limit_ups": 1}, + {"symbol": "A", "date": d2, "consecutive_limit_ups": 2}, + {"symbol": "A", "date": d3, "consecutive_limit_ups": 0}, + {"symbol": "B", "date": d1, "consecutive_limit_ups": 1}, + {"symbol": "B", "date": d2, "consecutive_limit_ups": 0}, + {"symbol": "C", "date": d2, "consecutive_limit_ups": 3}, + ]) + out = with_prev_consecutive(df) + prev = {r["symbol"] + str(r["date"]): r["_prev_consec"] for r in out.iter_rows(named=True)} + assert prev["A" + str(d1)] is None + assert prev["A" + str(d2)] == 1 + assert prev["B" + str(d2)] == 1 + + agg = _aggregate_daily(df) + by_date = {r["date"]: r for r in agg.iter_rows(named=True)} + assert by_date[d1]["first_board"] == 2 + assert by_date[d1]["ge2_count"] == 0 + # d2: A=2板(晋级), B=断板(昨1今0), C=3板(新面孔); pool=2(A,B) <10 → promo null + assert by_date[d2]["ge2_count"] == 2 + assert by_date[d2]["promo_pool"] == 2 + assert by_date[d2]["promo_rate"] is None + assert by_date[d2]["ladder_completeness"] == 1.0 # 档位 {2,3}, height=3 → 2/2 + assert by_date[d3]["first_board"] == 0 + + def test_promo_rate_with_sufficient_pool(self): + d1, d2 = _days(2) + rows = [] + for i in range(12): + rows.append({"symbol": f"S{i}", "date": d1, "consecutive_limit_ups": 1}) + rows.append({ + "symbol": f"S{i}", "date": d2, + "consecutive_limit_ups": 2 if i < 4 else 0, # 4 晋级, 8 断板 + }) + agg = _aggregate_daily(_frame(rows)) + d2_row = {r["date"]: r for r in agg.iter_rows(named=True)}[d2] + assert d2_row["promo_pool"] == 12 + assert d2_row["promo_rate"] == round(4 / 12, 4) + + def test_promo_small_pool_is_null(self): + row = {"promo_pool": 5, "promo_ok": 5, "max_consecutive": 3, "rungs_filled": 2} + assert finalize_ladder_row(row)["promo_rate"] is None + row2 = {"promo_pool": 20, "promo_ok": 8, "max_consecutive": 3, "rungs_filled": 2} + assert finalize_ladder_row(row2)["promo_rate"] == 0.4 + + def test_completeness_gap(self): + # height=5, 只有 2板和5板 → rungs {2,5} → 2/4 + row = {"max_consecutive": 5, "rungs_filled": 2, "promo_pool": 0, "promo_ok": 0} + assert finalize_ladder_row(row)["ladder_completeness"] == 0.5 + + +def _series(specs: list[dict]) -> pl.DataFrame: + """specs: [{days, height, first, ge2, promo, seal, state}] 逐段展开成日序。""" + rows = [] + for sp in specs: + for _ in range(sp["days"]): + rows.append({ + "date": None, # 由调用方生成后填充 + "max_consecutive": sp["height"], + "first_board": sp["first"], + "ge2_count": sp["ge2"], + "promo_rate": sp["promo"], + "seal_rate": sp["seal"], + **({"state": sp.get("state", "range")} if sp.get("state") else {}), + }) + dates = _days(len(rows)) + for r, d in zip(rows, dates, strict=True): + r["date"] = d + return pl.DataFrame(rows) + + +class TestClassifyPhaseSeries: + def _labels(self, specs): + df = _series(specs) + return classify_phase_series(df)["phase"].to_list() + + def test_climax_and_persistence(self): + labels = self._labels([ + {"days": 6, "height": 5, "first": 40, "ge2": 12, "promo": 0.2, "seal": 0.6, "state": "strong"}, + {"days": 5, "height": 12, "first": 300, "ge2": CLIMAX_GE2 + 40, "promo": 0.5, "seal": 0.7, "state": "strong"}, + {"days": 8, "height": 5, "first": 40, "ge2": 12, "promo": 0.2, "seal": 0.6, "state": "range"}, + ]) + assert PHASE_CLIMAX in labels + assert labels[-1] == PHASE_REPAIR + # EMA 平滑 + 2 日确认: 阶段切换总数有限, 不出现 1 日翻转噪声 + switches = sum(1 for a, b in pairwise(labels) if a != b) + assert switches <= 4 + + def test_rally_positive_state(self): + labels = self._labels([ + {"days": 8, "height": 8, "first": 60, "ge2": 18, "promo": 0.3, "seal": 0.7, "state": "strong"}, + ]) + assert PHASE_RALLY in labels + + def test_rally_vetoed_in_weak_state(self): + labels = self._labels([ + {"days": 8, "height": 8, "first": 60, "ge2": 18, "promo": 0.3, "seal": 0.7, "state": "weak"}, + ]) + assert PHASE_RALLY not in labels + assert all(p == PHASE_REPAIR for p in labels) + + def test_ice(self): + labels = self._labels([ + {"days": 6, "height": ICE_HEIGHT - 1, "first": ICE_FIRST_BOARD - 1, + "ge2": ICE_GE2 - 1, "promo": 0.1, "seal": 0.5, "state": "range"}, + ]) + assert PHASE_ICE in labels + + def test_ebb_from_high(self): + labels = self._labels([ + {"days": 8, "height": 9, "first": 60, "ge2": 20, "promo": 0.3, "seal": 0.7, "state": "strong"}, + {"days": 6, "height": 6, "first": 30, "ge2": 6, "promo": EBB_PROMO - 0.03, "seal": 0.5, "state": "range"}, + ]) + assert PHASE_EBB in labels + + def test_ignite_expansion(self): + labels = self._labels([ + {"days": 6, "height": 4, "first": 25, "ge2": 5, "promo": 0.15, "seal": 0.6, "state": "range"}, + {"days": 8, "height": 6, "first": 50, "ge2": 14, "promo": 0.24, "seal": 0.68, "state": "lean_strong"}, + ]) + assert PHASE_IGNITE in labels + + def test_promo_null_leading_days_ffilled(self): + specs = [ + {"days": 4, "height": 5, "first": 40, "ge2": 10, "promo": None, "seal": 0.6, "state": "range"}, + {"days": 4, "height": 6, "first": 50, "ge2": 14, "promo": 0.25, "seal": 0.68, "state": "strong"}, + ] + df = _series(specs) + out = classify_phase_series(df) + assert out["phase"].null_count() == 0 + + +class TestRefreshPhaseLabels: + def test_roundtrip_writes_phase_keeps_state(self, tmp_path): + specs = [ + {"days": 10, "height": 8, "first": 60, "ge2": 18, "promo": 0.3, "seal": 0.7, "state": "strong"}, + ] + df = _series(specs) + regime_path(tmp_path).parent.mkdir(parents=True) + df.write_parquet(regime_path(tmp_path)) + n = refresh_phase_labels(tmp_path) + assert n == 10 + out = pl.read_parquet(regime_path(tmp_path)) + assert "phase" in out.columns + assert PHASE_RALLY in set(out["phase"].to_list()) + assert set(out["state"].to_list()) == {"strong"} + + def test_missing_columns_returns_zero(self, tmp_path): + regime_path(tmp_path).parent.mkdir(parents=True) + pl.DataFrame({"date": _days(3), "state": ["range"] * 3}).write_parquet(regime_path(tmp_path)) + assert refresh_phase_labels(tmp_path) == 0 diff --git a/backend/tests/test_matrix_field_columns_expansion.py b/backend/tests/test_matrix_field_columns_expansion.py new file mode 100644 index 0000000..ae41ebe --- /dev/null +++ b/backend/tests/test_matrix_field_columns_expansion.py @@ -0,0 +1,65 @@ +"""每日信号路径的字段依赖展开回归测试。 + +挖掘发布的 FactorRankResearchMatrixStrategy 把因子权重放在类级 SCORING, +META["scoring"] 为空。每日信号/实时矩阵路径通过 _matrix_field_columns 决定 +矩阵字段, 必须展开 required_fields_for_params 的虚拟因子依赖 +(limit_up_count_* -> consecutive_limit_ups), 否则 compute_signals 抛 +"MarketDataMatrix missing field: consecutive_limit_ups"。 +""" +from __future__ import annotations + +import types +from datetime import date, timedelta + +import polars as pl + +from app.backtest.matrix import build_market_data_matrix +from app.strategy.builtin.factor_rank_research import FactorRankResearchMatrixStrategy +from app.strategy.engine import StrategyEngine + + +def _mined_limit_up_strategy() -> types.SimpleNamespace: + strategy = FactorRankResearchMatrixStrategy( + {"amplitude": 2.0, "limit_up_count_60d": 1.0}, + {"amplitude": "low", "limit_up_count_60d": "low"}, + ) + return types.SimpleNamespace( + matrix_strategy=strategy, + basic_filter=None, + meta={"scoring": {}}, + ) + + +def test_matrix_field_columns_expand_parameter_scoring_dependencies(): + strategy = _mined_limit_up_strategy() + fields = StrategyEngine._matrix_field_columns(strategy, None, {}) + assert "consecutive_limit_ups" in fields + assert "amplitude" in fields + + +def test_mined_limit_up_strategy_signals_build_from_panel_fields(): + rows = [] + start = date(2024, 1, 1) + for offset in range(80): + close = 10.0 + offset * 0.04 + rows.append({ + "symbol": "000001.SZ", + "date": start + timedelta(days=offset), + "open": close - 0.05, + "high": close + 0.15, + "low": close - 0.15, + "close": close, + "volume": 1000.0 + offset * 5.0, + "amount": 100000.0, + "amplitude": 1.5, + "turnover_rate": 5.0, + "consecutive_limit_ups": (offset % 17) + 1 if offset % 17 == 0 else 0, + }) + panel = pl.DataFrame(rows) + strategy = _mined_limit_up_strategy() + market = build_market_data_matrix( + panel, + field_columns=StrategyEngine._matrix_field_columns(strategy, None, {}), + ) + signals = strategy.matrix_strategy.compute_signals(market, {}) + assert signals.shape == market.shape diff --git a/backend/tests/test_matrix_prewarm_owner.py b/backend/tests/test_matrix_prewarm_owner.py new file mode 100644 index 0000000..256f73c --- /dev/null +++ b/backend/tests/test_matrix_prewarm_owner.py @@ -0,0 +1,75 @@ +from __future__ import annotations + +import threading +import time + +from app.services.heavy_job_limiter import HeavyJobCancelledError, HeavyJobLimiter +from app.services.matrix_prewarm_owner import MatrixCachePrewarmOwner + + +def test_owner_deduplicates_running_work_and_reuses_after_completion() -> None: + owner = MatrixCachePrewarmOwner() + started = threading.Event() + release = threading.Event() + calls: list[str] = [] + + def target() -> None: + calls.append("run") + started.set() + assert release.wait(2) + + assert owner.schedule(target) + assert started.wait(1) + assert not owner.schedule(target) + + release.set() + deadline = time.monotonic() + 1 + while time.monotonic() < deadline and len(calls) < 2: + if owner.schedule(lambda: calls.append("run")): + break + time.sleep(0.005) + + assert calls == ["run", "run"] + assert owner.shutdown(timeout=1) + + +def test_shutdown_cancels_limiter_wait_and_rejects_new_work() -> None: + limiter = HeavyJobLimiter(capacity=2, cancel_poll_interval=0.005) + owner = MatrixCachePrewarmOwner() + waiting = threading.Event() + cancelled = threading.Event() + assert limiter.acquire("mining", timeout=0) + + def target() -> None: + waiting.set() + try: + with limiter.slot("normal", cancel_event=owner.cancel_event): + raise AssertionError("cancelled prewarm must not acquire capacity") + except HeavyJobCancelledError: + cancelled.set() + + assert owner.schedule(target) + assert waiting.wait(1) + assert owner.shutdown(timeout=1) + assert cancelled.is_set() + assert not owner.schedule(target) + limiter.release("mining") + + +def test_shutdown_join_is_bounded_for_uncooperative_target() -> None: + owner = MatrixCachePrewarmOwner() + release = threading.Event() + started = threading.Event() + + def target() -> None: + started.set() + release.wait(2) + + assert owner.schedule(target) + assert started.wait(1) + before = time.monotonic() + assert not owner.shutdown(timeout=0.02) + assert time.monotonic() - before < 0.2 + + release.set() + assert owner.shutdown(timeout=1) diff --git a/backend/tests/test_mining_api.py b/backend/tests/test_mining_api.py new file mode 100644 index 0000000..bd49847 --- /dev/null +++ b/backend/tests/test_mining_api.py @@ -0,0 +1,606 @@ +from __future__ import annotations + +import json +from datetime import date, timedelta +from pathlib import Path +from types import SimpleNamespace +from urllib.parse import quote + +import polars as pl +import pytest +from fastapi import FastAPI +from fastapi.testclient import TestClient + +from app.api.mining import router +from app.backtest.mining import compute_candidate_signature +from app.services.mining_jobs import MiningRunStore +from app.strategy.engine import StrategyEngine + +_FACTOR_DEFINITION = { + "kind": "factor_rank", + "factor_names": ["turnover_rate"], + "scoring": {"turnover_rate": 1.0}, + "directions": {"turnover_rate": "high"}, +} +_FACTOR_SIGNATURE = compute_candidate_signature(_FACTOR_DEFINITION) + + +class _Repo: + def __init__(self, data_dir) -> None: + self.store = SimpleNamespace(data_dir=data_dir) + + @staticmethod + def get_matrix_data_generation(asset_type="stock"): + return f"generation-{asset_type}" + + @staticmethod + def latest_enriched_date(asset_type="stock"): + del asset_type + return date(2026, 1, 9) + + @staticmethod + def get_instruments_asset(asset_type): + del asset_type + return pl.DataFrame({"symbol": ["000001.SZ"], "name": ["测试"]}) + + +class _Manager: + def __init__(self, data_dir) -> None: + self.store = MiningRunStore(data_dir) + + def start(self, request, fingerprint, force=False, source="manual", run_id=None): + del force + manifest = self.store.create(request, fingerprint, run_id=run_id) + self.store.append_event( + manifest["run_id"], + "queued", + {"status": "queued", "source": source}, + ) + return manifest + + def cancel(self, run_id): + manifest = self.store.get(run_id) + if manifest is None: + raise KeyError(run_id) + if manifest["status"] == "queued": + manifest = self.store.transition_status(run_id, "cancelled") + self.store.append_event(run_id, "cancelled", {"status": "cancelled"}) + return manifest + + +def _write_enriched_dates( + data_dir: Path, + count: int, + *, + asset_type: str = "stock", + first: date = date(2020, 1, 1), +) -> list[date]: + dirname = "kline_etf_enriched" if asset_type == "etf" else "kline_daily_enriched" + values = [first + timedelta(days=index) for index in range(count)] + for value in values: + partition = data_dir / dirname / f"date={value.isoformat()}" + partition.mkdir(parents=True, exist_ok=True) + (partition / "part.parquet").touch() + return values + + +def _client(tmp_path): + _write_enriched_dates(tmp_path, 219, first=date(2022, 8, 15)) + app = FastAPI() + app.include_router(router) + app.state.repo = _Repo(tmp_path) + app.state.mining_manager = _Manager(tmp_path) + app.state.strategy_engine = SimpleNamespace() + return TestClient(app), app.state.mining_manager.store + + +def _successful_run(store: MiningRunStore, run_id: str = "result-run"): + manifest = store.create( + { + "factor_names": ["turnover_rate"], + "strategy_ids": [], + "asset_type": "stock", + "budget_profile": "exploratory", + "correlation_threshold": 0.75, + }, + {"generation": "test"}, + run_id=run_id, + ) + store.append_event(run_id, "queued", {"status": "queued", "source": "manual"}) + store.transition_status(run_id, "running") + store.append_event(run_id, "running", {"status": "running"}) + + frames = { + "factors": pl.DataFrame({ + "factor_name": ["turnover_rate"], + "label": ["换手率"], + "direction": [1], + "score": [1.2], + "ic_mean": [0.1], + "ir": [0.8], + "coverage": [1.0], + "turnover": [0.2], + "spread_return": [None], + "spread_sharpe": [None], + "selected": [True], + "excluded_reason": [None], + }), + "correlation": pl.DataFrame({ + "factor_x": ["turnover_rate"], + "factor_y": ["turnover_rate"], + "rho": [1.0], + "pair_count": [3], + }), + "candidates": pl.DataFrame({ + "signature": [_FACTOR_SIGNATURE], + "name": ["因子组合 · 换手率"], + "kind": ["factor_combination"], + "factor_names_json": ['["turnover_rate"]'], + "strategy_id": [None], + "definition_json": [json.dumps(_FACTOR_DEFINITION, sort_keys=True)], + "regime_state": ["overall"], + "score": [0.9], + "oos_return": [0.08], + "oos_sharpe": [0.9], + "oos_max_drawdown": [-0.12], + "oos_positive_fold_ratio": [1.0], + "oos_n_trades": [70], + "confidence": ["standard"], + "valid_folds": [3], + "skipped_folds": [0], + "promoted_candidate_id": [None], + "published_strategy_id": [None], + }, schema_overrides={ + "strategy_id": pl.String, + "promoted_candidate_id": pl.String, + "published_strategy_id": pl.String, + }), + "folds": pl.DataFrame({ + "candidate_signature": [_FACTOR_SIGNATURE, _FACTOR_SIGNATURE], + "fold": [0, 0], + "label": ["OOS 1", "OOS 1"], + "regime_state": ["overall", "strong"], + "n_dates": [3, 2], + "train_start": ["2025-01-01", "2025-01-01"], + "train_end": ["2025-12-31", "2025-12-31"], + "test_start": ["2026-01-05", "2026-01-05"], + "test_end": ["2026-01-09", "2026-01-09"], + "selected_factors_json": ['["turnover_rate"]'] * 2, + "total_return": [0.08, 0.1], + "sharpe": [0.9, 1.1], + "max_drawdown": [-0.12, -0.08], + "n_trades": [70, 40], + "skipped": [False, False], + "reason": [None, None], + }), + } + for name, frame in frames.items(): + frame.write_parquet(store.artifact_path(run_id, name)) + store.register_artifact(run_id, name) + store.write_summary(run_id, { + "status": "succeeded", + "factor_count": 1, + "selected_factor_count": 1, + "candidate_count": 1, + "valid_fold_count": 1, + "skipped_fold_count": 0, + "confidence": "low", + "budget_exhausted": False, + "elapsed_ms": 123.4, + "data_as_of": "2026-01-09", + "methodology_version": "factor_v2", + "algorithm_version": "mining-v1", + "panel_scans": 1, + "matrix_bytes": 4096, + "phase_ms": {"panel": 1.0, "total": 123.4}, + "worker": {"peak_rss_bytes": 1000, "serialized_result_bytes": 2000}, + }) + store.transition_status(run_id, "succeeded") + store.append_event(run_id, "succeeded", {"status": "succeeded"}) + return manifest + + +def test_start_is_strict_and_projects_server_signature(tmp_path): + client, store = _client(tmp_path) + payload = { + "factor_names": ["turnover_rate"], + "budget_profile": "exploratory", + "force": False, + } + + response = client.post("/api/backtest/mining/runs", json=payload) + + assert response.status_code == 200 + body = response.json() + assert body["status"] == "queued" + assert body["signature"] == store.get(body["run_id"])["run_signature"] + assert body["request"]["factor_names"] == ["turnover_rate"] + assert "force" not in body["request"] + assert body["source"] == "manual" + assert client.post( + "/api/backtest/mining/runs", + json={**payload, "matching": "close_t"}, + ).status_code == 422 + assert client.post( + "/api/backtest/mining/runs", + json={"factor_names": ["unknown_factor"]}, + ).status_code == 422 + + +def test_start_accepts_iso_dates_and_persists_json_safe_request(tmp_path): + client, store = _client(tmp_path) + + response = client.post( + "/api/backtest/mining/runs", + json={ + "factor_names": ["turnover_rate"], + "budget_profile": "exploratory", + "start": "2022-08-15", + "end": "2026-08-15", + }, + ) + + assert response.status_code == 200 + run_id = response.json()["run_id"] + manifest = store.get(run_id) + assert manifest is not None + assert manifest["request"]["start"] == "2022-08-15" + assert manifest["request"]["end"] == "2026-08-15" + assert client.post( + "/api/backtest/mining/runs", + json={ + "factor_names": ["turnover_rate"], + "start": "2022/08/15", + }, + ).status_code == 422 + + +@pytest.mark.parametrize( + ("profile", "required_bars"), + [("exploratory", 219), ("balanced", 786), ("strict", 1164)], +) +def test_availability_enforces_exact_profile_boundaries( + tmp_path, + profile, + required_bars, +): + client, _store = _client(tmp_path) + dates = _write_enriched_dates( + tmp_path, + required_bars, + first=date(2015, 1, 1), + ) + + eligible = client.get( + "/api/backtest/mining/availability", + params={ + "asset_type": "stock", + "budget_profile": profile, + "start": dates[0].isoformat(), + "end": dates[-1].isoformat(), + }, + ) + insufficient = client.get( + "/api/backtest/mining/availability", + params={ + "asset_type": "stock", + "budget_profile": profile, + "start": dates[1].isoformat(), + "end": dates[-1].isoformat(), + }, + ) + + assert eligible.status_code == 200 + assert eligible.json() == { + "asset_type": "stock", + "budget_profile": profile, + "trading_bars": required_bars, + "required_bars": required_bars, + "outer_folds": 1 if profile == "exploratory" else 3, + "required_outer_folds": 1 if profile == "exploratory" else 3, + "eligible": True, + "available_start": dates[0].isoformat(), + "available_end": "2023-03-21", + "effective_start": dates[0].isoformat(), + "effective_end": dates[-1].isoformat(), + "suggested_start": dates[0].isoformat(), + } + assert insufficient.status_code == 200 + assert insufficient.json()["trading_bars"] == required_bars - 1 + assert insufficient.json()["eligible"] is False + assert insufficient.json()["suggested_start"] == dates[0].isoformat() + + +def test_start_rejects_balanced_625_bar_range_before_creating_run(tmp_path): + client, store = _client(tmp_path) + dates = _write_enriched_dates(tmp_path, 625, first=date(2024, 1, 15)) + + response = client.post( + "/api/backtest/mining/runs", + json={ + "factor_names": ["turnover_rate"], + "budget_profile": "balanced", + "start": dates[0].isoformat(), + "end": dates[-1].isoformat(), + "force": True, + }, + ) + + assert response.status_code == 400 + assert response.json()["detail"] == ( + "balanced mining requires at least 786 enriched trading bars for 3 outer " + "folds; effective range 2024-01-15 to 2025-09-30 has 625" + ) + assert store.list_runs() == [] + + +def test_availability_uses_asset_specific_valid_partitions(tmp_path): + client, _store = _client(tmp_path) + etf_dates = _write_enriched_dates( + tmp_path, + 219, + asset_type="etf", + first=date(2024, 1, 1), + ) + malformed = tmp_path / "kline_etf_enriched" / "date=not-a-date" + malformed.mkdir(parents=True) + (malformed / "part.parquet").touch() + (tmp_path / "kline_etf_enriched" / "date=2023-12-31").mkdir(parents=True) + + response = client.get( + "/api/backtest/mining/availability", + params={ + "asset_type": "etf", + "budget_profile": "exploratory", + "start": etf_dates[0].isoformat(), + "end": etf_dates[-1].isoformat(), + }, + ) + + assert response.status_code == 200 + assert response.json()["trading_bars"] == 219 + assert response.json()["eligible"] is True + + +def test_result_reconstructs_artifacts_without_exposing_definition(tmp_path): + client, store = _client(tmp_path) + _successful_run(store) + + response = client.get("/api/backtest/mining/runs/result-run/result") + + assert response.status_code == 200 + body = response.json() + assert body["summary"]["peak_rss_bytes"] == 1000 + assert body["correlation"]["matrix"] == [[1.0]] + assert body["candidates"][0]["factor_names"] == ["turnover_rate"] + assert "definition_json" not in body["candidates"][0] + assert body["candidates"][0]["folds"][0]["selected_factors"] == ["turnover_rate"] + assert body["candidates"][0]["gate"] == {"qualified": True, "reasons": []} + assert body["request_summary"] == { + "asset_type": "stock", + "budget_profile": "exploratory", + "start": None, + "end": None, + "factor_count": 1, + "strategy_count": 0, + "commission_pct": None, + "stamp_tax_pct": None, + "slippage_bps": None, + "correlation_threshold": 0.75, + } + regimes = {row["state"]: row for row in body["regimes"]} + assert regimes["overall"]["n_dates"] == 3 + assert regimes["strong"]["n_dates"] == 2 + assert regimes["range"]["total_return"] is None + assert body["telemetry"]["panel_scans"] == 1 + + +def test_result_marks_legacy_fold_rows_without_evaluation_kind(tmp_path): + client, store = _client(tmp_path) + _successful_run(store) + + response = client.get("/api/backtest/mining/runs/result-run/result") + + assert response.status_code == 200 + fold = response.json()["candidates"][0]["folds"][0] + assert fold["evaluation_kind"] is None + + +def test_publish_endpoint_rejects_candidate_below_evidence_gate(tmp_path): + client, store = _client(tmp_path) + _successful_run(store) + path = store.artifact_path("result-run", "candidates") + pl.read_parquet(path).with_columns( + pl.lit("low").alias("confidence"), + ).write_parquet(path) + + response = client.post( + f"/api/backtest/mining/runs/result-run/candidates/" + f"{quote(_FACTOR_SIGNATURE, safe='')}/publish", + ) + + assert response.status_code == 400 + assert "exploratory results can only be saved" in response.json()["detail"] + + +def test_promote_endpoint_uses_persisted_definition_only(tmp_path): + client, store = _client(tmp_path) + _successful_run(store) + + response = client.post( + f"/api/backtest/mining/runs/result-run/candidates/" + f"{quote(_FACTOR_SIGNATURE, safe='')}/promote" + ) + + assert response.status_code == 200 + body = response.json() + assert body["status"] == "pending" + assert body["config"]["origin_run_id"] == "result-run" + assert body["config"]["candidate_signature"] == _FACTOR_SIGNATURE + assert body["config"]["factor_names"] == ["turnover_rate"] + assert "definition_json" not in body + persisted = pl.read_parquet(store.artifact_path("result-run", "candidates")) + assert persisted["promoted_candidate_id"][0] == body["id"] + + +def test_publish_endpoint_uses_persisted_definition_and_invalidates_runtime( + tmp_path, +) -> None: + client, store = _client(tmp_path) + _successful_run(store) + builtin_dir = Path(__file__).resolve().parents[1] / "app" / "strategy" / "builtin" + custom_dir = tmp_path / "strategies" / "custom" + engine = StrategyEngine(strategy_dirs=[builtin_dir, custom_dir]) + invalidations: list[str] = [] + client.app.state.strategy_engine = engine + client.app.state.monitor_engine = SimpleNamespace( + invalidate_strategy_state=lambda: invalidations.append("monitor") + ) + + response = client.post( + f"/api/backtest/mining/runs/result-run/candidates/" + f"{quote(_FACTOR_SIGNATURE, safe='')}/publish", + json={ + "strategy_id": "caller-selected", + "scoring": {"rsi_14": 999.0}, + }, + ) + + assert response.status_code == 200 + strategy_id = response.json()["strategy_id"] + strategy = engine.get(strategy_id) + assert strategy.meta["origin_run_id"] == "result-run" + assert strategy.meta["candidate_signature"] == _FACTOR_SIGNATURE + assert strategy.matrix_strategy._scoring == {"turnover_rate": 1.0} + assert strategy.matrix_strategy._directions == {"turnover_rate": "high"} + assert invalidations == ["monitor"] + persisted = pl.read_parquet(store.artifact_path("result-run", "candidates")) + assert persisted["published_strategy_id"][0] == strategy_id + + +def test_result_fails_closed_when_artifact_is_missing(tmp_path): + client, store = _client(tmp_path) + _successful_run(store) + store.artifact_path("result-run", "folds").unlink() + + response = client.get("/api/backtest/mining/runs/result-run/result") + + assert response.status_code == 500 + assert response.json()["detail"] == "mining result artifacts are unavailable" + + +def test_sse_maps_failed_event_and_honors_last_event_id(tmp_path): + client, store = _client(tmp_path) + store.create( + {"factor_names": ["turnover_rate"]}, + {"generation": "test"}, + run_id="failed-run", + ) + queued = store.append_event( + "failed-run", "queued", {"status": "queued", "source": "manual"} + ) + store.transition_status("failed-run", "failed", error="worker failed") + failed = store.append_event( + "failed-run", "error", {"status": "failed", "message": "worker failed"} + ) + + response = client.get( + "/api/backtest/mining/runs/failed-run/events", + headers={"Last-Event-ID": str(queued["id"])}, + ) + + assert response.status_code == 200 + assert f"id: {failed['id']}" in response.text + assert "event: failed" in response.text + assert "event: error" not in response.text + assert "worker failed" in response.text + + +def test_sse_recovers_progress_snapshot_when_history_is_truncated(tmp_path): + client, store = _client(tmp_path) + store.create( + {"factor_names": ["turnover_rate"]}, + {"generation": "test"}, + run_id="truncated-run", + ) + store.write_summary( + "truncated-run", + {"progress": {"phase": "search", "done": 7, "total": 10}}, + ) + for index in range(260): + store.append_event( + "truncated-run", + "progress", + {"phase": "search", "done": index, "total": 260}, + ) + store.transition_status("truncated-run", "failed", error="worker failed") + store.append_event( + "truncated-run", + "error", + {"status": "failed", "message": "worker failed"}, + ) + + response = client.get("/api/backtest/mining/runs/truncated-run/events") + + assert response.status_code == 200 + assert '"done": 7' in response.text + assert "event: failed" in response.text + + +def test_start_rejects_incompatible_strategy_before_creating_run(tmp_path): + client, store = _client(tmp_path) + client.app.state.strategy_engine = SimpleNamespace( + get=lambda _strategy_id: SimpleNamespace( + meta={ + "research_only": True, + "asset_types": ["stock"], + "timeframes": ["1d"], + }, + execution_backend="matrix_native", + ) + ) + + response = client.post( + "/api/backtest/mining/runs", + json={ + "factor_names": ["turnover_rate"], + "strategy_ids": ["factor_rank_research"], + "budget_profile": "exploratory", + }, + ) + + assert response.status_code == 400 + assert store.list_runs() == [] + + +def test_config_patch_merges_current_values(tmp_path, monkeypatch): + client, _store = _client(tmp_path) + current = { + "mining_schedule_enabled": False, + "mining_schedule_weekday": 4, + "mining_budget_profile": "balanced", + } + saved = [] + monkeypatch.setattr( + "app.api.mining.preferences.get_mining_schedule", + lambda: dict(current), + ) + + def set_schedule(enabled, weekday, profile): + saved.append((enabled, weekday, profile)) + return { + "mining_schedule_enabled": enabled, + "mining_schedule_weekday": weekday, + "mining_budget_profile": profile, + } + + monkeypatch.setattr("app.api.mining.preferences.set_mining_schedule", set_schedule) + + response = client.patch( + "/api/backtest/mining/config", + json={"mining_schedule_enabled": True}, + ) + + assert response.status_code == 200 + assert saved == [(True, 4, "balanced")] + assert client.patch("/api/backtest/mining/config", json={}).status_code == 400 diff --git a/backend/tests/test_mining_candidates.py b/backend/tests/test_mining_candidates.py new file mode 100644 index 0000000..78c2d28 --- /dev/null +++ b/backend/tests/test_mining_candidates.py @@ -0,0 +1,679 @@ +from __future__ import annotations + +import json +from concurrent.futures import ThreadPoolExecutor +from pathlib import Path +from types import SimpleNamespace + +import polars as pl +import pytest + +from app.backtest.candidates import CandidateStore, CandidateValidationError +from app.backtest.mining import compute_candidate_signature +from app.services.mining_candidates import ( + MiningCandidateService, + _published_strategy_id, +) +from app.services.mining_jobs import MiningRunStore +from app.strategy import config as strategy_config +from app.strategy.engine import StrategyEngine + + +class _StrategyEngine: + def __init__(self) -> None: + self.strategies = { + "existing_daily": SimpleNamespace( + id="existing_daily", + execution_backend="matrix_native", + meta={ + "id": "existing_daily", + "research_only": False, + "timeframes": ["1d"], + "asset_types": ["stock"], + }, + ) + } + + def get(self, strategy_id: str): + if strategy_id not in self.strategies: + raise KeyError(strategy_id) + return self.strategies[strategy_id] + + def list_strategies(self): + return [strategy.meta for strategy in self.strategies.values()] + + +def _factor_definition() -> dict: + return { + "kind": "factor_rank", + "factor_names": ["turnover_rate", "rsi_14"], + "scoring": {"turnover_rate": 1.0, "rsi_14": 2.0}, + "directions": {"turnover_rate": "high", "rsi_14": "low"}, + } + + +def _create_run( + tmp_path, + *, + definition: dict | None = None, + status: str = "succeeded", + run_id: str = "mining-run", +) -> tuple[MiningRunStore, str, str]: + definition = definition or _factor_definition() + signature = compute_candidate_signature(definition) + store = MiningRunStore(tmp_path) + store.create( + { + "factor_names": ["turnover_rate", "rsi_14"], + "strategy_ids": ["existing_daily", "ma_golden_cross"], + "asset_type": "stock", + "start": "2025-01-01", + "end": "2026-01-09", + "budget_profile": "exploratory", + "commission_pct": 0.0002, + "stamp_tax_pct": 0.0005, + "slippage_bps": 5.0, + }, + {"generation": "test"}, + run_id=run_id, + ) + frame = pl.DataFrame({ + "signature": [signature], + "name": ["因子组合候选"], + "kind": [ + "existing_strategy" + if definition["kind"] == "existing_strategy" + else "factor_combination" + ], + "factor_names_json": [json.dumps(definition.get("factor_names", []))], + "strategy_id": [definition.get("strategy_id")], + "definition_json": [json.dumps(definition, sort_keys=True)], + "regime_state": ["overall"], + "score": [0.9], + "oos_return": [0.08], + "oos_sharpe": [0.9], + "oos_max_drawdown": [-0.12], + "oos_positive_fold_ratio": [1.0], + "oos_n_trades": [70], + "confidence": ["standard"], + "valid_folds": [3], + "skipped_folds": [0], + "promoted_candidate_id": [None], + "published_strategy_id": [None], + }, schema_overrides={ + "strategy_id": pl.String, + "promoted_candidate_id": pl.String, + "published_strategy_id": pl.String, + }) + frame.write_parquet(store.artifact_path(run_id, "candidates")) + store.register_artifact(run_id, "candidates") + store.write_summary(run_id, { + "data_as_of": "2026-01-09", + "algorithm_version": "mining-v1", + "methodology_version": "factor_v2", + }) + if status != "queued": + store.transition_status(run_id, "running") + store.transition_status(run_id, status) + return store, run_id, signature + + +def _service(tmp_path, store: MiningRunStore) -> MiningCandidateService: + return MiningCandidateService( + tmp_path, + store, + CandidateStore(tmp_path), + _StrategyEngine(), + strategy_cache_invalidator=lambda _data_dir: None, + ) + + +def _real_service( + tmp_path, + store: MiningRunStore, + *, + cache_invalidator=None, + monitor_invalidator=None, +) -> tuple[MiningCandidateService, StrategyEngine]: + builtin_dir = Path(__file__).resolve().parents[1] / "app" / "strategy" / "builtin" + custom_dir = tmp_path / "strategies" / "custom" + engine = StrategyEngine(strategy_dirs=[builtin_dir, custom_dir]) + service = MiningCandidateService( + tmp_path, + store, + CandidateStore(tmp_path), + engine, + strategy_cache_invalidator=cache_invalidator or (lambda _data_dir: None), + monitor_state_invalidator=monitor_invalidator, + ) + return service, engine + + +def test_promote_rereads_artifact_and_repairs_backlink_idempotently(tmp_path) -> None: + store, run_id, signature = _create_run(tmp_path) + service = _service(tmp_path, store) + + first = service.promote(run_id, signature) + second = service.promote(run_id, signature) + + assert second == first + assert first["kind"] == "strategy" + assert first["source_id"].startswith("mined_factor_") + assert first["status"] == "pending" + assert first["config"]["origin_run_id"] == run_id + assert first["config"]["candidate_signature"] == signature + assert first["config"]["factor_names"] == ["turnover_rate", "rsi_14"] + assert first["config"]["directions"] == ["high", "low"] + assert first["config"]["weights"] == [1.0, 2.0] + assert first["metrics"]["oos_sharpe"] == pytest.approx(0.9) + persisted = pl.read_parquet(store.artifact_path(run_id, "candidates")).row(0, named=True) + assert persisted["promoted_candidate_id"] == first["id"] + assert len(CandidateStore(tmp_path).list()) == 1 + + +def test_promote_repairs_backlink_after_partial_failure(tmp_path, monkeypatch) -> None: + store, run_id, signature = _create_run(tmp_path) + service = _service(tmp_path, store) + original = service._write_backlink + calls = 0 + + def fail_once(*args, **kwargs): + nonlocal calls + calls += 1 + if calls == 1: + raise RuntimeError("injected backlink failure") + return original(*args, **kwargs) + + monkeypatch.setattr(service, "_write_backlink", fail_once) + with pytest.raises(RuntimeError, match="injected"): + service.promote(run_id, signature) + + created = CandidateStore(tmp_path).list() + assert len(created) == 1 + recovered = service.promote(run_id, signature) + assert recovered["id"] == created[0]["id"] + persisted = pl.read_parquet(store.artifact_path(run_id, "candidates")).row(0, named=True) + assert persisted["promoted_candidate_id"] == created[0]["id"] + assert len(CandidateStore(tmp_path).list()) == 1 + + +def test_promote_rejects_non_successful_run(tmp_path) -> None: + store, run_id, signature = _create_run(tmp_path, status="queued") + + with pytest.raises(ValueError, match="successful"): + _service(tmp_path, store).promote(run_id, signature) + + assert CandidateStore(tmp_path).list() == [] + + +def test_promote_rejects_tampered_definition_before_candidate_write(tmp_path) -> None: + store, run_id, signature = _create_run(tmp_path) + path = store.artifact_path(run_id, "candidates") + frame = pl.read_parquet(path).with_columns( + pl.lit(json.dumps({ + "kind": "factor_rank", + "factor_names": ["turnover_rate"], + "scoring": {"turnover_rate": 1.0}, + "directions": {"turnover_rate": "high"}, + })).alias("definition_json") + ) + frame.write_parquet(path) + + with pytest.raises(ValueError, match=r"signature|definition"): + _service(tmp_path, store).promote(run_id, signature) + + assert CandidateStore(tmp_path).list() == [] + + +def test_promote_rejects_factor_not_selected_in_origin_request(tmp_path) -> None: + definition = { + "kind": "factor_rank", + "factor_names": ["momentum_20d"], + "scoring": {"momentum_20d": 1.0}, + "directions": {"momentum_20d": "high"}, + } + store, run_id, signature = _create_run(tmp_path, definition=definition) + + with pytest.raises(ValueError, match="origin request"): + _service(tmp_path, store).promote(run_id, signature) + + +def test_promote_existing_strategy_revalidates_current_engine_contract(tmp_path) -> None: + definition = {"kind": "existing_strategy", "strategy_id": "existing_daily"} + store, run_id, signature = _create_run(tmp_path, definition=definition) + + promoted = _service(tmp_path, store).promote(run_id, signature) + + assert promoted["source_id"] == "existing_daily" + assert promoted["config"]["strategy_id"] == "existing_daily" + + +def test_publish_existing_strategy_returns_verified_id_and_repairs_backlink(tmp_path) -> None: + definition = {"kind": "existing_strategy", "strategy_id": "existing_daily"} + store, run_id, signature = _create_run(tmp_path, definition=definition) + service = _service(tmp_path, store) + + first = service.publish(run_id, signature) + second = service.publish(run_id, signature) + with pytest.raises(TypeError): + service.publish(run_id, signature, "existing_daily") + + assert first == second == {"ok": True, "strategy_id": "existing_daily"} + persisted = pl.read_parquet(store.artifact_path(run_id, "candidates")).row(0, named=True) + assert persisted["published_strategy_id"] == "existing_daily" + assert CandidateStore(tmp_path).list() == [] + + +def test_promote_requires_unique_artifact_signature(tmp_path) -> None: + store, run_id, signature = _create_run(tmp_path) + path = store.artifact_path(run_id, "candidates") + frame = pl.read_parquet(path) + pl.concat([frame, frame]).write_parquet(path) + + with pytest.raises(ValueError, match="duplicate"): + _service(tmp_path, store).promote(run_id, signature) + + +def test_promote_concurrent_calls_create_one_authoritative_candidate(tmp_path) -> None: + store, run_id, signature = _create_run(tmp_path) + service = _service(tmp_path, store) + + with ThreadPoolExecutor(max_workers=8) as executor: + items = list(executor.map( + lambda _index: service.promote(run_id, signature), + range(16), + )) + + assert len({item["id"] for item in items}) == 1 + assert len(CandidateStore(tmp_path).list()) == 1 + + +def test_promote_rejects_artifact_conflicting_with_existing_store_record( + tmp_path, +) -> None: + store, run_id, signature = _create_run(tmp_path) + service = _service(tmp_path, store) + original = service.promote(run_id, signature) + path = store.artifact_path(run_id, "candidates") + pl.read_parquet(path).with_columns( + pl.lit(1.1).alias("oos_sharpe"), + pl.lit(None, dtype=pl.String).alias("promoted_candidate_id"), + ).write_parquet(path) + + with pytest.raises(CandidateValidationError, match="冲突"): + service.promote(run_id, signature) + + persisted = pl.read_parquet(path).row(0, named=True) + assert persisted["promoted_candidate_id"] is None + stored = CandidateStore(tmp_path).list()[0] + assert stored == original + assert stored["metrics"]["oos_sharpe"] == pytest.approx(0.9) + + +@pytest.mark.parametrize( + ("definition", "message"), + [ + ( + { + "kind": "factor_rank", + "factor_names": ["turnover_rate"], + "scoring": {"turnover_rate": 0.0}, + "directions": {"turnover_rate": "high"}, + }, + "positive", + ), + ( + { + "kind": "factor_rank", + "factor_names": ["turnover_rate"], + "scoring": {"turnover_rate": float("inf")}, + "directions": {"turnover_rate": "high"}, + }, + "finite", + ), + ( + { + "kind": "factor_rank", + "factor_names": ["turnover_rate"], + "scoring": {"turnover_rate": 1.0}, + "directions": {"turnover_rate": "sideways"}, + }, + "directions", + ), + ( + { + "kind": "factor_rank", + "factor_names": ["not_a_factor"], + "scoring": {"not_a_factor": 1.0}, + "directions": {"not_a_factor": "high"}, + }, + "unknown factors", + ), + ( + { + "kind": "factor_rank", + "factor_names": [ + "momentum_5d", + "momentum_10d", + "momentum_20d", + "momentum_30d", + "momentum_60d", + ], + "scoring": { + "momentum_5d": 1.0, + "momentum_10d": 1.0, + "momentum_20d": 1.0, + "momentum_30d": 1.0, + "momentum_60d": 1.0, + }, + "directions": { + "momentum_5d": "high", + "momentum_10d": "high", + "momentum_20d": "high", + "momentum_30d": "high", + "momentum_60d": "high", + }, + }, + "1 to 4", + ), + ], +) +def test_promote_rejects_invalid_factor_contract(tmp_path, definition, message) -> None: + store, run_id, signature = _create_run(tmp_path) + path = store.artifact_path(run_id, "candidates") + frame = pl.read_parquet(path).with_columns( + pl.lit(signature).alias("signature"), + pl.lit(json.dumps(definition)).alias("definition_json"), + pl.lit(json.dumps(definition["factor_names"])).alias("factor_names_json"), + ) + frame.write_parquet(path) + + with pytest.raises(ValueError, match=message): + _service(tmp_path, store).promote(run_id, signature) + + +@pytest.mark.parametrize("column", ["oos_sharpe", "oos_return", "score"]) +def test_promote_rejects_nonfinite_artifact_values(tmp_path, column) -> None: + store, run_id, signature = _create_run(tmp_path) + path = store.artifact_path(run_id, "candidates") + pl.read_parquet(path).with_columns(pl.lit(float("nan")).alias(column)).write_parquet(path) + + with pytest.raises(ValueError, match="finite"): + _service(tmp_path, store).promote(run_id, signature) + + +def test_promote_rejects_corrupt_or_missing_schema_artifact(tmp_path) -> None: + store, run_id, signature = _create_run(tmp_path) + path = store.artifact_path(run_id, "candidates") + path.write_bytes(b"not parquet") + with pytest.raises(RuntimeError, match="failed to read"): + _service(tmp_path, store).promote(run_id, signature) + + path.unlink() + pl.DataFrame({"signature": [signature]}).write_parquet(path) + with pytest.raises(ValueError, match="schema"): + _service(tmp_path, store).promote(run_id, signature) + + +def test_publish_factor_discovers_public_strategy_and_repairs_runtime_state(tmp_path) -> None: + store, run_id, signature = _create_run(tmp_path) + invalidations: list[object] = [] + service, engine = _real_service( + tmp_path, + store, + cache_invalidator=lambda data_dir: invalidations.append(data_dir), + monitor_invalidator=lambda: invalidations.append("monitor"), + ) + strategy_config.save_override( + tmp_path, + "factor_rank_research", + {"params": {"entry_score": 99.0}}, + ) + + result = service.publish(run_id, signature) + repeated = service.publish(run_id, signature) + + assert repeated == result + strategy = engine.get(result["strategy_id"]) + assert strategy.source == "custom" + assert strategy.execution_backend == "matrix_native" + assert strategy.meta["origin_run_id"] == run_id + assert strategy.meta["candidate_signature"] == signature + assert strategy.meta["research_only"] is False + assert strategy.meta["asset_types"] == ["stock"] + assert strategy.matrix_strategy._scoring == {"turnover_rate": 1.0, "rsi_14": 2.0} + assert strategy.matrix_strategy._directions == { + "turnover_rate": "high", + "rsi_14": "low", + } + assert result["strategy_id"] in { + meta["id"] for meta in engine.list_strategies() + } + assert strategy_config.load_override( + tmp_path, "factor_rank_research" + ) == {"params": {"entry_score": 99.0}} + assert not (tmp_path / "user_data" / "strategy_overrides" / f"{result['strategy_id']}.json").exists() + persisted = pl.read_parquet(store.artifact_path(run_id, "candidates")).row(0, named=True) + assert persisted["published_strategy_id"] == result["strategy_id"] + assert invalidations == [tmp_path, "monitor", tmp_path, "monitor"] + + +def test_publish_factor_repairs_backlink_after_source_was_verified( + tmp_path, + monkeypatch, +) -> None: + store, run_id, signature = _create_run(tmp_path) + service, _engine = _real_service(tmp_path, store) + original = service._write_backlink + calls = 0 + + def fail_once(*args, **kwargs): + nonlocal calls + calls += 1 + if calls == 1: + raise RuntimeError("injected publication backlink failure") + return original(*args, **kwargs) + + monkeypatch.setattr(service, "_write_backlink", fail_once) + with pytest.raises(RuntimeError, match="injected publication"): + service.publish(run_id, signature) + + result = service.publish(run_id, signature) + strategy_path = tmp_path / "strategies" / "custom" / f"{result['strategy_id']}.py" + assert strategy_path.is_file() + persisted = pl.read_parquet(store.artifact_path(run_id, "candidates")).row(0, named=True) + assert persisted["published_strategy_id"] == result["strategy_id"] + + +def test_publish_factor_uses_server_run_scoped_id_and_refuses_collision(tmp_path) -> None: + store, run_id, signature = _create_run(tmp_path) + service, _engine = _real_service(tmp_path, store) + expected_id = _published_strategy_id(run_id, signature) + + with pytest.raises(TypeError): + service.publish(run_id, signature, "mined_factor_caller_selected") + + target = tmp_path / "strategies" / "custom" / f"{expected_id}.py" + target.parent.mkdir(parents=True, exist_ok=True) + target.write_text("user owned", encoding="utf-8") + with pytest.raises(ValueError, match="collision"): + service.publish(run_id, signature) + assert target.read_text(encoding="utf-8") == "user owned" + + +def test_publish_factor_same_signature_in_different_runs_has_independent_ids( + tmp_path, +) -> None: + store, first_run_id, signature = _create_run(tmp_path, run_id="mining-run-one") + _other_store, second_run_id, second_signature = _create_run( + tmp_path, + run_id="mining-run-two", + ) + service, engine = _real_service(tmp_path, store) + + first = service.publish(first_run_id, signature) + second = service.publish(second_run_id, second_signature) + + assert signature == second_signature + assert first["strategy_id"] == _published_strategy_id(first_run_id, signature) + assert second["strategy_id"] == _published_strategy_id( + second_run_id, + second_signature, + ) + assert first["strategy_id"] != second["strategy_id"] + assert engine.has(first["strategy_id"]) + assert engine.has(second["strategy_id"]) + + +def test_publish_factor_rejects_inconsistent_backlink(tmp_path) -> None: + store, run_id, signature = _create_run(tmp_path) + path = store.artifact_path(run_id, "candidates") + pl.read_parquet(path).with_columns( + pl.lit("mined_factor_other").alias("published_strategy_id") + ).write_parquet(path) + service, engine = _real_service(tmp_path, store) + + with pytest.raises(ValueError, match="backlink is inconsistent"): + service.publish(run_id, signature) + + expected_id = _published_strategy_id(run_id, signature) + assert not engine.has(expected_id) + assert not (tmp_path / "strategies" / "custom" / f"{expected_id}.py").exists() + + +def test_publish_factor_rolls_back_file_and_skips_invalidations_on_reload_failure( + tmp_path, + monkeypatch, +) -> None: + store, run_id, signature = _create_run(tmp_path) + invalidations: list[str] = [] + service, engine = _real_service( + tmp_path, + store, + cache_invalidator=lambda _data_dir: invalidations.append("cache"), + monitor_invalidator=lambda: invalidations.append("monitor"), + ) + real_reload = engine.reload + calls = 0 + + def fail_once() -> None: + nonlocal calls + calls += 1 + if calls == 1: + raise ValueError("injected reload failure") + real_reload() + + monkeypatch.setattr(engine, "reload", fail_once) + expected_id = _published_strategy_id(run_id, signature) + with pytest.raises(RuntimeError, match="injected reload failure"): + service.publish(run_id, signature) + + assert not (tmp_path / "strategies" / "custom" / f"{expected_id}.py").exists() + assert not engine.has(expected_id) + assert invalidations == [] + persisted = pl.read_parquet(store.artifact_path(run_id, "candidates")).row(0, named=True) + assert persisted["published_strategy_id"] is None + + +def test_publish_factor_rolls_back_on_runtime_invalidation_failure(tmp_path) -> None: + store, run_id, signature = _create_run(tmp_path) + invalidations: list[str] = [] + + def fail_monitor() -> None: + invalidations.append("monitor") + raise ValueError("injected monitor invalidation failure") + + service, engine = _real_service( + tmp_path, + store, + cache_invalidator=lambda _data_dir: invalidations.append("cache"), + monitor_invalidator=fail_monitor, + ) + expected_id = _published_strategy_id(run_id, signature) + + with pytest.raises(RuntimeError, match="injected monitor invalidation failure"): + service.publish(run_id, signature) + + assert invalidations == ["cache", "monitor"] + assert not (tmp_path / "strategies" / "custom" / f"{expected_id}.py").exists() + assert not engine.has(expected_id) + persisted = pl.read_parquet(store.artifact_path(run_id, "candidates")).row(0, named=True) + assert persisted["published_strategy_id"] is None + + +def test_publish_existing_does_not_reload_or_invalidate(tmp_path) -> None: + definition = {"kind": "existing_strategy", "strategy_id": "ma_golden_cross"} + store, run_id, signature = _create_run(tmp_path, definition=definition) + invalidations: list[str] = [] + service, engine = _real_service( + tmp_path, + store, + cache_invalidator=lambda _data_dir: invalidations.append("cache"), + monitor_invalidator=lambda: invalidations.append("monitor"), + ) + original = engine.get("ma_golden_cross") + + result = service.publish(run_id, signature) + + assert result == {"ok": True, "strategy_id": "ma_golden_cross"} + assert engine.get("ma_golden_cross") is original + assert invalidations == [] + +def _rewrite_candidate_metric( + store: MiningRunStore, + run_id: str, + column: str, + value, +) -> None: + path = store.artifact_path(run_id, "candidates") + frame = pl.read_parquet(path) + frame.with_columns( + pl.lit(value, dtype=frame.schema[column]).alias(column), + ).write_parquet(path) + + +def test_publish_rejects_low_confidence_exploratory_candidate(tmp_path) -> None: + store, run_id, signature = _create_run(tmp_path) + _rewrite_candidate_metric(store, run_id, "confidence", "low") + service = _service(tmp_path, store) + + with pytest.raises(ValueError, match="exploratory results can only be saved"): + service.publish(run_id, signature) + + +def test_publish_rejects_candidate_below_evidence_gate(tmp_path) -> None: + store, run_id, signature = _create_run(tmp_path) + _rewrite_candidate_metric(store, run_id, "oos_sharpe", 0.2) + service = _service(tmp_path, store) + + with pytest.raises(ValueError, match=r"OOS Sharpe of at least 0.5"): + service.publish(run_id, signature) + + +def test_publish_rejects_candidate_with_insufficient_folds(tmp_path) -> None: + store, run_id, signature = _create_run(tmp_path) + _rewrite_candidate_metric(store, run_id, "valid_folds", 1) + service = _service(tmp_path, store) + + with pytest.raises(ValueError, match="at least 2 valid outer folds"): + service.publish(run_id, signature) + + +def test_publish_rejects_candidate_missing_required_metrics(tmp_path) -> None: + store, run_id, signature = _create_run(tmp_path) + _rewrite_candidate_metric(store, run_id, "oos_n_trades", None) + service = _service(tmp_path, store) + + with pytest.raises(ValueError, match="does not meet the promotion gate"): + service.publish(run_id, signature) + + +def test_promote_still_allowed_for_gated_candidates(tmp_path) -> None: + store, run_id, signature = _create_run(tmp_path) + _rewrite_candidate_metric(store, run_id, "confidence", "low") + _rewrite_candidate_metric(store, run_id, "oos_sharpe", 0.1) + service = _service(tmp_path, store) + + result = service.promote(run_id, signature) + + assert result["status"] == "pending" diff --git a/backend/tests/test_mining_jobs.py b/backend/tests/test_mining_jobs.py new file mode 100644 index 0000000..9263bff --- /dev/null +++ b/backend/tests/test_mining_jobs.py @@ -0,0 +1,263 @@ +from __future__ import annotations + +import json +import threading +from datetime import date +from pathlib import Path + +import pytest + +from app.services.mining_jobs import ( + ACTIVE_RUN_STATUSES, + MAX_EVENT_PAYLOAD_BYTES, + SUCCESS_RUN_STATUSES, + InvalidMiningStatusTransitionError, + MiningRunStore, + MiningRunValidationError, + canonicalize_request, + compute_run_signature, +) + + +def _store(tmp_path: Path) -> MiningRunStore: + return MiningRunStore(tmp_path) + + +def test_create_and_atomic_summary_reads(tmp_path: Path) -> None: + store = _store(tmp_path) + manifest = store.create( + {"symbols": ["000001.SZ"], "start": date(2025, 1, 1)}, + {"daily_generation": 7}, + run_id="run_atomic", + ) + run_dir = tmp_path / "research" / "mining" / "runs" / "run_atomic" + + assert manifest["status"] == "queued" + assert manifest["request"]["start"] == "2025-01-01" + assert json.loads((run_dir / "manifest.json").read_text(encoding="utf-8")) == manifest + assert store.read_summary("run_atomic") == {} + + failures: list[Exception] = [] + stop = threading.Event() + + def reader() -> None: + while not stop.is_set(): + try: + value = store.read_summary("run_atomic") + assert isinstance(value.get("iteration"), int) + except Exception as exc: + failures.append(exc) + return + + store.write_summary("run_atomic", {"iteration": -1}) + thread = threading.Thread(target=reader) + thread.start() + for iteration in range(50): + store.write_summary("run_atomic", {"iteration": iteration}) + stop.set() + thread.join(timeout=1) + + assert failures == [] + assert store.read_summary("run_atomic") == {"iteration": 49} + assert not list(run_dir.glob("*.tmp")) + assert not list(run_dir.glob(".*.tmp")) + + +def test_signature_is_canonical_and_covers_request_dimensions() -> None: + first = { + "symbols": ["000001.SZ", "600000.SH"], + "window": {"start": "2025-01-01", "end": "2025-06-30"}, + "budget": 100, + } + reordered = { + "budget": 100, + "window": {"end": "2025-06-30", "start": "2025-01-01"}, + "symbols": ["000001.SZ", "600000.SH"], + } + + assert canonicalize_request(first) == canonicalize_request(reordered) + signature = compute_run_signature(first, {"daily": "v7", "enriched": "v2"}) + assert signature == compute_run_signature(reordered, {"enriched": "v2", "daily": "v7"}) + assert len(signature) == 64 + assert signature != compute_run_signature( + {**first, "budget": 101}, {"daily": "v7", "enriched": "v2"} + ) + assert signature != compute_run_signature(first, {"daily": "v8", "enriched": "v2"}) + assert signature != compute_run_signature( + {**first, "symbols": list(reversed(first["symbols"]))}, + {"daily": "v7", "enriched": "v2"}, + ) + + +def test_events_are_bounded_monotonic_and_support_after_id(tmp_path: Path) -> None: + store = _store(tmp_path) + store.create({}, "data-v1", run_id="event_run") + + for index in range(300): + event = store.append_event("event_run", "progress", {"step": index}) + assert event["id"] == index + 1 + + retained = store.read_events("event_run") + assert len(retained) == 256 + assert [event["id"] for event in retained] == list(range(45, 301)) + assert [event["id"] for event in store.read_events("event_run", after_id=295)] == list( + range(296, 301) + ) + + with pytest.raises(MiningRunValidationError, match="payload exceeds"): + store.append_event( + "event_run", + "result", + {"large_result": "x" * (MAX_EVENT_PAYLOAD_BYTES + 1)}, + ) + + +def test_status_transitions_summary_and_artifact_registration(tmp_path: Path) -> None: + store = _store(tmp_path) + store.create({"budget": 10}, "data-v1", run_id="lifecycle") + + running = store.transition_status("lifecycle", "running") + assert running["started_at"] is not None + cancelling = store.transition_status("lifecycle", "cancelling") + assert cancelling["cancellation_requested_at"] is not None + cancelled = store.transition_status("lifecycle", "cancelled") + assert cancelled["finished_at"] is not None + + with pytest.raises(InvalidMiningStatusTransitionError): + store.transition_status("lifecycle", "running") + + store.create({}, "data-v1", run_id="artifacts") + artifact = store.artifact_path("artifacts", "factors") + manifest = store.register_artifact("artifacts", "factors", artifact) + assert artifact.name == "factors.parquet" + assert manifest["artifacts"] == {"factors": "factors.parquet"} + assert store.write_summary("artifacts", {"candidate_count": 3}) == {"candidate_count": 3} + + with pytest.raises(MiningRunValidationError, match="escapes"): + store.register_artifact("artifacts", "folds", "../other/folds.parquet") + + +def test_historical_manifest_defaults_and_startup_recovery(tmp_path: Path) -> None: + store = _store(tmp_path) + runs_root = store.runs_root + old_dir = runs_root / "old_running" + old_dir.mkdir() + (old_dir / "manifest.json").write_text( + json.dumps( + { + "run_id": "old_running", + "status": "running", + "request": {"budget": 10}, + "data_fingerprint": "v1", + "created_at": "2025-01-01T00:00:00+00:00", + "artifacts": { + "factors": "factors.parquet", + "folds": "../escaped/folds.parquet", + "unknown": "unknown.parquet", + }, + } + ), + encoding="utf-8", + ) + store.create({}, "v1", run_id="was_cancelling") + store.transition_status("was_cancelling", "cancelling") + store.create({}, "v1", run_id="still_queued") + + historical = store.get("old_running") + assert historical is not None + assert historical["artifacts"] == {"factors": "factors.parquet"} + assert historical["finished_at"] is None + assert historical["run_signature"] == compute_run_signature({"budget": 10}, "v1") + + assert store.recover_interrupted() == 3 + assert store.get("old_running")["status"] == "interrupted" # type: ignore[index] + assert store.get("was_cancelling")["status"] == "interrupted" # type: ignore[index] + assert store.get("still_queued")["status"] == "interrupted" # type: ignore[index] + assert store.recover_interrupted() == 0 + + +def test_run_ids_and_paths_are_restricted_to_runs_root(tmp_path: Path) -> None: + store = _store(tmp_path) + + for run_id in ["", ".", "..", "../escape", "a/b", "a\\b", "with space"]: + with pytest.raises(MiningRunValidationError): + store.get(run_id) + + with pytest.raises(MiningRunValidationError): + store.create({}, "v1", run_id="../escape") + with pytest.raises(MiningRunValidationError): + store.create({}, "v1", run_id="") + assert not (tmp_path / "research" / "mining" / "escape").exists() + + +def test_find_by_signature_can_filter_active_and_success_runs(tmp_path: Path) -> None: + store = _store(tmp_path) + queued = store.create({"budget": 1}, "v1", run_id="queued_match") + store.create({"budget": 1}, "v1", run_id="failed_match") + store.transition_status("failed_match", "failed", error="failed") + store.create({"budget": 2}, "v1", run_id="success_match") + store.transition_status("success_match", "running") + store.transition_status("success_match", "succeeded_with_budget_exhausted") + + assert ( + store.find_by_signature(queued["run_signature"], statuses=ACTIVE_RUN_STATUSES)["run_id"] + == "queued_match" + ) # type: ignore[index] + assert store.find_by_signature(queued["run_signature"], statuses=SUCCESS_RUN_STATUSES) is None + success = store.get("success_match") + assert success is not None + assert ( + store.find_by_signature(success["run_signature"], statuses=SUCCESS_RUN_STATUSES)["run_id"] + == "success_match" + ) # type: ignore[index] + + +def test_list_runs_is_bounded_sorted_and_filters_status(tmp_path: Path) -> None: + store = _store(tmp_path) + store.create({"budget": 1}, "v1", run_id="first") + store.create({"budget": 2}, "v1", run_id="second") + store.transition_status("second", "running") + store.transition_status("second", "succeeded") + + runs = store.list_runs(limit=1) + assert [run["run_id"] for run in runs] == ["second"] + assert [run["run_id"] for run in store.list_runs(statuses={"queued"})] == ["first"] + + with pytest.raises(MiningRunValidationError, match="limit"): + store.list_runs(limit=0) + with pytest.raises(MiningRunValidationError, match="statuses"): + store.list_runs(statuses={"unknown"}) # type: ignore[arg-type] + + +def test_concurrent_event_appends_have_unique_contiguous_ids(tmp_path: Path) -> None: + first_store = _store(tmp_path) + second_store = _store(tmp_path) + first_store.create({}, "v1", run_id="concurrent") + barrier = threading.Barrier(5) + failures: list[Exception] = [] + + def append_batch(store: MiningRunStore, worker: int) -> None: + try: + barrier.wait() + for index in range(30): + store.append_event("concurrent", "progress", {"worker": worker, "index": index}) + except Exception as exc: + failures.append(exc) + + threads = [ + threading.Thread( + target=append_batch, + args=(first_store if worker % 2 == 0 else second_store, worker), + ) + for worker in range(4) + ] + for thread in threads: + thread.start() + barrier.wait() + for thread in threads: + thread.join(timeout=3) + + assert all(not thread.is_alive() for thread in threads) + assert failures == [] + ids = [event["id"] for event in first_store.read_events("concurrent")] + assert ids == list(range(1, 121)) diff --git a/backend/tests/test_mining_manager.py b/backend/tests/test_mining_manager.py new file mode 100644 index 0000000..dbaa6f0 --- /dev/null +++ b/backend/tests/test_mining_manager.py @@ -0,0 +1,352 @@ +from __future__ import annotations + +import threading +import time +from collections.abc import Callable +from pathlib import Path +from typing import Any + +import pytest + +import app.services.mining_manager as mining_manager_module +from app.services.heavy_job_limiter import HeavyJobLimiter +from app.services.mining_manager import MiningJobManager + + +def _task_factory(kind: str, data_dir: Path, payload: dict[str, Any]) -> dict[str, Any]: + return { + "kind": kind, + "data_dir": str(data_dir), + "payload": payload, + } + + +def _wait_for_status( + manager: MiningJobManager, + run_id: str, + status: str, + *, + timeout: float = 2.0, +) -> dict[str, Any]: + deadline = time.monotonic() + timeout + while time.monotonic() < deadline: + manifest = manager.store.get(run_id) + assert manifest is not None + if manifest["status"] == status: + return manifest + time.sleep(0.005) + pytest.fail(f"run {run_id} did not reach {status}") + + +@pytest.fixture +def isolated_limiter(monkeypatch: pytest.MonkeyPatch) -> HeavyJobLimiter: + limiter = HeavyJobLimiter(capacity=2, cancel_poll_interval=0.005) + monkeypatch.setattr(mining_manager_module, "shared_heavy_job_limiter", limiter) + return limiter + + +@pytest.fixture +def make_manager( + tmp_path: Path, + isolated_limiter: HeavyJobLimiter, +): + managers: list[MiningJobManager] = [] + + def factory( + runner: Callable[ + [dict[str, Any], Callable[[dict[str, Any]], None], threading.Event], + dict[str, Any], + ], + ) -> MiningJobManager: + manager = MiningJobManager( + tmp_path, + worker_runner=runner, + task_factory=_task_factory, + ) + managers.append(manager) + return manager + + yield factory + + for manager in managers: + manager.shutdown() + assert isolated_limiter.in_use == 0 + + +def test_start_records_states_events_progress_and_worker_payload( + make_manager, tmp_path: Path +) -> None: + progress_recorded = threading.Event() + finish = threading.Event() + tasks: list[dict[str, Any]] = [] + progress = {"phase": "screen", "done": 1, "total": 2} + result = {"status": "succeeded", "candidate_count": 3, "elapsed_ms": 12.5} + + def runner(task, progress_cb, cancel_event): + tasks.append(task) + progress_cb(progress) + progress_recorded.set() + assert finish.wait(2) + assert not cancel_event.is_set() + return result + + manager = make_manager(runner) + request = {"factor_names": ["momentum"], "budget_profile": "balanced"} + created = manager.start(request, {"daily": "v1"}, source="scheduled") + run_id = created["run_id"] + + assert created["status"] == "queued" + assert progress_recorded.wait(1) + assert manager.store.read_summary(run_id) == {"progress": progress} + assert [event["type"] for event in manager.store.read_events(run_id)] == [ + "queued", + "running", + "progress", + ] + assert manager.store.read_events(run_id)[0]["payload"]["source"] == "scheduled" + assert tasks == [ + { + "kind": "mining", + "data_dir": str(tmp_path.resolve()), + "payload": { + "run_id": run_id, + "request": request, + "data_fingerprint": {"daily": "v1"}, + "source": "scheduled", + }, + } + ] + + finish.set() + terminal = _wait_for_status(manager, run_id, "succeeded") + assert terminal["started_at"] is not None + assert terminal["finished_at"] is not None + assert manager.store.read_summary(run_id) == result + assert [event["type"] for event in manager.store.read_events(run_id)] == [ + "queued", + "running", + "progress", + "succeeded", + ] + + +def test_start_accepts_valid_persistent_run_id(make_manager) -> None: + def runner(task, progress_cb, cancel_event): + return {"status": "succeeded"} + + manager = make_manager(runner) + created = manager.start( + {"factor_names": ["value"]}, + "data-v1", + run_id="weekly_claim_2026_33", + ) + + assert created["run_id"] == "weekly_claim_2026_33" + terminal = _wait_for_status(manager, created["run_id"], "succeeded") + assert terminal["run_id"] == "weekly_claim_2026_33" + + +def test_duplicate_persistent_run_id_reuses_existing_without_starting_runner( + make_manager, +) -> None: + runner_called = threading.Event() + + def runner(task, progress_cb, cancel_event): + runner_called.set() + return {"status": "succeeded"} + + manager = make_manager(runner) + existing = manager.store.create( + {"factor_names": ["value"]}, + "data-v1", + run_id="weekly_claim_2026_33", + ) + + reused = manager.start( + {"factor_names": ["value"]}, + "data-v1", + run_id="weekly_claim_2026_33", + ) + + assert reused == existing + assert not runner_called.wait(0.05) + + +def test_start_reuses_active_and_success_but_force_creates_new_run(make_manager) -> None: + started = threading.Event() + release = threading.Event() + tasks: list[dict[str, Any]] = [] + + def runner(task, progress_cb, cancel_event): + tasks.append(task) + started.set() + assert release.wait(2) + return {"status": "succeeded", "candidate_count": 1} + + manager = make_manager(runner) + request = {"factor_names": ["value"]} + first = manager.start(request, "data-v1") + assert started.wait(1) + + active_reuse = manager.start(request, "data-v1") + assert active_reuse["run_id"] == first["run_id"] + assert len(tasks) == 1 + + release.set() + _wait_for_status(manager, first["run_id"], "succeeded") + success_reuse = manager.start(request, "data-v1") + assert success_reuse["run_id"] == first["run_id"] + assert len(tasks) == 1 + + forced = manager.start(request, "data-v1", force=True) + assert forced["run_id"] != first["run_id"] + _wait_for_status(manager, forced["run_id"], "succeeded") + assert len(tasks) == 2 + assert len(manager.store.list_runs()) == 2 + + +def test_cancel_while_waiting_for_capacity_never_calls_runner( + make_manager, + isolated_limiter: HeavyJobLimiter, +) -> None: + runner_called = threading.Event() + + def runner(task, progress_cb, cancel_event): + runner_called.set() + return {"status": "succeeded"} + + assert isolated_limiter.acquire("mining", timeout=0) + try: + manager = make_manager(runner) + created = manager.start({"factor_names": ["quality"]}, "data-v1") + run_id = created["run_id"] + assert manager.store.get(run_id)["status"] == "queued" # type: ignore[index] + + cancelling = manager.cancel(run_id) + assert cancelling["status"] == "cancelling" + _wait_for_status(manager, run_id, "cancelled") + assert not runner_called.is_set() + assert [event["type"] for event in manager.store.read_events(run_id)] == [ + "queued", + "cancelling", + "cancelled", + ] + finally: + isolated_limiter.release("mining") + + +def test_cancel_running_job_wins_over_worker_success(make_manager) -> None: + runner_started = threading.Event() + + def runner(task, progress_cb, cancel_event): + runner_started.set() + assert cancel_event.wait(2) + return {"status": "succeeded", "candidate_count": 9} + + manager = make_manager(runner) + created = manager.start({"factor_names": ["growth"]}, "data-v1") + run_id = created["run_id"] + assert runner_started.wait(1) + + cancelling = manager.cancel(run_id) + assert cancelling["status"] == "cancelling" + _wait_for_status(manager, run_id, "cancelled") + event_types = [event["type"] for event in manager.store.read_events(run_id)] + assert event_types == ["queued", "running", "cancelling", "cancelled"] + assert manager.store.read_summary(run_id) == {} + + +def test_runner_exception_marks_failed_and_appends_error_event(make_manager) -> None: + def runner(task, progress_cb, cancel_event): + raise RuntimeError("mining exploded") + + manager = make_manager(runner) + created = manager.start({"factor_names": ["size"]}, "data-v1") + run_id = created["run_id"] + + failed = _wait_for_status(manager, run_id, "failed") + assert failed["error"] == "mining exploded" + events = manager.store.read_events(run_id) + assert [event["type"] for event in events] == ["queued", "running", "error"] + assert events[-1]["payload"] == { + "status": "failed", + "message": "mining exploded", + } + + +def test_non_dict_worker_result_is_rejected(make_manager) -> None: + def runner(task, progress_cb, cancel_event): + return ["full", "result"] + + manager = make_manager(runner) + created = manager.start({"factor_names": ["liquidity"]}, "data-v1") + + failed = _wait_for_status(manager, created["run_id"], "failed") + assert failed["error"] == "mining worker result must be a compact dict" + + +def test_budget_exhausted_result_uses_distinct_success_status(make_manager) -> None: + result = { + "status": "succeeded_with_budget_exhausted", + "candidate_count": 2, + "budget_exhausted": True, + } + + def runner(task, progress_cb, cancel_event): + return result + + manager = make_manager(runner) + created = manager.start({"factor_names": ["volatility"]}, "data-v1") + run_id = created["run_id"] + + _wait_for_status(manager, run_id, "succeeded_with_budget_exhausted") + assert manager.store.read_summary(run_id) == result + assert manager.store.read_events(run_id)[-1]["type"] == ("succeeded_with_budget_exhausted") + + +def test_recover_interrupted_delegates_to_store(make_manager) -> None: + def runner(task, progress_cb, cancel_event): + return {"status": "succeeded"} + + manager = make_manager(runner) + manager.store.create({}, "v1", run_id="running_before_restart") + manager.store.transition_status("running_before_restart", "running") + manager.store.create({}, "v1", run_id="cancelling_before_restart") + manager.store.transition_status("cancelling_before_restart", "cancelling") + manager.store.create({}, "v1", run_id="queued_before_restart") + + assert manager.recover_interrupted() == 3 + assert manager.store.get("running_before_restart")["status"] == "interrupted" # type: ignore[index] + assert manager.store.get("cancelling_before_restart")["status"] == "interrupted" # type: ignore[index] + assert manager.store.get("queued_before_restart")["status"] == "interrupted" # type: ignore[index] + + +def test_shutdown_sets_cancel_uses_bounded_join_and_keeps_history( + make_manager, + monkeypatch: pytest.MonkeyPatch, +) -> None: + runner_started = threading.Event() + release_runner = threading.Event() + + def runner(task, progress_cb, cancel_event): + runner_started.set() + assert release_runner.wait(2) + return {"status": "succeeded"} + + monkeypatch.setattr(mining_manager_module, "_SHUTDOWN_JOIN_SECONDS", 0.02) + manager = make_manager(runner) + created = manager.start({"factor_names": ["reversal"]}, "data-v1") + run_id = created["run_id"] + assert runner_started.wait(1) + + started = time.monotonic() + manager.shutdown() + elapsed = time.monotonic() - started + assert elapsed < 0.2 + assert manager.store.get(run_id)["status"] == "cancelling" # type: ignore[index] + + release_runner.set() + _wait_for_status(manager, run_id, "cancelled") + assert manager.store.get(run_id) is not None + with pytest.raises(RuntimeError, match="shut down"): + manager.start({"factor_names": ["new"]}, "data-v1") diff --git a/backend/tests/test_mining_process_lock.py b/backend/tests/test_mining_process_lock.py new file mode 100644 index 0000000..4d15cee --- /dev/null +++ b/backend/tests/test_mining_process_lock.py @@ -0,0 +1,77 @@ +from __future__ import annotations + +import multiprocessing +import os +from pathlib import Path +from queue import Empty + +from app.services.mining_process_lock import ( + MiningProcessLock, + MiningProcessLockError, +) + + +def _acquire_in_spawned_process(data_dir: str, result_queue) -> None: + lock = MiningProcessLock(Path(data_dir)) + try: + lock.acquire() + except MiningProcessLockError as exc: + result_queue.put(("blocked", str(exc))) + return + try: + result_queue.put(("acquired", None)) + finally: + lock.release() + + +def _spawn_lock_attempt(data_dir: Path) -> tuple[str, str | None]: + context = multiprocessing.get_context("spawn") + result_queue = context.Queue() + process = context.Process( + target=_acquire_in_spawned_process, + args=(str(data_dir), result_queue), + ) + process.start() + process.join(timeout=10) + if process.is_alive(): + process.terminate() + process.join(timeout=5) + raise AssertionError("spawned lock process did not exit") + assert process.exitcode == 0 + try: + return result_queue.get(timeout=2) + except Empty as exc: + raise AssertionError("spawned lock process returned no result") from exc + finally: + result_queue.close() + result_queue.join_thread() + + +def test_process_lock_rejects_contention_and_allows_acquire_after_release( + tmp_path, +) -> None: + owner = MiningProcessLock(tmp_path) + owner.acquire() + + blocked, message = _spawn_lock_attempt(tmp_path) + assert blocked == "blocked" + assert message is not None and "already owns mining" in message + + owner.release() + acquired, message = _spawn_lock_attempt(tmp_path) + assert acquired == "acquired" + assert message is None + + +def test_process_lock_handle_is_not_inheritable_and_release_is_idempotent( + tmp_path, +) -> None: + lock = MiningProcessLock(tmp_path) + lock.acquire() + + stream = vars(lock)["_stream"] + assert stream is not None + assert not os.get_inheritable(stream.fileno()) + + lock.release() + lock.release() diff --git a/backend/tests/test_mining_schedule.py b/backend/tests/test_mining_schedule.py new file mode 100644 index 0000000..a661d01 --- /dev/null +++ b/backend/tests/test_mining_schedule.py @@ -0,0 +1,427 @@ +from __future__ import annotations + +from datetime import date, datetime, timedelta +from pathlib import Path +from types import SimpleNamespace +from zoneinfo import ZoneInfo + +import polars as pl +import pytest + +from app.jobs import daily_pipeline +from app.services import mining_schedule, preferences +from app.services.mining_jobs import MiningRunStore + + +class FakeRepo: + def __init__(self, data_dir: Path, *, latest: date = date(2026, 8, 14)) -> None: + self.store = SimpleNamespace(data_dir=data_dir) + self.latest = latest + self.generation = "generation-1" + + def latest_enriched_date(self, asset_type: str = "stock") -> date | None: + assert asset_type == "stock" + return self.latest + + def get_matrix_data_generation(self, asset_type: str = "stock") -> str: + assert asset_type == "stock" + return self.generation + + def get_instruments_asset(self, asset_type: str = "stock") -> pl.DataFrame: + assert asset_type == "stock" + return pl.DataFrame({ + "symbol": ["000001.SZ"], + "name": ["示例"], + "total_shares": [1_000_000.0], + "float_shares": [800_000.0], + }) + + +class FakeManager: + def __init__(self, data_dir: Path) -> None: + self.store = MiningRunStore(data_dir) + self.calls: list[dict] = [] + + def start(self, request, fingerprint, *, force: bool, source: str, run_id: str): + call = { + "request": request, + "fingerprint": fingerprint, + "force": force, + "source": source, + "run_id": run_id, + } + self.calls.append(call) + manifest = self.store.create(request, fingerprint, run_id=run_id) + return {"run_id": manifest["run_id"]} + + +@pytest.fixture +def scheduled_state(tmp_path: Path, monkeypatch): + repo = FakeRepo(tmp_path) + manager = FakeManager(tmp_path) + state = SimpleNamespace(repo=repo, mining_manager=manager, strategy_engine=None) + monkeypatch.setattr( + preferences, + "get_mining_schedule", + lambda: { + "mining_schedule_enabled": True, + "mining_schedule_weekday": 4, + "mining_budget_profile": "balanced", + }, + ) + _write_prerequisites(tmp_path, repo.latest, days=1200) + return state + + +def _friday(week_offset: int = 0) -> datetime: + return datetime(2026, 8, 14, 16, tzinfo=ZoneInfo("Asia/Shanghai")) + timedelta( + weeks=week_offset + ) + + +def _write_prerequisites(data_dir: Path, latest: date, *, days: int) -> None: + enriched = data_dir / "kline_daily_enriched" + trading_dates: list[date] = [] + for offset in range(days): + day = latest - timedelta(days=offset) + if day.weekday() >= 5: + continue + trading_dates.append(day) + partition = enriched / f"date={day.isoformat()}" + partition.mkdir(parents=True, exist_ok=True) + (partition / "part.parquet").write_bytes(b"enriched") + regime = data_dir / "regime_history" / "part.parquet" + regime.parent.mkdir(parents=True, exist_ok=True) + pl.DataFrame({ + "date": sorted(trading_dates), + "state": ["range"] * len(trading_dates), + }).write_parquet(regime) + + +def test_beijing_date_and_iso_week_use_china_timezone(): + utc = ZoneInfo("UTC") + instant = datetime(2026, 8, 13, 16, 30, tzinfo=utc) + + assert mining_schedule.beijing_date(instant) == date(2026, 8, 14) + assert mining_schedule.iso_week(date(2027, 1, 1)) == (2026, 53) + + +def test_fingerprint_retries_generation_change_and_returns_stable_token( + tmp_path, + monkeypatch, +) -> None: + repo = FakeRepo(tmp_path) + state = SimpleNamespace(strategy_engine=None) + generations = iter([ + "generation-1", + "generation-2", + "generation-2", + "generation-2", + ]) + monkeypatch.setattr(repo, "get_matrix_data_generation", lambda _asset: next(generations)) + + fingerprint = mining_schedule.build_data_fingerprint( + repo, + state, + {"asset_type": "stock", "strategy_ids": []}, + ) + + assert fingerprint["generation"] == "generation-2" + + +def test_implementation_metadata_is_recursive_content_based_and_root_independent( + tmp_path, +) -> None: + roots = [tmp_path / "first" / "app", tmp_path / "second" / "app"] + for root in roots: + nested = root / "backtest" + nested.mkdir(parents=True) + (root / "main.py").write_text("VALUE = 1\n", encoding="utf-8") + (nested / "runtime.py").write_text("RESULT = 1\n", encoding="utf-8") + (nested / "ignored.txt").write_text("ignored\n", encoding="utf-8") + + first = mining_schedule._implementation_metadata(roots[0]) + second = mining_schedule._implementation_metadata(roots[1]) + (roots[1] / "backtest" / "runtime.py").write_text("RESULT = 2\n", encoding="utf-8") + changed = mining_schedule._implementation_metadata(roots[1]) + + assert first == second + assert first["file_count"] == 2 + assert str(tmp_path) not in str(first) + assert first["digest"] != changed["digest"] + + +def test_fingerprint_covers_result_implementation_digest( + tmp_path, + monkeypatch, +) -> None: + repo = FakeRepo(tmp_path) + state = SimpleNamespace(strategy_engine=None) + first = mining_schedule.build_data_fingerprint( + repo, + state, + {"asset_type": "stock", "strategy_ids": []}, + ) + monkeypatch.setattr( + mining_schedule, + "_implementation_metadata", + lambda _root: {"file_count": 1, "digest": "changed-runtime"}, + ) + second = mining_schedule.build_data_fingerprint( + repo, + state, + {"asset_type": "stock", "strategy_ids": []}, + ) + + assert first["implementation"] != second["implementation"] + assert first["digest"] != second["digest"] + + +def test_selected_strategy_metadata_changes_with_same_size_source_edit(tmp_path) -> None: + source = tmp_path / "strategies" / "custom" / "demo.py" + source.parent.mkdir(parents=True) + source.write_text("VALUE = 1\n", encoding="utf-8") + strategy = SimpleNamespace(execution_backend="matrix_native", file_path=source) + state = SimpleNamespace( + strategy_engine=SimpleNamespace(get=lambda _strategy_id: strategy) + ) + + first = mining_schedule._selected_strategy_metadata( + state, + ["demo"], + tmp_path, + ) + source.write_text("VALUE = 2\n", encoding="utf-8") + second = mining_schedule._selected_strategy_metadata( + state, + ["demo"], + tmp_path, + ) + + assert first[0]["source"]["size"] == second[0]["source"]["size"] + assert first[0]["source"]["sha256"] != second[0]["source"]["sha256"] + assert first[0]["source_tree"]["digest"] != second[0]["source_tree"]["digest"] + + +def test_fingerprint_rejects_continuously_changing_generation( + tmp_path, + monkeypatch, +) -> None: + repo = FakeRepo(tmp_path) + state = SimpleNamespace(strategy_engine=None) + generations = iter(["a", "b", "c", "d"]) + monkeypatch.setattr(repo, "get_matrix_data_generation", lambda _asset: next(generations)) + + with pytest.raises(ValueError, match="changed"): + mining_schedule.build_data_fingerprint( + repo, + state, + {"asset_type": "stock", "strategy_ids": []}, + ) + + +def test_disabled_and_before_scheduled_weekday_do_not_enqueue( + scheduled_state, + monkeypatch, +): + state = scheduled_state + monkeypatch.setattr( + preferences, + "get_mining_schedule", + lambda: { + "mining_schedule_enabled": False, + "mining_schedule_weekday": 4, + "mining_budget_profile": "balanced", + }, + ) + assert mining_schedule.run_weekly_mining(state, now=_friday())["status"] == "disabled" + + monkeypatch.setattr( + preferences, + "get_mining_schedule", + lambda: { + "mining_schedule_enabled": True, + "mining_schedule_weekday": 4, + "mining_budget_profile": "balanced", + }, + ) + thursday = _friday() - timedelta(days=1) + assert mining_schedule.run_weekly_mining(state, now=thursday)["status"] == "weekday_mismatch" + assert state.mining_manager.calls == [] + + +def test_later_workday_catches_up_once_in_same_iso_week(scheduled_state, monkeypatch): + monkeypatch.setattr( + preferences, + "get_mining_schedule", + lambda: { + "mining_schedule_enabled": True, + "mining_schedule_weekday": 3, + "mining_budget_profile": "balanced", + }, + ) + + first = mining_schedule.run_weekly_mining(scheduled_state, now=_friday()) + second = mining_schedule.run_weekly_mining(scheduled_state, now=_friday()) + + assert first["status"] == "enqueued" + assert second == {"status": "already_claimed", "run_id": first["run_id"]} + assert len(scheduled_state.mining_manager.calls) == 1 + + +def test_same_week_and_fingerprint_enqueue_once(scheduled_state): + first = mining_schedule.run_weekly_mining(scheduled_state, now=_friday()) + second = mining_schedule.run_weekly_mining(scheduled_state, now=_friday()) + + assert first["status"] == "enqueued" + assert second == {"status": "already_claimed", "run_id": first["run_id"]} + assert len(scheduled_state.mining_manager.calls) == 1 + call = scheduled_state.mining_manager.calls[0] + assert call["force"] is False + assert call["source"] == "scheduled" + assert call["run_id"] == first["run_id"] + assert call["run_id"] == call["fingerprint"]["source_claim"] + assert call["request"]["asset_type"] == "stock" + assert call["request"]["symbols"] is None + assert call["request"]["strategy_ids"] == [] + assert call["request"]["require_regime"] is True + assert call["request"]["end"] == "2026-08-14" + assert len(call["request"]["factor_names"]) <= 48 + + +def test_profile_change_cannot_bypass_same_week_claim(scheduled_state, monkeypatch): + first = mining_schedule.run_weekly_mining(scheduled_state, now=_friday()) + scheduled_state.mining_manager.store.transition_status( + first["run_id"], "failed", error="worker failed" + ) + monkeypatch.setattr( + preferences, + "get_mining_schedule", + lambda: { + "mining_schedule_enabled": True, + "mining_schedule_weekday": 4, + "mining_budget_profile": "strict", + }, + ) + + second = mining_schedule.run_weekly_mining(scheduled_state, now=_friday()) + + assert second == {"status": "already_claimed", "run_id": first["run_id"]} + assert len(scheduled_state.mining_manager.calls) == 1 + + +def test_new_week_creates_new_claim_but_same_week_metadata_change_does_not( + scheduled_state, +): + manager = scheduled_state.mining_manager + first = mining_schedule.run_weekly_mining(scheduled_state, now=_friday()) + next_week = mining_schedule.run_weekly_mining(scheduled_state, now=_friday(1)) + + latest_file = ( + scheduled_state.repo.store.data_dir + / "kline_daily_enriched" + / "date=2026-08-14" + / "part.parquet" + ) + latest_file.write_bytes(b"changed-enriched-metadata") + changed = mining_schedule.run_weekly_mining(scheduled_state, now=_friday()) + + assert first["run_id"] != next_week["run_id"] + assert changed == {"status": "already_claimed", "run_id": first["run_id"]} + assert len(manager.calls) == 2 + + +def test_missing_regime_records_visible_skipped_prerequisite(scheduled_state): + regime = scheduled_state.repo.store.data_dir / "regime_history" / "part.parquet" + regime.unlink() + + result = mining_schedule.run_weekly_mining(scheduled_state, now=_friday()) + manifest = scheduled_state.mining_manager.store.get(result["run_id"]) + + assert result["status"] == "skipped_prerequisite" + assert manifest is not None + assert manifest["status"] == "skipped_prerequisite" + assert "regime" in manifest["error"] + assert scheduled_state.mining_manager.calls == [] + + +def test_incomplete_regime_coverage_records_visible_skip(scheduled_state): + regime_path = ( + scheduled_state.repo.store.data_dir + / "regime_history" + / "part.parquet" + ) + history = pl.read_parquet(regime_path).sort("date") + history.filter(pl.col("date") != history["date"][-2]).write_parquet(regime_path) + + result = mining_schedule.run_weekly_mining(scheduled_state, now=_friday()) + manifest = scheduled_state.mining_manager.store.get(result["run_id"]) + + assert result["status"] == "skipped_prerequisite" + assert manifest is not None + assert "T-1" in manifest["error"] + assert scheduled_state.mining_manager.calls == [] + + +def test_early_regime_gap_records_visible_skipped_prerequisite(scheduled_state): + data_dir = scheduled_state.repo.store.data_dir + regime_path = data_dir / "regime_history" / "part.parquet" + history = pl.read_parquet(regime_path).sort("date") + history.slice(1).write_parquet(regime_path) + + result = mining_schedule.run_weekly_mining(scheduled_state, now=_friday()) + manifest = scheduled_state.mining_manager.store.get(result["run_id"]) + + assert result["status"] == "skipped_prerequisite" + assert manifest is not None + assert "T-1" in manifest["error"] + assert scheduled_state.mining_manager.calls == [] + + +def test_insufficient_data_records_visible_skipped_prerequisite(tmp_path, monkeypatch): + repo = FakeRepo(tmp_path) + manager = FakeManager(tmp_path) + state = SimpleNamespace(repo=repo, mining_manager=manager, strategy_engine=None) + monkeypatch.setattr( + preferences, + "get_mining_schedule", + lambda: { + "mining_schedule_enabled": True, + "mining_schedule_weekday": 4, + "mining_budget_profile": "strict", + }, + ) + _write_prerequisites(tmp_path, repo.latest, days=30) + + result = mining_schedule.run_weekly_mining(state, now=_friday()) + manifest = manager.store.get(result["run_id"]) + + assert result["status"] == "skipped_prerequisite" + assert manifest is not None + assert manifest["status"] == "skipped_prerequisite" + assert "insufficient" in manifest["error"] + assert manager.calls == [] + + +def test_pipeline_failure_does_not_trigger_mining(monkeypatch): + mining_calls = [] + monkeypatch.setattr(daily_pipeline, "_run_tracked", lambda *_args: False) + monkeypatch.setattr( + "app.services.mining_schedule.run_weekly_mining", + lambda state: mining_calls.append(state), + ) + + daily_pipeline._scheduled_pipeline_task(lambda: None) + + assert mining_calls == [] + + +def test_enqueue_failure_does_not_escape_successful_pipeline(monkeypatch): + monkeypatch.setattr(daily_pipeline, "_run_tracked", lambda *_args: True) + + def fail_enqueue(_state): + raise RuntimeError("queue unavailable") + + monkeypatch.setattr("app.services.mining_schedule.run_weekly_mining", fail_enqueue) + + daily_pipeline._scheduled_pipeline_task(lambda: None) diff --git a/backend/tests/test_minute_range_api.py b/backend/tests/test_minute_range_api.py index 52a7712..c7c53d3 100644 --- a/backend/tests/test_minute_range_api.py +++ b/backend/tests/test_minute_range_api.py @@ -26,7 +26,13 @@ def _request(repo=None, capset=None): def test_minute_range_returns_latest_sessions_with_previous_closes(): repo = MagicMock() repo.resolve_asset_type.return_value = "stock" - repo.execute_one.return_value = ("浦发银行", 1.0, 1.0) + # _get_stock_info 走 instruments 内存缓存 (不再走 execute_one DuckDB 查询) + repo.get_instruments.return_value = pl.DataFrame({ + "symbol": ["600000.SH"], + "name": ["浦发银行"], + "total_shares": [1.0], + "float_shares": [1.0], + }) repo.get_minute_range.return_value = pl.DataFrame({ "symbol": ["600000.SH"] * 3, "datetime": [ diff --git a/backend/tests/test_override_signature_cache.py b/backend/tests/test_override_signature_cache.py new file mode 100644 index 0000000..a5e9bbc --- /dev/null +++ b/backend/tests/test_override_signature_cache.py @@ -0,0 +1,97 @@ +"""策略 override mtime 签名缓存测试 — 读盘去重, 写入/删除后立即可见, 返回深拷贝。""" +from __future__ import annotations + +import json +import os +from pathlib import Path + +import pytest + +from app.strategy import config as strat_config + + +@pytest.fixture(autouse=True) +def _clean_cache(): + strat_config._override_cache.clear() + strat_config._override_cache_sig.clear() + yield + strat_config._override_cache.clear() + strat_config._override_cache_sig.clear() + + +def _patched_loads(monkeypatch, counter: dict): + real_loads = json.loads + + def _counting(text): + counter["loads"] += 1 + return real_loads(text) + + monkeypatch.setattr(strat_config.json, "loads", _counting) + + +def test_second_load_hits_cache_without_disk_parse(tmp_path, monkeypatch): + strat_config.save_override(tmp_path, "s1", {"params": {"p": 1}}) + counter = {"loads": 0} + _patched_loads(monkeypatch, counter) + + assert strat_config.load_override(tmp_path, "s1")["params"] == {"p": 1} + assert strat_config.load_override(tmp_path, "s1")["params"] == {"p": 1} + assert counter["loads"] == 0 or counter["loads"] == 1, "save 后首次 load 允许一次 parse" + before = counter["loads"] + strat_config.load_override(tmp_path, "s1") + assert counter["loads"] == before, "签名未变时不得重复读盘+parse" + + +def test_external_file_change_visible(tmp_path): + strat_config.save_override(tmp_path, "s1", {"params": {"p": 1}}) + assert strat_config.load_override(tmp_path, "s1")["params"]["p"] == 1 + + p: Path = tmp_path / "user_data" / "strategy_overrides" / "s1.json" + p.write_text(json.dumps({"params": {"p": 2}}), encoding="utf-8") + st = p.stat() + os.utime(p, ns=(st.st_atime_ns, st.st_mtime_ns + 1_000_000)) + + assert strat_config.load_override(tmp_path, "s1")["params"]["p"] == 2 + + +def test_save_override_invalidates_cache(tmp_path): + strat_config.save_override(tmp_path, "s1", {"params": {"p": 1}}) + assert strat_config.load_override(tmp_path, "s1")["params"]["p"] == 1 + + strat_config.save_override(tmp_path, "s1", {"params": {"p": 9}}) + assert strat_config.load_override(tmp_path, "s1")["params"]["p"] == 9 + + +def test_delete_override_invalidates_cache(tmp_path): + strat_config.save_override(tmp_path, "s1", {"params": {"p": 1}}) + assert strat_config.load_override(tmp_path, "s1") != {} + + strat_config.delete_override(tmp_path, "s1") + assert strat_config.load_override(tmp_path, "s1") == {} + assert strat_config.load_override(tmp_path, "s1") == {} + + +def test_load_returns_deep_copy_not_cached_object(tmp_path): + strat_config.save_override(tmp_path, "s1", {"params": {"p": 1}, "basic_filter": {"a": 1}}) + first = strat_config.load_override(tmp_path, "s1") + first["params"]["p"] = 999 + first["extra"] = True + + again = strat_config.load_override(tmp_path, "s1") + assert again["params"]["p"] == 1 + assert "extra" not in again + + +def test_basic_filter_cleaning_preserved(tmp_path): + strat_config.save_override( + tmp_path, "s1", {"basic_filter": {"keep": 1, "drop": None}}, + ) + data = strat_config.load_override(tmp_path, "s1") + assert data["basic_filter"] == {"keep": 1} + + strat_config.save_override(tmp_path, "s2", {"basic_filter": {"drop": None}}) + assert "basic_filter" not in strat_config.load_override(tmp_path, "s2") + + +def test_load_missing_override_returns_empty(tmp_path): + assert strat_config.load_override(tmp_path, "never_saved") == {} diff --git a/backend/tests/test_preferences_cache.py b/backend/tests/test_preferences_cache.py new file mode 100644 index 0000000..634a42d --- /dev/null +++ b/backend/tests/test_preferences_cache.py @@ -0,0 +1,123 @@ +"""preferences mtime 缓存测试 — 读盘去重, 且外部修改/自身写入后立即可见。""" +from __future__ import annotations + +import json +import os + +import pytest + +from app.services import preferences + + +@pytest.fixture(autouse=True) +def _isolated(tmp_path, monkeypatch): + path = tmp_path / "preferences.json" + monkeypatch.setattr(preferences, "_path", lambda: path) + preferences._invalidate_cache() + yield path + preferences._invalidate_cache() + + +def _patched_loads(monkeypatch, counter: dict): + real_loads = json.loads + + def _counting(text): + counter["loads"] += 1 + return real_loads(text) + + monkeypatch.setattr(preferences.json, "loads", _counting) + + +def test_second_load_hits_cache_without_disk_parse(_isolated, monkeypatch): + _isolated.write_text(json.dumps({"realtime_quotes_enabled": True}), encoding="utf-8") + counter = {"loads": 0} + _patched_loads(monkeypatch, counter) + + assert preferences.load()["realtime_quotes_enabled"] is True + assert preferences.load()["realtime_quotes_enabled"] is True + assert counter["loads"] == 1, "签名未变时第二次 load 不得重复读盘+parse" + + +def test_external_file_change_invalidates_cache(_isolated, monkeypatch): + _isolated.write_text(json.dumps({"realtime_quote_interval": 6.0}), encoding="utf-8") + assert preferences.load()["realtime_quote_interval"] == 6.0 + + _isolated.write_text(json.dumps({"realtime_quote_interval": 3.0}), encoding="utf-8") + # 同尺寸修改且 mtime 粒度可能不变时, 显式推进 mtime 模拟真实场景 + st = _isolated.stat() + os.utime(_isolated, ns=(st.st_atime_ns, st.st_mtime_ns + 1_000_000)) + + assert preferences.load()["realtime_quote_interval"] == 3.0 + + +def test_save_then_load_sees_merged_values(_isolated): + _isolated.write_text(json.dumps({"a": 1}), encoding="utf-8") + out = preferences.save({"b": 2}) + assert out == {"a": 1, "b": 2} + assert preferences.load() == {"a": 1, "b": 2} + + +def test_interval_setter_invalidates_cache(_isolated): + preferences.set_realtime_quote_interval(2.0) + assert preferences.load()["realtime_quote_interval"] == 2.0 + + +def test_load_returns_copy_not_cached_object(_isolated): + _isolated.write_text(json.dumps({"k": [1, 2]}), encoding="utf-8") + first = preferences.load() + first["k"].append(3) + first["extra"] = True + again = preferences.load() + assert again == {"k": [1, 2]} + + +def test_mining_schedule_defaults_are_disabled(_isolated): + assert preferences.get_mining_schedule() == { + "mining_schedule_enabled": False, + "mining_schedule_weekday": 4, + "mining_budget_profile": "balanced", + } + + +def test_mining_schedule_invalid_stored_values_fail_closed(_isolated): + _isolated.write_text( + json.dumps( + { + "mining_schedule_enabled": "false", + "mining_schedule_weekday": True, + "mining_budget_profile": None, + } + ), + encoding="utf-8", + ) + + assert preferences.get_mining_schedule() == { + "mining_schedule_enabled": False, + "mining_schedule_weekday": 4, + "mining_budget_profile": "balanced", + } + + +def test_mining_schedule_setter_saves_group_once(monkeypatch): + calls = [] + monkeypatch.setattr(preferences, "save", lambda updates: calls.append(updates) or updates) + + result = preferences.set_mining_schedule(True, 2, "strict") + + assert result == { + "mining_schedule_enabled": True, + "mining_schedule_weekday": 2, + "mining_budget_profile": "strict", + } + assert calls == [result] + + +@pytest.mark.parametrize("weekday", [-1, 5, True]) +def test_mining_schedule_setter_rejects_invalid_weekday(weekday): + with pytest.raises(ValueError, match="weekday"): + preferences.set_mining_schedule(True, weekday, "balanced") + + +def test_mining_schedule_setter_rejects_invalid_profile(): + with pytest.raises(ValueError, match="profile"): + preferences.set_mining_schedule(True, 4, "exploratory") diff --git a/backend/tests/test_price_limits.py b/backend/tests/test_price_limits.py index 218bf55..8857621 100644 --- a/backend/tests/test_price_limits.py +++ b/backend/tests/test_price_limits.py @@ -200,6 +200,7 @@ def test_realtime_limit_prices_ignore_stale_instrument_date(): "close": [9.10], "raw_close": [9.10], "raw_high": [9.10], + "raw_low": [9.10], "_prev_close_raw": [10.0], "volume": [1000.0], }) @@ -215,3 +216,41 @@ def test_realtime_limit_prices_ignore_stale_instrument_date(): assert result["signal_limit_down"][0] is False assert "_instrument_as_of" not in result.columns + + +def test_limit_down_recovery_uses_raw_low_under_later_ex_div(): + """除权事件之后重算历史时, 跌停翘板"曾触及跌停"必须用原始价 low 判断。 + + day2 (历史日): 原始 low 9.30 未触及跌停价 9.00, 不应触发翘板; + 但 day3 除权 (ex_factor=2) 使 day2 前复权 low 变为 4.65, + 若误用复权 low 对比原始口径跌停价会误报翘板。 + day3 (除权日, 最新日不复权): 涨跌停基准切换为前复权昨收 4.825 → 跌停价 4.34, + 原始 low 4.34 触及且收阳未封死 → 真翘板。 + """ + raw = pl.DataFrame({ + "symbol": ["600001.SH"] * 3, + "date": [date(2024, 1, 2), date(2024, 1, 3), date(2024, 1, 4)], + "open": [10.00, 9.60, 4.30], + "high": [10.10, 9.70, 4.45], + "low": [9.90, 9.30, 4.34], + "close": [10.00, 9.65, 4.42], + "volume": [10000.0, 10000.0, 10000.0], + "amount": [1.0e7, 1.0e7, 1.0e7], + }) + factors = pl.DataFrame({ + "symbol": ["600001.SH"], + "trade_date": [date(2024, 1, 4)], + "ex_factor": [2.0], + }) + instruments = pl.DataFrame({ + "symbol": ["600001.SH"], + "name": ["普通股"], + "float_shares": [1.0e8], + }) + + df = pipeline.compute_enriched(raw, factors=factors, instruments=instruments) + + day2 = df.filter(pl.col("date") == date(2024, 1, 3)) + assert day2["signal_limit_down_recovery"][0] is False + day3 = df.filter(pl.col("date") == date(2024, 1, 4)) + assert day3["signal_limit_down_recovery"][0] is True diff --git a/backend/tests/test_quote_name_map_reuse.py b/backend/tests/test_quote_name_map_reuse.py new file mode 100644 index 0000000..37d0931 --- /dev/null +++ b/backend/tests/test_quote_name_map_reuse.py @@ -0,0 +1,57 @@ +"""监控 name_map 测试 — 走 repo.get_name_map() memo, 过滤空名称与旧行为一致。""" +from __future__ import annotations + +from types import SimpleNamespace + +from app.services.quote_service import _monitor_name_map + + +class _FakeRepo: + def __init__(self, mapping: dict[str, str]) -> None: + self._mapping = mapping + self.calls = 0 + + def get_name_map(self) -> dict[str, str]: + self.calls += 1 + return dict(self._mapping) + + +def test_filters_falsy_names_like_legacy_build(): + repo = _FakeRepo({ + "600000.SH": "浦发银行", + "000001.SZ": "", # 空名称: 旧 iter_rows 构建会跳过 + "399001.SZ": None, # None 名称: 同上 + "510300.SH": "沪深300ETF", + }) + assert _monitor_name_map(repo) == { + "600000.SH": "浦发银行", + "510300.SH": "沪深300ETF", + } + + +def test_merges_all_asset_types_from_repo_map(): + # get_name_map 已合并股票 + ETF + 指数 (股票优先), 监控回填无需再分表构建 + repo = _FakeRepo({"600000.SH": "股票", "510300.SH": "ETF", "000001.SH": "指数"}) + assert _monitor_name_map(repo) == repo._mapping + + +def test_delegates_to_repo_each_call(): + repo = _FakeRepo({"600000.SH": "浦发银行"}) + _monitor_name_map(repo) + _monitor_name_map(repo) + assert repo.calls == 2 + + +def test_empty_repo_map_returns_empty(): + assert _monitor_name_map(_FakeRepo({})) == {} + + +def test_survives_repo_failure(): + # 与旧行为一致: name_map 构建失败不影响监控主流程 (调用方捕获) + repo = SimpleNamespace() + try: + _monitor_name_map(repo) # type: ignore[arg-type] + raised = False + except AttributeError: + raised = True + assert raised, "repo 无 get_name_map 时应抛出, 由调用方 try 兜底" diff --git a/backend/tests/test_realtime_turnover_rate.py b/backend/tests/test_realtime_turnover_rate.py index c4ad75a..bb0a5aa 100644 --- a/backend/tests/test_realtime_turnover_rate.py +++ b/backend/tests/test_realtime_turnover_rate.py @@ -16,6 +16,7 @@ def _today_rows(turnover_rate: float | None = None) -> pl.DataFrame: "close": 10.0, "raw_close": 10.0, "raw_high": 10.0, + "raw_low": 10.0, "volume": 8000.0, } if turnover_rate is not None: diff --git a/backend/tests/test_regime_builder.py b/backend/tests/test_regime_builder.py index c031546..a33027a 100644 --- a/backend/tests/test_regime_builder.py +++ b/backend/tests/test_regime_builder.py @@ -341,17 +341,30 @@ def test_build_regime_mask_fails_when_required_t1_date_is_missing(tmp_path): ) -def test_build_regime_mask_first_day_allowed(tmp_path): - """首日无前一日环境数据 → 默认允许(不阻断)。""" +def test_build_regime_mask_first_formal_day_requires_warmup_predecessor(tmp_path): + """正式首日缺少前一交易标签时必须阻断; warmup 前缀可安全对齐。""" from app.backtest.strategy import StrategyBacktestService regime_builder.upsert_regime_history(tmp_path, pl.DataFrame({ - "date": [date(2026, 1, 1)], - "state": ["weak"], "score": [10], + "date": [date(2026, 1, 1), date(2026, 1, 2)], + "state": ["weak", "strong"], + "score": [10, 85], })) - labels = ("2026-01-01", "2026-01-02") + with pytest.raises(ValueError, match="正式首日"): + StrategyBacktestService._build_regime_mask( + ("2026-01-01", "2026-01-02"), + {"states": ["strong"]}, + tmp_path, + required_start=date(2026, 1, 1), + required_end=date(2026, 1, 2), + ) + mask = StrategyBacktestService._build_regime_mask( - labels, {"states": ["strong"]}, tmp_path, + ("2026-01-01", "2026-01-02", "2026-01-03"), + {"states": ["strong"]}, + tmp_path, + required_start=date(2026, 1, 2), + required_end=date(2026, 1, 3), ) - # 1/1 首日 → True; 1/2 由 1/1(weak) → False - assert mask.tolist() == [True, False] + assert mask is not None + assert mask.tolist() == [True, False, True] diff --git a/backend/tests/test_repository_index.py b/backend/tests/test_repository_index.py index 3e546d3..56c0450 100644 --- a/backend/tests/test_repository_index.py +++ b/backend/tests/test_repository_index.py @@ -46,6 +46,43 @@ def test_name_map_stock_beats_index(repo): assert repo.get_name_map(["600000.SH"]).get("600000.SH") == "浦发银行" +def _write_stock_instruments(repo, symbols, names): + pl.DataFrame({ + "symbol": symbols, "name": names, "code": [s[:6] for s in symbols], + "exchange": ["SH"] * len(symbols), "region": ["CN"] * len(symbols), + "type": ["stock"] * len(symbols), + "listing_date": [None] * len(symbols), "total_shares": [None] * len(symbols), + "float_shares": [None] * len(symbols), "tick_size": [None] * len(symbols), + "limit_up": [None] * len(symbols), "limit_down": [None] * len(symbols), + "as_of": ["2026-08-14"] * len(symbols), + }).write_parquet(repo.store.data_dir / "instruments" / "instruments.parquet") + repo._refresh_instruments() + + +def test_name_map_partial_query_does_not_poison_cache(repo): + """带 symbols 的部分查询不能把残缺映射写入缓存 (自选新加股票无名称的回归). + + 旧 bug: 首次 get_name_map(["600000.SH"]) 把只含 600000 的映射缓存住, + 之后自选加入 000001.SZ 再查名称命中残缺缓存 → name=None。 + """ + _write_stock_instruments(repo, ["600000.SH", "000001.SZ"], ["浦发银行", "平安银行"]) + first = repo.get_name_map(["600000.SH"]) + assert first == {"600000.SH": "浦发银行"} + # 缓存必须是全量: 后续其他 symbols 查询仍能命中 + second = repo.get_name_map(["000001.SZ"]) + assert second == {"000001.SZ": "平安银行"} + full = repo.get_name_map() + assert full == {"600000.SH": "浦发银行", "000001.SZ": "平安银行"} + + +def test_name_map_cache_invalidated_on_instruments_refresh(repo): + """维表刷新后缓存必须失效: 新收录的股票能立刻查到名称。""" + _write_stock_instruments(repo, ["600000.SH"], ["浦发银行"]) + assert repo.get_name_map(["600000.SH"]) == {"600000.SH": "浦发银行"} + _write_stock_instruments(repo, ["600000.SH", "301999.SZ"], ["浦发银行", "新股股份"]) + assert repo.get_name_map(["301999.SZ"]) == {"301999.SZ": "新股股份"} + + import datetime as _dt diff --git a/backend/tests/test_screener_builtin_params.py b/backend/tests/test_screener_builtin_params.py index 00e0d98..660d9d2 100644 --- a/backend/tests/test_screener_builtin_params.py +++ b/backend/tests/test_screener_builtin_params.py @@ -44,6 +44,11 @@ class _CapturingStrategyEngine: def has(self, strategy_id): return strategy_id == "builtin_strategy" + def get(self, strategy_id): + if not self.has(strategy_id): + raise ValueError(f"unknown strategy: {strategy_id}") + return types.SimpleNamespace(meta={"id": strategy_id}) + def run(self, strategy_id, context, *, pool=None, params=None, overrides=None): self.calls.append({ "kind": "run", diff --git a/backend/tests/test_settings_mining_schedule.py b/backend/tests/test_settings_mining_schedule.py new file mode 100644 index 0000000..3b7e78f --- /dev/null +++ b/backend/tests/test_settings_mining_schedule.py @@ -0,0 +1,71 @@ +from __future__ import annotations + +import pytest +from pydantic import ValidationError + +from app.api import settings + + +def test_mining_schedule_model_is_strict_and_forbids_extra_fields(): + valid = settings.MiningSchedulePrefs( + mining_schedule_enabled=True, + mining_schedule_weekday=4, + mining_budget_profile="strict", + ) + assert valid.model_dump() == { + "mining_schedule_enabled": True, + "mining_schedule_weekday": 4, + "mining_budget_profile": "strict", + } + + invalid_payloads = [ + { + "mining_schedule_enabled": "true", + "mining_schedule_weekday": 4, + "mining_budget_profile": "balanced", + }, + { + "mining_schedule_enabled": True, + "mining_schedule_weekday": 5, + "mining_budget_profile": "balanced", + }, + { + "mining_schedule_enabled": True, + "mining_schedule_weekday": 4, + "mining_budget_profile": "exploratory", + }, + { + "mining_schedule_enabled": True, + "mining_schedule_weekday": 4, + "mining_budget_profile": "balanced", + "unknown": True, + }, + ] + for payload in invalid_payloads: + with pytest.raises(ValidationError): + settings.MiningSchedulePrefs.model_validate(payload) + + +def test_update_mining_schedule_calls_group_setter_once(monkeypatch): + calls = [] + monkeypatch.setattr( + "app.services.preferences.set_mining_schedule", + lambda enabled, weekday, profile: ( + calls.append((enabled, weekday, profile)) + or { + "mining_schedule_enabled": enabled, + "mining_schedule_weekday": weekday, + "mining_budget_profile": profile, + } + ), + ) + request = settings.MiningSchedulePrefs( + mining_schedule_enabled=True, + mining_schedule_weekday=1, + mining_budget_profile="strict", + ) + + result = settings.update_mining_schedule(request) + + assert calls == [(True, 1, "strict")] + assert result["mining_budget_profile"] == "strict" diff --git a/backend/tests/test_st_limit_and_sharpe.py b/backend/tests/test_st_limit_and_sharpe.py index 75402b5..bb82bbd 100644 --- a/backend/tests/test_st_limit_and_sharpe.py +++ b/backend/tests/test_st_limit_and_sharpe.py @@ -55,6 +55,7 @@ def _two_day( "raw_close": [prev_close, today_close], "close": [prev_close, today_close], "raw_high": [prev_close, today_close], + "raw_low": [prev_close, today_close], "open": [prev_close, today_close], "high": [prev_close, today_close], "low": [prev_close, today_close], diff --git a/docs/features.md b/docs/features.md index 3fa5cce..8e9c09d 100644 --- a/docs/features.md +++ b/docs/features.md @@ -8,7 +8,7 @@ ## 🔍 选股引擎(Screener) -**20 个内置策略**,每个策略一个独立 Python 文件,基于 Polars 表达式向量化实现(`backend/app/strategy/builtin/`): +**18 个内置策略**,每个策略一个独立 Python 文件,基于 Polars 表达式向量化实现(`backend/app/strategy/builtin/`): | 类型 | 代表策略 | | :---------- | :------------------------------------------------------- | @@ -54,6 +54,10 @@ 输出净值曲线 · 夏普 · 最大回撤 · 胜率 · 交易明细。SSE 流式进度支持切页重连,不会丢失回测任务。 +**因子与策略挖掘**:复用已有日频因子和 matrix-native 策略，通过 T-1 市场环境、相关去重和嵌套样本外验证生成研究候选。任务在 spawn worker 中运行，支持持久 run ID、取消、刷新重连和显式发布；自动周度任务默认关闭且永不自动发布。完整口径见 [因子与策略挖掘](./mining.md)。 + +**市场阶段与主线**:市场环境页在原 5 档状态之外新增情绪周期阶段(冰点/启动/主升/高潮/退潮/修复,由连板梯队的高度、宽度、晋级率、梯队完整度判定,平均段长约 10 天)与主线识别(概念/行业维度的涨停梯队聚合排名,可配置宽基标签过滤)。完整口径见 [市场阶段与主线识别](./market-phase.md)。 + **ETF 支持**:三种模式的后端与 API 均支持 `asset_type=etf`,回测面板改从 `kline_etf_enriched` 读取(单次回测为单一资产类型,不混合股票与 ETF)。策略组合与因子回测页均有 `股票 / ETF` 切换,ETF 模式下策略列表与标的搜索跟随资产。需先开启 ETF 拉取并跑盘后管道。 --- diff --git a/docs/market-phase.md b/docs/market-phase.md new file mode 100644 index 0000000..90ba2af --- /dev/null +++ b/docs/market-phase.md @@ -0,0 +1,95 @@ +# 市场阶段（情绪周期）与主线识别 + +本文说明市场环境页的阶段体系与主线识别的口径、阈值来源、持久化设计、已知偏差与运行方式。它与原有的 5 档环境 state 并存，不替代任何既有消费方。 + +## 功能边界 + +阶段体系回答"市场处于情绪周期什么位置"，主线识别回答"当前/某阶段内什么板块概念在领涨"。两者都只用本地已存储数据（`consecutive_limit_ups`、`amount`、概念映射快照），不依赖扩展数据源，2020-08 起全历史可回算。 + +明确不做的： + +- 挖掘、回测环境过滤、因子 regime 统计仍用原 5 档 `state`，本期不切换到阶段体系。 +- 概念成分是当前快照，不改成 timeseries 积累模式（见「快照回填偏差」）。 +- 不生成任何交易信号；阶段与主线仅供研究分析。 + +## 与 5 档 state 的关系 + +| | `state`（原有） | `phase`（本期新增） | +|---|---|---| +| 驱动量 | 赚钱/投机/抗跌/趋势 4 维综合分 | 连板梯队：高度、宽度、晋级率、梯队完整度 | +| 档位 | 强势/偏强/震荡/偏弱/弱势（5 档） | 冰点/启动/主升/高潮/退潮/修复（6 阶段） | +| 消费方 | 回测环境过滤、挖掘、策略页 | 市场环境页分析与主线识别 | +| 持续性 | 日频打分，切换频繁（历史 76.6% 天数发生切换，平均段长 1.1-1.5 天） | EMA 平滑 + 2 日确认，平均段长 9.7 天 | + +`state`/`score` 列原样保留，新列（`phase`、`first_board`、`ge2_count`、`ge3_count`、`ge5_count`、`ladder_completeness`、`promo_rate`、`promo_pool`）对既有消费方透明。 + +## 每日梯队指标 + +全部由已存储的 `consecutive_limit_ups` 列向量化派生，实现在 `backend/app/services/market_phase.py`： + +- `first_board`：首板（1 连板）家数。 +- `ge2_count` / `ge3_count` / `ge5_count`：N 板以上家数（宽度）。 +- `promo_rate` 晋级率：昨日连板池今日继续封板的比例。昨日连板数用 `consec.shift(1).over("symbol")` 按个股前一日连接（跨批次边界也正确，`_compute_batch` 在 warmup 截断前计算）；池不足 10 家记 `null`（小样本噪声），不填 0。 +- `ladder_completeness` 梯队完整度：2..height 档位中非空档位占比；height < 3 时为 `null`。 +- 高度（`max_consecutive`）与封板率（`seal_rate`）沿用 regime 已有列。 + +## 阶段规则 + +词汇与优先级：`climax 高潮 > rally 主升 > ebb 退潮 > ignite 启动 > ice 冰点 > repair 修复（兜底）`。冰点排在退潮前判定——长期死市不应被标成"自高位退潮"。 + +阈值标定自 2020-08~2026-08 全市场 1454 个交易日的 p10/p60/p90 分位数，全部集中在模块顶部常量，调整只改那里： + +| 阶段 | 核心条件（EMA 平滑后） | +|---|---| +| 高潮 climax | ge2 ≥ 50（p90 的 2 倍）或首板 ≥ 220（p90 的 2.5 倍），历史占比 <2% | +| 主升 rally | 高度 ≥7 且 ge2 ≥15 且晋级率 ≥0.23（全中位以上）；或晋级率 ≥0.30（p85+）配合高度 ≥5、ge2 ≥12 | +| 退潮 ebb | 晋级率 <0.15（p20）且宽度自 5 日前高位（ge2>12 或高度>6）回落；或晋级率 <0.13 且封板率 <0.57 双弱 | +| 启动 ignite | 宽度/高度自低位扩张（ge2 较 5 日前 +3 且 ≥8，或高度抬升且 ≥5）且晋级率恢复到 ~0.19-0.20 | +| 冰点 ice | 高度 ≤4、ge2 ≤6、首板 ≤24 同时贴地（均 ~p10） | +| 修复 repair | 兜底 | + +**持续性设计**：驱动量先做 EMA 平滑（alpha=1/3，约 5 日），原始标签出来后再做 2 日确认（切换需连续 2 日出现新标签才生效）。 + +**弱档否决**：5 档 `state ∈ {weak, lean_weak}` 时，正向阶段（主升/高潮/启动）一律降为修复。这修复了一类错标：连板梯队强但大盘崩的交易日（如 2024-01 微盘流动性危机）会被梯队指标误判为主升/启动——涨停生态与大盘背离时，以大盘弱势为准。 + +**回填验收**（1454 天真实数据）：平均段长 9.7 天（对比原 5 档的 1.1-1.5 天）。抽查：2024-09-24→10-08 为启动→主升→高潮（九二四行情）；2024-01/02 微盘崩为退潮/冰点；高潮 6 年仅 2 段（2024-10-08、2024-10-31 ST 重组潮 17 板），均为真实极端期。 + +已知特性，如实说明：退潮/冰点天然是短段（平均 2.8/2.5 天）——恐慌释放本身快于趋势形成；修复是占比最高的兜底段（~74% 天数），A股大部分时间没有处于可辨认的周期位置。 + +## 主线识别 + +实现在 `backend/app/services/market_mainline.py`。复用 `rps_rotation` 的概念映射加载，窄扫描 `kline_daily_enriched` 的 symbol/date/consecutive_limit_ups/amount 四列，按 (date, 概念/行业) 聚合： + +- `limit_up_count` 涨停家数、`ge2_count` 二板以上家数、`max_boards` 最高板、`boards_sum`、`rungs_filled` 梯队档位数、龙头股（按连板数、成交额排序取第一）。 +- 主线分 = 当日截面 rank 归一后 `0.35*涨停数 + 0.25*最高板 + 0.25*梯队档位数 + 0.15*二板宽度`。这是"同板块涨停越多、梯队越完整越是主升主线"判据的直接量化。 +- 每概念当日涨停 <3 家不参与排名；每日持久化 top30 到 `data/mainline_history/part.parquet`（upsert 按 date+kind 整日替换）。 +- 行业维度取前两级（如 `计算机-软件开发`），作为概念维度的交叉验证。 + +### 宽基/风格标签过滤 + +融资融券（~7700 家）、沪深股通（~3300 家）这类超大概念会垄断 top1，需要过滤。配置存于用户偏好（`preferences.json`），市场环境页「过滤」面板可改： + +- 成员数上限：默认 600，超过视为宽基/风格标签不参与排名（夹取范围 50-5000）。保留华为概念（2006）、人工智能（2166）等真主题。 +- 成员数下限：默认 4（夹取 1-200）。 +- 名称黑名单：手动屏蔽任意概念，支持逗号/分号/空格分隔。 + +修改保存后自动触发全量主线重算（`POST /api/regime/mainline/recompute`，秒级）。API 层为 `PUT /api/preferences/mainline-filter`。 + +### 快照回填偏差 + +概念成分为**当前快照回看历史**（本地自 2026-07 起留存，无历史版本）。新纳入指数或改名的个股会出现在旧时段、成分调整会错归属，因此早年主线存在归属漂移，越近越准。此口径限制以 `membership_note` 字段随 API 返回并在页面展示。若后续把 ext 概念同步改为按月累积快照，主线历史精度会逐月自然提升。 + +## API 与运行 + +- `GET /api/regime/phases?start&end`：连续阶段段列表（阶段、区间、天数、高度/宽度/晋级率/封板率均值、段内 top 主线）。 +- `GET /api/regime/mainline?start&end&top&kind`：窗口内主线排行（top1 天数、日均分、最高板）与每日明细。 +- `POST /api/regime/mainline/recompute`：过滤配置变更后的全量重算（两类维度）。 +- `POST /api/regime/recompute`：扩展为重算 regime 后自动重标 phase 并回填主线。 +- daily pipeline 在 regime 步骤后追加主线增量（复用 `pipeline_regime_enabled` 开关，软失败不阻塞）。 + +阶段标签由 `regime_builder.refresh_phase_labels` 在每次 regime upsert 后对全量历史重标（1454 行，开销可忽略）——因为 EMA 与 2 日确认依赖完整序列。 + +## 测试 + +- `backend/tests/test_market_phase.py`：梯队聚合、晋级率（池不足记 null）、梯队完整度、阶段序列规则、弱档否决、持续性（噪声下不出现 1 日翻转）、refresh 往返。 +- `backend/tests/test_market_mainline.py`：概念/行业聚合、宽基过滤、黑名单、最少涨停家数、同日 upsert 替换、增量补齐、偏好读写与夹取。 diff --git a/docs/mining.md b/docs/mining.md new file mode 100644 index 0000000..79f666e --- /dev/null +++ b/docs/mining.md @@ -0,0 +1,138 @@ +# 因子与策略挖掘 + +本文说明 V1 因子与策略挖掘的金融口径、执行边界、结果解释和运行要求。 + +## 功能边界 + +V1 仅研究仓库已经提供的日频因子和用户明确选择的 matrix-native 日线策略。它完成以下闭环： + +1. 在训练区间重新计算因子方向与统计。 +2. 按日截面 Rank IC 计算因子相关性并去重。 +3. 搜索最多四个因子的受控排名组合；进入 beam 搜索的因子按训练折综合分排序并截断到 `beam_width` 个，保证单因子打分后组合搜索仍有代理预算可用。 +4. 用嵌套样本外验证比较新组合；用户选择的已有策略作为对照轨在每个 outer 测试窗独立评估，不参与因子竞争，也不会占用候选名额。 +5. 将运行、事件和结果持久化，允许刷新后重连。 +6. 将候选保存到研究候选库；只有用户显式确认且通过晋级门槛后才发布独立策略。 + +V1 不生成任意公式，不接受 AI 自由代码，不使用扩展数据生成新因子，也不使用分钟数据优化入场。分钟级成交和分钟因子需要独立的数据完整性、防未来函数和性能边界，属于后续版本范围。 + +因子数量以运行时 `FACTOR_COLUMNS` 目录为准。当前目录与后续版本可能不同；单次请求硬上限为 48，不应把历史设计稿中的固定数量当作稳定 API 契约。 + +当前目录除价量技术类（动量、均线偏离、趋势、波动率、量价、价格位置、超买超卖）外，还包含三个 A 股实证维度：收益形态（`max_ret_20d` 彩票效应、`ret_skew_20d`、`up_days_20d`）、流动性（`amihud_20d` 非流动性、`turnover_z_60d` 换手异动）、涨停基因（`limit_up_count_20d/60d`，基于存储列 `consecutive_limit_ups` 计数，涨停判定沿用环境信号口径）。这些因子仍只用本地日频存储数据计算，不依赖扩展数据源。 + +财务因子（`pb_latest`、`roe_latest`、`gross_margin_latest`、`net_margin_latest`、`revenue_yoy_latest`、`net_income_yoy_latest`、`debt_ratio_latest`）来自本地财务快照（数据页同步），采用严格点时口径：**因子值只在晚于公告日的交易日生效**（公告多在盘后， 保守取公告次一交易日起），同一报告期以最新公告为准。无财务数据的标的、公告前的日期一律为空值并从当日截面剔除，绝不填 0；本地完全没有财务数据时因子回测直接返回明确错误而不是全空结果。回测区间早于首次公告时同样报告"无有效数据"。挖掘中财务因子在训练折覆盖不足时综合分为 0 并被自然淘汰，不会阻塞其他因子。财务报表同步按 `(symbol, period_end)` 累积历史（同 shares 表模式），每次同步只拉最新期并为新标的补全量历史；随着季度累积，财务因子的可回测区间会逐步变长。 + +## 时间与收益口径 + +### 全局交易日标签 + +1、3、5 日 forward return 都按全局交易日轴精确连接。停牌或缺行不会把“下一条标的数据”误当成下一交易日。 + +周频使用每个 ISO 周的第一个实际交易日，月频使用每月第一个实际交易日。节假日不会导致整周漏掉调仓。 + +### T-1 市场环境 + +交易日 T 只能使用上一交易日已经得到的环境标签 T-1。**统计与挖掘口径**聚合为三档： + +```text +strong = strong + lean_strong +range = range +weak = lean_weak + weak +``` + +**策略回测的环境过滤**按原始五档匹配：勾选“强势”只允许 T-1 为 strong 的交易日入场，需要三档口径时必须同时勾选“强势+偏强”。挖掘内部的 strong/range/weak 环境拆分仍按上方三档聚合实现（显式枚举原始状态），两者互不影响。 + +正式区间缺少前驱交易日或前驱环境时会 fail-closed，不会用当日环境、最近自然日或默认环境补齐。 + +### 成交和成本 + +候选策略沿用现有回测撮合规则，包括 T+1、佣金、卖侧印花税、滑点以及涨跌停不可成交约束。因子统计中的 long-short spread 仅用于衡量因子区分能力，是理论价差，不表示 A 股可执行卖空。 + +## 防止未来数据 + +挖掘使用嵌套 walk-forward，而不是在完整样本上选择后再报告同一段表现： + +- 每个 inner 训练折独立学习方向、计算统计、相关去重和组合搜索。 +- inner test 只用于选择候选，不参与该折的训练计算。 +- 选择完成后在完整 outer train 上重新训练。 +- outer test 只进行一次最终样本外评估。 +- 训练和测试之间保留 purge 与 embargo；默认 purge 为 30 个交易日。 + +任何 fold 缺数据、缺 T-1 环境或不能可靠撮合时都记录为 skipped 并给出原因，缺失指标返回 `null`，不会显示为 0。 + +## 候选证据口径 + +run 级的“有效折”统计只描述因子赛道：它按每折被选中的候选聚合，不是任何单个候选的样本量。单个候选的逐折证据由三类行组成，`folds.parquet` 的 `evaluation_kind` 区分： + +- `selected`：该候选在该 outer 折经 inner 验证胜出后的 outer 测试结果。 +- `cross`：该候选的定义在其他折胜出后，在本折补评的跨折结果。胜出定义会在所有 outer 折上评估，使单个候选的证据不再依赖“它恰好在哪里获胜”。 +- `benchmark`：对照策略在该 outer 测试窗的独立评估，与因子赛道成败无关；即使因子赛道在某折没有任何候选完成内部验证，对照行仍会写入。 + +对照策略是固定定义，不需要逐折重拟合，因此每个 outer 折只评估一次；预算耗尽时写入带原因的 skipped 行，不会静默缺失。探索档（exploratory）结果固定为低置信度，只能保存为 pending 候选。 + +## 晋级与发布门槛 + +保存（promote）始终允许，结果进入研究候选库 pending 状态。发布（publish）在服务端强制校验以下证据门槛，不满足即拒绝并返回原因列表： + +- 非探索档置信度（exploratory 运行产生的候选不能发布）； +- 至少 2 个有效 outer 折； +- 正收益折比例不低于 2/3； +- 样本外 Sharpe 不低于 0.5； +- 最大回撤不劣于 -25%； +- 样本外交易数不低于 60。 + +门槛按 artifact 行指标在读取时计算，不改变历史 artifact 的 schema，因此旧运行的候选会得到相同的门槛判断。工作台会在候选上显示“达标/未达标”标记，未达标的候选“显式发布”按钮被禁用并展示原因。 + +## 置信度 + +三个预算档使用不同的训练窗口： + +| 档位 | 外层训练 | 外层测试 | 步长 | 用途 | +| --- | ---: | ---: | ---: | --- | +| exploratory | 126 | 63 | 63 | 数据较短时探索，只能作为低置信度 pending 候选 | +| balanced | 504 | 126 | 63 | 默认自动研究，至少需要 3 个 outer folds | +| strict | 756 | 126 | 126 | 更长训练窗，至少需要 3 个 outer folds | + +探索性结果不是已验证策略。候选晋级仍需同时检查正收益折比例、样本外 Sharpe、最大回撤、交易数和环境样本覆盖；发布动作会按上文“晋级与发布门槛”在服务端强制执行同一组阈值。 + +## 任务与资源隔离 + +挖掘通过 `spawn` 子进程执行，不在 FastAPI 请求线程、实时行情回调线程或浏览器连接生命周期内运行。浏览器断开不会取消任务；刷新后可通过持久 run ID 重连。取消请求会进入 `cancelling`，界面应等待后端进入终态。 + +共享重任务限流容量为 2：普通回测、优化、walk-forward 和矩阵预热占 1，挖掘独占 2。因此一个挖掘任务不会与另一项大矩阵计算并发。 + +当前 run store 和重任务 limiter 使用进程内锁。生产环境必须只启动一个应用进程负责挖掘；多 worker Uvicorn 部署不能保证跨进程单飞、事件追加和容量限制。要支持多应用进程，必须先增加操作系统级文件锁或外部任务协调器。 + +每个运行目录包含 manifest、compact summary、最近 256 条事件和四个 Parquet artifact。大面板、完整矩阵对象和逐折宽结果不会通过 worker IPC 返回。 + +## 自动运行 + +周度自动挖掘默认关闭，只允许 balanced 或 strict。启用后，它会在北京时间配置工作日及其后的同周工作日、日线 enriched 刷新和环境更新成功后尝试入队；如果配置日的数据流水线失败，后续工作日可以补跑。 + +同一 ISO 周使用确定性的 claim，只触发一次。已经生成运行记录的失败或 `skipped_prerequisite` 仍会占用该周 claim，不重复消耗资源。数据或 T-1 环境覆盖不足时会生成可见的 `skipped_prerequisite` 运行，不会静默降级到 exploratory。挖掘失败不改变已经成功的日度数据流水线状态。 + +自动任务只生成 pending 结果，永远不会自动发布策略。 + +## 保存与发布 + +“保存候选”只从服务端已注册的 `candidates.parquet` 读取定义，并重新校验 artifact schema、canonical signature、原始请求中的因子/策略范围和当前策略兼容性，再写入研究候选库。客户端只能提交 run ID 与 candidate signature，不能在保存时重交权重、方向、公式或代码。保存按 `(origin_run_id, candidate_signature)` 幂等；如果候选库已写入但 artifact backlink 回写失败，重试只修复 backlink，不会创建重复候选。 + +“发布”是独立的显式动作： + +- 已有策略候选返回原策略 ID，不复制或覆盖源文件。 +- 因子组合候选由服务端根据 run ID 与 candidate signature 派生独立策略 ID；客户端不能提交策略 ID、权重、方向、公式或代码。 +- 不同 run 即使得到相同组合，也会生成互相独立的策略文件；同一 run 与 signature 重试时只验证已有源码并修复 backlink。 +- 发布过程执行 AST/META 校验、create-only 原子写入、引擎 reload、策略缓存失效和监控状态失效。 +- reload 或运行时失效失败会回滚首次创建的新文件；backlink 回写失败不会删除已成功加载的策略，重试可修复 backlink。 +- 发布不会修改共享 `factor_rank_research` 源码或 override。 + +发布仅表示把固定候选变成可使用策略，不代表样本外表现会在未来持续。 + +## 性能口径 + +相关矩阵按交易日计算 pairwise-finite Spearman，只聚合因子平方级的逐日结果，不物化百万行永久 rank 宽表。缺失集合不同的因子会先取共同 finite 样本再排名；无法估计的 pair 保持空值，不按零处理。 + +生产 runtime 只生成本次搜索 horizon 的一列 forward label，并在阶段间释放中间列。内存表示优化对照 run `46ed81d537e9404baa06324a3ac3a45f` 在 132.0 万行、243 个交易日、44 个因子上峰值 RSS 为 1.291 GiB，总耗时 25.140 秒；相对 2.395 GiB、37.358 秒的原始对照基线，RSS 和耗时分别下降 46.09% 和 32.70%，四个 Parquet artifact 逐项完全一致。 + +最终 `mining-v2` 额外修复了缺失掩码下的 pairwise Spearman 口径，因此 correlation artifact 与 v1 不再要求数值相等。最终 run `10574abb5d8e4b32ade7cbdd23975c45` 峰值 RSS 为 1.350 GiB、总耗时 40.699 秒，相对原始对照基线内存下降 43.63%、耗时增加 8.94%；仍满足 1.5 GiB 内存门槛和统计增强耗时不超过 30% 的目标。v2 的 Float32 聚合与 Float64 慢参考具有相同 pair counts、空值位置和 0.75 剪枝判断，相关系数最大绝对误差为 `1.70e-7`。 + +这些结果只证明上述基准工作负载达到目标，不表示所有数据规模和搜索预算都具有固定内存上界。当前验证结果：后端全量测试 `876 passed, 24 warnings`，挖掘相关回归含基准轨、跨折证据与晋级门槛共 145 项通过，前端 TypeScript 检查和生产构建均通过；另以真实数据完成 exploratory 运行核验 `selected`/`cross`/`benchmark` 三类行与发布禁用。 diff --git a/docs/strategy.md b/docs/strategy.md index d2b3c1e..a63e454 100644 --- a/docs/strategy.md +++ b/docs/strategy.md @@ -16,6 +16,8 @@ | 量价 / 涨停 | 量价齐升 · 高换手强势 · 连板股 · 断板反包 · 涨停动量 · 接近涨停 | | 反转 / 波动 | 超跌反弹 · 超卖反转 · 新低反转 · 低波动龙头 · 回踩 MA20 · 回踩支撑 · 强势开盘 | +内置目录 `backend/app/strategy/builtin/` 还包含一个仅供挖掘 worker 使用的受控因子排名研究模板。它不出现在普通选股列表，也不能通过普通策略 API 直接运行或保存 override；挖掘结果发布时会生成独立策略。详见 [因子与策略挖掘](./mining.md)。 + 内置目录 `backend/app/strategy/builtin/` 由项目维护,**AI 生成的策略不会落入此目录**。 --- diff --git a/frontend/src/components/Layout.tsx b/frontend/src/components/Layout.tsx index feca72d..d7a9268 100644 --- a/frontend/src/components/Layout.tsx +++ b/frontend/src/components/Layout.tsx @@ -25,6 +25,7 @@ import { Star, ScanSearch, History, + Pickaxe, FileText, Settings, Key, @@ -79,6 +80,7 @@ const nav = [ { to: '/watchlist', label: '自选', icon: Star }, { to: '/screener', label: '策略', icon: ScanSearch }, { to: '/backtest', label: '回测', icon: History }, + { to: '/mining', label: '挖掘', icon: Pickaxe }, { to: '/stock-analysis', label: '个股分析', icon: TrendingUp }, { to: '/limit-ladder', label: '连板梯队', icon: Flame }, { to: '/concept-analysis', label: '概念分析', icon: Layers3 }, @@ -424,12 +426,11 @@ export function Layout() { : (dataSources?.custom?.find(s => s.name === activeProvider)?.display_name || activeProvider) const isCustomActive = activeProvider !== 'tickflow' - // 轮询触发记录总数 → 更新监控中心徽标 (每 15 秒) + // 轮询触发记录总数 → 更新监控中心徽标 (每 15 秒; 后台标签页由 SSE 事件驱动, 不轮询) const alertsTotalQuery = useQuery({ queryKey: ['alerts-total'], queryFn: () => api.alertsList({ days: 7, limit: 1 }), refetchInterval: 15000, - refetchIntervalInBackground: true, select: (data) => data.total, }) // 只在拿到真实总数时同步徽标 (避免 data=undefined 时传 0 重置 lastSeen) @@ -456,11 +457,27 @@ export function Layout() { const navItems = savedOrder.length > 0 ? (() => { const byTo = new Map(allNav.map(n => [n.to, n])) - const ordered = savedOrder + const ordered = (savedOrder .map(id => byTo.get(id) ?? byTo.get(`/analysis/${id}`)) - .filter(Boolean) - const seen = new Set(ordered.map(n => n!.to)) - return [...ordered as typeof allNav, ...allNav.filter(n => !seen.has(n.to))] + .filter(Boolean)) as typeof allNav + const seen = new Set(ordered.map(n => n.to)) + const merged = [...ordered] + for (const item of allNav) { + if (seen.has(item.to)) continue + // 未保存过排序的新条目: 内置页插回默认位置(排在已保存的默认前驱之后), + // 分析/扩展菜单仍追加到末尾 + const defaultIndex = nav.findIndex(n => n.to === item.to) + let anchor = -1 + if (defaultIndex > 0) { + for (let i = defaultIndex - 1; i >= 0 && anchor < 0; i -= 1) { + anchor = merged.findIndex(n => n.to === nav[i].to) + } + } + if (anchor >= 0) merged.splice(anchor + 1, 0, item) + else if (defaultIndex >= 0) merged.unshift(item) + else merged.push(item) + } + return merged })() : allNav diff --git a/frontend/src/lib/api.ts b/frontend/src/lib/api.ts index 8433d58..38e0ef9 100644 --- a/frontend/src/lib/api.ts +++ b/frontend/src/lib/api.ts @@ -473,6 +473,15 @@ export interface RegimeRow { speculation_score?: number resilience_score?: number trend_score?: number + // 情绪周期阶段与梯队指标(重算后才有; 旧数据可能缺) + phase?: MarketPhase | null + first_board?: number | null + ge2_count?: number | null + ge3_count?: number | null + ge5_count?: number | null + ladder_completeness?: number | null + promo_rate?: number | null + promo_pool?: number | null } export interface RegimeHistory { @@ -498,6 +507,90 @@ export interface RegimeCoverage { latest_date: string | null } +// ── 市场阶段(情绪周期) 与 主线 ── +export type MarketPhase = 'ice' | 'ignite' | 'rally' | 'climax' | 'ebb' | 'repair' + +export const MARKET_PHASE_LABELS: Record = { + ice: '冰点', + ignite: '启动', + rally: '主升', + climax: '高潮', + ebb: '退潮', + repair: '修复', +} + +export const MARKET_PHASE_COLORS: Record = { + ice: '#38bdf8', // 天蓝(冻结) + ignite: '#f59e0b', // 琥珀(升温) + rally: '#ef4444', // 红(主升) + climax: '#d946ef', // 品红(极端) + ebb: '#14b8a6', // 青(退潮) + repair: '#94a3b8', // 灰(修复) +} + +export const MARKET_PHASE_ORDER: MarketPhase[] = ['ice', 'ignite', 'rally', 'climax', 'ebb', 'repair'] + +export interface MainlineMemberStat { + member: string + top5_days: number + score_sum: number + max_boards: number + leader_symbol: string +} + +export interface PhaseSegment { + phase: MarketPhase + label: string + start: string + end: string + days: number + avg_height: number + avg_first_board: number + avg_ge2: number + avg_promo: number | null + avg_seal_rate: number + top_mainlines: MainlineMemberStat[] +} + +export interface PhaseSegments { + segments: PhaseSegment[] + total: number +} + +export interface MainlineRow { + date: string + kind: string + member: string + limit_up_count: number + ge2_count: number + max_boards: number + boards_sum: number + rungs_filled: number + leader_symbol: string + score: number + rank: number +} + +export interface MainlineLeader { + member: string + top1_days: number + avg_score: number + max_boards: number +} + +export interface MainlineFilter { + min_members: number + max_members: number + blacklist: string[] +} + +export interface MainlineResult { + rows: MainlineRow[] + leaders: MainlineLeader[] + membership_note: string + filter: MainlineFilter +} + // ===== 大盘复盘 ===== export interface AiReviewReport { id: string @@ -846,6 +939,217 @@ export interface FactorBatchResult { error: string | null } +// ===== Factor / strategy mining ===== +export type MiningBudgetProfile = 'exploratory' | 'balanced' | 'strict' +export type MiningRunStatus = + | 'queued' + | 'running' + | 'cancelling' + | 'succeeded' + | 'succeeded_with_budget_exhausted' + | 'failed' + | 'cancelled' + | 'interrupted' + | 'skipped_prerequisite' + +export interface MiningAvailability { + asset_type: 'stock' | 'etf' + budget_profile: MiningBudgetProfile + trading_bars: number + required_bars: number + outer_folds: number + required_outer_folds: number + eligible: boolean + available_start: string | null + available_end: string | null + effective_start: string | null + effective_end: string | null + suggested_start: string | null +} + +export interface MiningRequestV1 { + factor_names: string[] + strategy_ids?: string[] + symbols?: string[] | null + asset_type?: 'stock' | 'etf' + start?: string | null + end?: string | null + budget_profile?: MiningBudgetProfile + commission_pct?: number + stamp_tax_pct?: number + slippage_bps?: number + correlation_threshold?: number + max_combination_factors?: number + beam_width?: number + max_finalists?: number + force?: boolean +} + +export interface MiningRunProgress { + phase: string + label?: string + done?: number + total?: number + percent?: number + elapsed_ms?: number + message?: string +} + +export interface MiningRun { + run_id: string + signature: string + status: MiningRunStatus + request: MiningRequestV1 + source?: 'manual' | 'scheduled' + created_at: string + updated_at: string + started_at?: string | null + finished_at?: string | null + data_as_of?: string | null + progress?: MiningRunProgress | null + error?: string | null + reused?: boolean + summary?: MiningResultSummary | null +} + +export interface MiningResultSummary { + factor_count: number + selected_factor_count: number + candidate_count: number + valid_fold_count: number + skipped_fold_count: number + confidence: 'low' | 'standard' | 'high' + budget_exhausted?: boolean + elapsed_ms?: number + peak_rss_bytes?: number +} + +export interface MiningFactorRow { + factor_name: string + label?: string + direction: 1 | -1 + score: number | null + ic_mean: number | null + ir: number | null + coverage: number | null + turnover: number | null + spread_return?: number | null + spread_sharpe?: number | null + selected: boolean + excluded_reason?: string | null +} + +export interface MiningRegimeRow { + state: 'overall' | 'strong' | 'range' | 'weak' | string + label: string + n_dates: number + total_return: number | null + sharpe: number | null + max_drawdown: number | null +} + +export interface MiningFoldRow { + fold: number + label?: string + train_start?: string + train_end?: string + test_start?: string + test_end?: string + selected_factors?: string[] + total_return: number | null + sharpe: number | null + max_drawdown?: number | null + n_trades?: number | null + skipped?: boolean + reason?: string | null + evaluation_kind?: 'selected' | 'cross' | 'benchmark' | null +} + +export interface MiningCandidateGate { + qualified: boolean + reasons: string[] +} + +export interface MiningCandidateRow { + signature: string + name: string + kind: 'factor_combination' | 'existing_strategy' + factor_names?: string[] + strategy_id?: string | null + regime_state?: string | null + score: number | null + oos_return: number | null + oos_sharpe: number | null + oos_max_drawdown: number | null + oos_positive_fold_ratio: number | null + oos_n_trades: number | null + confidence: 'low' | 'standard' | 'high' + valid_folds?: number | null + skipped_folds?: number | null + promoted_candidate_id?: string | null + published_strategy_id?: string | null + gate?: MiningCandidateGate | null + folds?: MiningFoldRow[] +} + +export interface MiningTelemetry { + elapsed_ms?: number + peak_rss_bytes?: number + panel_scans?: number + matrix_bytes?: number + cache_hits?: number + fold_reuses?: number + serialized_result_bytes?: number + phase_ms?: Record +} + +export interface MiningRequestSummary { + asset_type: string + budget_profile: string + start: string | null + end: string | null + factor_count: number + strategy_count: number + commission_pct: number | null + stamp_tax_pct: number | null + slippage_bps: number | null + correlation_threshold: number | null +} + +export interface MiningResult { + run_id: string + methodology_version: string + algorithm_version: string + data_as_of: string | null + summary: MiningResultSummary + request_summary?: MiningRequestSummary | null + factors: MiningFactorRow[] + correlation: { + labels: string[] + matrix: (number | null)[][] + pair_counts?: (number | null)[][] + threshold: number + } + regimes: MiningRegimeRow[] + candidates: MiningCandidateRow[] + folds: MiningFoldRow[] + telemetry: MiningTelemetry +} + +export interface MiningEvent { + id: number + type: string + timestamp?: string + payload?: Record + message?: string +} + +export interface MiningScheduleConfig { + mining_schedule_enabled: boolean + mining_schedule_weekday: number + mining_budget_profile: Exclude +} + export type ResearchCandidateKind = 'factor' | 'strategy' export type ResearchCandidateStatus = 'pending' | 'validated' | 'rejected' @@ -1751,8 +2055,28 @@ export const api = { if (start) params.set('start', start) if (end) params.set('end', end) const qs = params.toString() - return request<{ ok: boolean; computed: number }>(`/api/regime/recompute${qs ? `?${qs}` : ''}`, { method: 'POST' }) + return request<{ ok: boolean; computed: number; phase_days?: number; mainline_rows?: number }>(`/api/regime/recompute${qs ? `?${qs}` : ''}`, { method: 'POST' }) }, + regimePhases: (start?: string, end?: string) => { + const params = new URLSearchParams() + if (start) params.set('start', start) + if (end) params.set('end', end) + const qs = params.toString() + return request(`/api/regime/phases${qs ? `?${qs}` : ''}`) + }, + regimeMainline: (start?: string, end?: string, top = 10, kind: 'concept' | 'industry' = 'concept') => { + const params = new URLSearchParams({ top: String(top), kind }) + if (start) params.set('start', start) + if (end) params.set('end', end) + return request(`/api/regime/mainline?${params.toString()}`) + }, + regimeMainlineRecompute: () => + request<{ ok: boolean; rows: number }>('/api/regime/mainline/recompute', { method: 'POST' }), + mainlineFilterUpdate: (payload: { min_members?: number; max_members?: number; blacklist?: string[] }) => + request('/api/settings/preferences/mainline-filter', { + method: 'PUT', + body: JSON.stringify(payload), + }), limitLadder: (asOf?: string, extColumns?: string, direction?: 'up' | 'down') => { const params = new URLSearchParams() @@ -1820,6 +2144,64 @@ export const api = { body: JSON.stringify(payload), }), + miningRuns: () => + request<{ items: MiningRun[] }>('/api/backtest/mining/runs'), + + miningAvailability: (params: { + assetType: 'stock' | 'etf' + budgetProfile: MiningBudgetProfile + start?: string + end?: string + }) => { + const query = new URLSearchParams({ + asset_type: params.assetType, + budget_profile: params.budgetProfile, + }) + if (params.start) query.set('start', params.start) + if (params.end) query.set('end', params.end) + return request(`/api/backtest/mining/availability?${query}`, { + quiet: true, + }) + }, + + miningRun: (runId: string) => + request(`/api/backtest/mining/runs/${encodeURIComponent(runId)}`), + + miningStart: (payload: MiningRequestV1) => + request('/api/backtest/mining/runs', { + method: 'POST', + body: JSON.stringify(payload), + }), + + miningResult: (runId: string) => + request(`/api/backtest/mining/runs/${encodeURIComponent(runId)}/result`), + + miningCancel: (runId: string) => + request(`/api/backtest/mining/runs/${encodeURIComponent(runId)}/cancel`, { + method: 'POST', + }), + + miningPromote: (runId: string, signature: string) => + request( + `/api/backtest/mining/runs/${encodeURIComponent(runId)}/candidates/${encodeURIComponent(signature)}/promote`, + { method: 'POST' }, + ), + + miningPublish: (runId: string, signature: string) => + request<{ ok: boolean; strategy_id: string }>( + `/api/backtest/mining/runs/${encodeURIComponent(runId)}/candidates/${encodeURIComponent(signature)}/publish`, + { method: 'POST' }, + ), + + miningConfig: () => + request('/api/backtest/mining/config'), + + updateMiningConfig: (payload: Partial) => + request('/api/backtest/mining/config', { + method: 'PATCH', + body: JSON.stringify(payload), + }), + researchCandidates: () => request<{ items: ResearchCandidate[] }>('/api/backtest/candidates'), diff --git a/frontend/src/lib/miningTask.ts b/frontend/src/lib/miningTask.ts new file mode 100644 index 0000000..10b23e8 --- /dev/null +++ b/frontend/src/lib/miningTask.ts @@ -0,0 +1,376 @@ +import { useSyncExternalStore } from 'react' +import { api, type MiningResult, type MiningRun, type MiningRunProgress, type MiningRunStatus } from './api' + +export interface MiningTask { + runId: string | null + isPending: boolean + cancelling: boolean + reconnecting: boolean + run: MiningRun | null + progress: MiningRunProgress | null + result: MiningResult | null + previousResult: MiningResult | null + error: string | null +} + +const ACTIVE_RUN_KEY = 'mining_active_run_id' +const TERMINAL_STATES = new Set([ + 'succeeded', + 'succeeded_with_budget_exhausted', + 'failed', + 'cancelled', + 'interrupted', + 'skipped_prerequisite', +]) +const SUCCESS_STATES = new Set([ + 'succeeded', + 'succeeded_with_budget_exhausted', +]) +const STATUS_POLL_INTERVAL_MS = 2000 + +let current: MiningTask = { + runId: null, + isPending: false, + cancelling: false, + reconnecting: false, + run: null, + progress: null, + result: null, + previousResult: null, + error: null, +} +let eventSource: EventSource | null = null +let connectionToken = 0 +let statusPoll: { + runId: string + token: number + timer: ReturnType | null +} | null = null +const listeners = new Set<() => void>() + +function emit() { + listeners.forEach(listener => listener()) +} + +function update(patch: Partial) { + current = { ...current, ...patch } + emit() +} + +function subscribe(listener: () => void) { + listeners.add(listener) + return () => listeners.delete(listener) +} + +function stopStatusPolling() { + if (statusPoll?.timer) clearTimeout(statusPoll.timer) + statusPoll = null +} + +function closeEvents() { + connectionToken += 1 + stopStatusPolling() + eventSource?.close() + eventSource = null +} + +function eventPayload(event: MessageEvent): Record { + try { + const parsed = JSON.parse(event.data) + if (parsed && typeof parsed === 'object') { + return parsed.payload && typeof parsed.payload === 'object' + ? { ...parsed, ...parsed.payload } + : parsed + } + } catch { /* ignore malformed progress events */ } + return {} +} + +async function refreshTerminalRun( + runId: string, + fallbackStatus?: MiningRunStatus, + knownRun?: MiningRun, + token = connectionToken, + fallbackError?: string, +) { + try { + const run = knownRun ?? await api.miningRun(runId) + let result: MiningResult | null = null + if (SUCCESS_STATES.has(run.status)) { + result = await api.miningResult(runId) + if (result.run_id !== runId) throw new Error('任务结果与运行 ID 不匹配') + } + if (current.runId !== runId || connectionToken !== token) return + localStorage.removeItem(ACTIVE_RUN_KEY) + update({ + run, + progress: run.progress ?? current.progress, + result, + isPending: false, + cancelling: false, + reconnecting: false, + error: run.error || fallbackError || null, + }) + } catch (error) { + if (current.runId !== runId || connectionToken !== token) return + localStorage.removeItem(ACTIVE_RUN_KEY) + const run = current.run && fallbackStatus + ? { ...current.run, status: fallbackStatus, error: fallbackError || current.run.error } + : current.run + update({ + run, + result: null, + isPending: false, + cancelling: false, + reconnecting: false, + error: fallbackStatus === 'cancelled' + ? '任务已取消' + : fallbackError || String((error as Error).message || error), + }) + } +} + +function startStatusPolling(runId: string, token: number, restart = false) { + if (restart) stopStatusPolling() + if (statusPoll?.runId === runId && statusPoll.token === token) return + stopStatusPolling() + + const poll = { runId, token, timer: null as ReturnType | null } + statusPoll = poll + + const pollStatus = async () => { + if ( + statusPoll !== poll + || current.runId !== runId + || connectionToken !== token + || !current.isPending + ) return + + try { + const run = await api.miningRun(runId) + if (statusPoll !== poll || current.runId !== runId || connectionToken !== token) return + update({ + run, + progress: run.progress ?? current.progress, + cancelling: current.cancelling || run.status === 'cancelling', + }) + if (TERMINAL_STATES.has(run.status)) { + closeEvents() + const terminalToken = connectionToken + await refreshTerminalRun(runId, run.status, run, terminalToken) + return + } + } catch { + // EventSource keeps reconnecting; polling is only a bounded status fallback. + } + + if ( + statusPoll !== poll + || current.runId !== runId + || connectionToken !== token + || !current.isPending + ) return + poll.timer = setTimeout(() => { + poll.timer = null + void pollStatus() + }, STATUS_POLL_INTERVAL_MS) + } + + void pollStatus() +} + +function connect(runId: string) { + closeEvents() + const token = connectionToken + const source = new EventSource(`/api/backtest/mining/runs/${encodeURIComponent(runId)}/events`) + eventSource = source + + source.onopen = () => { + if (token !== connectionToken) return + update({ reconnecting: false }) + if (!current.cancelling) stopStatusPolling() + } + + source.addEventListener('progress', event => { + if (token !== connectionToken) return + update({ + progress: eventPayload(event as MessageEvent) as unknown as MiningRunProgress, + reconnecting: false, + }) + if (!current.cancelling) stopStatusPolling() + }) + + const onTerminal = (event: Event) => { + if (token !== connectionToken) return + const payload = eventPayload(event as MessageEvent) + const eventType = (event as MessageEvent).type + const status = (payload.status || eventType) as MiningRunStatus + closeEvents() + const terminalToken = connectionToken + void refreshTerminalRun( + runId, + status, + undefined, + terminalToken, + typeof payload.message === 'string' ? payload.message : undefined, + ) + } + for (const type of [ + 'succeeded', + 'succeeded_with_budget_exhausted', + 'failed', + 'cancelled', + 'interrupted', + 'skipped_prerequisite', + ]) { + source.addEventListener(type, onTerminal) + } + + source.onerror = () => { + if (token !== connectionToken || !current.isPending) return + update({ reconnecting: true }) + startStatusPolling(runId, token) + } +} + +export async function startMining(payload: Parameters[0]) { + closeEvents() + localStorage.removeItem(ACTIVE_RUN_KEY) + const token = connectionToken + update({ + runId: null, + isPending: true, + cancelling: false, + reconnecting: false, + run: null, + progress: { phase: 'queued', label: '创建任务' }, + result: null, + previousResult: current.result ?? current.previousResult, + error: null, + }) + try { + const run = await api.miningStart(payload) + if (connectionToken !== token || current.runId !== null) return + localStorage.setItem(ACTIVE_RUN_KEY, run.run_id) + update({ + runId: run.run_id, + run, + progress: run.progress ?? current.progress, + isPending: !TERMINAL_STATES.has(run.status), + }) + if (TERMINAL_STATES.has(run.status)) { + await refreshTerminalRun(run.run_id, run.status, run, token) + } else { + connect(run.run_id) + } + } catch (error) { + if (connectionToken !== token || current.runId !== null) return + update({ + isPending: false, + error: String((error as Error).message || error), + }) + } +} + +export async function cancelMining() { + if (!current.runId || !current.isPending || current.cancelling) return + const runId = current.runId + const token = connectionToken + update({ cancelling: true, error: null }) + startStatusPolling(runId, token, true) + try { + const run = await api.miningCancel(runId) + if (current.runId !== runId || connectionToken !== token) return + update({ + run, + progress: run.progress ?? current.progress, + cancelling: !TERMINAL_STATES.has(run.status), + }) + if (TERMINAL_STATES.has(run.status)) { + closeEvents() + const terminalToken = connectionToken + await refreshTerminalRun(runId, run.status, run, terminalToken) + } + } catch (error) { + if (current.runId !== runId || connectionToken !== token) return + update({ + cancelling: true, + reconnecting: true, + error: String((error as Error).message || error), + }) + startStatusPolling(runId, token, true) + } +} + +export async function attachMiningRun(runId: string): Promise { + closeEvents() + const token = connectionToken + const previousResult = current.result ?? current.previousResult + update({ + runId, + isPending: true, + cancelling: false, + reconnecting: true, + run: null, + progress: { phase: 'reconnecting', label: '读取任务状态' }, + result: null, + previousResult, + error: null, + }) + try { + const run = await api.miningRun(runId) + if (current.runId !== runId || connectionToken !== token) return false + update({ + run, + progress: run.progress ?? null, + isPending: !TERMINAL_STATES.has(run.status), + cancelling: run.status === 'cancelling', + reconnecting: false, + error: run.error ?? null, + }) + if (TERMINAL_STATES.has(run.status)) { + await refreshTerminalRun(runId, run.status, run, token) + } else { + localStorage.setItem(ACTIVE_RUN_KEY, runId) + connect(runId) + } + return true + } catch (error) { + if (current.runId !== runId || connectionToken !== token) return false + localStorage.removeItem(ACTIVE_RUN_KEY) + update({ + isPending: false, + reconnecting: false, + error: String((error as Error).message || error), + }) + return false + } +} + +export function tryReconnectMining(): boolean { + const runId = localStorage.getItem(ACTIVE_RUN_KEY) + if (!runId) return false + void attachMiningRun(runId) + return true +} + +export function clearMiningTask() { + closeEvents() + localStorage.removeItem(ACTIVE_RUN_KEY) + current = { + runId: null, + isPending: false, + cancelling: false, + reconnecting: false, + run: null, + progress: null, + result: null, + previousResult: current.result ?? current.previousResult, + error: null, + } + emit() +} + +export function useMiningTask(): MiningTask { + return useSyncExternalStore(subscribe, () => current, () => current) +} diff --git a/frontend/src/lib/queryKeys.ts b/frontend/src/lib/queryKeys.ts index 073eef0..1e048a4 100644 --- a/frontend/src/lib/queryKeys.ts +++ b/frontend/src/lib/queryKeys.ts @@ -26,7 +26,11 @@ export const QK = { watchlistGroups: ['watchlist-groups'] as const, watchlistQuotes: ['watchlist-quotes'] as const, watchlistEnriched: (ext?: string) => ['watchlist-enriched', ext] as const, - watchlistKlineBatch: (symbols: string) => ['watchlist-kline-batch', symbols] as const, + // 不用 watchlist- 前缀: 日K历史盘中几乎不变, 若被 SSE quotes_updated 高频失效 + // (expert 1s) 会导致全自选日K每秒重拉, staleTime 形同虚设。 + // 刷新点: staleTime 过期 + Watchlist 增删自选/改蜡烛天数时的手动失效; + // 当日最后一根蜡烛由 Watchlist 用 enriched 实时 OHLC 前端修补 (零额外请求)。 + watchlistKlineBatch: (symbols: string) => ['kline-batch', symbols] as const, // 不用 watchlist- 前缀: 避免被 SSE quotes_updated 高频失效(expert 1s/pro 2s) // 导致每次都拉 TickFlow 触限流。分时图用固定 refetchInterval 刷新即可。 minuteBatch: (symbols: string) => ['minute-batch', symbols] as const, @@ -45,8 +49,16 @@ export const QK = { // Backtest backtestStatus: ['backtest-status'] as const, factorColumns: ['backtest-factor-columns'] as const, + miningRuns: ['backtest-mining-runs'] as const, + miningAvailability: (assetType: string, profile: string, start: string, end: string) => + ['backtest-mining-availability', assetType, profile, start, end] as const, + miningRun: (id: string) => ['backtest-mining-run', id] as const, + miningResult: (id: string) => ['backtest-mining-result', id] as const, + miningConfig: ['backtest-mining-config'] as const, researchCandidates: ['research-candidates'] as const, - strategyLinkOptions: ['strategy-link-options'] as const, + strategyLinkOptions: (assetType?: 'stock' | 'etf') => assetType + ? ['strategy-link-options', assetType] as const + : ['strategy-link-options'] as const, strategyDetail: (id: string) => ['strategy-detail', id] as const, // Data / Pipeline @@ -96,6 +108,8 @@ export const QK = { regimeLatest: ['regime-latest'] as const, regimeStates: (days: number) => ['regime-states', days] as const, regimeCoverage: ['regime-coverage'] as const, + regimePhases: (start?: string, end?: string) => ['regime-phases', start ?? '', end ?? ''] as const, + regimeMainline: (kind: string, start?: string, end?: string) => ['regime-mainline', kind, start ?? '', end ?? ''] as const, } as const // ===== SSE 应该 invalidate 的 key 前缀列表 ===== @@ -107,7 +121,11 @@ export const QK = { // 且在 monitor "重算" 窗口内读到空结果, 造成策略列表闪烁 (变 0 → 空失效 → 又出现)。 export const SSE_INVALIDATE_PREFIXES = [ - 'watchlist', + // 精确前缀: 只命中自选页的实时数据 (quotes/enriched)。不能用宽泛的 'watchlist' —— + // 会误伤 ['watchlist'] (自选列表) 和 ['watchlist-groups'] (分组配置, 只随手动操作变化)。 + // 旧设置里的 'watchlist' 单开关由 useQuoteStream 兼容读取。 + 'watchlist-quotes', + 'watchlist-enriched', 'quote-status', 'index-quotes', 'overview-market', diff --git a/frontend/src/lib/useQuoteStream.ts b/frontend/src/lib/useQuoteStream.ts index 867c46f..8eb5432 100644 --- a/frontend/src/lib/useQuoteStream.ts +++ b/frontend/src/lib/useQuoteStream.ts @@ -137,6 +137,13 @@ export function useQuoteStream( const activePrefixes = SSE_INVALIDATE_PREFIXES.filter((p) => { // 'quote-status' 始终刷新 (全局状态) if (p === 'quote-status') return true + // 兼容旧配置: 'watchlist' 拆成两个精确前缀后, 未单独设置时沿用旧 'watchlist' 开关 + if ( + (p === 'watchlist-quotes' || p === 'watchlist-enriched') && + pages[p] === undefined + ) { + return pages['watchlist'] !== false + } return pages[p] !== false }) qc.invalidateQueries({ diff --git a/frontend/src/pages/Backtest.tsx b/frontend/src/pages/Backtest.tsx index 89bf7c3..0936c85 100644 --- a/frontend/src/pages/Backtest.tsx +++ b/frontend/src/pages/Backtest.tsx @@ -1,4 +1,5 @@ import { useState } from 'react' +import { Navigate, useSearchParams } from 'react-router-dom' import { BarChart3, BookmarkCheck, FlaskConical, ShieldCheck } from 'lucide-react' import { PageHeader } from '@/components/PageHeader' import { FactorDiscovery } from './backtest/FactorDiscovery' @@ -27,9 +28,28 @@ const MODES: Record('strategy') + const [searchParams, setSearchParams] = useSearchParams() + const requestedTab = searchParams.get('tab') const [candidatesOpen, setCandidatesOpen] = useState(false) + // 旧链接兼容: 挖掘已升级为一级路由 /mining, 保留 run/candidate 参数重定向 + if (requestedTab === 'mining') { + const next = new URLSearchParams(searchParams) + next.delete('tab') + const search = next.toString() + return + } + + const activeTab: Tab = requestedTab && requestedTab in MODES + ? requestedTab as Tab + : 'strategy' + + const changeTab = (tab: Tab) => { + const next = new URLSearchParams(searchParams) + next.set('tab', tab) + setSearchParams(next, { replace: true }) + } + return (
setActiveTab(tab)} + onClick={() => changeTab(tab)} aria-current={active ? 'page' : undefined} className={`inline-flex h-7 items-center gap-1 rounded-[5px] px-1.5 text-[11px] font-medium transition-colors sm:gap-1.5 sm:px-2.5 sm:text-xs ${active ? 'bg-accent text-white shadow-sm' diff --git a/frontend/src/pages/Dashboard.tsx b/frontend/src/pages/Dashboard.tsx index 641942a..c55eada 100644 --- a/frontend/src/pages/Dashboard.tsx +++ b/frontend/src/pages/Dashboard.tsx @@ -102,7 +102,6 @@ function MonitorWidget({ onStockClick }: { onStockClick: (event: AlertEvent) => queryKey: ['alerts', ''], queryFn: () => api.alertsList({ days: 7, limit: 10 }), refetchInterval: 10000, - refetchIntervalInBackground: true, }) const events: AlertEvent[] = alerts.data?.alerts ?? [] diff --git a/frontend/src/pages/LimitUpLadder.tsx b/frontend/src/pages/LimitUpLadder.tsx index c9b7f3a..b8b17d9 100644 --- a/frontend/src/pages/LimitUpLadder.tsx +++ b/frontend/src/pages/LimitUpLadder.tsx @@ -1517,7 +1517,10 @@ export function LimitUpLadder() { const extColumnsParam = useMemo(() => buildExtColumnsParam(extFields), [extFields]) const { data, isLoading, refetch, isFetching } = useQuery({ - queryKey: [QK.limitLadder(asOf || undefined), extColumnsParam, direction], + // key 必须拍平 (spread 展开): key[0] 为字符串 'limit-ladder' 才能被 SSE 前缀失效 + // 命中实现实时刷新, depth_updated 事件 (invalidate ['limit-ladder']) 也才能匹配本查询。 + // 嵌套数组 key 会导致前者靠 String() 侥幸命中、后者永远失配。 + queryKey: [...QK.limitLadder(asOf || undefined), extColumnsParam, direction], queryFn: () => api.limitLadder(asOf || undefined, extColumnsParam, direction), staleTime: 5 * 60_000, }) diff --git a/frontend/src/pages/Mining.tsx b/frontend/src/pages/Mining.tsx new file mode 100644 index 0000000..9c7fba2 --- /dev/null +++ b/frontend/src/pages/Mining.tsx @@ -0,0 +1,37 @@ +import { useState } from 'react' +import { BookmarkCheck } from 'lucide-react' +import { PageHeader } from '@/components/PageHeader' +import { MiningWorkbench } from './backtest/MiningWorkbench' +import { ResearchCandidatesDialog } from './backtest/ResearchCandidatesDialog' + +export function Mining() { + const [candidatesOpen, setCandidatesOpen] = useState(false) + + return ( +
+ 嵌套样本外因子与策略挖掘} + className="shrink-0 flex-wrap gap-x-4 gap-y-2 bg-base/95 px-3 lg:flex-nowrap lg:px-5" + right={( + + )} + /> + +
+ +
+ + {candidatesOpen && setCandidatesOpen(false)} />} +
+ ) +} diff --git a/frontend/src/pages/Monitor.tsx b/frontend/src/pages/Monitor.tsx index 5af1d56..ee0b744 100644 --- a/frontend/src/pages/Monitor.tsx +++ b/frontend/src/pages/Monitor.tsx @@ -135,8 +135,8 @@ export function Monitor() { const alertsQuery = useQuery({ queryKey: [...QK.alerts(filter === 'all' ? undefined : filter), extColumnsParam ?? ''], queryFn: () => api.alertsList({ days: 7, limit: 500, source: filter === 'all' ? undefined : filter, extColumns: extColumnsParam }), + // 10s 轮询仅作 SSE strategy_alert 事件的兜底; 后台标签页不再拉 500 条全量 refetchInterval: 10000, - refetchIntervalInBackground: true, }) const total = alertsQuery.data?.total ?? 0 @@ -351,7 +351,7 @@ function AlertsList({ alertsQuery, confirmClear, setConfirmClear, total, enterTs const isNew = ev.ts > enterTs return ( api.regimeStates(days), staleTime: 5 * 60 * 1000, }) + // 情绪周期阶段段 + 主线排行(与 history 同一时间范围) + const phases = useQuery({ + queryKey: QK.regimePhases(histRange.start, histRange.end), + queryFn: () => api.regimePhases(histRange.start, histRange.end), + staleTime: 5 * 60 * 1000, + }) + const [mainlineKind, setMainlineKind] = useState<'concept' | 'industry'>('concept') + const [filterOpen, setFilterOpen] = useState(false) + const mainline = useQuery({ + queryKey: QK.regimeMainline(mainlineKind, histRange.start, histRange.end), + queryFn: () => api.regimeMainline(histRange.start, histRange.end, 10, mainlineKind), + staleTime: 5 * 60 * 1000, + }) const [recomputing, setRecomputing] = useState(false) const rows: RegimeRow[] = history.data?.rows ?? [] const latest = rows.length > 0 ? rows[rows.length - 1] : null + const hasPhaseData = rows.length > 0 && rows.some(r => r.phase != null) + const segments = phases.data?.segments ?? [] + + // 当前阶段持续天数(末尾连续同阶段) + 当前主线(最新交易日 top3) + const phaseStreak = useMemo(() => { + if (!hasPhaseData) return null + const lastPhase = rows[rows.length - 1].phase + let streak = 1 + for (let i = rows.length - 2; i >= 0; i--) { + if (rows[i].phase === lastPhase) streak++ + else break + } + return { phase: lastPhase as MarketPhase, streak } + }, [rows, hasPhaseData]) + const latestMainlines = useMemo(() => { + const mlRows = mainline.data?.rows ?? [] + if (mlRows.length === 0) return [] + const lastDate = mlRows[mlRows.length - 1].date + return mlRows.filter(r => r.date === lastDate && r.rank <= 3) + }, [mainline.data]) // ── 当前势头: 末尾连续同态天数 + score 5日斜率(改善/恶化) + 上次弱势距今 ── const momentum = useMemo(() => { @@ -185,6 +219,77 @@ export function Regime() { + // 阶段时间轴: 高度折线 + 2板以上宽度柱 + 晋级率曲线, 背景色带=情绪周期阶段 + const phaseOption = useMemo(() => { + if (rows.length === 0 || !hasPhaseData) return null + const dates = rows.map(r => r.date) + const heights = rows.map(r => r.max_consecutive) + const ge2 = rows.map(r => r.ge2_count ?? null) + const promo = rows.map(r => (r.promo_rate != null ? Math.round(r.promo_rate * 100) : null)) + const phaseBands: any[] = [] + let bandStart = rows[0]?.date + let prevPhase = rows[0]?.phase + rows.forEach((r, i) => { + if (r.phase !== prevPhase || i === rows.length - 1) { + const bandEnd = i === rows.length - 1 ? r.date : rows[i - 1].date + if (prevPhase && MARKET_PHASE_COLORS[prevPhase as MarketPhase]) { + phaseBands.push([ + { xAxis: bandStart, itemStyle: { color: MARKET_PHASE_COLORS[prevPhase as MarketPhase], opacity: 0.10 } }, + { xAxis: bandEnd }, + ]) + } + bandStart = r.date + prevPhase = r.phase + } + }) + return { + backgroundColor: 'transparent', + tooltip: { + trigger: 'axis', backgroundColor: ct.tooltipBg, borderColor: ct.tooltipBorder, + textStyle: { color: ct.tooltipText }, + formatter: (params: any) => { + const p0 = Array.isArray(params) ? params[0] : params + const i = dates.indexOf(p0.axisValue) + const r = rows[i] + if (!r) return '' + const phase = r.phase ? MARKET_PHASE_LABELS[r.phase] : '—' + return [ + `${r.date} · ${phase}`, + `高度 ${r.max_consecutive} · 首板 ${r.first_board ?? '—'} · 2板+ ${r.ge2_count ?? '—'}`, + `晋级率 ${r.promo_rate != null ? (r.promo_rate * 100).toFixed(1) + '%' : '—'} · 封板率 ${r.seal_rate != null ? (r.seal_rate * 100).toFixed(1) + '%' : '—'}`, + ].join('
') + }, + }, + legend: { + data: ['高度', '2板+', '晋级率'], textStyle: { color: ct.text, fontSize: 10 }, top: 0, + }, + grid: { left: 44, right: 44, top: 32, bottom: 44 }, + xAxis: { + type: 'category', data: dates, boundaryGap: false, + axisLabel: { color: ct.text, fontSize: 10, formatter: (v: string) => v.slice(5) }, + axisLine: { lineStyle: { color: ct.grid } }, + }, + yAxis: [ + { type: 'value', name: '高度/宽度', position: 'left', axisLabel: { color: ct.text, fontSize: 10 }, splitLine: { show: false }, nameTextStyle: { color: ct.text } }, + { type: 'value', name: '晋级率%', min: 0, max: 100, position: 'right', axisLabel: { color: ct.text, fontSize: 10 }, splitLine: { lineStyle: { color: ct.grid } }, nameTextStyle: { color: ct.text } }, + ], + dataZoom: [ + { type: 'inside', start: Math.max(0, 100 - (60 / days) * 100) }, + { type: 'slider', bottom: 6, height: 14, borderColor: ct.border, fillerColor: ct.zoomFill, textStyle: { color: ct.text } }, + ], + series: [ + { name: '2板+', type: 'bar', data: ge2, yAxisIndex: 0, barMaxWidth: 5, + itemStyle: { color: '#f59e0b', opacity: 0.4 }, z: 1 }, + { name: '高度', type: 'line', data: heights, smooth: true, symbol: 'none', yAxisIndex: 0, + lineStyle: { width: 1.6, color: '#ef4444' }, z: 3, + markArea: { silent: true, data: phaseBands } }, + { name: '晋级率', type: 'line', data: promo, smooth: true, symbol: 'none', yAxisIndex: 1, + lineStyle: { width: 1.2, color: '#3b82f6', type: 'dotted' }, z: 2 }, + ], + } + }, [rows, days, ct, hasPhaseData]) + const phaseChartRef = useEChart(phaseOption, [phaseOption]) + // 趋势图: 综合分主线 + 4 子维度曲线(可切换) + 状态背景色带 + 涨停数柱状 const trendOption = useMemo(() => { if (rows.length === 0) return null @@ -366,6 +471,8 @@ export function Regime() { qc.invalidateQueries({ queryKey: ['regime-history'] }), qc.invalidateQueries({ queryKey: ['regime-states'] }), qc.invalidateQueries({ queryKey: ['regime-latest'] }), + qc.invalidateQueries({ queryKey: ['regime-phases'] }), + qc.invalidateQueries({ queryKey: ['regime-mainline'] }), qc.invalidateQueries({ queryKey: QK.regimeCoverage }), ]) } catch (e) { @@ -429,6 +536,207 @@ export function Regime() {
+ {/* ── 市场阶段概览 (情绪周期 + 梯队指标 + 当前主线) ── */} + {hasPhaseData && latest ? ( +
+ {/* 当前阶段 */} +
+
+ 当前阶段 · {latest.date} +
+
+ + {MARKET_PHASE_LABELS[phaseStreak?.phase ?? 'repair']} + + {phaseStreak && 第 {phaseStreak.streak} 天} +
+
+ {latestMainlines.length > 0 ? latestMainlines.map(m => ( + + {m.member} + + )) : 暂无主线数据} +
+
+ {([ + { label: '市场高度', val: latest.max_consecutive, unit: '板', color: '#ef4444' }, + { label: '首板宽度', val: latest.first_board, unit: '家', color: '#f97316' }, + { label: '2板+宽度', val: latest.ge2_count, unit: '家', color: '#f59e0b' }, + { label: '晋级率', val: latest.promo_rate != null ? `${(latest.promo_rate * 100).toFixed(0)}%` : '—', + unit: '', color: '#3b82f6', + sub: latest.promo_pool != null ? `池 ${latest.promo_pool} 家` : undefined }, + { label: '梯队完整度', val: latest.ladder_completeness != null ? `${(latest.ladder_completeness * 100).toFixed(0)}%` : '—', + unit: '', color: '#a855f7', sub: '2板→最高板不断档' }, + ] as { label: string; val: React.ReactNode; unit: string; color: string; sub?: string }[]).map(k => ( +
+
+ {k.label} +
+
+ {k.val}{k.unit} +
+ {k.sub &&
{k.sub}
} +
+ ))} +
+ ) : ( +
+ 市场阶段(情绪周期)数据尚未生成 — 点击右上角「重算」即可回填全部历史阶段与主线 +
+ )} + + {/* ── 情绪周期时间轴 (阶段色带 + 高度/宽度/晋级率) ── */} + {hasPhaseData && rows.length > 0 && ( +
+ +
+
+ {rows.map(r => ( +
+ ))} +
+
+ {MARKET_PHASE_ORDER.map(p => ( + + + {MARKET_PHASE_LABELS[p]} + + ))} +
+
+ )} + + {/* ── 阶段 × 主线 (什么阶段走什么主升) ── */} + {segments.length > 0 && ( +
+ +
+ + + + + + + + + + + + + + + {[...segments].reverse().map((seg, i) => ( + + + + + + + + + + + ))} + +
阶段区间天数高度2板+晋级率封板率主导主线
+ + {seg.label} + + + {seg.start.slice(5)} ~ {seg.end.slice(5)} + {seg.days}{seg.avg_height}{seg.avg_ge2} + {seg.avg_promo != null ? `${(seg.avg_promo * 100).toFixed(0)}%` : '—'} + + {seg.avg_seal_rate != null ? `${(seg.avg_seal_rate * 100).toFixed(0)}%` : '—'} + +
+ {seg.top_mainlines.length > 0 ? seg.top_mainlines.map(m => ( + + {m.member}{m.top5_days}d + + )) : —} +
+
+
+
+ )} + + {/* ── 主线排行 (窗口内持续性 + 过滤设置) ── */} +
+ + {mainline.data?.membership_note} + + + } + /> +
+
+ {([['concept', '概念'], ['industry', '行业']] as const).map(([k, label]) => ( + + ))} +
+ 窗口内 top1 天数排序 · 点击「过滤」配置宽基概念屏蔽 +
+ {filterOpen && ( + { + await qc.invalidateQueries({ queryKey: ['regime-mainline'] }) + await qc.invalidateQueries({ queryKey: ['regime-phases'] }) + }} + /> + )} +
+ + + + + + + + + + + + {(mainline.data?.leaders ?? []).map((l, i) => ( + + + + + + + + ))} + {(mainline.data?.leaders ?? []).length === 0 && ( + + )} + +
#主线top1 天数日均分最高板
{i + 1}{l.member}{l.top1_days}{l.avg_score}{l.max_boards} 板
+ {mainline.isLoading ? '加载中…' : '暂无主线数据 — 点击「重算」回填, 或检查过滤设置'} +
+
+
+ {/* ── 最新日概览 (4 个指标卡, 去掉与看板重复的涨停/涨跌/成交额) ── */} {latest ? (
@@ -661,6 +969,91 @@ export function Regime() { ) } +// ── 主线过滤设置面板 ────────────────────────────────────── +// 宽基/风格标签(融资融券/沪深股通等数千成分)会霸占主线榜首。默认按成员数 +// 上限过滤; 用户可调阈值并按名称屏蔽特定概念, 保存后自动重算主线。 +function MainlineFilterPanel({ filter, onDone }: { + filter: { min_members: number; max_members: number; blacklist: string[] } | undefined + onDone: () => Promise +}) { + const [minMembers, setMinMembers] = useState(String(filter?.min_members ?? 4)) + const [maxMembers, setMaxMembers] = useState(String(filter?.max_members ?? 600)) + const [blacklist, setBlacklist] = useState(filter?.blacklist ?? []) + const [input, setInput] = useState('') + const [saving, setSaving] = useState(false) + + const addTag = () => { + const v = input.trim() + if (v && !blacklist.includes(v)) setBlacklist([...blacklist, v]) + setInput('') + } + + const save = async () => { + setSaving(true) + try { + await api.mainlineFilterUpdate({ + min_members: Math.max(1, Number(minMembers) || 4), + max_members: Math.max(50, Number(maxMembers) || 600), + blacklist, + }) + await api.regimeMainlineRecompute() + toast('过滤已保存, 主线已重算', 'success') + await onDone() + } catch (e) { + toast(`保存失败 · ${String((e as Error)?.message || e)}`, 'error') + } finally { + setSaving(false) + } + } + + return ( +
+
+ + +
+ 按名称屏蔽(回车添加) +
+ setInput(e.target.value)} + onKeyDown={e => { if (e.key === 'Enter') { e.preventDefault(); addTag() } }} + placeholder="如: 融资融券、沪股通" + className="h-7 flex-1 rounded-input border border-border bg-base px-2 text-xs text-foreground outline-none focus:border-accent" /> +
+ {blacklist.length > 0 && ( +
+ {blacklist.map(b => ( + + {b} + + + ))} +
+ )} +
+ +
+
+ 说明: 成分股数超过上限的概念(如 融资融券~7700家/沪深股通~3300家)视为宽基/风格标签, 不参与主线排名; 修改后自动重算全部历史主线(秒级)。 +
+
+ ) +} + // ── 自定义天数输入弹窗 ──────────────────────────────────── function CustomDaysModal({ current, onClose, onApply }: { current: number diff --git a/frontend/src/pages/Screener.tsx b/frontend/src/pages/Screener.tsx index b6b533f..0b93868 100644 --- a/frontend/src/pages/Screener.tsx +++ b/frontend/src/pages/Screener.tsx @@ -36,6 +36,9 @@ import { type ColumnConfig, } from '@/lib/screener-columns' +// 获取策略为占位功能, 暂时隐藏入口; 恢复时改回 true +const SHOW_STRATEGY_STORE = false + export function Screener() { const [assetType, setAssetType] = useState<'stock' | 'etf'>('stock') const [activeStrategy, setActiveStrategy] = useState(null) @@ -115,10 +118,12 @@ export function Screener() { setFilter(filterMap.current.get(strategyId) ?? { ...defaultFilter }) }, []) - // 对原始结果应用过滤 - const filteredRows = result - ? applyFilter(result.rows, filter) - : [] + // 对原始结果应用过滤 (memo: 否则每次渲染都对全部结果行过滤, + // 且新数组身份会击穿下游 displayRows 的 memo) + const filteredRows = useMemo( + () => (result ? applyFilter(result.rows, filter) : []), + [result, filter], + ) const { data: prefs } = usePreferences() const screenerAutoRun = prefs?.screener_auto_run ?? true @@ -698,16 +703,18 @@ export function Screener() { 创建策略 · AI - {/* 获取策略（占位，敬请期待） */} - + {/* 获取策略（占位，敬请期待）— 暂时隐藏 */} + {SHOW_STRATEGY_STORE && ( + + )}
} /> diff --git a/frontend/src/pages/Watchlist.tsx b/frontend/src/pages/Watchlist.tsx index 5118768..41643a9 100644 --- a/frontend/src/pages/Watchlist.tsx +++ b/frontend/src/pages/Watchlist.tsx @@ -787,7 +787,32 @@ export function Watchlist() { staleTime: 5 * 60_000, // 5 分钟内不重请求 }) - const klineData = dailyKVisible ? (klineBatch.data?.data ?? {}) : {} + // 当日蜡烛实时修补: 历史 K 线按 staleTime 周期拉取 (见 queryKeys 注释), 最后一根 + // 蜡烛用每 tick 刷新的 enriched 当日 OHLC 前端覆盖/追加, 蜡烛随实时行情跳动, 零额外请求。 + const klineData = useMemo(() => { + const base = dailyKVisible ? (klineBatch.data?.data ?? {}) : {} + const liveRows = enriched.data?.rows + const asOf = enriched.data?.as_of + if (!dailyKVisible || !liveRows?.length || !asOf) return base + const liveBySymbol = new Map(liveRows.map((r: any) => [r.symbol, r])) + const patched: Record = {} + for (const sym of Object.keys(base)) { + const arr = base[sym] + if (!Array.isArray(arr) || arr.length === 0) { patched[sym] = arr; continue } + const live = liveBySymbol.get(sym) + const { open, high, low, close } = live ?? {} + if (open == null || high == null || low == null || close == null) { patched[sym] = arr; continue } + const last = arr[arr.length - 1] + if (last.date === asOf) { + patched[sym] = [...arr.slice(0, -1), { ...last, open, high, low, close }] + } else if (last.date < asOf) { + patched[sym] = [...arr, { date: asOf, open, high, low, close }] + } else { + patched[sym] = arr + } + } + return patched + }, [dailyKVisible, klineBatch.data, enriched.data]) // 批量分时数据 (Pro+ 用户, 列可见时才拉) // 刷新策略: 仅当实时行情运行 且 用户在实时监控设置里开启 minute_intraday_refresh 时 @@ -811,7 +836,7 @@ export function Watchlist() { qc.setQueryData(QK.watchlist, data) qc.invalidateQueries({ queryKey: QK.watchlist }) qc.invalidateQueries({ queryKey: ['watchlist-enriched'] }) - qc.invalidateQueries({ queryKey: ['watchlist-kline-batch'] }) + qc.invalidateQueries({ queryKey: ['kline-batch'] }) }, }) @@ -826,7 +851,7 @@ export function Watchlist() { // 2. 清除 list 缓存，触发后台 refetch qc.invalidateQueries({ queryKey: QK.watchlist }) qc.invalidateQueries({ queryKey: ['watchlist-enriched'] }) - qc.invalidateQueries({ queryKey: ['watchlist-kline-batch'] }) + qc.invalidateQueries({ queryKey: ['kline-batch'] }) }, }) @@ -836,7 +861,7 @@ export function Watchlist() { qc.setQueryData(QK.watchlist, data) qc.invalidateQueries({ queryKey: QK.watchlist }) qc.invalidateQueries({ queryKey: ['watchlist-enriched'] }) - qc.invalidateQueries({ queryKey: ['watchlist-kline-batch'] }) + qc.invalidateQueries({ queryKey: ['kline-batch'] }) qc.invalidateQueries({ queryKey: QK.preferences }) qc.invalidateQueries({ queryKey: QK.quoteStatus }) }, @@ -850,7 +875,7 @@ export function Watchlist() { qc.setQueryData(['watchlist-enriched', extColumnsParam], { rows: [], as_of: null, elapsed_ms: 0 }) qc.invalidateQueries({ queryKey: QK.watchlist }) qc.invalidateQueries({ queryKey: ['watchlist-enriched'] }) - qc.invalidateQueries({ queryKey: ['watchlist-kline-batch'] }) + qc.invalidateQueries({ queryKey: ['kline-batch'] }) }, }) diff --git a/frontend/src/pages/backtest/MiningWorkbench.tsx b/frontend/src/pages/backtest/MiningWorkbench.tsx new file mode 100644 index 0000000..d76f4be --- /dev/null +++ b/frontend/src/pages/backtest/MiningWorkbench.tsx @@ -0,0 +1,698 @@ +import { useEffect, useMemo, useRef, useState } from 'react' +import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query' +import { useSearchParams } from 'react-router-dom' +import { + AlertTriangle, + CheckCircle2, + Clock3, + Database, + FlaskConical, + Gauge, + Link2, + LoaderCircle, + Play, + RefreshCw, + Rocket, + Save, + Settings2, + Square, +} from 'lucide-react' +import { EmptyState } from '@/components/EmptyState' +import { toast } from '@/components/Toast' +import { + api, + type FactorColumn, + type MiningBudgetProfile, + type MiningCandidateGate, + type MiningCandidateRow, + type MiningRequestV1, + type MiningResult, + type MiningRun, + type MiningScheduleConfig, +} from '@/lib/api' +import { + attachMiningRun, + cancelMining, + startMining, + tryReconnectMining, + useMiningTask, +} from '@/lib/miningTask' +import { QK } from '@/lib/queryKeys' +import { FactorCorrelationHeatmap } from './charts/FactorCorrelationHeatmap' +import { MiningOosChart } from './charts/MiningOosChart' +import { RegimeComparisonChart } from './charts/RegimeComparisonChart' + +const DRAFT_KEY = 'mining_workbench_draft_v1' +const TODAY = new Date().toISOString().slice(0, 10) +const INPUT = 'h-8 w-full rounded-input border border-border bg-surface px-2 text-xs text-foreground outline-none transition-colors focus:border-accent' +const LABEL = 'mb-1 block text-[10px] font-medium text-secondary' +const SUCCESS = new Set(['succeeded', 'succeeded_with_budget_exhausted']) +const ACTIVE = new Set(['queued', 'running', 'cancelling']) +const PROFILE_LABELS: Record = { + exploratory: '探索档', + balanced: '均衡档', + strict: '严格档', +} + +interface MiningDraft { + assetType: 'stock' | 'etf' + start: string + end: string + profile: MiningBudgetProfile + factorNames: string[] + strategyIds: string[] + commissionBps: string + stampTaxBps: string + slippageBps: string + correlationThreshold: string + maxCombinationFactors: string + beamWidth: string + maxFinalists: string + force: boolean +} + +function yearsAgo(years: number) { + const value = new Date() + value.setFullYear(value.getFullYear() - years) + return value.toISOString().slice(0, 10) +} + +const DEFAULT_DRAFT: MiningDraft = { + assetType: 'stock', + start: yearsAgo(4), + end: TODAY, + profile: 'exploratory', + factorNames: [], + strategyIds: [], + commissionBps: '2', + stampTaxBps: '5', + slippageBps: '5', + correlationThreshold: '0.75', + maxCombinationFactors: '4', + beamWidth: '12', + maxFinalists: '8', + force: false, +} + +function loadDraft(): MiningDraft { + try { + const value = JSON.parse(localStorage.getItem(DRAFT_KEY) || '') + if (!value || typeof value !== 'object') return DEFAULT_DRAFT + return { ...DEFAULT_DRAFT, ...value } + } catch { + return DEFAULT_DRAFT + } +} + +function parseBoundedNumber(value: string, label: string, min: number, max: number, integer = false) { + const parsed = Number(value) + if (!Number.isFinite(parsed) || parsed < min || parsed > max || (integer && !Number.isInteger(parsed))) { + toast(`${label}需为 ${min}–${max}${integer ? ' 的整数' : ''}`, 'error') + return null + } + return parsed +} + +function formatNumber(value: number | null | undefined, digits = 2) { + return typeof value === 'number' && Number.isFinite(value) ? value.toFixed(digits) : '—' +} + +function formatPct(value: number | null | undefined, digits = 2) { + return typeof value === 'number' && Number.isFinite(value) ? `${(value * 100).toFixed(digits)}%` : '—' +} + +function formatBytes(value: number | null | undefined) { + if (typeof value !== 'number' || !Number.isFinite(value)) return '—' + if (value >= 1024 ** 3) return `${(value / 1024 ** 3).toFixed(2)} GB` + if (value >= 1024 ** 2) return `${(value / 1024 ** 2).toFixed(1)} MB` + if (value >= 1024) return `${(value / 1024).toFixed(1)} KB` + return `${value} B` +} + +function statusLabel(status?: string) { + return ({ + queued: '排队中', + running: '挖掘中', + cancelling: '正在取消', + succeeded: '已完成', + succeeded_with_budget_exhausted: '已完成（预算耗尽）', + failed: '失败', + cancelled: '已取消', + interrupted: '启动中断', + skipped_prerequisite: '前置条件不足', + } as Record)[status || ''] || '未运行' +} + +function confidenceLabel(value?: string) { + return value === 'high' ? '高' : value === 'standard' ? '标准' : '低' +} + +function definitionLabel(candidate: MiningCandidateRow) { + if (candidate.kind === 'existing_strategy') return candidate.strategy_id || '已有策略' + return candidate.factor_names?.join(' + ') || '因子组合' +} + +function gateTitle(gate?: MiningCandidateGate | null) { + if (!gate || !gate.reasons.length) return undefined + return gate.reasons.join('\n') +} + +function RequestSummaryLine({ result }: { result: MiningResult }) { + const request = result.request_summary + if (!request) return null + const items: [string, string][] = [ + ['资产', request.asset_type === 'etf' ? 'ETF' : '股票'], + ['档位', PROFILE_LABELS[request.budget_profile as MiningBudgetProfile] || request.budget_profile], + ['区间', `${request.start || '—'} → ${request.end || '—'}`], + ['因子', String(request.factor_count)], + ['对照策略', String(request.strategy_count)], + ['成本', `佣金 ${formatBps(request.commission_pct)} / 印花 ${formatBps(request.stamp_tax_pct)} / 滑点 ${typeof request.slippage_bps === 'number' && Number.isFinite(request.slippage_bps) ? `${request.slippage_bps.toFixed(1)}bp` : '—'}`], + ['相关阈值', request.correlation_threshold == null ? '—' : request.correlation_threshold.toFixed(2)], + ] + return ( +
+ {items.map(([label, value]) => ( + + {label}{' '} + {value} + + ))} +
+ ) +} + +function formatBps(ratio: number | null | undefined, digits = 1) { + return typeof ratio === 'number' && Number.isFinite(ratio) ? `${(ratio * 10000).toFixed(digits)}bp` : '—' +} + +function foldKindLabel(kind?: string | null) { + if (kind === 'cross') return '跨折' + if (kind === 'benchmark') return '对照' + return undefined +} + +function SummaryStrip({ result }: { result: MiningResult }) { + const items = [ + ['因子', `${result.summary.selected_factor_count}/${result.summary.factor_count}`], + ['候选', String(result.summary.candidate_count)], + ['有效折', String(result.summary.valid_fold_count)], + ['跳过折', String(result.summary.skipped_fold_count)], + ['置信度', confidenceLabel(result.summary.confidence)], + ['耗时', result.summary.elapsed_ms == null ? '—' : `${(result.summary.elapsed_ms / 1000).toFixed(1)}s`], + ['峰值内存', formatBytes(result.summary.peak_rss_bytes)], + ] + return ( +
+ {items.map(([label, value]) => ( +
+
{label}
+
{value}
+
+ ))} +
+ ) +} + +function RunStatus({ run, progress, error, reconnecting }: { run: MiningRun | null; progress?: { label?: string; phase?: string; percent?: number } | null; error?: string | null; reconnecting?: boolean }) { + const active = !!run && ACTIVE.has(run.status) + const success = !!run && SUCCESS.has(run.status) + const Icon = reconnecting ? RefreshCw : active ? LoaderCircle : success ? CheckCircle2 : error ? AlertTriangle : Clock3 + return ( +
+ +
+
+ {reconnecting ? '连接恢复中' : run ? statusLabel(run.status) : '研究任务'} + {progress?.label ? ` · ${progress.label}` : ''} +
+ {(error || progress?.phase) && ( +
+ {error || progress?.phase} +
+ )} +
+ {typeof progress?.percent === 'number' && ( + {Math.round(progress.percent)}% + )} + {run?.run_id && {run.run_id}} +
+ ) +} + +function FactorTable({ result }: { result: MiningResult }) { + return ( +
+
+ 因子方向评分ICIR覆盖换手价差Sharpe状态 +
+ {result.factors.map(row => ( +
+ {row.label || row.factor_name} + {row.direction === 1 ? '正向' : '反向'} + {formatNumber(row.score, 3)} + {formatNumber(row.ic_mean, 4)} + {formatNumber(row.ir, 2)} + {formatPct(row.coverage, 1)} + {formatPct(row.turnover, 1)} + {formatPct(row.spread_return, 2)} + {formatNumber(row.spread_sharpe, 2)} + + {row.selected ? '入选' : row.excluded_reason || '未入选'} + +
+ ))} +
+ ) +} + +export function MiningWorkbench() { + const queryClient = useQueryClient() + const [searchParams, setSearchParams] = useSearchParams() + const initializedFactors = useRef(false) + const [draft, setDraft] = useState(loadDraft) + const [scheduleDraft, setScheduleDraft] = useState(null) + const [correlationScope, setCorrelationScope] = useState<'all' | 'selected'>('selected') + const task = useMiningTask() + const runFromUrl = searchParams.get('run') || '' + const selectedCandidate = searchParams.get('candidate') || '' + + const factorQuery = useQuery({ queryKey: QK.factorColumns, queryFn: api.factorColumns }) + const strategyQuery = useQuery({ + queryKey: QK.strategyLinkOptions(draft.assetType), + queryFn: () => api.strategyList(draft.assetType), + }) + const runsQuery = useQuery({ + queryKey: QK.miningRuns, + queryFn: api.miningRuns, + refetchInterval: task.isPending ? 5000 : false, + }) + const validDateRange = !draft.start || !draft.end || draft.start <= draft.end + const availabilityQuery = useQuery({ + queryKey: QK.miningAvailability( + draft.assetType, + draft.profile, + draft.start, + draft.end, + ), + queryFn: () => api.miningAvailability({ + assetType: draft.assetType, + budgetProfile: draft.profile, + start: draft.start || undefined, + end: draft.end || undefined, + }), + enabled: validDateRange, + staleTime: 30_000, + }) + const configQuery = useQuery({ queryKey: QK.miningConfig, queryFn: api.miningConfig }) + + useEffect(() => { + localStorage.setItem(DRAFT_KEY, JSON.stringify(draft)) + }, [draft]) + + useEffect(() => { + if (initializedFactors.current || !factorQuery.data?.columns.length) return + initializedFactors.current = true + if (!draft.factorNames.length) { + setDraft(current => ({ ...current, factorNames: factorQuery.data!.columns.slice(0, 48).map(item => item.id) })) + } + }, [factorQuery.data, draft.factorNames.length]) + + useEffect(() => { + if (configQuery.data && !scheduleDraft) setScheduleDraft(configQuery.data) + }, [configQuery.data, scheduleDraft]) + + useEffect(() => { + if (runFromUrl) { + if (task.isPending && !task.runId) return + if (task.runId !== runFromUrl) void attachMiningRun(runFromUrl) + return + } + if (task.runId) { + const params = new URLSearchParams(searchParams) + params.set('run', task.runId) + setSearchParams(params, { replace: true }) + return + } + tryReconnectMining() + }, [runFromUrl, searchParams, setSearchParams, task.runId]) + + const currentResult = task.runId + && (!runFromUrl || runFromUrl === task.runId) + && task.run?.run_id === task.runId + && SUCCESS.has(task.run.status) + && task.result?.run_id === task.runId + ? task.result + : null + const showingPrevious = !!( + task.runId + && (!runFromUrl || runFromUrl === task.runId) + && task.previousResult + && task.previousResult.run_id !== task.runId + && ( + task.isPending + || !!task.error + || (!!task.run && !SUCCESS.has(task.run.status)) + ) + ) + const result = currentResult ?? (showingPrevious ? task.previousResult : null) + const candidates = result?.candidates ?? [] + const activeCandidate = candidates.find(item => item.signature === selectedCandidate) ?? candidates[0] ?? null + const candidateFolds = activeCandidate?.folds?.length ? activeCandidate.folds : result?.folds ?? [] + const correlation = useMemo(() => { + if (!result || correlationScope === 'all') return result?.correlation ?? null + const selected = new Set(result.factors.filter(item => item.selected).map(item => item.factor_name)) + const indexes = result.correlation.labels + .map((label, index) => selected.has(label) ? index : -1) + .filter(index => index >= 0) + if (!indexes.length) return result.correlation + return { + ...result.correlation, + labels: indexes.map(index => result.correlation.labels[index]), + matrix: indexes.map(row => indexes.map(column => result.correlation.matrix[row]?.[column] ?? null)), + pair_counts: indexes.map(row => indexes.map(column => result.correlation.pair_counts?.[row]?.[column] ?? null)), + } + }, [result, correlationScope]) + + const setSelectedCandidate = (signature: string) => { + const params = new URLSearchParams(searchParams) + if (signature) params.set('candidate', signature) + else params.delete('candidate') + setSearchParams(params, { replace: true }) + } + + useEffect(() => { + if (!selectedCandidate && candidates[0]) setSelectedCandidate(candidates[0].signature) + if (selectedCandidate && candidates.length && !candidates.some(item => item.signature === selectedCandidate)) { + setSelectedCandidate(candidates[0]?.signature || '') + } + }, [candidates, selectedCandidate]) + + const factorGroups = useMemo(() => { + const groups: Record = {} + for (const item of factorQuery.data?.columns ?? []) (groups[item.group] ??= []).push(item) + return groups + }, [factorQuery.data]) + const strategies = strategyQuery.data?.strategies.filter(item => item.execution_backend === 'matrix_native') ?? [] + + useEffect(() => { + if (!strategyQuery.data) return + const compatibleIds = new Set(strategies.map(item => item.id)) + setDraft(current => { + const strategyIds = current.strategyIds.filter(id => compatibleIds.has(id)) + return strategyIds.length === current.strategyIds.length ? current : { ...current, strategyIds } + }) + }, [strategyQuery.data]) + + const updateDraft = (key: K, value: MiningDraft[K]) => { + setDraft(current => ({ ...current, [key]: value })) + } + const changeAssetType = (assetType: MiningDraft['assetType']) => { + setDraft(current => ({ + ...current, + assetType, + strategyIds: [], + })) + } + const toggleFactor = (id: string) => { + setDraft(current => ({ + ...current, + factorNames: current.factorNames.includes(id) + ? current.factorNames.filter(value => value !== id) + : current.factorNames.length < 48 ? [...current.factorNames, id] : current.factorNames, + })) + } + const toggleStrategy = (id: string) => { + setDraft(current => ({ + ...current, + strategyIds: current.strategyIds.includes(id) + ? current.strategyIds.filter(value => value !== id) + : current.strategyIds.length < 8 ? [...current.strategyIds, id] : current.strategyIds, + })) + } + + const runMining = () => { + if (!draft.factorNames.length) { + toast('至少选择一个因子', 'error') + return + } + if (draft.start && draft.end && draft.start > draft.end) { + toast('开始日期不能晚于结束日期', 'error') + return + } + if (availabilityQuery.isPending || availabilityQuery.isFetching) { + toast('正在核验有效交易日，请稍候', 'error') + return + } + if (availabilityQuery.isError || !availabilityQuery.data) { + toast('无法核验有效交易日，请检查数据状态后重试', 'error') + return + } + if (!availabilityQuery.data.eligible) { + toast( + `${PROFILE_LABELS[draft.profile]}至少需要 ${availabilityQuery.data.required_bars} 个交易日，当前范围仅 ${availabilityQuery.data.trading_bars} 个`, + 'error', + ) + return + } + const commissionBps = parseBoundedNumber(draft.commissionBps, '佣金', 0, 500) + const stampTaxBps = parseBoundedNumber(draft.stampTaxBps, '印花税', 0, 500) + const slippageBps = parseBoundedNumber(draft.slippageBps, '滑点', 0, 1000) + const correlationThreshold = parseBoundedNumber(draft.correlationThreshold, '相关阈值', Number.EPSILON, 1) + const maxCombinationFactors = parseBoundedNumber(draft.maxCombinationFactors, '组合上限', 1, 4, true) + const beamWidth = parseBoundedNumber(draft.beamWidth, 'Beam', 1, 12, true) + const maxFinalists = parseBoundedNumber(draft.maxFinalists, 'Finalists', 1, 8, true) + if ([commissionBps, stampTaxBps, slippageBps, correlationThreshold, maxCombinationFactors, beamWidth, maxFinalists].some(value => value == null)) return + const payload: MiningRequestV1 = { + factor_names: draft.factorNames, + strategy_ids: draft.strategyIds, + asset_type: draft.assetType, + start: draft.start || null, + end: draft.end || null, + budget_profile: draft.profile, + commission_pct: commissionBps! / 10000, + stamp_tax_pct: stampTaxBps! / 10000, + slippage_bps: slippageBps!, + correlation_threshold: correlationThreshold!, + max_combination_factors: maxCombinationFactors!, + beam_width: beamWidth!, + max_finalists: maxFinalists!, + force: draft.force, + } + const params = new URLSearchParams(searchParams) + params.delete('run') + params.delete('candidate') + setSearchParams(params, { replace: true }) + void startMining(payload).then(() => queryClient.invalidateQueries({ queryKey: QK.miningRuns })) + } + + const promote = useMutation({ + mutationFn: (candidate: MiningCandidateRow) => { + if (!currentResult) throw new Error('只能保存当前已成功运行的候选') + return api.miningPromote(currentResult.run_id, candidate.signature) + }, + onSuccess: () => { + queryClient.invalidateQueries({ queryKey: QK.researchCandidates }) + toast('候选已保存，状态为待验证', 'success') + }, + onError: error => toast(`保存失败 · ${String((error as Error).message || error)}`, 'error'), + }) + const publish = useMutation({ + mutationFn: (candidate: MiningCandidateRow) => { + if (!currentResult) throw new Error('只能发布当前已成功运行的候选') + return api.miningPublish(currentResult.run_id, candidate.signature) + }, + onSuccess: value => { + queryClient.invalidateQueries({ queryKey: QK.screenerStrategies(draft.assetType) }) + toast(`策略已发布 · ${value.strategy_id}`, 'success') + }, + onError: error => toast(`发布失败 · ${String((error as Error).message || error)}`, 'error'), + }) + const saveSchedule = useMutation({ + mutationFn: (value: MiningScheduleConfig) => api.updateMiningConfig(value), + onSuccess: value => { + setScheduleDraft(value) + queryClient.setQueryData(QK.miningConfig, value) + toast('自动挖掘配置已保存', 'success') + }, + onError: error => toast(`保存失败 · ${String((error as Error).message || error)}`, 'error'), + }) + + const attachRun = (run: MiningRun) => { + const params = new URLSearchParams(searchParams) + params.set('run', run.run_id) + params.delete('candidate') + setSearchParams(params, { replace: true }) + } + + return ( +
+ + +
+ + {showingPrevious &&
历史结果 · run {result?.run_id}。当前 run {task.runId} {task.isPending ? '仍在执行' : '未成功完成'}，以下内容仅供参考，候选操作已禁用。
} + + {!result ? ( +
+ ) : ( +
+ + + +
+

因子排名

{result.methodology_version}
+
+
+ +
+
+
+

市场环境对比

+ {activeCandidate && candidates[0] && activeCandidate.signature !== candidates[0].signature && 环境数据属于排名首位候选（{candidates[0].name}）} +
+ ({ state: row.state, label: row.label, nDates: row.n_dates, sharpe: row.sharpe, return: row.total_return, maxDrawdown: row.max_drawdown }))} /> +
+

逐折样本外

({ fold: row.fold, label: row.label || `Fold ${row.fold}`, return: row.total_return, sharpe: row.sharpe, skipped: row.skipped, reason: row.reason || undefined }))} />
+
+ +
+
+
+

相关矩阵

+
阈值 {result.correlation.threshold.toFixed(2)} · 按日截面 Rank
+
+
+ {(['selected', 'all'] as const).map(scope => ( + + ))} +
+
+
+
+ +
+
+
+ +

策略候选

对照策略在全部 outer 折独立评估 · 发布始终需要人工确认
{candidates.map(candidate => )}{!candidates.length &&
暂无晋级候选
}
{activeCandidate ?
{activeCandidate.name}{activeCandidate.gate && {activeCandidate.gate.qualified ? '达标' : '未达标'}}
{definitionLabel(activeCandidate)}
{activeCandidate.gate && !activeCandidate.gate.qualified &&
未达晋级门槛，仅可保存为待定候选：{activeCandidate.gate.reasons.join('；')}
}
{[['平均每折收益', formatPct(activeCandidate.oos_return)], ['Sharpe', formatNumber(activeCandidate.oos_sharpe)], ['最大回撤', formatPct(activeCandidate.oos_max_drawdown)], ['正收益折', formatPct(activeCandidate.oos_positive_fold_ratio)], ['有效折', activeCandidate.valid_folds == null ? '—' : String(activeCandidate.valid_folds)], ['交易数', activeCandidate.oos_n_trades == null ? '—' : String(activeCandidate.oos_n_trades)]].map(([label, value]) =>
{label}
{value}
)}
{candidateFolds.map(fold =>
Fold {fold.fold}{foldKindLabel(fold.evaluation_kind) && {foldKindLabel(fold.evaluation_kind)}}{fold.train_start || '—'} → {fold.train_end || '—'}{fold.test_start || '—'} → {fold.test_end || '—'}{formatPct(fold.total_return)}{formatNumber(fold.sharpe)}{formatPct(fold.max_drawdown)}{fold.skipped ? fold.reason || '跳过' : `${fold.n_trades ?? '—'} 笔`}
)}
:
选择候选查看定义与逐折结果
}
+ +

性能与复用

{[['总耗时', result.telemetry.elapsed_ms == null ? '—' : `${(result.telemetry.elapsed_ms / 1000).toFixed(1)}s`], ['峰值 RSS', formatBytes(result.telemetry.peak_rss_bytes)], ['面板扫描', result.telemetry.panel_scans ?? '—'], ['矩阵字节', formatBytes(result.telemetry.matrix_bytes)], ['缓存命中', result.telemetry.cache_hits ?? '—'], ['Fold 复用', result.telemetry.fold_reuses ?? '—'], ['IPC 结果', formatBytes(result.telemetry.serialized_result_bytes)]].map(([label, value]) =>
{label}
{String(value)}
)}
{result.telemetry.phase_ms &&
{Object.entries(result.telemetry.phase_ms).map(([phase, ms]) => {phase} {ms.toFixed(1)}ms)}
}
+
+ )} + + {task.runId &&
刷新后通过持久 run ID 自动重连；浏览器断开不会取消 worker。
} +
+
+ ) +} diff --git a/frontend/src/pages/backtest/ResearchCandidatesDialog.tsx b/frontend/src/pages/backtest/ResearchCandidatesDialog.tsx index 0d8534b..2aa7b74 100644 --- a/frontend/src/pages/backtest/ResearchCandidatesDialog.tsx +++ b/frontend/src/pages/backtest/ResearchCandidatesDialog.tsx @@ -46,7 +46,7 @@ export function ResearchCandidatesDialog({ onClose }: { onClose: () => void }) { const [kind, setKind] = useState<'all' | 'factor' | 'strategy'>('all') const [linkDraft, setLinkDraft] = useState(null) const candidates = useQuery({ queryKey: QK.researchCandidates, queryFn: api.researchCandidates }) - const strategies = useQuery({ queryKey: QK.strategyLinkOptions, queryFn: () => api.strategyList() }) + const strategies = useQuery({ queryKey: QK.strategyLinkOptions(), queryFn: () => api.strategyList() }) const factorColumns = useQuery({ queryKey: QK.factorColumns, queryFn: api.factorColumns }) const supportedFactors = useMemo( () => new Set((factorColumns.data?.columns ?? []).map(item => item.id)), @@ -98,7 +98,7 @@ export function ResearchCandidatesDialog({ onClose }: { onClose: () => void }) { onSuccess: result => { queryClient.invalidateQueries({ queryKey: QK.strategyDetail(result.strategyId) }) queryClient.invalidateQueries({ queryKey: ['screener-strategies'] }) - queryClient.invalidateQueries({ queryKey: QK.strategyLinkOptions }) + queryClient.invalidateQueries({ queryKey: QK.strategyLinkOptions() }) setLinkDraft(null) toast(`已加入“${result.strategyName}”评分方案`, 'success') }, diff --git a/frontend/src/pages/backtest/charts/FactorCorrelationHeatmap.tsx b/frontend/src/pages/backtest/charts/FactorCorrelationHeatmap.tsx new file mode 100644 index 0000000..fd0c039 --- /dev/null +++ b/frontend/src/pages/backtest/charts/FactorCorrelationHeatmap.tsx @@ -0,0 +1,191 @@ +import { useEffect, useMemo, useState } from 'react' +import type { EChartsOption } from 'echarts' +import { useChartTheme } from '@/lib/theme' +import { useECharts } from './useECharts' + +export interface FactorCorrelationHeatmapProps { + labels: string[] + matrix: (number | null)[][] + pairCounts?: (number | null)[][] + threshold?: number +} + +interface HeatmapDatum { + value: [number, number, number, number | null] + itemStyle?: { opacity: number } +} + +interface PreparedHeatmap { + labels: string[] + data: HeatmapDatum[] +} + +const EMPTY_HEATMAP: PreparedHeatmap = { labels: [], data: [] } + +function escapeHtml(value: string): string { + return value.replace(/[&<>'"]/g, char => ({ + '&': '&', + '<': '<', + '>': '>', + "'": ''', + '"': '"', + })[char] ?? char) +} + +export function FactorCorrelationHeatmap({ + labels, + matrix, + pairCounts, + threshold, +}: FactorCorrelationHeatmapProps) { + const ct = useChartTheme() + const [prepared, setPrepared] = useState(EMPTY_HEATMAP) + + // Flattening can dominate render time for wide factor sets, so keep it out of render. + useEffect(() => { + if (!labels.length || !matrix.length) { + setPrepared(EMPTY_HEATMAP) + return + } + + const nextLabels = labels.slice() + const data: HeatmapDatum[] = [] + const thresholdValue = typeof threshold === 'number' && Number.isFinite(threshold) + ? Math.min(1, Math.max(0, Math.abs(threshold))) + : null + + for (let rowIndex = 0; rowIndex < nextLabels.length; rowIndex += 1) { + const row = matrix[rowIndex] + if (!row) continue + + for (let columnIndex = 0; columnIndex < nextLabels.length; columnIndex += 1) { + const rho = row[columnIndex] + if (typeof rho !== 'number' || !Number.isFinite(rho)) continue + + const rawPairCount = pairCounts?.[rowIndex]?.[columnIndex] + const pairCount = typeof rawPairCount === 'number' && Number.isFinite(rawPairCount) + ? rawPairCount + : null + const passesThreshold = thresholdValue == null + || rowIndex === columnIndex + || Math.abs(rho) >= thresholdValue + + data.push({ + value: [columnIndex, rowIndex, rho, pairCount], + ...(passesThreshold ? {} : { itemStyle: { opacity: 0.3 } }), + }) + } + } + + setPrepared({ labels: nextLabels, data }) + }, [labels, matrix, pairCounts, threshold]) + + const option = useMemo(() => { + if (!prepared.data.length) return null + + return { + animation: false, + grid: { left: 78, right: 16, top: 14, bottom: 72 }, + tooltip: { + trigger: 'item', + confine: true, + backgroundColor: ct.tooltipBg, + borderColor: ct.tooltipBorder, + textStyle: { color: ct.tooltipText, fontSize: 12 }, + formatter: (params: any) => { + const value = params.value as HeatmapDatum['value'] | undefined + if (!value) return '' + const [columnIndex, rowIndex, rho, pairCount] = value + const rowLabel = escapeHtml(prepared.labels[rowIndex] ?? '') + const columnLabel = escapeHtml(prepared.labels[columnIndex] ?? '') + return `
${rowLabel} × ${columnLabel}
+
rho${rho.toFixed(4)}
+
配对数${pairCount == null ? '—' : pairCount.toLocaleString('zh-CN')}
` + }, + }, + xAxis: { + type: 'category', + data: prepared.labels, + axisLabel: { + color: ct.text, + fontSize: 10, + interval: 0, + rotate: prepared.labels.length > 6 ? 40 : 0, + width: 68, + overflow: 'truncate', + }, + axisLine: { lineStyle: { color: ct.border } }, + axisTick: { show: false }, + splitArea: { show: false }, + }, + yAxis: { + type: 'category', + data: prepared.labels, + inverse: true, + axisLabel: { + color: ct.text, + fontSize: 10, + width: 64, + overflow: 'truncate', + }, + axisLine: { lineStyle: { color: ct.border } }, + axisTick: { show: false }, + splitArea: { show: false }, + }, + visualMap: { + type: 'continuous', + min: -1, + max: 1, + dimension: 2, + orient: 'horizontal', + left: 'center', + bottom: 4, + itemWidth: 100, + itemHeight: 8, + calculable: false, + precision: 1, + text: ['1', '-1'], + textGap: 6, + textStyle: { color: ct.text, fontSize: 10 }, + inRange: { + color: ['#2563eb', ct.fillSubtle, '#ef4444'], + }, + }, + series: [{ + name: '相关性', + type: 'heatmap', + data: prepared.data, + progressive: 2000, + itemStyle: { + borderColor: ct.border, + borderWidth: 1, + }, + emphasis: { + itemStyle: { + borderColor: ct.textStrong, + borderWidth: 1, + }, + }, + }], + } + }, [prepared, ct]) + + const chartRef = useECharts(option, [prepared, ct]) + const isEmpty = prepared.data.length === 0 + + return ( +
+
+ {isEmpty && ( +
+ 暂无相关性数据 +
+ )} +
+ ) +} diff --git a/frontend/src/pages/backtest/charts/MiningOosChart.tsx b/frontend/src/pages/backtest/charts/MiningOosChart.tsx new file mode 100644 index 0000000..dae25ba --- /dev/null +++ b/frontend/src/pages/backtest/charts/MiningOosChart.tsx @@ -0,0 +1,201 @@ +import { useMemo } from 'react' +import type { EChartsOption } from 'echarts' +import { useChartTheme } from '@/lib/theme' +import { useECharts } from './useECharts' + +export interface MiningOosFold { + fold: number | string + label: string + return: number | null + sharpe: number | null + skipped?: boolean + reason?: string +} + +export interface MiningOosChartProps { + folds: MiningOosFold[] +} + +function finiteOrNull(value: number | null): number | null { + return typeof value === 'number' && Number.isFinite(value) ? value : null +} + +function escapeHtml(value: string): string { + return value.replace(/[&<>'"]/g, char => ({ + '&': '&', + '<': '<', + '>': '>', + "'": ''', + '"': '"', + })[char] ?? char) +} + +export function MiningOosChart({ folds }: MiningOosChartProps) { + const ct = useChartTheme() + const preparedFolds = useMemo(() => folds.map(fold => ({ + ...fold, + return: fold.skipped ? null : finiteOrNull(fold.return), + sharpe: fold.skipped ? null : finiteOrNull(fold.sharpe), + })), [folds]) + + const hasDisplayData = preparedFolds.some(fold => ( + fold.skipped || fold.return != null || fold.sharpe != null + )) + + const option = useMemo(() => { + if (!preparedFolds.length || !hasDisplayData) return null + + return { + animation: false, + grid: { left: 54, right: 48, top: 48, bottom: 52 }, + legend: { + top: 2, + left: 'center', + itemWidth: 12, + itemHeight: 8, + itemGap: 14, + textStyle: { color: ct.text, fontSize: 10 }, + data: ['样本外收益', 'Sharpe', '已跳过'], + }, + tooltip: { + trigger: 'axis', + confine: true, + axisPointer: { type: 'shadow' }, + backgroundColor: ct.tooltipBg, + borderColor: ct.tooltipBorder, + textStyle: { color: ct.tooltipText, fontSize: 12 }, + formatter: (params: any) => { + const items = Array.isArray(params) ? params : [params] + const skippedItem = items.find(item => Array.isArray(item.value) && typeof item.value[2] === 'number') + const index = skippedItem + ? skippedItem.value[2] as number + : items[0]?.dataIndex as number | undefined + const fold = index == null ? undefined : preparedFolds[index] + if (!fold) return '' + + const heading = fold.label || `Fold ${fold.fold}` + if (fold.skipped) { + const reason = fold.reason ? escapeHtml(fold.reason) : '未提供原因' + return `
${escapeHtml(heading)}
+
已跳过
+
${reason}
` + } + + return `
${escapeHtml(heading)}
+
样本外收益${fold.return == null ? '—' : `${(fold.return * 100).toFixed(2)}%`}
+
Sharpe${fold.sharpe == null ? '—' : fold.sharpe.toFixed(2)}
` + }, + }, + xAxis: { + type: 'category', + data: preparedFolds.map(fold => fold.label || `Fold ${fold.fold}`), + axisLabel: { + interval: 0, + fontSize: 10, + width: 68, + overflow: 'truncate', + formatter: (_value: string, index: number) => preparedFolds[index]?.skipped + ? `{skipped|${preparedFolds[index]?.label || `Fold ${preparedFolds[index]?.fold ?? ''}`}}` + : `{normal|${preparedFolds[index]?.label || `Fold ${preparedFolds[index]?.fold ?? ''}`}}`, + rich: { + normal: { color: ct.text }, + skipped: { color: ct.text, opacity: 0.5 }, + }, + }, + axisLine: { lineStyle: { color: ct.border } }, + axisTick: { show: false }, + }, + yAxis: [ + { + type: 'value', + name: '收益', + nameTextStyle: { color: ct.text, fontSize: 10 }, + axisLabel: { + color: ct.text, + fontSize: 10, + formatter: (value: number) => `${value.toFixed(0)}%`, + }, + axisLine: { show: false }, + splitLine: { lineStyle: { color: ct.grid } }, + }, + { + type: 'value', + name: 'Sharpe', + nameTextStyle: { color: ct.text, fontSize: 10 }, + axisLabel: { color: ct.text, fontSize: 10 }, + axisLine: { show: false }, + splitLine: { show: false }, + }, + ], + series: [ + { + name: '样本外收益', + type: 'bar', + data: preparedFolds.map(fold => fold.return == null + ? null + : { + value: fold.return * 100, + itemStyle: { color: fold.return >= 0 ? '#ef4444' : '#22c55e' }, + }), + barMaxWidth: 28, + }, + { + name: 'Sharpe', + type: 'line', + yAxisIndex: 1, + data: preparedFolds.map(fold => fold.sharpe), + connectNulls: false, + symbol: 'circle', + symbolSize: 6, + lineStyle: { color: '#3b82f6', width: 1.5 }, + itemStyle: { color: '#3b82f6' }, + z: 5, + }, + { + name: '已跳过', + type: 'custom', + data: preparedFolds.flatMap((fold, index) => fold.skipped ? [[index, 0, index]] : []), + renderItem: (params: any, api: any) => { + const x = api.coord([api.value(0), 0])[0] + const coordinateSystem = params.coordSys as { y: number } + return { + type: 'text', + x, + y: coordinateSystem.y + 7, + style: { + text: '跳过', + fill: ct.text, + opacity: 0.65, + fontSize: 10, + align: 'center', + verticalAlign: 'top', + }, + } + }, + z: 10, + }, + ], + } + }, [preparedFolds, hasDisplayData, ct]) + + const chartRef = useECharts(option, [preparedFolds, ct]) + const emptyMessage = folds.length === 0 + ? '暂无样本外验证数据' + : '暂无可展示的样本外指标' + + return ( +
+
+ {!hasDisplayData && ( +
+ {emptyMessage} +
+ )} +
+ ) +} diff --git a/frontend/src/pages/backtest/charts/RegimeComparisonChart.tsx b/frontend/src/pages/backtest/charts/RegimeComparisonChart.tsx new file mode 100644 index 0000000..3c9ce4a --- /dev/null +++ b/frontend/src/pages/backtest/charts/RegimeComparisonChart.tsx @@ -0,0 +1,182 @@ +import { useMemo } from 'react' +import type { EChartsOption } from 'echarts' +import { useChartTheme } from '@/lib/theme' +import { useECharts } from './useECharts' + +export interface RegimeComparisonRow { + state: string + label: string + nDates: number + sharpe: number | null + return: number | null + maxDrawdown: number | null +} + +export interface RegimeComparisonChartProps { + rows: RegimeComparisonRow[] +} + +function finiteOrNull(value: number | null): number | null { + return typeof value === 'number' && Number.isFinite(value) ? value : null +} + +function escapeHtml(value: string): string { + return value.replace(/[&<>'"]/g, char => ({ + '&': '&', + '<': '<', + '>': '>', + "'": ''', + '"': '"', + })[char] ?? char) +} + +export function RegimeComparisonChart({ rows }: RegimeComparisonChartProps) { + const ct = useChartTheme() + const preparedRows = useMemo(() => rows.map(row => { + const hasEnoughSamples = Number.isFinite(row.nDates) && row.nDates >= 2 + return { + ...row, + hasEnoughSamples, + sharpe: hasEnoughSamples ? finiteOrNull(row.sharpe) : null, + return: hasEnoughSamples ? finiteOrNull(row.return) : null, + maxDrawdown: hasEnoughSamples ? finiteOrNull(row.maxDrawdown) : null, + } + }), [rows]) + + const hasMetrics = preparedRows.some(row => ( + row.return != null || row.sharpe != null || row.maxDrawdown != null + )) + + const option = useMemo(() => { + if (!preparedRows.length || !hasMetrics) return null + + return { + animation: false, + color: ['#ef4444', '#22c55e', '#3b82f6'], + grid: { left: 54, right: 48, top: 48, bottom: 48 }, + legend: { + top: 2, + left: 'center', + itemWidth: 12, + itemHeight: 8, + itemGap: 12, + textStyle: { color: ct.text, fontSize: 10 }, + data: ['收益', '最大回撤', 'Sharpe'], + }, + tooltip: { + trigger: 'axis', + confine: true, + axisPointer: { type: 'shadow' }, + backgroundColor: ct.tooltipBg, + borderColor: ct.tooltipBorder, + textStyle: { color: ct.tooltipText, fontSize: 12 }, + formatter: (params: any) => { + const items = Array.isArray(params) ? params : [params] + const index = items[0]?.dataIndex as number | undefined + const row = index == null ? undefined : preparedRows[index] + if (!row) return '' + + const state = row.state && row.state !== row.label + ? `${escapeHtml(row.state)}` + : '' + const status = row.hasEnoughSamples ? '' : '
样本不足
' + return `
${escapeHtml(row.label)} ${state}
+
交易日${row.nDates.toLocaleString('zh-CN')}
+
收益${row.return == null ? '—' : `${(row.return * 100).toFixed(2)}%`}
+
最大回撤${row.maxDrawdown == null ? '—' : `${(row.maxDrawdown * 100).toFixed(2)}%`}
+
Sharpe${row.sharpe == null ? '—' : row.sharpe.toFixed(2)}
${status}` + }, + }, + xAxis: { + type: 'category', + data: preparedRows.map(row => row.label), + axisLabel: { + interval: 0, + fontSize: 10, + width: 72, + overflow: 'truncate', + formatter: (_value: string, index: number) => preparedRows[index]?.hasEnoughSamples + ? `{normal|${preparedRows[index]?.label ?? ''}}` + : `{muted|${preparedRows[index]?.label ?? ''}}`, + rich: { + normal: { color: ct.text }, + muted: { color: ct.text, opacity: 0.45 }, + }, + }, + axisLine: { lineStyle: { color: ct.border } }, + axisTick: { show: false }, + }, + yAxis: [ + { + type: 'value', + name: '比例', + nameTextStyle: { color: ct.text, fontSize: 10 }, + axisLabel: { + color: ct.text, + fontSize: 10, + formatter: (value: number) => `${value.toFixed(0)}%`, + }, + axisLine: { show: false }, + splitLine: { lineStyle: { color: ct.grid } }, + }, + { + type: 'value', + name: 'Sharpe', + nameTextStyle: { color: ct.text, fontSize: 10 }, + axisLabel: { color: ct.text, fontSize: 10 }, + axisLine: { show: false }, + splitLine: { show: false }, + }, + ], + series: [ + { + name: '收益', + type: 'bar', + data: preparedRows.map(row => row.return == null ? null : row.return * 100), + barMaxWidth: 24, + itemStyle: { color: '#ef4444' }, + }, + { + name: '最大回撤', + type: 'bar', + data: preparedRows.map(row => row.maxDrawdown == null ? null : row.maxDrawdown * 100), + barMaxWidth: 24, + itemStyle: { color: '#22c55e' }, + }, + { + name: 'Sharpe', + type: 'line', + yAxisIndex: 1, + data: preparedRows.map(row => row.sharpe), + connectNulls: false, + symbol: 'circle', + symbolSize: 6, + lineStyle: { color: '#3b82f6', width: 1.5 }, + itemStyle: { color: '#3b82f6' }, + z: 5, + }, + ], + } + }, [preparedRows, hasMetrics, ct]) + + const chartRef = useECharts(option, [preparedRows, ct]) + const emptyMessage = rows.length === 0 + ? '暂无市场状态数据' + : '样本不足，暂无可比较指标' + + return ( +
+
+ {!hasMetrics && ( +
+ {emptyMessage} +
+ )} +
+ ) +} diff --git a/frontend/src/pages/backtest/charts/useECharts.ts b/frontend/src/pages/backtest/charts/useECharts.ts index 186e2eb..5952124 100644 --- a/frontend/src/pages/backtest/charts/useECharts.ts +++ b/frontend/src/pages/backtest/charts/useECharts.ts @@ -21,12 +21,13 @@ export function useECharts( // 初始化 / 销毁 useEffect(() => { if (!chartRef.current) return - instanceRef.current = echarts.init(chartRef.current, undefined, { renderer: 'canvas' }) - const handleResize = () => instanceRef.current?.resize() - window.addEventListener('resize', handleResize) + const container = chartRef.current + instanceRef.current = echarts.init(container, undefined, { renderer: 'canvas' }) + const resizeObserver = new ResizeObserver(() => instanceRef.current?.resize()) + resizeObserver.observe(container) return () => { - window.removeEventListener('resize', handleResize) + resizeObserver.disconnect() instanceRef.current?.dispose() instanceRef.current = null } diff --git a/frontend/src/pages/settings/MenuSettings.tsx b/frontend/src/pages/settings/MenuSettings.tsx index b2e51e5..2127d18 100644 --- a/frontend/src/pages/settings/MenuSettings.tsx +++ b/frontend/src/pages/settings/MenuSettings.tsx @@ -35,6 +35,7 @@ const BUILTIN_PAGES: NavEntry[] = [ { id: '/watchlist', label: '自选', type: 'builtin', visible: true }, { id: '/screener', label: '策略', type: 'builtin', visible: true }, { id: '/backtest', label: '回测', type: 'builtin', visible: true }, + { id: '/mining', label: '挖掘', type: 'builtin', visible: true }, { id: '/limit-ladder', label: '连板梯队', type: 'builtin', visible: true }, { id: '/concept-analysis', label: '概念分析', type: 'builtin', visible: true }, { id: '/industry-analysis', label: '行业分析', type: 'builtin', visible: true }, @@ -187,7 +188,18 @@ export function SettingsMenuSettingsPanel() { } } for (const e of [...BUILTIN_PAGES, ...analysisEntries]) { - if (!seen.has(e.id)) ordered.push(e) + if (seen.has(e.id)) continue + // 未保存过排序的新条目: 内置页插回默认位置, 分析菜单追加到末尾 + const defaultIndex = BUILTIN_PAGES.findIndex(p => p.id === e.id) + let anchor = -1 + if (defaultIndex > 0) { + for (let i = defaultIndex - 1; i >= 0 && anchor < 0; i -= 1) { + anchor = ordered.findIndex(o => o.id === BUILTIN_PAGES[i].id) + } + } + if (anchor >= 0) ordered.splice(anchor + 1, 0, e) + else if (defaultIndex >= 0) ordered.unshift(e) + else ordered.push(e) } return ordered }, [prefs?.nav_order, analysisEntries]) @@ -207,7 +219,18 @@ export function SettingsMenuSettingsPanel() { if (e) { result.push(e); seen.add(id) } } for (const e of allEntries) { - if (!seen.has(e.id)) result.push(e) + if (seen.has(e.id)) continue + // 与 allEntries 同一语义: 未保存的新内置页插回默认位置而非追加到末尾 + const defaultIndex = BUILTIN_PAGES.findIndex(p => p.id === e.id) + let anchor = -1 + if (defaultIndex > 0) { + for (let i = defaultIndex - 1; i >= 0 && anchor < 0; i -= 1) { + anchor = result.findIndex(o => o.id === BUILTIN_PAGES[i].id) + } + } + if (anchor >= 0) result.splice(anchor + 1, 0, e) + else if (defaultIndex >= 0) result.unshift(e) + else result.push(e) } return result }, [localOrder, prefs?.nav_order, allEntries]) diff --git a/frontend/src/router.tsx b/frontend/src/router.tsx index dcfea77..8fb0297 100644 --- a/frontend/src/router.tsx +++ b/frontend/src/router.tsx @@ -18,6 +18,7 @@ import { const Watchlist = lazy(() => import('./pages/Watchlist').then(m => ({ default: m.Watchlist }))) const Screener = lazy(() => import('./pages/Screener').then(m => ({ default: m.Screener }))) const Backtest = lazy(() => import('./pages/Backtest').then(m => ({ default: m.Backtest }))) +const Mining = lazy(() => import('./pages/Mining').then(m => ({ default: m.Mining }))) const Financials = lazy(() => import('./pages/Financials').then(m => ({ default: m.Financials }))) const Data = lazy(() => import('./pages/Data').then(m => ({ default: m.Data }))) const Monitor = lazy(() => import('./pages/Monitor').then(m => ({ default: m.Monitor }))) @@ -48,6 +49,7 @@ const CORE_ROUTE_PATHS = new Set([ '/watchlist', '/screener', '/backtest', + '/mining', '/financials', '/data', '/monitor', @@ -119,6 +121,7 @@ export const router = createBrowserRouter([ { path: 'watchlist', element: }, { path: 'screener', element: }, { path: 'backtest', element: }, + { path: 'mining', element: }, { path: 'financials', element: }, { path: 'data', element: }, { path: 'monitor', element: }, diff --git a/gui-test-screenshots/phase_t1_overview.png b/gui-test-screenshots/phase_t1_overview.png new file mode 100644 index 0000000000000000000000000000000000000000..7eaf5b6fed984f80a2c5b95f2bda7670fa3ee07e GIT binary patch literal 219323 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

u~uRKbc3A)vHp#hu)^b0Sit9r)Gf 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

    #uJ?cYpZd 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

    u~uRKbc3A)vHp#hu)^b0Sit9r)Gf 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

      #uJ?cYpZd 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�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�^X&S_c(k$r8 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 N$x13pREZe|{2v0&4~_r; literal 0 HcmV?d00001 diff --git a/gui-test-screenshots/t1-desktop-empty-dark.png b/gui-test-screenshots/t1-desktop-empty-dark.png new file mode 100644 index 0000000000000000000000000000000000000000..cb5d7631aae3ade035352b3a3e3e7140f3ccd402 GIT binary patch literal 200478 zcmY&@2{zv z>Y1A9nW;W~`b>nfq7)i3F)|bs6q<~*xGEGBd>#}OY%n6sKRwGV&>>Jzm{2m}BI@p0 zXOOU8G$X&hhNnBiQ&OuYx3}D%N}-#F?qwKkci&>P;`4Z)Dm# z!>>A4K3?8{5+V+TPH=F5&bRikG6cEm+hPdVme|W`TJ#VR6^Hsj%4G-;ro=>qgZZCE zkj_yP)2G)dLX2HNpDaFuyE2Tt=9#ae<$QodGj(g{^Sot=8Fc(_$A5&)zde&QwII5uq^@7&f|m z9G@V$Mvx=2kNW{IQF1{tV=H?EtLWEkAq$99)&l*1PvoksXD9SU!8l>IJ76Qt2k@tS z5tAioi*a&<;?V8FWhU+rh#y#JlCo~hJ+J#MM4W_YN*CTPjf~6P^1YZBg@4(SCKYx# zipDbM7`xo)6=sO)EcE~GnnSyQwn_mh`;Y7O6LrhfmtJai{aDncd>WsZUioK&HQY06 z!>fLxD3(bE*zU#29zV8{WT!U`w*zjdGZ!0e6(F?dBd5<3EJz7lM;Ol7l*M_#c5n)v zLUh&x)-Pya4RVk3h&zCcwtl;a>KtP4hNd8S8BE_bTn)PY&#k!`EyOu=WS8bVehTo?FVVutmpZUW57!xiI{OLsNnB_ zsat33bTTUw8QaoZscwnQtV&+mv0?)lNutjVo3rPW`G$Fx9}sw zEtRHObKFIf_fO_#;^AklLk_I>BA@jZtzzp#_)A)|bmHGeQM8Xa=j!$Q-W=OfkG(3# zAWg^jtD{wy8_j=gUOHXAY5EKhEIrQOkN&d1al4--esq=IGU&69xJ;W`8v9%Hyo+&i zU6ZhPyni+-Ap7r|+-?c@>|J0E{}$?WRod#kNB#HdB-Bstvn(>K8WK8eC(_3sJ1dY8 zhyPaXBK2C3^VF=kfgvfIRNJ7fvy;(DcJo4w97vfyp3+lO>;3HF5<-PHjh=10GVpBj<;KqZzWfQ2byWDvgj~;6^Q(-|*aZ{n zuzl!m8b++WHK=j1cM978>J#!SA$(X}hTSznh%}a$vnJb#6Mo8nuJZO5DHV`%G#f0e z7q$a^6JyGii&1(NO<xZTIdrG&QD zbNZ_nb+!~erz`>6(z}8WQxnSOLQq5biGHS;D4XHBsznErBLt?=av3Qq6fqKDwo|xq z-K7-OYKAi>4Jh8UUe#I+ATRgLqGNKu$66fA&^V+HnW1CulUP>MzYuUMUJ?nL_*D#6 zi|!pBDW86#VN~g@o!Au;x5hkyPKNRyr(YKUB0sd6NY-q0;Xi>4ijoxiSoeKZ`x-T) zq-P`l^(9yfjTXpConP92)HW)@jCHKV%hyT>y4qu=AR7`SZSCTRnR0%Tw*@}s(pGtd zdgK(m2S!U7X&KUGR@qWyJS1%JyJp&-Kadz_{^QQ@J_UXOq#^S%KjfM|Po z1?wj%{nDqId*hg9@xb|7cUi$=26_y6DNUp6wH{uk*44lBBBZ_PBs2pjP?3{Y^Uj!+mc)-oxELt`9MQYx3}+eR%xN%S1q`#G!A`Unj9377{0f=L8!^h zHJJ|;Gn=dL2SVCghkb;4kW0XTzolD`%{|U}mhCSmMr-P}?Z*Xf`CAlf^6eCO>|3|h zQ(<}kjT{DK(!P_|AAfo4OkSrvhzt^Kb_8m})mX=89uGC|S1J<}5PqF`D5{EVAPgp@ zo6MAn%Nr>3ZASxxW$etE-~Y5fNx5AES|EQ`Ay7#<2El=aekT}084pt3A5Q8YG#Ibk zNn)2o2oQbY8^i&DU*X&rNm&jdW{J|ld&U|V2 z{049&*~ei6+UCQvNa#ou?AB^Gfsw@UDFQuyrWSf+*Yk_t&z(0Ho4wqNx*?i+0@7|_ zn*c9jm-@}R{^={EjD3zGqi6J7IR*;OkJO}7*NsB^)v&FWH8X;fsI+nhgBBGnVoz_x zt02HDW}bxcJeFc3{eL6Ks6H_s_<+1nswXdh~gTKXq{EvMCXg z0;v&c-2=}IS3>EDgDIK21h@gl;;>;FwhE87F85OxCzll)6dM-+H5ZnwdIFf7DdLZD zIH|}wzshoy^JYSpM{b>u&kk45<@?X~H-F(7_fF3Pa^WiMvZ|V#n+CBp{dnP}Mka^N z#ik4F{DCt+H;L;>Vmd6=HO`wYsuKq>rLqMMs*ZTYK#^~hccbY5kt(SNK`ySo#4fE8 z;9)r^pDc*#IZGxn3LDJyT5u5V?vRnz@a-3AphN;VUw}7=kaO&-th3dm2Q98v>OG77 zb$wKa<%rJAm>Gc?d(wS4gV!&OnS!ha35y_?2-ZG-l&|%dY-B+A#_|9&pq7Kc|Q59@{bE`$>;NAw;N@S7e*a` zn>XeM_mASwM`o5yc-yK}Was zbh5d=3e>HCdNNA5OV4xY%wY%32NxoG}1R`P|Nd|S^l6YmIa<@Fh)H+{iv7uvo!O*aXoXyH&4N& zu@;ZHO2BaCE3eYc?qWixbb~45VRCYGx(;3MP?0%V(7`&6fcatVym**9Dy_iP(kX>IwcRnZajSTZ zH!C)&o#gxv#_o<#-^Pc1`^Lwe^HU2&!p2bv^_Yr;oKv$WgWjXYfX=~MK+bDj22$_< zsjF>n!LLo#<&IhKq4=l=jj7blY@N{6+nyJl<)+>MnIqNtFVm^8-}s-2N_=wciR4%e zs?!o}ex+`$%%U`TE_?!alH3vt3Kh}(Pp-D@=09F1nWKm5;9gfta{EbB5b!a!w8(bC zIKCTq(6aD~KB)f_R{yuw0dTL$DzZL`a6dUuS;cbMi>AZ{NxO-$x%Y<&89=K}o8k;* z_hSi*;xTo+;zI~EB%qD^rf{alWe_ZHh7t@jjXXA4gK^LQQ{FUe7DZ&9E~$7NO&Vu@ zP<@b7yKNCzHGz_CeyoDhB=Uz2{gHVo?{uWM=0+ART)`Ykx+^Ap38;!UO z@u@&Ym;zd+BkbH--}^wi+LZz$udpow+!%jOIm%#@i&!#Natd+f^C!bA;i*JL)**y zrQcKTdyC(5&Bv0TWnVYfE(PPIhM)xJr)<=90$x*Mf}ED!?xo!Us=bft59hLv<0F>t zwP`Xe)Bkb-TkoLPw`*rDp~!_t9s%i-bkCpnN+~P0%pYUj-nSobCHC(Zjl^TqG?8}$lf=B_x!&8$)PniTyx-A8($#+&+lMheqQ9{(eq27X2jY}4OeE%MGs zE3OJJ!6qx2W?@i{%-nhJ|Q(i2SE6PUS$1|z%c*2Nkof0)u! z)7usjP3sCQ^XL!o5<+>|g%3UIz6mntPT`ER6n&aLX2rAQCPw9mkWw}sj>f{D7@lIn zXksV$E+0j$jYoprgvr1!Rxu>efeS4A zNgr+YDnI<%3o`WrI+>gp7nLz_(8wfq9Old^>`GWU3^M#mFn<~FH}Id3=+2$>05LhO z?TB2fC@&*lb~iN!2w0I8&tZy<+h%rDS#i0lKH#3mM{BgrwHNi0IS+*+J@g45krdd; zUsPIMssAmW*_qY;p;7MW>?@UB%!*bb=GQKOW{kKoX`p*BVYfRjmc$(6C@dB|jg1xY zt9p?n9PGlYNJK8iL4vqK(p84$R9pKVPL7FWohDf^guDzzp(N$j-Z1z3)OJ-j#FIp+ z59Bp>x#RAme<6p0*1A5n-CkZEiJG)xC{wYbZSnAVAX{d|iy|;iJ@>HCi*Q=Dhjo5X z&@MwNwF7`rO)j|H56JdYmIAtwSm=KOGTJz+tr?c@sK@+~vHZ40>*aFRu>rJGZ0fSK zsX7&!Kj;;hJ;@!!tvty%7xMOdz5?5=r7yn5Aq!+tY1GrjLGMSXfj$d#$`3itYUq|w^0=SA;JHVHd1J&XPV&$cg-Ao zNmq{mel;~k!;DBi5%)sLg*G}>FUd z0wy3k`A+A4I(ZIPE|xH>4AtR))#BBVLXH#~n6tksNnW*~Wj9hnWwTsHIppnXI7eMo zF@{k=j(D0$)4)H)`4sesVgTewEar^EW6jrB)dV!G};tc_2i-k2NQ~-_nP0L?@|K8?ijgD1qYeu_B%$?+K%N%@8ryVq_yLrdKs`Wq48Oo=*F4`2O){lxon# zcEZ{`9H~_q?RM7g)x(GVj2XcL`80#Lm@@E$w{wPz+KVwggoJ-d5$$?`FGk4Zzko_7 zxsUXztK6U7rpDAMNhwk1>*fnWSOL`Hrf36}{SNXXapXBv8M}ABSvR5d*h3GJeZni& zr1hGN+;=uWyOwzh)D;=*El~#@^rXNx9mJ;Xevi8onh0Q=!$|43LxMF|qls30`#Fxx ziRRPq7F`acVMg2V+tJLQU=XmYU0qKDM^PxmimyIgRa#7h|g)am2 zMY6xB8V0c6J=>B3a_v^dj;y?^+4PK!=nSFJQFkIHoBqKbA(1An2xj@yxwfwJM29hKf26f#hj|e^f}bh*(HzS z=i;wb&&32oI2s>L>LGo76G9?Ne9?X#Bz~ljuLx3>S(H~)k3X#{lRZ8YRxJptEI(M? zLMXWXKHRjlGVObBFH7iBk6D|wN+!5{UX{HLUyed`Pj#2tTnK*~y~>j-)~?z3lh)Z5 z&FVjQaBK*ET(2m7Jl~DrUX({&zxti|JsqC+oo{K)bvMuTIiJM_(NM9Y&fw*f_HD5^#6YDI3!GA+ zIY5DN%+hjf2HLt<-x6rtGT4UD!@;LMm%f!kpdQ2O#@w>oVjxd09b-_V-b-W?dzWw6FVvo}eI;y3}`CWG2RCXf~#4RY+P zYvM%#pp0bR&R=Nhk#}z11a7ELYHD)3*Vt1QFD0uLeqG7vA@YTC%VZ3z@GPDNS6s9vWOz+N^wA>AS^{GZhcq^N9EL(XK*Pufs60_Z?Y_xB+phJc@P5bx@ekg$>!)} z8@m|XM#j1z_J$2p zB0t)j()IAHKyVx?PxEh;AuL~o!QZdJcYyUL1yuAGUKR3)R)H8iXA(3wzISj~huDLn zN2XB|vYiZ$x6B+F%DYy1pi&(I5HsC#oI{S)U^iI^Dbw|;&}^qV?2vR(F;Q^-b_avf zh6nsPyBNBa^U3s4rVdgo{h!p`o8#uomX8rFMyQ2tlnQ-xIzy{2E-9;jZ{D3d{|zps z5)u`aY7-v+3I3pQv$fv7)xI97ZiXTKMN+^u_UM>V54_mm2mn#okph9R;y42N5xh_3#_~a+(J03$PkQ$Yoa&%SS_<8g>ooSZ-76F6g*}A){%Zs&&lN> zrY4xpyruZX;6sYUyTs9ogUN|m1D%_ALK*)~8H&x+V}YJDaq8;!e1si(thZ~W&umQxW0MTdibP-Gr9e1tnrj zj=mlI-;WF zEL!?@de|qXV{uh~hiH`(r}cFC1GKIOvPbhr3qwSFqFIjxMem>-!m148j27_VB8)2k zLVcRaf0VK~q0VwY1-4so`+EmKVZD5p;0VjMMg!-O@ml)@+T~Ks4hci2Ga+KOkJ&yN z!pdusClc2`6spiAJx*UGl>zFNoSSV?l{u#awmbLQVSb@7=dU^V&Gq4J?|56IYR#GF zPC9=vN>P=Q9nh^QOlBQO*RFPfu3SrF!{&n?!dgItK9snHv=DqWuun9IiPfXyx^tCXZRu9S{2bXRiFaIEH$i7gF-#bg!E3z1C-(-7n#&dm8< za1oH^IJKs**+>|UR$>VRqjpx4^OsTxfI1XI4n4iGUvod|%PMyFa?gxAMz-D|cLwjN z4`D-oM~WY(%^${{U9W3fcJC$+En!z16mvo!O3$x;7B%+|TS|JI>b6`THupl`eMIJ_ z8PL?;pO1W3*C2*}tmlQCk2`2#ecX6sjD?P?t0)9Z$pt~2AfS@-)AQ5akY7-c*PlnP z8fJ=t?vKN3gAaQxtqCFSYrl#)2_aHH!5AeBte@L{-WKo23FUfEms5criECo_7;)tv z&td;;Hwfps2T{TJNW+h{4~zCbj_>|%_6_&3jxAf!}NGM~UA##m7>g-+L49 zSqYucCOMnsfHFL`gx-OCxX~}|5bo)Xi-KwrRVU!Ab*&&W3-oXHI{)yDVkEo2Cxtzk zp)@ND_rn=d(x6r|wLY>n%_>*218NO+w2DJ?tZg{{Kp=&?>{|L*%yC2a!}UtsGu*^W zp5^OUwdY+P3c>wOF8Td1YY$#^0%8m#TZsQ!&9CzQwyeXtolG{Ywy@dELf4=J`hpqc zu>)Z-JN3fJfyrj?JyzB7T03AAti@S>GOS^%8KfCXpcz}b+6*RzUA3nf@R#?A=0b?N z3qg89`zd7oL=}iaG+>V4>*HUhF0ErMf&b=N6u-SROwp(C1z|KLQaBdsI{Qp=XH}y@ zG@Axw1?|e-=UBUMn4lms63>Rl$d8+VcttW}w>q|AwzMF*1mc0t#|%A-LoU5ajxC#Q zlSQT_@IRVCkEJ90tsXxzP1XAn^8jtX6*|EGsi&{7(q<#QT!b0b9K$htkQa=>RgXdU zdlzj*uq}EexGkc1PzL$;eEj$T4~pR$NE~V_gc%JGip`*Bs%C5s*F3h^_#odBj2lV= zl7)T|a2Z03?x-dCPq`O*(^48bpDg$|bHc9S7#R#cMk5>%RYo>8OY;l^kqwSB%z=<( z{B76HPtKb+ZBLsm=cfB%QPT|>eWYEZ@&7*Az@GRHL6@`*Sr!Z@9_-j^ERn##m12o9 zVieM4c(n@b{$9+y0utwVXHqKwteb9MR$7s4L9{{ngWiRXq1(s z3M>rp+2&Dkr$G1X^~sg)ha!2rjb;t!p^qpsitTaF@3DtqAak>=Ag2vfx(7_VtH`SU1F{{p=9W%Cl z6wu&=Tr#}zk!(r4*40v3?Tv<6f@}o*6DTk~{F1GzmW;r7Eo0G45AMMaBlT*%LVw*- z)oKSv<&AQ0w7F0LyUjVbLe0-?X6PpRE59qZ{cBN(ah7AkFetF4is>Z=oRZ3a`a#X4 z!B+451wWiP=q;2gLAz2aDex{_BQ_KZBWDE?C&l2&uk>E5a%H*hEPFHvJw$~6_Gbj$ zUzCSS=*>2h)nd(8d_Ct3jy%3V&nbMwQB0(DM`Noc^pXEB7qHjd*4h4afW2Jfjd+52 zKfMdmM;m?G)C+vaQ)%4YvWYv3v&>9qsID6mbD{_n3k_Z zXF}v_lhA$pGM9rJ7E8_gm9zPL5ave6z1EuZ^EA}0p|SBCK4PrxrU+qL-!!@pI~-yf zxnL=Ukn+gBv z`&qem%As{tU`rE|xL1G4%*nEvTtlnp^)Bwz@`oj78zvtb3cq))&s}Tz`CSas7Ca)x zh8sr35Jm++i`dQ>^QefGOk?ik57(qyDwmLdd^->6`=UTai*TG?(?(y#PNsdwCdQV4 z?*rMHlRu9iJe3!v7U4fZ&xU#~46hf9B`lDW+VotP8JR{0V=URRS;vPdJ~HqXY8^VC zL|k69ryseRp|Ui#mg*Z%(zdLTxGqh1o{!$=?Vox$Ls4cQwV8kFKs^coy+{sEpK+=3 ztyN8A80)BGQ8w=1%@)dDP*TVQOv;pmSxHuy+4@YRAXm_-Y_pwSLr7Ge+J>YSv@}X9 zQ%Mj-P1xF6-|f!9p|e|6D9yV6QR>7(ttKpgb5LGxF!9P-a6db!My*lJ5#LUqWXTy1 zhjf*DCTwJAgw7;39*>rYrrdm6SDQm1Bo^VfSYU1o^HR?U@Mwd87d$bq$kjTkB#ctL zDiRcoTou7<-Hv-cy(fWIKs!pDs_@m+;kg!XLW2Wvk(7mc@(^;n9yAr6 zcAIetvH#VyJQd|J;7hnvE~0<~j4;K&UA>=;B2fth_hOd7a@MWs3A8TjpPksL*>cgh zBl_Slp{COkGJxILc?iQz0lPhE#W-*hte>)U7ru;_A~ye7wj~!>*0cLzD3sBDkwH8t zf5j}Wo>|>xQ4!T#rjUWajgBeZYlW-%n}0{#!GENFidC1f9=18A$5KVpRoFxkiPKJW zI~bSPq~O}T&sWJB%h{cY()^G(DO8nr+3mVd-uN z3)69p2#k$Zhxu+rSq7El019Q>fv4_7_(_Pu6hm$!Xu1FG8}H?2;`-0&Xq3E}ZKBOG z#_jgb9D%Qtq(P;yVt4MKx(KkCxg+KUIGQV-0}lZ&+l{2= z6p7o7(5O;i|M3j_ld3uX;4j@2cCd)Ym&Nf5I?gQXT~}MTCa))psCfyH0_$!bs|sN7 zR?nCcuDkLKUH{Cvg-vfsxSzD089wg{eZeF~A5|$W_61%|eYw%38F{atdYmeA1Cbyj z2%T$^g~2C6b;db_z>iBe*XhFd^S*5vSzwzb=JXL9?qR%Scx*ZA#5hI`68HK8- z!vAqu%8m3M2%pzG@66X$5=5>cC>kx~6(3&+tpgWtUp5-`1KGBnYi|^};dXdinf7}M zWigFXEV0BZKYJCW>zrrJEEX`HWbRGd-m&X>(#9=cG&O8hA@0N?z!$C__|A?8hB)sl?WD~G4J-=Y)bqm=&xC6{t-k&iGDXd^P`RUcpy5!hc_S z?L4T_3#w&NGu?JPGs_y**4#?IGblHcYy0zRJ9^s8sKf`oZPkS$n|j|SX%6XwkRaq% zNeE*3vGftHl(PrX-&qN&>1jJ*_E+B0T#$f23vcpl^bqcfYU$HP>j~Bv*68i)J%$wo zxTBeH|7A6$DB#3uvB#OE(LmV?%pKG(gGLu5Ua)m}h0=b@c1-1MlF1y2F=k)Di$~7n zZEP9}=I?N_%cS+<*v#jbwa>7dYs^Gn6>j>@iQFJn5ACbi7i#No8+YVw6eEfh5z>M3 zV9|-{U*Bf2j$n~*dqYCa?M*vCRf}`3i3P56SQuyx>ZxavO)TrgbkTQD-iejE;6?`#}23Lzj?bYxq( zVeaTRzm&ss^@t%N6%KBivWGTOc(dsso;3K6kjYw_(_!*^OZhucPm>H42CVR1vfa`c zU%?yMhRtKjOWA$5i2W-6mMRY-CWiZ?v0_4$ol2txx#W$?SluQ&ZP*2vl zW==+v3QlL*ktBRh^d^(cOeylVQT=4>7&dX{8}^O?+>gMHi>mSkaANA!L3`8HN}$8uEAGmiv%-mn1RA+wV@aA>|sq>n0>KWVn5PWW8OP+ zPqIs4V*!T+%vtW@W`5Diq7py}+es2@mW&G#x92NItrmqNF0g{wIH$NC>(plHYEkom z1-@D08nYIeE-a>YYq(hg@=t2YBV1GM84srV$SFXJXVuuP4RggIBj$I4E!l6z>0ii? z{whZ?Lg(!$^Q$D_jsJyDGWXILSYhb&&0`YnmD)PAl&({}#tm>@rt>42!@7WjCOB+F zQ7DI1$na2GI0E^TbH$!xuwi_K9SJcFCgu?9sh|_hWyKjE?~}3bwCX}a&Q=+$78oqQ zk63LH`u!Ttit0A^Xm4Wg`_-F9TEVW6NY8VDJe%6e1Iepq* z7&*!gNBPZ+hd(hi7fR)pi~Pc7lTtg1hMqo*SNa;+I#kE1z=b!#LUEwSH9zz~6cQ?t zVA!Bjf;(s4`>IvL*bEn^cuMiYe7`@}IdiVxqe9`kp+8xy&Q^}u&S1Oftj-ENH#)XN zod~9rmUG*2k^e(tZHXX0D1>- zEOxnIA@P!r!ShFxlOI8I>h3_{pRvA;2@s@YN9cVGacPO7z5N*)Ps3{cxH$;+*k5qV zcD7jTg0qaa_Z*v(L}QQ?V+wt|cu*JHWx)`(u6L~isx73be-|6{Oi#!f`SX+UILYJYzhgwA^hlCaaX@}30>oC07XoBrn zNU@{QO(a&7w0TMD1jVbdK1zyT1mY>0HxAB&+HKvgGRu4b8`jQ4<$MY*=YNZ{U0sg0 zH7!`Iy|APx8T|*ta$7sg)@%WtazQ#FwE2O?s_t&EflQWwZvWaZ?h#z=y*8o(;PZ$B z3V#yo?Zex0_800`6nOriM=Xk~jb%F;OwxOV<*bVG6=4=BkEoC^(?d;ot+dsQdGM4B zZCrMI31;Xt)KDdknXSIfNd>|a5IB;aX)^3FtPN+8I>B6cJOQV-*%Ox}r$&)L%t+1l z`Ck?9)mT1|7Nj?|65!k{*9{=-*8O}dwg8s*dflMtxcpN^MY{;@9p+Xdj5o6v7+))G zSLH;t`YK<`l_nl-tZMESxhsHsz`l6jOFo@KloEMedo~5 zb`F%-Uxz(8`~u0Ql%MPxjTb`})K2+|Klwoc)ibGlkckuo=JNWqKWH>cQp{zTzktYF z1(Ss;g+?Fz^VY&oh*a$h=GCWUVP%!urFD9|>H&O1aDZCL^;&TcP?ItxkW1D;^WLy$_jw$tQuG7N(a9I~F!X<6^xT5_eB)m^2z5a&Y9Plf}>daY**a zo~oQ}fgU7DFAZQQPmLe8G>yGh3&iPaxTxRMwPT^s7qDP-fRY_eC$EB_AW)C4HRq%;(d6I1qTETtici!IT5Jt;9 zCs07YSMu=PC$pNEq0yF}TrGrbQp#imRYGk{!>*0r#uybm3eT=^1w8_iH!ND9TgQ|# zlDofU6}o)M1cnHB)9XYu7A}W3f)+~^8zPs<6>e8fLB&hrFbRq9#F%zVG>Kz9<_py; z?f9js!Nns`uy3kYdn<;CR0f3J=#UHM-qFSJ=|s2QP4A&>lMSINtC0MTl2 zK~*3LX<5YSy7lOyL1q>*5%+ZGj;n1~tJTCxxY5={r)~P0gjabs=F6+E-w^>inT((E zoRYwNgx52_-b&eUKI4bH!J_j0mkYpQ99zagfwU$?f+T*fnB}!>=Zmq{4VH@!Q~pqR zP;QJx3^Uz6q*cG)^Y0O(E-jmhq{*AaEGFZx^AWx>G&3~*D=GD)5XtrFhXg5(`l1%C zriEJMR`r)plK}v!HT}B_%8v64vu}*DJmP%}DL`9UIsJbXqk#rUl?y}sKVd>g4`p*n zcfNe-(Z~lkuN`so?>@hKE1O|bVMQ^!^eh_{E0~Z!&=2>G09MV)~Tv%_q z?p_L-J8TO{2x-AKEO1Y(;vAX8w4LXZ%Vg1n9ry=lj@E;+&$6&TrpZr{eX!~Kze$W; zjesptKDTr+7eE?lx7u(9PAUaKKtd@EXr?&3R}Q3DYN*I)8Eja;XOa6bREHZgQ5@fJ zI-*nB^`@|gMo*W84G^9?n zoF=raOrwr>fc~K)=fq}?4ka|Bzl{*%-b*<8x0c;^97_zjnj-L}KiOvt#v}Y`j2*pP z&4}m~J3CKv5;qU1;I1zYn)p2WJ%6QcmfC<$10ivMW14D5G++`cTC>N3Nyntx>Xh=Q z)wHH-C2ITcM7P7r?Qo9+7{LbrU2<^3R4S?!_eD|ZxbA`KcS~m3jDUGyv{Fv)JBIal z_Z_vV!Fnf0DSc9Tr<~nOd7ZBeaY4Q>pE^E#JZIndAx~SykcRD&iQC7Z`D zH?rDKO6ehvbYk|r+SfxY{M^`~wQj+-4T_5bp>+X@_q(lKP-|K5N4~w36O7f3jQ0zN zE>r>uuUnS`UuMB&0&)b6?iJPx692RneyKuK_H)`U($BrxvLRdco)9m{;hT4EoW6a| zD&0rN`Gq=RE?KUCfZl5+iHnoJ&XXw5+=N8RHzCxf^8ATo#`(;zPK{2S#cyS*>dwdV zdvYZFqg3AprUo5_tvOL(aQgeF@jVEY;h@f-uH>50M^N3=K6Y{KBq4@2>&fK5>&pJ_ zDnf$TdoT<%K`V{wBXE5tnJ`3u;Oy!0!eSRO%A%B*Z~W{Q3;+vnSs(9*cT#FDTeb*I z=N-Hop$8r(4~3I`gZonD8C-FH-9FALs+N>a=9Efu{dl1$;@&>5N5JA^j7SR-GuIH~ zi9a9=Q(xlnshcnI7{w%T94b*6kvZ?Xgao?>>B3;;+_;5t&tWWkAiPKsEnl(6Ox6E3}R~cHeL;vAo=ZIGy(Hw zvwit!BWtT1HlQ(Nn`gjI8ReL@eUhbky*DE?98ZpXF2qKuM2{aMmH3 z8C##aWtcd?6OA_QhNiA9$`+>_F~Ks4mL$%DB5nzK;`odEmpy#R{aEC3vt$Zk;E(*f zo&x*ahDJ#60~E)^y`XnbhcScBcMWtsiIY%Tsg>g7!q(2@#Qbt!{*Ngmif9?1+?VjC zPuoZciP|ovfkan*4(%I#mHJjzz+l!3$c9lnUk*Cto#P(ZJHG6F*_k;_D6Fc>@mwJC z+A~*b)GxPk0j%V|U)d!d`H|w58JbB|iu8|u_LhWrr!bI|rVS1C98EFf?>tNFJ%d&d zBDUhu)U#M<2{Fnzhu)G%)_{fS$J>kP^c^@Z}4*k4Ia+sPV^~eL6F1*B0v() zxpvtwxJ-?((HL!0e69gm05v})X6hFXgbc}O_Vvg!QVKkNMAeowPQ5Hs#Kd|Jz5L8j zM1GJlWF&-I_t5r$T!rwBkzMu1r@A`Hr@CCunj7ED$`+*yZqw0sMkv z#Q!p*WK7QQIqMj!&Dd0#@_h{>cgv^%{UO;l*i1h-O2+3~k_zYRuw>;$wu&UwM6`qm zW(JB8op}O%_-@*u8b4{*n7(}p0*h8RMR9K2@gcc(&I5IM6tKC;&pF`^0a4p4;-cXz zUa%(Kdmw$XCb+)*a$=&2XQN2L9sABt?b&Z@=-fc{DXzB8MHa)(^;ojynwS5n!S8L{ zzP-*Xo&qNBj}LBUjNemO+Q&~{gv~?OVVpKHF=_H4T-(_kPclY>#5!$LychIUYetUo z{_?3KsPgTLpb}K=00z;t+@soknS{LE9YwPRy47+?x#z~m@vdml@z>!>d9C{~AG&=mCSiMmI_;)UVJuu3c zke!vJTGIuU8J#$U!goFa*K>I#909;c=EbCovk6XyCFj2ZiU87l{Z|0XRGk8OZ3tHf z(0+Db^#X`JHHwkjKzyMw2#rwr$X89bYlBN^t_##H`0@IE0si{)x^>H@NMNdeC94q7O=Cp0>r5(caLs{nw^Z7DXk}Tm-Z)mL%qUYH{1CA-8 zCK2{f6Dnh>LszT?PRwpGm8LnXDhqsLI01 zVo@KX2x5Q}%*mzJs0Az{$zW551;X$?7iWrzE6|7`hOypy5l@?;NyBj@Ao>yxL5w;( zMDBg&dS=L!hSm;WA@>eP01D7gp{uNy4szvC5i_l_3PrtU%!k9>G$VCu2meT1389mb z!pfj0WJiACEh)4h*R;bZ+N3Ihc1jaRD0$6>lQepaak22o-vhMQOkKYJVDGu~S~P1$ zWmOf3>=Z(^2KFXJ}8b}3JI7b`|gWe!W*$SYGD%APz4-9 zNh-yHU->jzEKhM0;4S33FJq{9>ZE=*rh8*R_4*k7-k!N8kcjt9gB@@<;QRCTtK>?g$Xakbf<#V_J_Z zUW}n3R*vHiJ1)t*YoYn23>gfmBMu;FFa5sO%-q3C|K!3GGHuNy4!`5pqXDz!;l`nK zadMjJOmrFTpBqK~^apzd{5CTg~JB}k# zsL)Ed?RvR0gz=rY4C=(V)KeNq|A|pv8jGF@A@&Oq+t>h3!e#tzAm1%;1#E7(=fCZL z4}%fY7EgY`#THYhir?zD4P=c$MvM*L!}hQ?ga!Xdk}9Y6NOLCKErt2`zPrJ|H(Hf` zX#^s+C02IFYUtxAvxLG&E5+ng{XtmK8L|R+qONwj1HH%h_R2wdtoZk{>;2F!2fUi? zf5EY0vVdI&RASI?l{wO!h);LJ+PWP4VIn8}x3=x8GVQFnH}ef61xItBkz?OZ=YG7J zfHkhlFc{xch;tWMAg>9Z27#vSQ=m%=aKniu?0QJbCv`0EfTH3+5Bu^h@@l3)#vpjv za`hF2Lpr{3o<*$ZXe=!j%~?6~YDG+i5IXXW)EbR7Ht4t_IrT}|=Y=Q#Z(S*{R)K?N zAkx0MV0>LLO;7L(ka`pmWCH}NUvilE@fN=$7Ou57Yn&U}Ra5u~g+PBdC7p1GsW&5y z4HNV00vs4;92%qo&#TO>HkC5S2HDyImv>mps6aE{;SbODj2g@4bnDb6*wlMRcDEB| z{qtR@l~mo~lM-XZwqlTM0kvEQxV4O?z1M#p(o_@X_%7B_I=(~M;vOAm}?chVsG4Ws;OfoEX z(srmr^|q{i0w*aP5P;ZhFmtOt^*gX@Xj7D5xS#&HO}P?eMW;-If~4)K+2314Jv6jo z?LKpH?AI&a@*e)fOmn5DDJZrn?XPf#KK}G+nKm`G#-M0#n+V3y$8|zhkr_*puo;4ti7yz`Z66XTg4n z?b$RGq08e7Bv&ktyIyJ7RZ=SMCiiy2dcP`#G!t1bm0yXuRPHd(Q=rdbg>MJQX5DwU#y`bQByk8$;7-`hS6zsTRp>Tb`! zlWY+B0S*Xjm>wYIkknMjY2hovfm}(3^Blh?kcR++Sb#XeDN;z1r)0H@(3(J5p=xe^ z?WjPG5}D7AzWINsdaJNHwyg^=xVw9R-~=Z)L4&&!+?|cPySux)OK^85xNq3FyGwKX zo^${1mwK(Q=9;#~9CK7*f|#yu(y$i0x-xm0iCSz=@z_LUF3k&wc~?UZxBy$Rdxuy(Th&sQN<%z%-z? z(&!0sO;YY=q)FqW$te^7{|tbY)zKR-y4%rt=<2sa@~$T**#|%ajv}-P<|_o(j@y_Y>;oqpoNI* zoKET~)(%^#*tctLiekuc!mXfE*#dXx zk(n{3p7VnATsQsdXh+<~=;_0|*jiO6TL>j(GLtfSEG(Jc?;<7CJ;B1Kd=mm7>RTr8 zpZVZze)%uZ(aW8EfhnGG^ zJX`3I;lVp}2i{Mc5klCb%{(N&;hgRUVoF!`&C7(?`8q+&avXt4bb$4JNIbOzF6Xk~ z@6^?%*Y>Ba7w};f?(uh$Akdi?cbkP!kQ=i!{Lgj2iHat*cy0prpSkJPNS*xyag#fs z*CI`#F+{jW9F0OZ?gy-QEY&CUWfB$*7GcsScF8=+RE5(td>M2$fff zC){}edKD1vMfA~A!N zXR!j8l%pr}hn$jeAA(hq%#{@wl)Il+mJLo-RnJ$h*FQg=Mswa@^tV1*lzh6@iE7%; z`p0}KCK!4zW?lcY*0y`Oy8`efDfRWj_AcR7O@{Udec_Oda6~V*`vx}Sv%CO+*sWSM&Z!X~9e_K_ic|wm)2+z6l<YR;@E&b^ zrMw0F>kq>=G>TeG%9KilvGGLbNtKisf$qPkVIRu zE|(7yA%ZUnSLATzGGo}kB8B;pY1p(qidHMyto1duR^U~cju2-Lw^#c^m9?dDWLj1Q z>CKgDNa1;lds~Tj&dZ~#iL_w+<_=@}9gkl?pO`#VCTbfA!M+C=I27*C1Syuxpo3E! z1)FQr6`19y!kj#r1E6~mHTGOt2-?Y)d3B60 zoWU3X$Yuh9wMF&zfnLb8>tJzc>_?nv5U<2IPkG97bS9?K?s?00;XTCjOCAE18?*f& zlyKOWOKu}JFR7JX4d|GLp;Y=9VY5c$padw85)6iW>PWu+F5!&5AWG-)aNy#bDqTpD zjQ$5zH3!!m9pl2HTND@#;@!4z?ocSByy<<9-Z9*z$jsDyV{ipwupKXPHXh&OoXO!2 znYF%A{=4mEhzP$XGjKhy@R+e09-|Taf(l(gb*7hnrd` zu9J51dZA;{xQ5#)Uv~le$6nn>c}QZZn~12hqz_;(nZ;f?{Ss+{GEO(Q_Mmp`scuo@ z2~24EVmPF(GG-|#aiPrlZ_}F#3|^tq`;*i(v|N+^(AU=A?7-Ki>$8SV1@dCgd(xSc z%gg%KSyVj*fBVuLjTCv>5R3N3WxVdqMX{4L|CX@WUI_mTZLC)(C0^b z<WjA9Lv6Q>&^2V3#uyu|6oYBsJLYX2ukyDFGM9=uALCDM33U(im8@ z2F~`A?oBY}8?dIuMQmy5O{&r(M)}ZX-{A26C}!*`g4C2AkP=ndBci{m>S*d`X$(h8 zk_cK?f_>klZc?f1mF2yCcl5Y^M()$D)DzO_R<2GjQuyX%xQFEUC_(b-+S%=K4Z2I{ z-r#F>h|#*awY#xuOMeyiSnaDBa&-CQjShh_kPqrDHlV6v}HxSzh7MuZ5{n~HhDKW zDL0+-vy+b~u2I+k=R9aG(D4^bNnmg$e1fp=TBzAL99ymERxtXPhUTeOZ-EzjFQx38Qre_a^0mkTy>*7ayurfg}U> zVJ{(+*!P8xCYS#XfDuB69wBexf-0~y+?Hki)i{*P5H3OE`XJ%9D5npPD4%d>n=lD2 zf$3O!HHrdH5omJTqp=DsHy1EHr6IjzAIg=_^cRCjc@L#9wxB1-_Pc=t-2VdQ`z_if zE+oVP0jrlYq%;$Wd5DBSH$4sBlhjo+yOPUu!ozoale2#W9r*Db@Hx~(G|ZwYq*W~L z@qGc9LM}y%{OM*By>xk=Ncj1NX&wl|`)ESXJZy3^bAmD+dm)wSMt>y!7)J7~incAf zj9F_Z)b5kW%57_{Iv$p^uWdV~a-XfyZQ*kidE$bOP|+s>(|Y@q_1F)mj(+qrF-Ln5 zQiW2+Fv-b56yNdEzj*97LIT~1J&){D!=WF`S`afG&X%ZU;#~Q2zI_kqGMxyq)QO}r zzY>RpiS%0lNWT!=Zoq;PDG?j#Bo+Mhi7ugrPkDdM)JcFf;OptwRL|5|dEb3JH|i5} znDiQrEoYN6MTIf*?dJg?fK*{SJ#N`Agtd0mMH07p`b*E@p4{IDi&Lk;d7)LG4Y?#? z0jsz3mYAgibgKBpAHJ>Wdg$^>3t~-&T4uwpTROBlqi-;67=ya|{JqQ}18lF!kxLVhr$zC4oDn5OPPfR7_`3A%v(1z7UfScd+?IUA6h#Ci2=` zbp>67inCslU7waul5dh7u}%V5J96^O;m;Ci3oHf6Z8e?;ZjfC4~3D)yTv(r++N|o z4Uwbr@#~qaN~sx7eRKv9gV9DC;B2UAkXat`ELKb`RMAb(Jj5!J>5!rpl}a^*dHncD`yhMZV@tb@S; z_?}IvbhUSXzDzdE*<5Z^Mfq5W{f77%JrG_t;n>ptHcfKj&A+i3{qlJ0{yF)zer>5~ zvvg@2JKAS_>3;WowR?SX^Y#YsinICXAvB}kgy5*9$?tMK;5IRF$4K{HP8XKsz>3U>;$pY9Mx#)Ox+>9kmZ=;$}g={rd$-VQOf9%UL;+<;2m>bV3}W68ORcXF9XRd8_!_k7EB{AszoMsOvUKVEVj##fs~Df;RRNnf|?jlQ?Dn)9-`VBhfKw~Vk1ZL za3s8TD1kBi8OnEbX<20n+ifT4m@8Zn=1b}77s(_M7YS0@0T&bef3gT3}LyF%wz)p9mLEv5inHlA6@890u$p5fkqYzB!w5* z{&I>hua7Td{(YZUU)GZ$q&wP67sgBXblUe_EkO zANf+_XY2|YMgdA@@S??KvE66}n*zEF*%r1LMlOJIqJZiLba#R4FI7_J#Aj4Feq#Oe z42uR#2iatei6c^0_7XMxs3zvY_&&RR^o4RN#$ULYoET_{2p757I!5oMo~EP^Q-m-C z$=I{MG;vzJ_7)xT7?STQ48RoW9aMj(cjxW%{T6D?oYFddUHB_^)7QFl%~h99_nm>l zJ^Mzd)isfi-i6}4=38QF|5aaPCJ#o%-Qw0W>=&r6ke41d;+%K073%PRv4FD`w)dlw z4>S2QL*Jpf214tuiL2(^l!gG9z!Z7>zRQja+Zc6~ro0cT{jXJr5~(xVM^#VrGn7 z+?Is2mKxn`k-$%^?D{5O3?w(_T;#&!IW(`_*<#EZ%2g(USoARP3IxwqRFGc@*UWiu zRH`SRxgwYbbgD*AVE+g0oKPb)B;-b~8=u$0WIVj7eL zJcF$8F{wwS|1vsBkcbJW!fjeEPck$6<~+vjgJx5=n17{2LcS}{x-*gZALj+@PtD-?_^?763Sz^scJk1h}m`+z0ADWMqF8a*6+X%PBzSPc}*<(i=s zQaVD$6(_(=%^Tp~sYQjFRe#P!uL6!}^03+JRmg-zs<$7 z%N85@hA3Ue1VGKcQSj|cleKFJ16lhkIKwj%j{J?3MyH_dO8;a_MpT-Zn5eTS#Od_b zD3;-<^Q%V)T?kCo)4Ra*A@bM_UDpk5YcZQV%hSNIHS|jic>a|4T5GB!GYCKa*|m;A z?K*(Q@3;ZB1ASNl9TQHX{0%mTv>q%Qf=Vf`8(Dorpg>f#c!tJAF@uW1H&$wbPgm7q z6wE;NN-1xbKG7z?6dZw&lq03gk!Emk#<6sxz6@y>RoEmS?4Y!c2L_nIGIeBNjx|P^ z{}6T$?raziL*nsGFtoUjH8cExlAB4dV+1_HUL`5kXVC8O#q{Kr%Di4uL7NgHbz|fq zw2~rR$Hzkkp~FJ>X>YRXL(9jj^S$+Xw4%FINAtryt%)d%HattKi)#+gp?dsy@kUXv zWuHcsk6pp4`l{f9kA?M#+emR-2!4!YXg$ZlVihR!B;BmR+; z6Z04AdZPc$d6IY+&w7cjmvI(f#XcXD zwT^8RVE(e!Vu+3~=6|Yu_CnI|CkTdn5|%F!oCH&XV>0db)2hTeXwF{xK_YSWv!|Ca z9OEl2fAQ6izG$RBsasjPai9-yyaAa%rDW$WeFIVGqYN>dy^_!tv!I!D#kBjO01ab@ z%h;U6mGA@2Elbo+olM4rrhzj0*cBlR@Y1W@l6N+-69<6-3i*|yfK{{#d;uf&YXAI> z0SOD)WIZ&PS(1aO10e{n_@jFvz-|$2Shis@tGR$`u7qKo9D!Uxvl%d6o)M}NCOKF} z9sh>|MV2(iL>);I(ruX>%p=Ag0d6yz;qWjgL9~6yPPMSZ@_gZeZzu1;OWkzm&pY?9 zpwgL#(kKsI^|!nW)~}4#hgccEKguq;*=uN1q%N>@l^LsiI;Fd8KN3>ds}^u?diKY%k<%v0t4NDiiKg1wCoWOID)VV_kA3bT7ssi6K-!sWY!kky#_X9$Oe zvMSj`s6l@MJ+dXh;_3Ev+EalMPHwN8b!EWi%zohYg0D-k>P39YLgp%YajM~Osn+Gq z!p|*~TldbJYtNy-?hOxrbi6mle!6>kN>d~@M2m>&a2(k~OdhCAmF!3tRXO?|s4DDH zeeZ4=X9NZ%a5)fLXmoq;?NR+hi=E0X-NcNBFfEJP*1LY44MFxY??{rIaL)cab|7dF zma5B&pH7t#uKTq=5sMyF_7udheeyba^CjCpG=e=iJs|YXH>W|N1&vMS1}eF(BTV=4 zO9$KYZ>Z48OZW6IZi5=S=QoU70-x-#eIngCL;hn9v6_2%xc^?IJvqmubtGa3@fJnm-H5^L zxTNm{nHZ4*HeKu~Qy$N~R27S7$G&6>G2i+}nm3=#Tbo_oAs-(6{JXnCAIGB*)=>NOM3D=zjr zlrz7ANvXr@dOGH0D!@k9Q!(8{4@f+v+;K@1_)#D4uqU?;SQN01=7;|bPG5LQ{ewAL z3sT;dpqVEA!>MZp==*`i5vdHxrLlz|Z;bzd0dgYRo6||CSSYW-W=(L6seMjm-|%tr zmg;`(mAYLfaP2@@jw$Mz%E0lMgn5n{_ar>O$on_n7I4ngIq`HA_iO@OKP0H0yh-WJ zM=IC8PLWm8LU$;p^p4Zf;`vE&mt-|4!#s>zLS~8%&jtY7r!KvReYwPBR-0e(&XJvcbaivxeg5K;LH ze(k>LCP9$V2~M*&L~l@~QI=TT-t*`mOT!LOLkc$NK$Y4f6 z$6w`Q`{dHYzZcl1%W0eGCE*JziiOK=wYGj~+HT9KMiQgk4|;G_Kk06{vjVTs1AfcS zWum2yXV_c(Pp^~hy46vyI5zw2J9$ZI;%O_7)@f6IKo6MUdxtoVki3RgLtA&eQjxh0p|AexlQNbDdVtvV6tA1=zpS zv4(qXCye0QD-#XKHL{{iaCGWMN|fywip+Vv6iKdfwm})vj>UMSW3$t`^J#;mQ zd}|aI%{a5W-Mw^KQ2JKPWJ`-RzN{{TJ_l+GiW=^?PG37YS$p5&!UO*&?5)dit#xlR zdin8vVz#O^(irx`LhyIg`mipJnpeq|9`?}4UU6Kj5ExLN;bp$#eKalTZvSfk4VTFv{ zW-il%He*CeO_zrXSs?JyDK~;hK_`h^GvZ#IJuoSKjLO}3>UE*w<==OF@(eC14C^3` zqy2N-kh3@46Z{Q(`|Jw2GQLgIjr_9fcsWN$e*4RMF+z_r7eQ18#1Sovaftcee$iQ} zv0f)BIvcdlly8CYulV|>h`H$?8Na3@+6iuQIc#SZP@XP2z+Xog8UJ=rXcfghl3^{aiew=49!J#VZ0L13Gc{F*1*jJvaTGa_j;smkWhvVCUn10h0g37G z4rK=vvpSla35f75qbmRNb$N%Tc=64M)&COss=oj5?P{+Wg;t zO_uXER0_lXpCb8JR8JjDH3e;DoM)tkxQ&w~R?{~5(Mai5hDV{l7+v0%X_Iu#{+nKP z5w+8$`~LkC$yeYtg=7C8lYM<`q>d)I$tl{E^k#$#(Nse(O7m0=uJr|-eG|I^cT)pi z-%uXlblZ^`tGH=S8#`|G;dOMSp0D9odUh#$Wi@d=$j;Hh);7t(jB=ne8`te({m<|J zb0TgERv0E{&?Pvrf`>eAfXrS&+bPrSV4ZB82J`pCF^3K@#K>{F<=%-5Y1)%5XIL3i zF@?DFLQ|y#HHH=gp{X)K#w$FxrqhTm%8C`Ir*zMpPIv1SeHMKMEw+qj0ZAI{8)Sv+ z|2s23AdUb7ahz42oh+j(*!fvSS~pjQE%2E7>vRorn3GO<%ev3iF>3lZa0k?>Lg??4 zet(|NB)D3>L>ZJ|#@hfC(m4KdA+%o|m$R96DDL)R{`#bhjL~S+5!A?XX_Q~b+J0vx zd@TI`S+J<5<5yjnGNZDx#-+2rFrKBhVa1|4PC$&exc)#s!LRPqwc1#GMA1Qe7C_6t zSb*5*SnuTlYgirR8BGCR`H!0&w|hhd2l@Blj>wqa6G938pXvw!T{zqX3<(u=aPs4R zGL5pTG{arH=k)VK5l}ijfj~GSgz3Vl z-sJQK(ZfnSN*7<%)K+9w*F@1vUhHcjtYg}SuOgEd(^3ZpIbghs;jN*JV;Zv+l}Q{k zd=YXmC!CvwUp0u#j+{RiuO8#!Az2;9kvacM9Qq8y3#`-ROYgRTBmk&M*U?rxLeSrE z&Wc!VBdAUVv6BRa`9lb2k_z!8YaSnq4;HsHYXq1rSC5ES7lyeV2V1k4h(s!>( z;u7ZjN43~1@(Ml0rdo}}^3&;8Z-^f@iFTSif2+Ps<{@Skh_3aq`A<>s6%L55yNl4* z89{vX{6VVuowpLqAgZ{pjH@Lzq0ryz`;p9>8>u|TgP&EodR%o+*Qy?CqPhpD!EzS< zDsSqq^1mSHHpI+J#s;j)otJX4Trp5-XJq)m2uA^*KcG|?i!!QL-Rx(Zid7_ zZ$T$wT?N-014YiwGHZ6r0ph!3N|%c_k2A&hBjz!q0e z=S#+novqKDM4kLcf=8Wf61qGySdbe%X@3O&9gaB=(*UuSic|zWv?FZy(G!n;K+r7F zHdS&he3wAn=1VUGTTBqgtPPt!w7jg91B(=Ya%KDqvoodTZKc$x@+mu7QWEnGOm_~Z z1P9QE*NnSTT(+7%2P_zbQLetYBJchrreq(14HY8bi~9NaFHu~;*O+Oatj6Jb$e`#l zuJ`ftlM&Oh>Z8hd=0ubp#tth}c8D{hgr2CA|9<}}{l|LEd1I*60#}wP7lpJoF`zqF zzD&QoxZNFaceou;eF825jEyUh%qEU21uGJkew)t;1~DOnAayf3Py|B1nqQ_%Hs?6`V=dqe;hQO} z=@rZpEHSs01;fWt(h<3uRKqGDh2&ya}7qS6eMQNw9Y&aie2X;R^@ zVsK@ldLeF>YTRzKhTF!%=3}PHrIz%2VJ^^&G<`8OF11|F2gRCO_Ff=Fh}Ce956#<8 zKY7xZ|7)DfAPDIGMT0=tJi4J`uJ54Tm|f1zYM^|or2g*>E9nCn>5#9>hEX($akeH807oV244qRbQS&V@l1~qm7 zZkuA31P-@t<6T!5&*Dn~JS|)MvQ4~=W6d2JY;<9}g7&RD4|Re#Ft1)sU)gSi3s*V8 z2qfIXx4BNdv4N(||MecmzW`TFpdxNSFKNAxKQo8%KG%1Pw0E2P8&Pd`b=k3Yd#lAN z!aDQM!ZJ1HS`KP??4+tnyB@oq%>!6Rc{Z-Rs1U*C(OBQX^j-Q}^odhAIP7q+(5Nqo z(dn3bRU-LC`TOo2t}MWaoM_-kCTBk$XK)&WFL~EzZR@>23j(Q+9InKcVzQto3;*L% zmmUMBaAhs{aDk@|#_=(K5?pzD^)cN=*;d(B7mSDmDN)s51F4QlL#xW+vuSeKRiGw* z340D_RN??Z&1H;LFsGsHphUdb|A-TUQ!c{~n%R_u#+dtHz zyChm=%OufSl0K&AJ|1Sb)Zd(4;!z-;A~o09rNw6({2_kVRINkHl{;%Jal0GTqhCr0 z0OpJR3eZhiC3380TNg;Ff*I+vITM2by{mE- zjoc-rJ!K{221;16TKO>)u^6vYwdK8$4^n^YXvRv$Ehs~azQ+CIXTS&8^czD{h)g0~ zgCUibX_Vfzepg(--$@mjCz-Tte{vzQCevV1C%Jc7(}zCEGD)?nQJ|UsjFy6dW!REe zNvU7iYS4{Yl~)?M1#5{LukZ|H7p(MTmPdu+`3@_)l9 zLQUndkkVo~e2Oa)G(gZ6S37E}R1>d`HVx0D&eGWW!qOCpm4?Hj5(^fbQ6*cmQ{?R2 z_;m;!F`MSf$0j7orj{8xLWNk$AX&%yJ%kaLW)6WF&U1cEnNcDyMT`)2rWv*HhYl0h z{c?gOzmvBeTp)W9aIo%P7xc45KmgFR3&lsYJ*$NfKmHmOvXOfG?7- zl^<)C2;-Nn!=e*PKn&+~*25*CmfNYLeXF%2Ikm!YLXh^elx`@~dwA)xIDv!|tD*`h z!*87@9OaJ0S4Dg&@D05(yNm;wszf!Io9PoEUJ<#nQi?S$*mV92lYw_6~c^3dhL`M zPH3=9c-q;A3%XB`{gZTG{?>Zn~8cD5ua&ge4eb988zl!_Qij z$z2GQh*;`eL@}rx4{b*dScwkYis2H3N=}m7hZ(WOHpgpa9Hc}J+-0uU3?xqcN4$H- zxEnM*tcwC?4aD|@Sr20#Y=6F73-jnfQeF(>7DFb&1L)F(Jtxysxg%*}rlfy8tVZG! zDHl9vjyMb{s1`B7OK`EITLz-xC6C!#V`&B=lwop1;}MHGsV(cUnPVxm$N3&z;=$sR zan{}=KE?GxAk-hWwn>)ZPMktV?Eb`S8A2I$4Dy@X#SUO5deHO(ekxUO@OeJAShwf+ zyrWTTbxk$#`?%*Up+^5NIkormGN=|y!wW5!&ax%skDz2n`h>959lkPixj6P1En~pL zm@M%IVceDy*ID)SmceR;vw!972xZPvW6$8%BRmb*+S+*EUEe6nY0O~37bA4yEnhyy z%;e!(QmY=j0)~{>F@5Il2o9i;g}&qc+@Qa@Q)DzUsv01wX1!TwmW9EtJVFm-WCMB13u`&FWPeq+Rbkm+Q22_%UDI13gL=_dRty=<)| zd`sFczHPKPKm_HYKP8DNIN-Z8`92R2ALz&u2A;!9bPTI~;yT#ow5 zi_N{R3quc5T#T?6_OVBUnPb31*sx%oR-b-SBDui6DT{3wNbsMA>VmQP^C|R8{M*vt zb^mCNDuR@)E=qYC4*~gm;+7{~*WHe~>-pWE&Ao^m+)66U6V%W6l>blf_b3j$OsfFc zo4C}CzgE)F(&F)HAV7xL3jhvjYI>e%M*y6|JOhL<^@LJR%PZs}3AcvG{(f&Q?d>;n zW;uLPLk8MPz;E`|D$ugvKi~vCdw4_COVowMbCkb83(v*ljuZ?K;DxPKTEc%dP*v8z z!i|yk#-GYh{K9`Z#~e9qF4+U~$aEn~mR`WDGS;i1uHH(k@?&NCv^Q?WH^6eaUI1bh z5;u>x$AJwL=;SCt0HGi+l(00q9JkJmMeHUp1)e2BHpXG!6Ff?c#3^5f7B&*9{0$nP zgrF!fzG!$SIRBPPPEkKe!VWKWfzYB_k`;saqONVHvSO3OxPAP@gTyP+JWAjax`$}G z^?0_xHqWOQ3Gk;KKiIo_i^p_o@n^$#7$0&*+y7Y5rnaN}`W`_IOKNv2WwPYr_y#40 z=^yGnq(2G_WV@A}KpH7)uR?w60t|@AB1lhWRv`@n>y(ppRG=Bn>P=8`0M5i z>Sfp|yUEk9mEl$^m{+)*>@RO+kqHO#syP9g=$;L*d_MaXG8?9EpVtKIW$((PL(wChRs%C*&m1vILzZ#M9>F zV@njQyuuL$$(#)-IcILk@(@MlgzaeIJ9FD=8;Oc}LmhV<(GX)0l~9i{NGL-r%5TRV zfTHIu-+r?E+8XY>sF5T|IWV^Wjg!2aU2V<9VHP#u*Mw1Mi03|Ml1 zyks^#wu1@&*_i|MeoU8jiLv>8_j*H6^t0g{v|bfK#A27@s(&>oig0*y#)8!sH)t^M zIvJDZyq_VP9Yo6QV84DU=Ghg`sw=sxTd5xMtG)E!1nK`Uq_|$7th+$bqC~V1iGfepT9GKV9Ci5Zs}RZ$m9qRYBxM8tn) z<;zC|z{|aKU%s$)4R_jO(w9y{hogE*LujVwAB3b8#P=b^PEce_Bw4VjxzfZTt4j4I zeoM5~>%_FbPHjaj!cP08m@evgp|AI#=8t`J1W@psXZmYKH>`Fh1H9*skg}8v*?c>xDQ}#<11&zP zD|oSDKSz4Ad3&=>M!C&#d3E_Jo*pB4a#FM#q8+T+6@-r_5nK6kBT1QAqf+x|vwtTW zO@DtMg(dH%`b_@_%?9unS?mHByW8BM*H0M;6&r)5RAsS$6vR+HsUXNxC zQ2N&3kYR^QIJ1g7?V82(gL8~g8^xHegKN>U_044Q_Ra7FS(Ckq0A0LlAJ>rYj6qto zoICuS+KhcM6isgp&^@P$`F*i6g_na&ZVIO&M}!!Yd6J&}Not`$Nw$wMV_gM-emq7t z{fy9NVA_h7BAYM2AU2%T2<6vud1s8-0A(Kodk}w12}2*!jxHb@Z#n8S)#+$!_aYq3 z#AD+k@_#DA`Po1WtE(U-?U$`IV`pnTgH2b8>a$PYi2REMw8qjR4&%S_V-Su^J{`G2 zYJyx{TwJ`o&ftulwZA?l0&QOBs;hsrpV@fS9XUshH{B;8C!n}^b?^-WOMb~jWjkKJ z(U8Qf%9XE{K9i{twCE}`x5v_+B@y@&6+po|W!(LsN$JCVMJ@K`-XKPC+maJ7u>`gz zV1Hh4|C!;`rG6(g$zth#z{4WMm3?8#8v0^*!6kl>envfx9+BK}eDgH4d&?IflT2(hCtkFio`{3o{;NallfnY~2PvGM6LO$S( zo(#tip?ajiik*Lkq!I|fX6ZZ9AHC&7zxQ>`q!AFTgT&}35?n!E)H;M==a~MD+^Ky< zo6r6A@x`{Lnpj(#ucO0rrnRw7!1QsBlW(oRUk)^1*0s=?-e;GC^2Z%lxpRD@Kuh<_ zxMt9L;QS$Tdx6U^(27lMRHsObypu0`XxpY`VJy0UKhs{s8A6mMCy5&CA4KaFS>9y$ zV2LE`Pex?l>-OQC_Xz(GD3@}Y{IS8*$h(s(oBxFz7Iob*v7MPG=3Dsdosg>e^_+Zp zqIQ-gHjupDM}pz?S9VxrgUYCtZX0c54;*7S`hnA!l*#bx6(dGw?Iy7SZ|D{=KcqkC z^M7q$%g3(#l&a?jp2&HVHkxHr76fbsfMWB(&Ne1@BmF^ER-+@%8!)3SgW}d>f|aP#x-3sok&{nvEY- z$gRRvWarX@AkjJNdfD&Y+v|_m=-)UmueLX)vMjM7Bwo&|?`Kob%AB&cNHBNw$Rl6e zlTDJEGE!MlRw*lQQgg?+W8f}0EwW3g-9G(8<#Qb3tSeR%Gwj&2o9OFiFZ9o{2`X$C zeMit|$6D-mYvH5Z3E?dKR4dEp`m(HQGQLDj>2Gx{Mh{g|0vL_c@>C6*(d+$%=CZ2+ zViuE?_MYJ|ffku`M`p)CntF8_`!z~8y|9#o^Hd2mi&a#P1-d?7ZYO`a(t<@J0-rJd z8t){PKY;mINNET@ehOVuiaUQ^;7QWg-9_@{5=-^^=D^r(Fpa*p`R#qA-skTt-JPJZ z2Ba+hkcd7D}^5k6yJj^#q%RC&j=q9Y$3^1=$D4B2a;SouQ zmWjapuh50(FZ@O1PPWPby>NIP)iqlZ-P0dy)kmx43r^5K49gvVm=nA*?2o1@nZ?*) zG}t)r*Z&y7z9+p1zz5gjwy~TD3P>8Vjy7BzQpspuX>J}fUq3k0Kc?l$?%TMri+Q2} zDVM7M@17LV`x_QnMunR)WSU z6DFFtPRZusQ&xx7Qf&~tCBU1x_B7ud|0`z~h1OT++Mmh*7|J5@QD$JAM82(tb+4EL z;_t8E17%jQ_n%l5VyihdJ)Cq0w5Px#agu=zxjscsb-Ur@hk+_B;qV2F`=lv#6B)(+ zeC)#3O}7ODG+VdB$9}S|3G*T_;$&y1cVR*JFt%iF`}rBqQRwdejn~DnjSy9;9*fyU zWlm2L$2`k-38HxAYp;GqwK<87b+=o`8rzztE#03h6?}Y<-(amd&aid;W_gJcpL7(5 zlZ!bCe`AK^V2%Ro-a|o!%G}|xVu>V50x{KcM)3(l`aU?4RDTrGl2XdtQJc>qA&*zO za#9kUr072iP@fn*mn&VbAiFe|Ni^Xv2N}d_i?}lPDzo>WU)#U+xdb%<{dH0obWfywX}TMYTxP4LV?|4g zV@z&R27&ibC8W@vjceNc-mgSkT#O9Wz)92T?5=+AV{qa97H^sdh+I0T3WPy3(|88U zDS5#P1>iX?$fCt0GHO(|w}hsAF3}w;ICLmaAOJVxgjPj?=l9C`vN{A0nqkdNlPYtX z*w_&-{)VXs(dGU-b;hD9JAI|4u?0|yR*7BHMdHsPUmL^v_x~1?Pb;ChdW4T@`fG1a zSOKTYKshvn+Lv&3>BX{`psNVo>&l~|F*qz~I1s1CTK@}(Q;1DW6Hz!}nKGq3O*$W| zNy^0EFpt$twq1jVhryh_$YDpae9Vp}`C6OeKYp{06k3wXGxS#s^NL97LnEwwA6}(r z1dnxzHkgAZ0=@~W6hSi1<9hrDq4rYmm_DAU=dekG$NTFF&uLk#4a&TkB*L3gtAg*UMUHwDC1$Xv?>7q(O`FqqKsc;)_dRF-RBO5#**k8Gr0 za_6nZrz!8|mV*ns{hCVK3qRZ~-|NN1VtvLYi-~_s1wn>nJ<~w!89c9N+Otv<%xAt* zK6w8VfW0^Ye@aUAdXbzrW*nkW(m!;+tqTD>*?k+57a1iEr&B(DXGL_rW!`dsakQ6X*AibaRB~Em z9~)W}NqCLD)(8I~d=%g!NA-fyA$?z3H62pw!@KoJaZ0G-}iJtnd75>6kOzBi?Zm)8Y!@T-k_D2|=M|$LuYLX{DVNpu@u&HVM zS?*tnzIuc5YppoGND0uJM1tJxbAO5_cc1Q_-offq4Wun{$6xj1^S-zM9O19B7E!Bc zt{n$-MvYaMB?P;b2bC^8zEu3+3p(j}sJ~I3aDrNwzw3nVjNx zZe$X%rp9W_*!>i}gm2Ea!=`_vVsau4rV>86o{%@)Uy@4Re+{?pf+>84@^&{l3)9U- zTrzw6Y-3v!vyf%4V!y~^tdua68NBPjFX}OY?TYV#TVYrEid&o*?cS#3Q4%9I_aFd1 z*srr?eNEZIO#CwQAogf`I?N>N7Op-g5s?w~FXV^N{~IpaO1xZVWs|Z3_U4eyq}w!@ z20ogRL~8wx+h<_9!wE6C*qoaX`Ln%L2A>n?kl+IEV2zOSXMh8Dck_|>p;427`4Z=V z>gt`n-#OfsgGC5GK0y53719!yEZt}G$`AJD_oneV&ORMX2Z|esBk+ykq6FePa%f^l zT-444;590Gh<0yZYY_4$|6Jht@`Dc%;wauikyxcRWnkQ_d?AaP2ii&Ql5CpSVP1g! zaU0;`dHtt7u|k^#N6A9?e!2u&E$<_auQpB)&X*=3V%?L3e>Q!E!cv)(-1wW z5G8q+2^Bv>^?E_>G`6?D&6UXcMFPEi!z|zrG+iePp=${s3<6VLwL@jsn%DGZmiAQq z!YCqggJRl|7h4?%i+=aT4}-1%oP;qWj<36md72MVFH!Zip=H6x~$U{aYf7?zyJ!2Y3 zK%!!|vKH574|Gnq;JH7$yE%W>Nd23|wUMS@xmql9M!M)!pWpx{ReM-^!=I7Rr%3uqTMxy2C4Ey?>48TIYpbKgw31MYwGOrAP`6UA2WZn(68}eAhpuSqL z?CQG?kUIx|wyYzV7p|=yIC6Y`I>;dv4{$T&=WhfQ&VwyeOrZh893^SF#@VR5znpZ^ z+EahE6Wh-=$2qa{Q`DNk=usp zoL%-fzbYEtn+c_WSW4nA3mXyFFV%#*u2^%ENeXTmkb&oOg^|soLr{t5j8%=P%5)Xo z%Tv3t!xY{a{8t$oy2`~c6WXU`R9~JO492UT8Dhb%QWzwiDm$#?1xqtfKnz{bNhFk0 zY*=pfV|G995CY0wQ0iRg zi4CA~A}**|eY>FgsvVSQFb2;RJ+VDR2OE(hfyhVjhkmv*=pGj&`m_&d^m8-E;D|+K*ZCXF9GR*RW4ju`^zbnc!HnH_Yu;5`Sl-Ao+z; zrd}DusF9E*0njKidNuR(^@y#VHTf3{P@3sfBi;4`Q^@%KOx?@3I$<7?&Olv>Qc)UQ zEg=rd1xHa0ewX5gB6&T8h$nWvycj)({}+#{8KR18*rXAKGH{>x2G9? z2`x8x6ENnb$|N5g>c7v+HPQ1VflFhEmb^n4Hdm^ZNC8sMhVTf#VNEG53Tnvi?(eOT zte_7Rg^I&sEOOKt!@*{MAPk>?cPzgW$AWEP2%#ibDO%xb`nEE|ZEk{-qwg!%9;un! zY|TLckx}-%d~(_}4ZrU|^W#8>sDpinX-0(1fm)~{oT8|E1QGGO<>3hDP?T$6j&Sdl zr9K?XOIHa!7V>_IV)~QkkYuIU)?drtGZfXo|K`FEGb>?Brvv6SM?#;{mg@3FClr01 z2kFcDS~Fcd-uxfZ47#6@aIh7Mp-dpg4CaQibjOvdz+uX`NLw)J4l zSd4;sjmA^aJ|_0(KN$>Qt4cCU`l|Qq-__zU_nO^4HteH}nrtQq)9V{2w`l8p$WLkv)~Uar1)b0i%4f4KVU zxTw3PZ@Rl6GpikZzEc?xj1VLFtl|&ZRq~OO}-GM)Y01@9Vms&wKuc{hgUP z6KBqMX3SzrqkGR=ox0YMl8ydFZN=3C>}#%~w&jSaNkvh}u7UYku=JWLLBpzHBA8V)$lVzliD zU28HBN&06Mj^Wyh!XT`e=YoI21>vf)O@6&jxvmzDl>}z)KHfFV4m!bt-wHPFTHGOT zrB}}pG0`N9D|(BL6WfJu5(FU-oTMfVm}+Lke1$)8vODDBB^-r5l^}m?Rf{HIO)h~o zAOIAQp?7@kY`mcd4ah^pMs4Uy8f&rellNGEG<~Uv|M2=N{$NZ1czjh+ zsE}h+Iza91kZs+#GVdvER#xJcKjNVd8>(D!UX&e;_prqB)?rC!?R4)0_N(6)E-iMa zfjl2lg%Ih8S(cgct1lN-r{oG{sjjL#R(t#9Qr)n}6MS##94mFg6AK%)j8(AUtskfo zX)owh=5$qdOlzYMV9(3|?}rbqNzR-jk4iTmKf9N*#Bl+nEXQl?YUhl}!%)i*&M@Y%E~8ZWxNhm5(c zG6C=;-13SAXmHPFB&Bxh9^Icf!Enl!E{0&P+^1L8`LwYVtweIhMT+Ihw(cQnbSR40 zUy}_|A$B?+?VVWM^d;V5ulh8 zfgWO1PugVktd(3sxmQ1(h4MhDT-PC|rePw9Gic9VabgJ~Bi&>b`BUk2HDk+jNtEniQKS6fo`|SD(YL10~0yT>gkB-At z=cW1dg^E6m6uX0*Ic5sg?hs}T@SN2b2#m$-x`xqW7zC!iF7i3sZ1n4k zPW9h(PKF&8l;BUDr;5Q#IaLWZ1TZYF(Gk;XG#)U1lsUkz6EWw219&&vD z>L7a7ufG#s2Y#}X+RP9VK`Kc@}Glkkz~=qDS-WkTAe&=1lmZ}C~p$DmIhhERlg_9+J2z&l&9 zn}&YTj}6FCdO!0a$!iNCD`nJN-!wE@UwaF5h=*rOLM0yzL$@VCw{7uFn}%2*LyzA% z9l~ot&0{hm_&9$mKF2V$Yd%!39{4}t9?_$b;I`4HizP-NUm3ZCvc8m9E_PXV#Dz%8 z=s`H_tG5^=nBdMMmN|)ayX>^JDEHM$hj@EerzTh;s>S9S$LhGHUg0>cZ0(Un2Y$G% zWNHE@2b4HWHuTMkruZg!xngHP9c6t(+ZSrKv&vEjt}NJ4!>T$OiA?CQ2dAT<-7l!A zLhVD2A9C)th`MuBrB9F%0WlTE3%$-KUiIxH&BJw=8}Xwpc83AN5P86QsSdtN0hPE)nTXc0+hWRMUTrarf3)qxzSVbE&;N{N@@&e?4*t{tG)afRv zlefqk$X9@&fwLY9YZAw~gYSXeMchjHLnKu;pUKooO-q z=Ifd;-&{vK5qwb@d>Ez!mIUWBY4c8gRb6xLsImHu%aRpx$gVxE%NbdL(1WrVH}u0y zP}{83{qs>P`S0c$mw&UmqLTILELy<@Y$#6>q0)r2zj(;8r-vr!Q8cB>;Ju=Dhqv)j z@w3JZ7GQ)zG_2F1Gc3s%dL1I^6{{-%2p{DZBq%=#SbQ^6Ce@D=vCf%c=ac7~x6O5q zt5H@_ev?Per-O14Jh`ZIld93?PAFm@i>S)wg|VX7>QYiA_Z%PcMo>z5!%5k_sUllI z$^j-4j|Sm0mJXnORXJya*+f<4eaN6X6a^@G+wTJKH2zGgu$DQdZP*bfjIsVY{t7G7 zwc(2)vC55*N*JY@1qOFcu>)dmRD+^g%s5qUV}i9!@8e~T(%f{(4SXZ{NFr&fuAPdG zF+8nKePGE00UZq$-YxLJqMX=1I|~8{l(mGl&hXfhW2!f6Rvxke1guv&Mlt~dHLBk}^M3uAA{WI%ceGq!^ZH*^(L>B@}-;WIK*Tr zfWRxG&En8HRPXa(4j=zI^IlCH{*K*sXQA39bV?o&rs3X6zJ01NsQuWDCOWZweB32; zyYifh9X2f%cM06sP*%9V)vr()Su?HD_tEil3K(OYuvZ9!Gbzcwt9c(59VTxzV%I7L zz#2}al&glruP~~Hqba{XGG(@sWrn!j1&H}n<6P$`YGf5u=qp4d;D+WgnC4@65I*qA zq1?Xk#Rmj!Z_`shxFXm)(veTKeZ-nYUS1ihw|PISDGn-;&NU6)qP-FRCiAI--9uC{ z1&+n+ljoBZy{%@D3;n85nnp4+p}ruSK}-Y(y}tJ0Xm%pV0bT=S*tMLj*@dC9j``__ zJzJd}P(q)3uSXv*0I(;aaB-rJOxDP%@2793G+`5!Gca(XS;LQ-~ z+9;C;|K|1yMlaB(=wNYPYjto^&X~R@o<3W51s?d@XeTPd9Aiu!Nk?Vnj;b<(LTYK; z5i;>>TMwA<0GUNR@$%wlWtRxa`v(hL%u$VMX7+b2ttr%W-mDC3pAe%w6$^Ylf#q7z zay-Rm?5T$itZW8BPC{La1`!po6Ae})g5XRKDf6K~Z;Wz>}gqH1eLx`~SDXoSoJ z?IwwZM=Pb`Om02DLgiWHtNRZ7Q3P_GKe2@8R>A)E@wsNfEMy=ZzjpAVX5_yKUZI3f&qTNs&QK z%Rho$;L#%R^a10d<%n_&z^}jJ+iFqfg=MYUZ~~=IO8$j1Q=6v$bP)U5iG~$5L8T2~ zgz6>Dq_st7gpLN6Z7zda2|XKfB%clx*x-OHkHJi+8nhz~dc%;@Pc9fI*$bSB6MAx6 zwOKm58#=vT656y4=pVv3D&odCuXj-|fLkXU$(GpRu;H)G4|>bY;-k>5kMVj7)Rdee z1ILZ~#-;9cgkgzny_|&s_6%Cu9In1vz5iGB_jEm6+*4KT&3Q`M6K!M%_V?C^$Zdhe zva;X-z+1*$9oX3qmNW-Z){_hE6w7bJYlus=c}}hUeTETwP}ztt*8?8#GPM4AmU;-V z5T*KM8FCKAnRv)Y?brz`n`QPL%ps&6*YPSarjPL)pquOS!A=_?T12Ccmv#OixT^R7 z&xXPKYnZk(_~G0`MC|&zU4XVd%kiTyb8w3D*C*OdM*cu0yC=G0Zu&e+4(iS%Vx{cp zLTufuVm;)a%I+8DN`sTz;LnFzT5&=|*1Lm*HMiWwS6rY@U?X)W#%n9K@t&XCPQx|C z0+#HTOaqi6IiL!&*VyzAXqV1~aaql&ssDt`4;%0_l3M0ZY68#qM4@5sh|s36q^>Ak ziW_KgOj|vCKPV*pNy;T8%xSxbb8&BSF+OD^z2p^sNFWJ@ET3Oy(k2qKIeEcI-)x(EY?^p`x7^?^3Y z0(gsJ2o06Wtb$U<)pv-GLLKfbV%#-`df_6_bY zq34~w!Fi>ZADG6!#nh4)ltN<#k2!CY_N2slFamr)_xD;~8VTukUn(z6J}?L^{MYV; zZVD}qy{JXC-~-T5w!-_^ZRKS%$C_P)~5&&U1C2ONJ?CPtqM z8WF~~Gb=%<^ZNm*V&7xb`czO5&O=vvfSe7&3SzkbBp?F$J4K<`>xFyTArY-tH^YSj zGY+d3PJ$O9pZ8hhX?yshYZbZJHBN}(pikbPDy!OoRwL1PKLsvR?4{e=|5eRnNFD)z zvkN*G?IF0fhj#Jm*OEV7@<2w|Hj`^2L|t)!Aas+*#8hzE%HUsChrWZSDJSwLOHzFI z1>LMNBUcPDbd%)jM4nHa*hKBWuPIbGKheDXvh+hBU3F=xt?!OyfLP%7ID=F~akn%e(lEkoa-7ea74No%7P zb?<6z*lwLNXM<5s5eq8dk|ZvU%?}sQLGqk3!~gqfVHciFCU3%JR_@dxMnd)o!?D|L zG)JDwk1mPFWizyP?1t3P9hJP95k^%yEC0t;fNSB0vk>9H0TcMM<8gfG7Yd&)?Gc9` zbF%CbWHx2p=;*EDWCB7r$v#3)JdlZl2ftbnQpKIUHP++D?ifiRo<8EF z{9TLk^ZBt@pwI~6zbrvPct@MdjW>mAGLUWXCVKPnqT(?9Mw;9rMBfloj$qL%^p9b55Y;4%Aio_KV9DdSeZ^H$BZ=v!2fd8v znsb_+@_5;3s1<443J|-)TCt_8LT&JIQGYX*BIHMF!fHytT@?`F-2@|*<3`65gq}bD z`tv@7eBQbgf7i6rI2qj)aNnZW4a^&8l$Z%DCvSo)JM!82` zYzF;?cfm(<*Ti7VS3iq3_rp?D1%D-eAV7&VBY`lNG^$0i2Txv_SL1}xyR5hdC*D23 zUMByT#q>YHFhUA_S&yt`Sb^>-Y8KTMON_z+pxEIb+ z`RSZ-786ZB(X9N9LI@A0wKNAOC#8sY=ZZ(2)1rwB;z!M?+x4JF){`69b9ckB38xuB zB@IF#fREm41*Mv^1SN;THS*)QIa|(}}WZgLHzmFnjX*}3OkQs#o z_k|JeHVMx+I0B+{n+k1fH-7!vu^eoOT^SkLWX-HYpJDuMPi>vZfe$)Q!V?g?f_&bS z&pKSG8NE33I;HU6oFtSm)?7Rk6ZA<{fZ}AjN)&@SWo}`g4CtP^WTh$XI7gp61cHL% zg{0F-m+m@PwoRTL99Mqq+aYvU?!4hF??%a^`KbfEC>%SCLU zEPw9ZC_2HDokx9})Lj=l;y05$=LQ^z9=O877ySRW50#6*7nhyHi5wNB`tYrKxz~v! z92&*|@NSL|)<)7pnqh0GZu7iA)bA*l9NJKc1_!_nOMYI<57RGO6+t)Dg$H9PDn#(?%-M7p(gFRzzwCpmIn>}5P{@K|wL_QM89^ZG(+KJ_ zcmvP~Dx=sgpzVYehazBebA5dv6N2fs+bhi6>kMNBy_fuC#swI;exwlO$#I?c>{@XY z%)#tjx!>V~1@XioER)hmUf@A%6F?t;ujPRMr-b`~>{1C2U|^*Zkv`aZCEC-~(CPoE zb<<_}jDV`v!&j#sdR(TQimX_O19+p1Lz>LYh{!Ix)#SdCiC{T$=n;-sYG>Yq@i1ce zR;Slc+a-UCLO=h?C^LQZ)tbR98@gt{*;PgBdU)iAKNt1=cu7w9!*ed zS$h7D-i6k}_Y{YQN#a zzkJOS427H|z%s%(fSS=}ff{>u0D3BX*jI&ede+Jr{75YW} zGQ8?d|1Am~BbsydgFvH=7=e47R=z(Mr=UegHpG0?krR;wE!B-S$ z;sXjioBW?+0%wHXtGh78*jHNx4J$VzMsIFi5dPZD4NVDiX_f*`&sjJt6jgp%aa=VH zaGix2-U^0D1YvpQ$dnBiOQ~yx57#HwBvg`Bc~7LrbF5SzA34wQeYxY#o`X3~kaF?| z>ql`_x|xsQN^kyldE|9Jndl^WYYpkJ{B59_ELP+XIgVd@XN%w8A!WT94f2|n@tsao2XcKTVh^Q2-k(knypQkZ2l&Jy#YR<@v%+anxUk( z$-?4h4ncIhHeRILq-oFwQR~f=4zvW?_^l5AN`pO1Q%?D+^R_0>_ejup6<0OUe{um# zB{ngPsv73Z+e~dRm`%SOXDk0TS|Jehe!t>!7%Jh7(`Mr(l{u96QWIJ_XWQoY5HLI_ zc|iq5!dID~qY{r{ukk`0AG}4j;5@P4u;Ik{%1ErUe2v9p>NS1{mr$O)ca1=4$NU9X zH+IX1Luc`Iiu-5RAi+C}3jw4IDJ+}<(y`FlK4*WhsRj&8Ic7}z>!@~$KA!tzMIYUL z$xm96{#acoG#Akfr5MCtqvduDPd!tbv zu$(@>A|o>Vp4sOzQJqYa{E^|^a@G!{5he&{7%XeUGur%rs8j;`X={XBMBI>_I=3AA z_20h!0{YO7j9o*3SkUhhn&kyrP_tHp@k&run4}9A82f}7Y1iJq=GjrTVbxJl>cqdu zaA#qq!W*a3QN=;o5gWOU zMZj3>N%HT9aYu0K*f0_Ce?YOtvh|u`gAawzM6;DM6}%8WQoFzkXn)v;@DGTf=4{uU z!K;F4V3=34JngLir{NE`m#+}yQ61mFs$C{#8x!s;>})urUuqf);-q}5ejdT^yVpeJ z3RYx6%7dH0aj0_jBGpZfj~SJ5Qfbz4(~01>*OFE*QL#|AsA_h;w$AuE#~_mfs#hlEf?`Rtn3_!ak-t-Xrk5E0T#V|m{3(je4=wt2osDj<`}{+&`|%43w@~ED z4-BU0Iz6TgI+OgFV5hh51=cps;K*i#l+g?MQth&(mN0WBBM1P=13Zn~V}(2FX<1T8 zOfwL(p3VM}NxoqzP_J&&v^WWtn{i_F+zZGXBz)@p{(Vht?Xc^o zEHBZZ^h4x3Y|Nq0hkYi#`+hz6(uL|Z3U*hwe^KTU2u zfy8NNl2>s$ETdz_WY?+na{eXjA@t%ELL`eS;H0)*dw{7lf+;MroUo52>eJmb{D5Tc zmYNv)5!=>?20axo+ytgWP7^3fakyM1c!ua>;v$Ph$l-{@hjLrZ2BD5>*0*J3d*rYv zSebKzT^(&J{cHF#ee~Z_ypLlMJ0dk98y*MBvD=}Qp{db>A6m8Q>yc2Ac{<!>7p>R>Y|e(cyY3TmWyZ*@2iie3d@GR#Ccptu%As0 zE9Fd~KN}_T`sd`N3biEBX`GSMKQ~dRjp=*F1ynKtgC~Q_QGc29BBG?$&4BK??)`*6 zJHUaeN1W?c^DyWRpL;(5tH_YCD^2Z`OEHM`V0E@3uL))hqnb5Gv< zKRJD+uFy(J-}#u;`shjpo!P-jVk-N4>!`WuGfccMZ~&a+}PHT<7B zKsyv?+zV!-onGb3%7*|u?|*gcqGam@B|)3#By zuMC^<4FiXBc7UfA&Uz!q(CKZL6Q+!^VMlTF5m$|dZKoN<9t&M6!vZZhS-t>HozY&? zSzSjvb$nR(yUu0BWD7&0a-r?0+G7K_LOG3|J2?ub{{#rnl$g~VoDZ!*x;|NH%*i2d z{u-V*>>8XuXr+>&SRcxtc^P6IJ`^5QhH988L~E?Aouwl8nfs8oX4CPIb+kBwkt+3|gS>(o5#47E*rT2hk zSB3lrqSad3v47oVTf96KaKzLj!Ugb70Jv!emmMZ`P!~QI%Kfxs3Mv#ABh70DK&%I3OjGkP}F6-#f|iYQS@6G&8@3h+tTkVo=|hJldKzq1mP541F@K2?AKunva-J$5{5s?m7M#Mx6q_}T0X3}g!6Vm;B{55f`xKdVt{~wpq$PD1F0LZ z_h(?t3kR^_W$;*QMDKX^)r(h!ZK5i4Nx1LohP#5?luO5o3}+Gu+hMOkp4emY*f?=@;m z)giB}+rQ?NDYfB4m))ne6aBhjJhw;SSEj}wsLJZC4Xsrta0Dpl8hyF0n9O0w@gP&1 z9@=R%JBnP-yKz>YDwql9i{9DIh}ZnduceR{Era0L9@0RSFjg^5^G~M+R(^zjASP)|?KcQ<-jy2?5!p+ht6(jCLUbQ`x!ClTF7L z@jpim(QJoC+tT{oWYddB{ekM>lE~#d%Ax4LnKiv(KU@H5pK4S#-p6DQ{fUKDVsF<6 z{C#gTQj~C_ZHxTFg&UjC{T3H5m!Aqmvs9na@O2t^4ObqM3#Y!*y|30#L0p$#^ugEx ztI1Q&e3(C;Wh74=24Y;q@-g#A`|l_Xev|K{Oq56G=0RM$mwP3PiGb@J?9zTi3GOft zpy&CGB7)0mjy5`y9h=+6#XBYpC_wQIS`1q23xs!Z#q_~Oji z^03d~?)R54b9Tq@OZz##oJpcr5@#7ct(|n9zCY8YeG7hvh;I$6o?ZRs6X+`=I0DEf|^T5W?9Mq>KYL=+ovl* z1XI++%COnW=_ZWcm>yZdh2m%m13?Y*p(g@KpCO8J)ouEj^c=-~#44jeGda8}DhHx&8^Vj<5lqXzC62|h_%gyo+vACKoohcZ z{!SG^#p@D0pF!t#!%ZKE!61`<$UK4q(A-TN8(N4%Hry;b-8luG^;w}PsLE+kb zg1SEnTRK^u9WD#urbrB)h&v(1#`8v-Lkcp59V&1|2UrJcrkVH8GTJ z6F6~6LbMo8stMVxv>rM~75v_@#b7M9F_E+kj`$iH*UYuGG0R$gbi^sH*u+JD$tFe@ zwp}H0Z`-jNoq^(fLpe!(Kxx5!D3+-Oqm%yO(}FoL;%PcM$*zP%uK2`Ue>Sjs8Hko} zKS)jhIGQW0Rxga_#8Kiw^m}V~Jl{5>Q>^Ikpe@pm0|=gw8%M-yJJ_~Fs9JeI8Zuv{(N82eFu0`&7pv-*1%>9$4zQ$L(A zpgM~voBb~;HqExtf+<&B3&?VnE!1}lg}#5AdSuiVH$bz-u~uHMNSYJu^*d_St)3tRMOtM8HV3MKYdiefwb!lUGAR!y%#t zFq!LDfmg5G(+#%$3QC@iKI>VzW`JFN-er_R#MriJ|C}GU`t>fK;`+4v{VnN=ng){O zsdsqo^Bw=>0=5eDlHdOk$r3tLBt3KvTYmGS$~u7_Fh@4a)N z2)*`F$aA>eosoVva;ibO|)P?OYQpi@3EV_?)v~G zyg?%xxSZO63DMv<he?JV12RXO>`LL+J&ui4z$fLUELu|~jgDW#L^S0Ql zA-{VTMM+$8a4P^|hzy`iP`*-S&01eUzU}0l#05b37msi4K`mZg-{(D>>d3RSQ#8%; z7AnCV_ptGaa$>I%&o?)NpGT0B_72{0=GXD6wF=}~V;TN3ef^8>Q|Tw@f|StU6J>Rd z;3Eqmvun0JRf}h*Xf1EEFahKxB_+Yfg9S7|F$|U8ou;?m`=Qp9I))F*hu!DQ0>3s% ze>l4*kyR}m9UWZ_QwCL6vXJL6!-Dh^lwEeKV=O^#6RM?l2>l`Hl1}qYCMoF4tS8iJ zG$@)xs3pm4qqsIceLu=Z^AY)YMlf*{)=r%}HXu4Wp80UwYwLXyb9_#IG(Ze+VX`}) zd_o23aB`RRuKMnJUzTEymbc6lSec;9JMTdX>T%pT3Nq*m%ry5!5bq9q@22_bVn#0mAf3O9A)!#9eDBYx zQCuId&}hZQ6#Y=8Mo+YHeDpd(5*+=*hos}^3wgBcTBOF-Aq58bU8%KZD%uO739B=S zJ9S{Jy8!{MQmVgLo%;nr&g9+G6J`{h|MF?GVU-YS)B*OFs`ep6@7hb`K!LSKThG@P z+0azBWi4sj>k^4{!tXx<-w=#1*w9k56 zI9y|XO$H`0gapvlDdmp}cFk{?nyQ{lj93ivK;{KqmPI5^(`uoaAWvBkWk;YS#G=yx zQ;0z}vfqlMdu=?wrS2eF3kiTb5hzVlE%3#D%y$pHYQPZ`@`67>T7@-I69cDJ?v#=a z=@0e37MZ?NMTnF`@9}Ye*`LhWaBkc%|2<|HX1u+W6E4gRFbJbXZ-rYX5|0rdb{!Lv zJV}SQ33uOcZpoSS^@%F6a}H}97Agckce74s{Sng=$S3A8DLiv{@kBPN%#cN!N@kVbHy4Dgbn<_L1TNv_iX?m_GW=Y z%QEmy4=tizZuqZU@eo3PPM~`o$`>nRhvj7FcFZ@F|CIijA;fY~Hz1+DdvvGYaE z;lNYsQlQerfN5au(s3H2lnt6#m~*CtGV%|BmVrjE98`j@cn|0&xo|Rz4qwSou)ah? z%B>GbvjqAGVTO|p=t?ZHE(141j}mb{*V@`7nPfuLP5>!Ws&uI z*X51FL|Tdj6mbHP{+P#N!1C7s5ELl6YZG9syH2U2Dv4b5d8=O>HlK>)2%FZe z0>q1xVz`&=t)`LhvKYN8AXQ3V5F*}`AW%M`o)9&QzGijr*9lk9(#%2U6O8vot9t;2*ZjA>ssPy{Y?tMOBZ#wgmhG5AY*=u&oy?L{xPm(!JyO0@@$(Y(vOBbC_DYkgJZ#1*;_Gt_8uLNChW5i~JlPY0=tT#_9|jKLBM2feY39I_?dqnGftrdGC%dpmr zaRyDug^AxkzW|{ilUY1^^|n7YlyJ+4kV6e4+d2<5L0j+plwH0>KAkDSn-ndXP}36- zetZB|`X7cdd9y#Hpd_Ti-LlE%;gi*)#nljqP=5Rxnkehi8yZSWmcys%RJ^_zA0g@L z%DoV;v&!Y%=3;nwi)AFa}d1*{N$8sme{&qMzLI^ zYp&Z0S>2n>ki7y6O*gIL)P`t_CI!o4H8Oy8+Xu8i%S4QbQmrOcXX(_s5iuzFxOT4s zhvd1$n<%1UA!Z_XdFEVEf1&=t z)S8k94BKsvzayttbt>!bI$PaRS>gEhExmN(-Rac3WqsGS+^hfx&C{6yF54^|(y?lcV_xF*|JZp;|)~0uS79zS%#xw^A58%=Oto4_4b=cTE zk2F&TDH*g!g^J=Y`w+3p7Fm&5^=uaGA%Cud?C)LJfTyOfC{1B5+Pk`Xy1GDn1qXD$ zDR!ON6a*jD{Gmu=TT4Ems=M-_g^2}|`X43fVVt56AravATXz)D)5}nh;M>i_ss>dc zyt<8@*Jjago;v>O)MKa-qnMvcFxc|P@+^UDWL(%T$rNm}@nGHZKr&wCxpOG)R6apv zB#~BcGCgq`KY4%< z(^vVjk>@JwYSx>h&z-S21_Jq91#V*qQ<4Log_>aXFo;-B_(+N$#{r9%g*U)`?X)D6 zSls5lmlx5G{XzMe4VhLp*MzE?Mcnw5LhA&-??s*9ItVCDYdN|zmaMX`h6yw9^IUu0 z81J8?0N&;t?WAxFXTeO_n5jP2w`!ydoBxWyZi6_VQ6Iiy#A~!8^9T6>^2%s$hG{2$ zOKXW5#ZTX{zn-%iF`g8iT!9e(9?U*Wsz5U z5=k51QfgqvluQ4{bMbnyeF#MegX)qy5i@i0i7uev+6?{gfkn(O1J|dKytyULo^WMD zkf#Bc<b=|=8DpkL zWqswIez}j95>c7lYP!IeuXPdF8z@VSY7y^W&BRdmsV=eZyWzCTtssW9@Y;uU<(3+z z@w=xdbyMCwKR45JUyD$TDrhKvcDO7i#dQbI4|arNn#F{n2NNb>SM-fkDQlS7Ty?D+ z4XuQznkFbvcjjLa|}jQKSOeyulDz0FnD6Yoi5fAdtxV{_Ma}`1myUncAs?4`<#nw#8|M@Pgp!IY^N zR~w#?uKwk#KKI2~EZKT=xugfmYVF(6I%_K6YClMG*mCGDu1zSah>DgtaQFZUQs&Tr z&!Y4;kTaaJ*scgCN5KM|zVGQ$8*iL}e+S^n$_6)R)%vKzUhmkNhW{{7%1`V3emG*& z8YiaeWLbGRsuz2t_}xZTNK$KuVah2dn~!72zrD>$a}C@vQ7l)Zm~(5yL*AgR;#(5` zGmCBc5v?NHI~nlT`)7@)IVO=aBh?QgW9Sd>;KDC%xg509W?~6M9_HZ#^eKP;7?s8= zaO;OrlZf8=%M+_VJQ;$)3S<0HY{`980+6Nw?kZ;;x5XirNc9p89>+o6ShEm&_m70= z#WdM4drEQ7kQ9RGVABz z!ejlVd z8hJ`tewU;idL6Y~LV#Q9bd#op+lsDDyoedMMn%xrr%&h&A@h$#qU|eG_2IOd5Nc7K z))aEXLpJ!8wKk%9+*p_WK30Tv#65A?`l>-{H*sv>Nu1X3*L$8v{e46Cuq*egkOIYe zHveJf(4FYsfr81uyq(3!#7TqDek4)q2c-%tvEh zWP|J&m>T}weGi@*4UkL4DciTnuwFZ1lEL(gj9EEjbmXCs+Vy8udhxaEUX0T`ozoLj07#ao5e%p5-Gza~b2us>8w^o*87>{z-O|Tq2ANhtF z4XKMYwGlCfy<0L(faq)5e7t{O2>*1B59U6O8_E)oaX-Nt-@ahx1z9b^FFxpf5DnN= z$$QH-{n1@%3g7l)sCiTw>sR|f!cmgQf4pehefJGg?p_*A9oScry?G)XYEjXVvIFFD z9h@M_v9S7Lhh5Q4LUIZi*7(ms$Vix`2NI2wromfS@|N+W(gLs8#G*V?NRWZ3f+|{y z+(4bk0G=eeIdo~1Ma%Czueohn^9oxk;FuKLUCugRRRh>`Dd@>%b7^vn_yl_2+l#!A zu3P4|z^-vm+m+E<|I8IJjfRXsJ0{-Lw_Z+vBU*kJ>|KhHqTkS&bX~Z5TQahW!@d9Z z+w`nvtb~HM`gPtT8(s&q$_v2q^e25SBXV_Jq)Vp$a{S*@8)~(mI%+FYu7yygRu*?{*9Aj6fyhfUosM*^j(eAYl9F#v-cGFx0*3R zms`d5(cn+#k;>lJi3E!=6|18JeUL8&NQoQE$??W~stuL#2?Mh6uGQxT;z&f#hFIx5 zB&q&sB*v!3KzOl%%(?{Uu- zJq6JI!7j^EE+VQLLNpJ|kG6e%GKO@Tk_~K@63aY>*KF_%HVuM}AALKUf zWy)616VAIbgm+wkwBf+NN;}L;1Dq1))I|FcanoiOU{d8Kr<`wzgNyvrEKm6CW%`@o zhwp~Y${r>%3yt=i9_}t);+XLiW@#&mTZF{~Yz!KMy>O_BNa}QvJ6xI6GFm7Jq&;e+ zKVy}7QkbUg>V??p)d;Nz=b+S)3;9F*y9sSR<8!?-Q06oEe@tCfP#j&i4Z+>r-Q5Nc z?h@QRxH|+1?(XjH?vTNq5Znic;O=lqzWS?fKXlDJov!Y)<*dEeUONoX?xq3cn|YSd z#9SWj--(QnetE>jNxXB=qrfmcB! zl{izD0aZtF7Si-zU*RwVZuEmyq17E8@(V|x^oaCD5?n5(cvP z3@j1^W}w5(#|j5!yqTt)Jjx3vZqVKTA1*&m$YL$n}p#Be97EXlK|@K zU3=Nye~FFbh;ww-hvL9wvD(%1xnQdan!z;MI%}vDRd_qY&Sb(FCNu3nM2DGpngo!N zfgPFNVVcKZuPtQMd8PFOTo*#hkqhbO=}=K%IG3RDaR{!{F$5bE$hsQJpvX2ALvd`7 zV>*p4n!Lv%+QOJ>=db}BTMH2AnOXAIn%0V~V$aZi&exnYt})jO_l_;$nqEndJcyV~ z7kfXG_gR>5G;$}#Yx)Q@d7xmUoRS7r@ZeX^EX*AG*@?dfqVeOyqH&3#tg}L0vl8)$ zKeBX$^{&dj${X(3NP%%d{H%&Grd)V^va3A_b0ry>^55_!+=Am((m4lY?dL_hpX6km zc%G_G6MSf${g>JM-!`#`y$W(((u+aI9qKaQrss7VsY*KNjNL4<`*?qW7Vu0MUi2Ki zi~o4lG&w7rYL&IFMFc<5{>_2w0pCUZ0Aa8B?vxa~*k z-T|?o8TbWz_m2}J-;Q%;d_JN(&7oZE@T}n^8bmcztLo$h%njT@uxtwU*$$q|WHFoS z+x8eAb$ECnb0y|=LN;gL<7=CkTVC^VhgR((2w>U=J}&If{-6@@^l37llkeAl|F2sg zp_q>YX`L?T-FbBJuF|O7zvp`d?7Ry-HNEviKNPP0X{5FFyu$tqtp0sE!(4NHU*qgx z2qObr`0hS9eS(yBs4AOZ__nJ*cBGP5|6~<3V7wX9o{vtz4A?8t_%~x{p%m)5jlfN^ z?##Sc@3U0Mw0<(E0wKX-DD>huT-lAFMxpi}M7S8c|Uq9($adfaIvf`cd zxQ6}1kNQ*;kk(k3G{01f8mP9`b>M~_4OA{29ff8W~5 z9X^MH_WE^~RB(V+qC~!}tP|im~ zCV+4`B=AOXU~gsmwXGj-^A8-s@M>hFZ3&$jrA7fj#4!Ba(3t}PGxfBCC{YgeFc6z`13`z`OS*CBFe~NRa)`A0UuB>=0kbSktkzafU_y-;+(Nv#sok?S}8CtSr@&TbT$%Asg5Mv z@y8B`_CuI>H&3NVQu&6)^2_V ziV6qdA4K=xO&>K!*nweC@O|KkRhE>B@rTfo7Z%b(_onw5Ddr12D|JpC#Ve@Pa_rWi znlgJvm2og;Cod_79L6JJ<;T{fJlm3w2ux&_7=x?-v_r=?CnG(Rke+koPyty}iHdZQ zQNgLNLyFtNF9kjR3nv{l=dl)ky3o4WNk5hUy~hhiRz+wbXTbZq)@Hw;V3ujm&m)m^ zAlAnx^d|Ra0$xHQZ)YVqw9NNET;YD-z81Wy_4BS|iSDXBd z!XpPRTLzMOlGAg+>4=A`NNY--hQ+8`(*lAkG<&GLL`piJ-a`-VvdCdJGi9hAAY0h8 zkf4J_9~q0W52;q{pE&>weSS%o8_LIT{RL}j9?Sqcq=L?D_rQUxnN;GF+rV>uv@wL1 zzn&L=%NZ8wtrPb#w;`BFsE3$rLulGzJ5p(zXYz74ZVcv9JFZr(N0+6q(LY+e98fg` zeK5iXJ^po3ew9m2?EtRfq2fH$5-*x{>XAZHyXH-WA~{-Rd2zrXYPeABJCdl-VpX{c zt^O|wI2Q@H<-;o1WzP_KuRa!N$Dsc_D8`3zPZA3G{d_EhiFuG&dh{;)hNSZGPA_gR zqhOG@V(FLRb0^2O;^QX0;9hKuUPuB0i_LizZyDO-M7|2koPl5aSE$3GCOIU;$8LO2 z12W8ygR~-rVW`x!iAx;9#6Mp)8>avKvG_?e-ZO$V*fh_*hyn9Y=)!iNw(ePpWl6bh zhPEx(2)1mQ0fbrf`?M0@FBVnHLSO~S3!`n7cBruG2+g?epdYXJ@` z7AiMzd}@zd@iDQVc51UD9l(&N2r-1BF$Z6dU>Lvpv_e0!{ZIWYhHO7#j1cz0p$tl< z$Syf&)crf;#~Sl+g4UKDz9r@hn&QT^tN6qujQ0}$#$XA^mlB~S4R_SM!0Z3wkFPa^ zDIbxdOJ;l(9Z03P7C+6(_81})PFEbByPb9Vue$Ic0@9Mn`DmUs1F;t@sMA(jQLZpr zx9X}IWf4I6b(!drV*%SYDK|Yc7SK2gRFzg__6o~v*8n{WzwPIYRNN;Tcj^S(_=qbe zhwRAF==3^;>ZCIB$ZCtS2N)%Fo!Oezp_cq7_ro>t zx`%G$nJLCpl=hf_1n!u28XKfLqxKp&Gw^VZNb~PZL~)W*Yrn#E|abLIKAr0%T;~Iw$mV<&UK`IWKuiz z%A-@{oxS9KM@@srPdUMnVh$|ME}|~|hM$RDR@G7k|7fqZCYEPcW|s8ysHbYU50jTr z>us{j#jUz_cWc*bWJcK2Z;bFqZgI4&Fl7X04!nYaA47}{VJ6@Fv#~&P)vxK8WGXL& z*q+i{BD1-9AYli?P)*@J%-(^CX;gwHNT^R#)~Z~thz?c>k8*gUmSvD=oug-jT2;v1rOxn8w0Szi;=TF7-wlQ7*rQq zSZ^oSD)iq+6OG@8M#N2(NzO!j9Ff{ap7L_Y3~4j0Q12%vTY|bLj9^N?q#;AvjUf&$ z{RUjhi5%v0r%=)Tb-*flhX$CH>P`5Q3zZe?oToMOsrEaZFfqyY$fENuYMd^iTOKI< zzq0({gGVVWVC1-h^Nf(-Eq#T+CCl8jLZd;i->qayil zn&plDQKhe!vSo4V9dCad48Qt;kAnb{b2A>&=#v=*QLWW!QYl-%I+tqLQ7KF|)#`=G* zR|s;-wExz%YLlySJyz}c-pi+3y)v?`XScyA)7IV7ho7i()qVZ6HuSrohkCdf^-YCc zUk9PO{B-*1@GoQ|rufY=J#7=;6Rr)-n(<&}K)W?yJHK;ykj??ZU9S!K>2yL+sGw?cU!0aO>&b znL}6a#=PIVqe^?3GFjX~9MFX?n_>IUyY#Wc z#848DLwA%;C#57*7^+HpkyDh5xJv}1D5SrzAQ++^Mx45xOe$U(>zogGQP)`2J3jT% z9JHBr7|Bz*>8qz&?WvA?>KSF00X^aOlKYg5CYF}V&tpU19}esVgZdo@;s(rKe+Q(7 z$bJ7N9G$d9anJ)KPOA+tC;4c$O=E(zrkIJQtPP@c6W!O)FAc)?2E*#3(I_3&;&1Q7 zqWp)W3c)wL;g{5Syc(>GALshoyx$Wq2-(q>7yf=2)An=l6}ovg(0G2oY0mIsZnb*m zZujk6Z*Rrswy&|{!MC$}JF8+*RDke%wL@hJ3;_~3e9?oWqH&Gpbv=^yt+VzwSV~TSiei;P2p^&@JT)aSbiqpWi2g1PN7R?&zV0Wkr!@N6O`- z2gM_1e@#U~?~KP4FMkw-3-SG^o@S;qZfNaO6vvPi^M>i3q}n-Rn;Gas8l3aanXaIS#4uHyjT!kV|t zj)&p-=I7^CgSWf>jK=b!9ae9vvA6F#GTiusR-^c|X)?Hs zbi5DSUiN(OGJ#F<;-I2{sVJi%+(PPA9363kW0rD5^43IOzENvt=AbIb%H%3$^;2TIR&ifZ^o&!g{!8z zPnHDasZ>={Q|)v9;ArXV>+0&7k(p#rd1uP#@k?O}o&=+z;x-0E2jJqs%UI@XXb*Ap zi2?a(oG}Bpv`c>>76UxIYi1X6u78S$u{jA_5%H@>+2V8>7P(vDW+r%u;nwAG3Z zw2br!_@jFAk3qwM=t-|4^A@RGG$zh}-NxeJbwycG1H4C_Y(;PJoLBe8shj;q*W=|d zaW&+rt(~16Bk*HUxm~dG>4Lb1Wyj4Tn=Mv@FP`535`o& z%%F0%m@jX!>oH2DlYle`VMkp^Ba1a=0^*B!F8xb6cnt5o5RigoaD19nT)23# zr{VgNFaLGN9B<=7Nap^zjjp-(TSx}x#4q_K{}7)2g;A#$%%Q2TJlNx{lB;2*T_OpHVjmNEBQPJHVJ(#)Y$Cc3^C@vYvS~ z#pCKjg=0sED{?^EWuav|fT_eryi7p&8HWj#pIy#)ryyesE->ju7%)8V=F%}gKNplL zRX$Au}?6gADWR`6Md&YTd>DxtC9FK!jmXIlr z$y1u}pLLb|b^DMxZX@b#W7Y+@fmhOC%8?T0C{F~=VD|* zbG2O{VeXFdGx)0v^+-~>S4x0m0|h$uwhDDpq-!)~xL9Jlvso`M)`3v!TC_7yn$`lx zqNV_>W)QluaxEa)ON&>P%i8>0pgMHJuDX8Vtx|4n%{Uz|W160+{7a-d5)vc#`fsF2 zmlzo-dVUs8&+7JO#g4l2*H^R@O7xV-zOZAA@}vY^oN%7h=$nvhbZ~guhH)N-;jwFz z-TWd2vaW3{WMOh0lL=+*haFTSKWP=_ISJk$Yb5m$L;vhg%k;CBG1f>y#9I6XREhgc zqFpzlstl)RvoQ{TC;qaYX{un2cw16TIBa3vHL&f-P+|-ty~GY7FkI8r<^-DlZlgB9 zK&LleVW4m?yPire9&xF>k07y8eISA!dk$v+X`W$#p#Y2%-@#Z!>Z*>*E$4)Epd0n_vq2 zw;5}L|5bK=vDcYqAS^{Y5^VJL0(1Wg!%}4i@NAQ3QX;2(L733Q`ss&UqVg(Cv?#}s zYy&hM!BKo7#6fD?nfdxgSx%WC6`H@B;(@*Mv&<~$s-CEA!}&7jlH6n`3)f&MJT-(T zAaF9~DJ_NJHslB%r@Jz!q#XO%o7N>G*`NVfg@Jp(5O1Lw#+g`NQ(scrMfpdhv8Ti| zl5SATLiA4@&kRT`{#T5}z2`ffhM<0jU5Vb0Bz4i5Y9FB+ANMK3m+_30MrU4=@FGBL zsp0i2{BEQ5Di^0)CO+alfh>>&ASodS!3mjCfld(?Qgd8txvhHmsLE+s!lJ1*-*!AB zqjf~yd=UOg##APm2s{5c#OSbI$0nvS%3YeXz>%oE2n_K|Hd_RU&uYP zu(BXim0XEYhK%lEtGlk{>44)*bu1~{@8dMU;jt@OffuP2i5@YUy&VmMGl?YF*B|2F zXe-u_nBpbwsyQSU=W$B&v}8d5w?DpcQz+ol6j3VpKWj znjI~GLt5vVFn@qOj#7fO|GKP`+3K^q2USSO;H+{eu{xTMt~ZTwukAF-8H`M20(Am) zFNXs3k5^zp@Z=bYCS42u)%dHS4M`WjyTnaYIvisd*URX z(-e>6>D)gNBL89)Ed|89RMBs~AQx!Kt8-bmY5a3eh$;)Ns z$Q2s&;>mR6yy9uLDcEdQ!ln6C6n{U6C-(Nm> z1b1sUC)7YFabfhr;OU8VxmQ1z_4k=T5DYe{{!rbm_n-8m2bPGV0(W6t)L8x(N$mGR zWOVpc+qIga%5^$RV~?YsQa6QA;-3S+n;>A2e&HH|zF|^|qf72Uq^K&l%G9($$~zsO zvR5`Nosa%PGBTUL z2`JAGs4T4Ir*XhZOCSS72j&WtQ!E&f)q^6pMS%2ueE?Hw?3>(myHwF2L;KQ|EUib# z1!h*%C=28<`w_T|@=_z6oCGSd2tEg%0P%Z0%OYb*SzMN4`~ZeG+d1uQ#W{3W zshuu0oFZiexDb>KC3E~NN8iO+2a=xt@y=od6+jW_frgntZlD}(`Zl=#YFxI1p?o8j zSmfNIp`l?BQRL!QLybnuvB=xxMiw5%^Lfi(cJ`jH>Q~F$7fo#V8RI3Z&h-F#u;X~x z!nFz>1d3~Q67hP9U>m6u??x^AR=yJ!$}y#FXEgK6Yv;h2&!%uvDg9eq(RYklg|rMdX$1bBZL3V+Do^RXxPnsLQ)@fj`Zl?IikdDy%Ziz(WcPg40qo zr(O6hXN@>6(ZdiQ9y$tN)%dJ;LkQivDo?h~?p`PJJC9F{;JChR!{k)t{dfAWjXJP& zn9yGcZM%O^(hlB!N!(OpNWZ=mwfr(ErSCGiy#lq+-p^rVh*PuevfjG7vwP0xo~29w zsP4{db;t|-I8qHVC5u}4#KNN~%QK#Xuc2B?Sydl<3KnVUcU?Dk(5+cx zun__|u7u0ombrdlf|G3wAdGhV6UTt`A{TY0sWpbRvEQhNZ(W45x3HP=ira@qsIKt= z10a$-zn_;DWGJ0Sg5OIP66m$Q^#Kd?h7!iiUot++j69NSK~k&(j94q2pDD<78DvmS z(lzb+)5QxuMVzMK@dkfI$qZ6+x`4O4WH`&IXmY5ilH~RsftV#IqpUAFf37*M-?npi zbajR8`<%H08~54vfnkw+wmFXi`-MXrjrd|V9W=tHh!U7sGv zm7(R;%k?s`=OuK*R{R%hS9$kpkkwT`^WFQ4fyt`d)l*q*+hQh_oo_;PWtBr>pUsc> z4k+nP=@PLfR)AtpTr`T1`b6T+gc`aA6E7jMLs7ZoHhM{7!xf?gT>aXY{LxPDyMzBbFZg=SgQPHP9oNOx47y3-2HGi z&xcnxPN}&ba1ubeUjIeDF%O9dI9YXJHvgBdAaiokRfP1#5q>HC1MgLI3UlkJ8bD=z zE?;MFwinBNHu%B%N+#)>_W{c%T@JIA7$ZI-jE>&kwoOG{ZjC6tTAg(+2JIBM3J_#w z*lteBrZHqK@-k8lU3MURP3>lv&odOkFw2c0p`jG@c$ajNBo#TYW=;|5ObbiGuwx(Z zkertL4uMU}*8@QCr)`r?0dbU{7{e_dgnuQpsJ`_Klvt|7^@Z<$YR^}Rf#a$@Ud{6J zhit_8qwx!*DaK(I(QlRv?MC)7DXW;basGA9KsSbcuT(WjDWOhGAH=RsJ{Vb3`cR(u zsceFk(h}J?Kk*8w)UvPmW4N8>2RVib_b|bc;3wEtMgHK`yw;xzh1nk|S+FsuS&>P# z@Hzv+Uu>gbErP`-4|eJer-5jZjzl3T8BegXhcnj^r;to*iAMd9yZ< zFZHJVHiB1o2J9t#xGw_33#o6t^{w9jA)5I7{qWtUB@Ck%FRJJ4S;I@_0XzKOJN2kx z*>VUku3@un=fixs)pg49yc~Bv(;I{@dIu##7JN?ZQ~~{Kr_}i?d8%_OS|u+<0yHmY zOTemT^Z5aIecT)|ho3Z4s07EHugn9q>$I|QecSRCDP)wWK?GK;*lJr^j^yYB%kZ(t zwD+V;n97&9TyAW2%!a=GOX^lXtyo-CbYa95f0#>aW0L5W!Lg0RP*_*YxF$A<2_b;D z$Y*4{STFxPTIwq>ato)S>%Wk(DE8B#4=MEFjhinj zbaUhN>P^G#+;?kh@i5f!_pw^%plMzW!7O`` zdQ12Er+VL;ybeKXjzf~ENjqbo{#6?1KPrte$ggFJHjsCkiY~0kMCqneb!SrVGF(e% zLreaUTVAX^v0nTN2tBJT!In;~EEZo}px5tJgb0E^=BxLU*yB-wOR(ZkxHuylynPWG zgVU$n|3fziG~A@pHvxaf3poQQa|omLs)kpDr31jhz#6%!ixB$L?o}2|TMu?)bcwzl z)unrnhoebDv`(#wF@0uRBrAS_JRu!dl$%XTlA+BfSGyl^YG^r7%%M`zEJj5AZkW1Mt-o_6*0^sjX0 zC%RHl28?3oJSWm8KQPDRaHM0Qz;mTm@5$yeoJjmlBDo=m>P4r0zYlj4evFTIkF5`K z^y~lLFXk|NS@ZPhr~WEzIUT&y_rOB5=HO6B{4j^ey`B^K#GSvRdaX{e(FYN=vqV~t z53H{+I~AzZ&X=0eMg@M<>*~ZXwK)?r;N?*G7ZnbFTtd&vGtuD@#mscY-kD{^gpvjn zu*`(%SA3^F#y>5{>1q+C32Cm6Hs9dg`C0R@1nG0bD=&@|L%1;v6l3*b=e2am*$Eqs zmWM0+7WKDv=HZV=4%F~t)I0y5@A12uJ=#4!EOZTw#{|b6099Sk?y521a(j~5#TKq7reWra0^j$W5pF}j!-c5#>t8Z5ax z*Rl3l<(3^eMtApl91M-nl~<&ak6msA4jDH&Y}MkgC?6sQl$HiuF0_&Z%~vr)xG8ff z5NC8PQnGht_4L6y2bqxqfp&>zVvXx|A89ODr}2_#1U;&|I|<-V?eWI6`_cqSovGyx zX5(+Go<}D~+`D3sGii}7HWXscDrqxLJ?`W51jOVOG4)YI);v%F4^vaJxmwKGSj!kr zv%ueYfi?S^@q9W+e1bAX86W+Nal<2PLM7WEPb}29M&-O)XM0D-mmJ7{{w!-j8h> zDVqqiY;tUWl?*b(?kL%9VFq{=1n@zRCyRRXsu~21dl5PUgdxT)+}Dbqu@@ZbJE_uO z0}^MSkxH?I z0K!>_;kOS(MZ?6&p&>0bFbK&Q?663Fxu+~Si_{cPn@S8`bmC!BYj05Lfk|EjU1-1H zYeYbN&MZ9^BA(&GugPr;gX*1p+K2XCDg!`vT+}JU_eV-0?2i_IL+#|T&V&c4#apc! z*HOPw=mZh7!>sF!JRzqYbHtcLK}j+hry>ca`pgW05(%i({6>%k8CwaD#Qt2A^aRJE z-y|(vRZV%2JRQe(8JWHoz?``Eu42n|LctXvOtc7&lWh2TmwHTOd`MZO_%9%zN#=}* zV{8EcbYRSULGR^IqBv6Ey1Owx>FRm;EQc9;G$=82SL&rn{G6>?y$9x~-%%B}AAcYR zKK=5%{D+-t2?JIX!r# zqkZbs0V8!0~Hp~D()c0Zrq-7%%QKYER@;_eHs#|#xy^~7mAy#TQ6luyJS?Fq<(wJGGzz-U* z#h?;dqH;OvY*qdXo&&Hw`9B@$#Wj;gj{m~~1Vqdf9ef(HBzri z%-zBh6xK8~S`-&Q#3*bj+WL=vYacpm!eu7vmxHw*zGeBv+rvzV5G*GFnHZPMY=N{P zb_V(Kau{bCd#JRsXk8$?R?H+@DQOd#~^XO2O`v``x`hSs&LLy)OeabKuELyrJSx@BY~wDh0Ps7a~-;m6%(2#nL+P{LHVn)jER5# z+y3N7)pHMkWT?5({hd2zc5?E&=K7NJ+gIO&xoDmq60LQEXi(ZTw|Vfuhp9vw@3Uat ziEFwgh?soNczW}VbsktQ_8B6e;xEn1&Y&iiR=6IWY-S-@f~bDEJI!ph-wa6hcz?TV z-SqA3Tn&wL{X(8QKCs{TDL39!a%N)n@kv=mcG30um56avS${(LmdfYY8FCXt9>QtAD_a)jA8oU>ZxmSqz31C+Y2wtfFd?(McMGwHKhEg~ z>a5R8Lf0?6Oziu8E`RY;Z*hJyz&5lM-icxup6~Z0)U8TVotE^bv6fAP*)H#v3Sq3Z z_4WP>-xx@I?AI6qP6x;O)l;U698Fm54cFIoLYhcE&D-&uX##37&7VlU9UW8Ra)wen zI1Utb-H+gmhv@&eA>c|MM_)Sw74B&%HYXr~yPG zZPRjVFCa`xrS0dTbTHflhu7Y-i0jz-Lr*NHqEB+}q*66(vQnmwV=-2+nW_dUe#WA# z2q57z&4kdyjvZx`U1Y!e%D;4YeJzCT{&l9Wmgm@^? zcVfHS-afhkJ=9Yc8AHLK!)K!B$81C)FD!#kZ-DQ1k6Fkj;rk$V^LZ#miYu{$L7&te}F?VREwiAUeZdio8danD5kEVLw@&x?s zt7Ef&oi|@lw>$)xJ(9gt25`RBc`7d6E4~gLY*;K?UWRYHe0zO4UL(w1;>?_H|FA55 z!YP;-t()zeIufJ951PvNu5sJ9*R3Q^Uh2-Ps(cbLq{a70xz1WPF(YJl0VAwHEPhD2 zW1E4uDMcI;qZ-A;(ceVrh>uyKPuh|_D3QdB0^fUf$9>O8uXpLe5MB9+E^{CZBsoZ) z^^nMlhvZ1b;_#xrSx(o{q`g5_cXM2|uUH^0jKB&%uvNC!+5gi0K*IbObC&j4nLQrf zjV2pMdc@A&W1beJMQwaJyumtISKW_1%;L*mPF@bLPjy8F?45bzJiYh*Kt3`DIrr1Q zadMIO%6kSI?i#pz%EWeYw`}?amo1iw{cI4J#3Xd5Xh&aCr>M614_H5cnVHTs;{;leW}c@UQRe34JI5fLd!-} zjwcNGdwTpnJ06jx_X0jX+6CvP(sB;y1)Y7I8Q+0eJUdtWVe2i%{NT-IV)$Cap!Ng$ zuMJ8ENg==Dq=ArKhE68)GzkcuUw=u`vJ^+%H;1&A?C*Q02ny{uh!wn@?1#K>~ zM5-8ylE!E{rewV^cqfy`5=-4(#Y#HxSB!o9zpaF^A|Ey|95(08&K*!z_{NiSeS>o6 z`M_>|S>*XxXwl5isU2WJwDD0>(x==G)ZPo91!z4*F{Uhxt{6x}e7ozPHYM4y)L1^7 zoci%F0(#?T2w}}Np}-Dw=7JQuo7ghH1NC!_&j=9ociqaJWQ}X?^%5;54NmyoM81d- zPI#r+ywMZdVfp%Xe6=fGR&nx$Dh+-yy=$0_&DDO1mws_jB}QZ&fqn)Icx=Sf$5u_7 zTc*LCa`9FwcD$~Na*X`4o z$XDh3Sn<)$`*a_GiHFY!gk(vB=q{PSd7>h_xWg|M(Yjd{JVoT2fO90(CxPfMqWKFpN7%^k33MP*H!n|_$t8>a_LhgiIE+^Zg$uLv|YD@urVbid8(Y04OI%Y*!Gj?%?uwlL5>$G)$tJz#IW&dPM0K_e)1u?p&=d;HEfTmN{iE{it3Ny1FhJMedSB^GiQ~c!uKb=yKWyX1IZgc7O4l5Irn0N;Y>7;xR%=L?ZF0yB=zX64%!v}j9fjX4kaZ2ad z@|M4Qk`MwZi=bT+T`vo+uwd_UE=NXYBD_0QusKp$!7}pO6g_cLEQJQsOqK;27du@O zd={#na;Po2D~51^Jb4|NDsu<|cHr#Bi=?GU&Ln zs2~+pZpIkj^o(FP4K3}&HXcIHdlE?9_hrLr;X|ei4>U}8x3v&=6ss;AGv8J4eXV0a zu=_9po7UIgvV*P{#;@!_i44stV)1o1C-5^^t9o@4z;Q1N;f{9j3lBpZDr z96T>}Cac{e{%BGdHgfj;^~h8Tu@Vj8Mqb}KWfQQP4b{+()oJvC^RKdzrZi_V>2RWx z)d*cDn*tD#$EAvKQPO!>J^1kWSauK?M5hb*p0i^Egr2yVP9$Wa0{w?w#UV!+?<`D^ zh+gK}FHH0I*bKi)vF#oP0RXU?u9&AX6xNqw>&pHt_Ks#?Dcz1h31m^k6Q~D#oQ?<5 z17H=1;)7Y@+Mk3+PK+L3c-qt;m+2Vccu@zQK3xcln50}5q7j|awcmmjBFT-%9c4k3 zBDXY5o&7?|K-D4T#Ucwpg~mtQr=9|X2BlFDQdIQr0Sv0FxrQ@~U@N4+!$`hsWi2@s z*x^7D3fa=GC=9~L>Z@TIRBNvP)OGbS?}mmKrH#mAI%EUnlB-^$NrVOl=Ha4bv|F0$ zm7~l9e#0}aaEUg;$uy3t720OimZPc;Jj>B>a{47O02={9d8 zg0o2mWr0GRvVHqv!^L*7jc8Zsi|%Im`_W4xH_VCQie#s`fmHp35N9kFL=PNva2fOM?;lrhQDJA&v}IuK88N>w*FKE>ILt7xF>O? zM^uq2bEj?eQ3aDQjBBX`yJHvY$hJAxS2s{>0j*H{mwS{|o=`+zM$yMjv_@{eMr4LT zM+$=hjRyW{G5{9e%S|TEYtKU5rQ{ve`y5sM z0X}QuzaW2Sbx7N`r9Z}7IF>#Hle9jyi2f*|`)(EA&jhZ+XhSyrxE{6Z|2#h@->456 z#~ZJcRds(mu&}27fCx=3)OyJP|EZ+6=36&dx^kou`Ka6gm=1RJHF5#cQJLZi)FBj9 zzz@{?LU6?m7b=?1BAQ5apBVxaXFtd96Cf{>@eGnoN{6ErNYla~h4xd6Kq%asX8FY_ zkd3xPH-8M~yPglJUUVdgzMs)_;FSyL{B32V=wJl-fK;ssCrirqQ@mPr_E4>|dy#Z* zLEQo#g>rR0$PKTASHb#hMLXOT6aQlpjf;Qxw~_-c97&s~Td|CvD-!4W(2r~zU<@AG`KT#vm zDdEY(Rmg3n?S@_KhULxggTy~*L(v4EGsv#4K=@1S5?ew)w^?G5gLxELTQT;u!7AEv-$1qOx&JXo(gxXGsQ?^kpvdD%*0_AP(D|hCQ z0+GRYOl0_!9B`o{ls`EN?_sG+i*k>OqE_fua1x;3q@q)@1VMYR3rBPi`b=AgHirMM5K4nZ=Y=36i`ma%#)k zyx(-&Fu+v|SxTIp68fVV574AO-%+mNI@f`OQHad$B2a!>WTnF`topS@u0$1ydgNMv z&}wiF&+aKD5-UjN=MhWjHPjwimwM8Ga5@D*zQ$v~Q^O9ao))3=q(y zu6dl`BRe?79|rGKooh@$lP&Hv&(ghLVOLpK?xXXSBBU83^RpY7G8bGkzG5`AipE$* zBj%J%<5nkpi~gWv!}F;JAOj;CEKy@7&63JYBI663ZU`J!{pEy51Xme-kKH$&Le2`a zsgxzn|6u|1c3kx3Yj&+YZJI|bh-TgCTth9%yU`KN1(ms81SN$_rDhUQQvEl%0;_FiG$F)9_l z{P_T?Pt@67qLbubu<^t3#}1ayUdT*0}>m@AWV2x zmqsnUY*q44A6O3`aID7ZeFl}Y;L^Lc<;1Gs$@CoT@1ACLi=fA-hEq;HIvHE(db12t zz3Wb7zl#k`-is?F`-LEUv~B}?KRv>RUsATj+ZJnAbKmYM*tayVHCc5lbJ{$(eKSg^ z-Ac4CnH=hS+38%c!P9)J8%g?x*Al0IT5Y-)+uh6GQ7_ctfjuZFWwv8=af?BZ^D)hH z1yp=a<$lOW14(LK4y@*=l(4m`FE;}Ac_(wx$(iCkMDe(7G2~KlX&J*-+*GIpI3#fp zd^e`?hHJ~KR^f%%@g#zBUir`skM4l=!mn&bb0YMKG*Y{UdG7LGpDM!L<8T5LgU6)C z4{yN#UcIPOPq!k20do+>XLi#MFtc2@B3!_W3M-?U2k18%CgT@n8-9p9D9ROntK4mf zt${oSi^+3punf8FuwFqO2#d8I)|tYaq(h~j?8XX>Aa4J(t{hw6BAmzsZfOGe4v@Qd zA9_Z$oml#U`-LI7iHsP=+THs#P}jg_@#OqNC7IMe(x@R3IOJeG&pL;2=RTN7iA3I3 zW2$25An4s3;W}A${R$eI*#a^u_OLG1W#{r{eM7*k(oq5rX_RJ>BL~iKka6uA%nI6N z8<@~_Xx(Ps)>oWZ9M4ooRf?&5jxeY6efFLdU0*?_r zK6P)*PeQGY;0y((-EriVajMWWSLA$f1=$`uh&6_LjwA~I^ytOP(+3$0`%d!hi<)On z%?VbtIMO?~y54j-bzM~z#F3+jgVZ4ugaQ^#v_V$9<*eN`-IiTyNRo;3vE*n;C-uk!$?nDoU3e%D73Tz5SXHGUsU5GlY zK;(;j>t|LhN&M<0E@7K_Q-Mc*DNSI_m|JH9pCcLh#qFeJL>;SK9l?hRD_$$IR~8)o zpF1wAhF1FQ(%Z?b$|}eJ-G{=oJc78EXI}VF<`VefGI9-s-zv0~F1+%t7=DCl-;tOk zt5!ki{1KSR;4yZ3duQ#eU%Ngq9j5g=+ZumR>OOLhrLDjF%pjq*NTG*GGwX7xFna-^ zF;r3gr4gANYQ$nIIuCUPGvs!>zO0+*o0^0Y{2TTq0vQi}N4>vDI}R zb;zsfNWrrhyYCl>C&Semd^j<8ufUO48mOgIYrWG7tMB#Yn|8aIm=DmL5~`KOKK)wrO5hR@-oR-zJ}8Cc|Aj%qyb9pbvrr(&=Q<`pFj)4~$rh>)?>vGtx8c zIm^Ji;pVZ3#cm0FWpIm8=#7?STT8>o;#^4t6KJ-+unA3uk7RzM5)uLud9yTl8Di zzvwl1dbf?7EZG6vk<%cFL%HZWvib$`2b@=RW*UXaLdPtpd@*k|)eB&OK0<>c4Mp6IxxA@6f;;sE2^(amyLqSM;IJCq-Bm|Y%x_QC z!&*i8$7=iYx`=;jcqW!Eei?=!2xH|y~6nA%r z;!bdiYjAgOaV->w7I)VcFZ4_A=X>)vYh}%vnSJG&J^MV4W5%5imvcSfue}o6lb1;k z!y()r-gr1ebI!j}WgqxWZ9+;K(Dd}EAZaZh*?`6AB1_fVER^m+hOS!JG;d7i*)r^lDN9J?M0ZxLE6 zg7<#cpkabvNNPH*@M9F19GDPl!Gb$lvZl2;}19ra3B2ET)1K@p!U9chMpdqIDgq7dPw>(w$ zHlb1J6!Ng-7;-hBg?3kp5TCK329I=p7N%nz&~&#QCzo`}n{$#)9_1MLceZ+p7vd*4 zG_gA`GM=%hZ#V7V7$ZNg2MuNq6>Ya*AEmN(iM4p@eNj}LKi7djqT`WpanqVi_*Cb6 z$~sb_$Fo4L?6A2Q0S=b78op^6xL7OVoZ93tn@GRd&v9^+;{_DGmqGN^jR%K3`m6r#WBa+s)%`i# zy0l+1{SEoA7hO2@?sD6D4JKqCTi0pF|FmO8D)xd{H*RpM8*=*g&CM3CzD zO49=*HRb%uz{VJJyB4#NC#nD}_wM6werKJ`&>$C0uJ|`YX=}V>%(HpUaeBt;*HlwtpnCK3+TopHTuqDta(MZIZ68dSG*(kiSdLVLnWzxs zsAeq-fbOPoNbw@kaq>r#+!L)o`ziZl{Ir0P@!*v60T*b`lES+yuIT^}&Fnc8yWNl8 z6oy61J>py`>R}BmTHIVdw6kQzroc zK|aW>sjJh`QzyYkrFD3KkIdLa#eXk$H@0y}u(lg;D%CFCrbV=}^sIz8K;2OF*O%Y< zptG&1do?FM{{!9t>>&yQvOdxPBS0Q@py}h-1|WEVi&P>6;~M`OJ8h(1axQcS0EJG8M~~kB^ot6c8}cgIBlTcafL}#+xNz7bIDOAHsd+qjWxNc z=?T=c88U;H@mU8XUHP0ATKS(?Stt7jH<1ZiU6pv8g7y^2hyBehjc9<&JsmYQlq)st z26dn&xE`KFe3MX2f)j}7jc!4bDW#;y2PG`6N6ZH$r@%xXt-cRW-Xqt0)L{?n<=Etf zfNI}j*L)hEaI~~vL)$0y@HYzJ67265OaJ=Ih?Odiw?DL>DUonBuNF@e4Ze=h&SD7$ z`%+F*-@a##he*WDRhKVaN0hzC%CIjjbYzXgQl6k8ZxyiBJX9-PH0S77H|cPEkY4Yr z)4Ri({G*}jAX*XTSs-%$-nN0O^Aw~VKCrrTGnU|n+{+e)VG^LtTYRS5Zdlhz_E$Un z&+%1KhcAcQa!VMeWHrlY0%XFw@`gWLCiobsSfcVy8r?SYNlf0mzmiFL%dHbym}J0g z+sd&Ie#IhbsH~5;(2O^fVXYuMGW1Oa?_bNQkgRzNLPr%Ouly4(Ob9KNx^_Qp|9%WGPXcv_0Quc*bmqAF%b zrdReKm35aA;t~*8Pgb+azRf^RvH@)jAZ12J+FrMP;I0mr6e8k-SnV-jOo_BOJ=&Bl z?|mR?EoxNQrKG9`O>`yeJT=TlnDkv#*e}HtxaGEYwED^R7f*=iZ$P(sTUTdK?dIeK z>EzQ9EiZh{HgjYLy&CHloE~C)Qj#)Q=jef)5b`Z>j^Qh#Ok;T)xO;5I@1JUI7-sJRPcss(^ zAiNeU4)XLPP>xZh(>OaUX}BibnF@Uiart3s!SZHkR*g0jHJFXa(Mny1HS}%&`T?R^ znn;(J&Jsg-DFCaSy?nO)#{}$D|a)TNb?#U8$B=?!0BoL6x+PU_@xRzGb*3D z#FtK=vdEz2=*gkYs_kUKV5s{w|tu*vq@8kg? zxKD^EIq9Fk0O*OS!CD$gNM1lifS=NHFBd0*Gf`ep3>CW@V~FB#WI|X)I$=efY~eBF zEO+j765klws>zUwrDINz$Cx8*PPvO*f0Mp?6A@b*{u|>Q({AIZTUhB?yxeQB13%)X zv2?8MhyIAC@2@W}fw;T?zx*Rjr9bb_duEoqxR0;HfA9a+a;``$zCtJ7wpeWP^78n+ z^lknBuNNRG^h3DIyc@Rd#v8h`P^y}U68U}^OGvrmJqUxk6<@QGe%76I`PPx!V=4TQ zumvsC0pvUWFK@I#o1fxZRqwho=|^zhjK1kj9&CqY@9Ce87qILmYv^eusyfX)t+3*~ zT!s9i0viS1EKYiSVuwy?4aCd(a|~|l*|$|UaOkcOouPgG0qo4rH8982tkP9dC19^% zj;Zp}ZcJ0>e$s`kPv~Un*a(L@$|&v8yQ#AX#)~-+kf9#6M#+xu{Mw;X(VT1#(7g@|$IDvEf1n-(1f&#DO_ij4Adi zErU!Bh}*_e^N0K{N$hK;)1T0`g4!pF6H_v!6)DDYh|$I>HP^c3c<3%#;k_@FWnI^iau} zMHYw-EspN=d$EH`Z{@dPvTA1E=eFqN~%q0!Ed$R zAH2V*>Y_LN&2cO->_YwJG87bYb>*uw!;R_P82s6PM=kJIX_LSkk?nzzU*1r@R^B_| zT$$X?hxd6|M&U!fB&R7i?Ll);o2#AnZ{Gk2F`DC98)(lHHC_l)Jt&6c5Fp91KABs zvk53T`AV_4uL+E-qgryJ{8<{w6nLsQS{p9Gy3Q$sC@}I!$%*x3Q4fM z(2q&}Iun<{>OR{u%C%F~8dfp=xiHQO7L%bF@1A3ak4YdA^K1L9K0Vb)-qnTVj|Gw@ zF(bcUttVrdvDU&d`BHNQaA*p?qlNN}X=PHm_< zKwp@93q@EBtFJRpC7>)hBDYMsBb~tFlmAj0Dk|VSTz|?x&VI<>&#Us6rSB~g#)Rau<9FRsfZXcR^_L*gm$j7W zxpF+yOL3FEgLx(XUd%tibAfgVZrAAOXev4y?;s)GaU?iZYycpEdKqvh$U0r3q)MQ? zzO%Nhl5GhQb^vxEYo8vG7cz5McZ26BE=0nwFJSPvC^liN(WkQ7vyGJ69kOSQjikn$ z>QvN=cdI?1kV)qxcVHp9)QD&(wPdypRT@*F%6~{B&8cM3bU-z1RYX+LV%N)zGnT0y z{;WmM9YD)SVp|e5PLqr}AhY#Sq!NM192*l>MzU-w!?om)-~&OP)K*f9AemwuisDW% z%Ngckre}={DMrGK%?>&u58VQo%Z?%C$7kej$)M+kY zwk;z$;G0*xb#!dJw|W&R@P@AbJ9)-Q3po7)GfThrYpxR7m5vjErc&o|SeXBDYN`TY zmB|M2Cqdd?+-)|KPmjm>Olil&SyWvN8LEsAeQHQ`Rg_G*RVJ+$Pr=V*gOuR|;?ib% z9uSsH{Jwa<0wsbdAqpY3m)6oZO$_2&hsT1vL~w~djeHGCArCi0u78g79_bm9bTLsK z9GYpBFGh?2yO>(Ed6Pv!eZG_s4FNZ%KAPos%L_|3R7aWcw^#;*7qhU8Vb(~aK;oe2 z&=17Bif&lw1R#16#tI-ZqKqXx!SfweS)~Rihrmy`uLG@nKg0S;ADP;#tMq3rJI#c) z@?XehWGDD_NTU>!3Ac+Yb2KOO7Jz3%83`lLOXh{4}EN?;EWwGVz@YaCL zDa5H5#Mlo}zwwLo=|>ne+V)w+t!hL5-fhbhTqKt~n&T3Ebf?7CRCO!xRXSO1r_$Z; zTl|XZt?}G_%Ws3>K&ER~FY`=LmS24xf_R1XOh6k|QY4>~8k44LweMl}IgAMPOJ@&n zbaT3aNemQSLH&z3iT$$okEZKDSGBF(>CtZQNMgY-D1V#)ls7P(yE{sowb6Po z+gZ*pI1)B*#I^cBEOa*V>Rtv;>fS^P)LAeK+`3$v1k?Ok5YI`vUXGfW*d(+z5&``! zEdePLJ+;ZqwdKoK?su3&uR#)O-aQ*1O-!7Zd)&}FIu_nGLvU7mKR9uyvUgoFE~&0} zYNE&!=&hu7#EB|ABH}UfyabZVOC(@s){H5A8>n3%OrwO2ih|IvCZnA#_lK2Qk~Na9 z0`ALi0O^V=Q&A~X!TV`0NLfBy!-(0(32IttJ)f>Gom;QMMAVvjbkrgB`YnmgJHe`5 zz%X3ztYYlQIP{(3qmJlfI%xYQktRQNF4|d!wwpr2s5uuyLS`xFbn5eQ*KQal0ZKIGs`QoP8^KojS037wDQ>1;uIjOna! zhU(``Qlz?uCXQG(%?)B?Kzukv|ID_sJC0l%P6Ka0j-^3AFUay|S~GojBAzLLiON#K z6PXWxoX=G;ZFY}aZOl|YI=jwbti8DFw~QX~H>Fy3FdxR@8(n5(jY8bpHsk1?@A}o) z%<G7Ua~%zaqK`k78kX<;wfU727~cGk z+UFg2TdkJIdcq~Vp@v0XzG?tJalsx%&x`7o_kdvi#;P}>nx=(r(mT2(>pH=j>Lq|+ z!P)yV>@(e=8Qb^S2+|)EfMIqhLD5tD>p^1=(tM8W%PZ!u<<2Xg+rB!#%6)K%o(UId zO#x7OSQ9j9aCZVr*0he5mb7Gzl}TA3h-gvYHh;J^Hc6;738D*f?6Jm8DV0T#uIt-k zC`BV@M3;MtTRlAsIrSVT5JJI$mdqFhkUSpH`-8d#g@Smaah)A0I@J=H@lly#+_U2T zq|^Y~pOC;ZwGmL|cx$;nR`72BcZgg|-TM<)85}*9+MI1xarZlQ>a9?C!X4xp<_LCB zx{_b)^?Us?$&ziw8YcG4X?o-4G~v%p?04G6d^3MGv8MC~3Wwl*xH}H~;*?N%9^OP%$hCMP$q#5+Le*jM z_ybvZ@^r)|u;Hv=7G{0w*2Z>#AFPJ!4V@U>_mZH{yHD$XyZ;vc?d=m$(_4{HIlOYI zf8D|U`&2m8@KvoFB(Zvvxavq+gH*%W?gY1ymX)c=|osORPJ;=(&x?)D!ymzF>bD;@LBe0B3Ra zr;fma&t+ZY>@N}8RbZsR(~CxFv0-q6BPAI#XT44k`vBFpy~<%n{mX@#NuNu#NZS|u zGvzA5>4TgNSFI}YGp-HN`ME5GL0H1`Z6iUu;94k0qQ@MBVIaeWTcu-!clCY_bqw3J zeEx=C7P?iW0}<7O#Dzxk*RjuzBlYKk*rHL<6oz7 z4IEvtob5-$01_aA5OZ;i6)w2`tcrtK_~5PM?WpkX<>AHt<$KMiKiwW){I6nf=T8!I z1D_7}B!mbmvg-$OHSICRQA68F%d04_qTg1`T!Zv|sxJ_-TJDA0UEmB;W~&D$gq7Yk zr?4bN=!aT#8zT=vE;>De6TlTHm?}MY-5>fk>b!~S@a(fzVe`nw%1A(>{`XTj3CO|v zSCF-K$LWu&TerD|doO)QE`MY#Vppp8QR0;N49<0L%|{FwcE{J>7gLv*JF({&lqma1 z7d6A~1QQ2?c0WoaNNoKwx!O%Ji4*)Q_Qg(sXz7zlHcJ*rj8rhRS~MA59wef>7nWQQ z+p<}tN?-&b7>^$%)(wRjki84abFK~E`Vrq#uz^+LJRT6Q#tiJ1)R3_XBR~|h>dTEe zr8;FfY+NxnhgJkfCAlv<&-8$YQ#_qg`T{^JS%xZz#{cs0efMvda?aFqca<63XDmFp zcM7BOQLTkW#GbKRRC&ACS~`9Bl6rLRj$NWM_XWQkLdQ_^&_Dz_3VV2ckkV>3#aX}= zJ~DEcn8rXuq%?C<0a21U$s6J}rTaTX6Ra{28ng}No}!t>$n}^_iJ>wSYJO4?n?S@Z zd}*o_P|+E_bY*s;HaM75z+i*KKt6)le_F@y*BvySN62idmhu&uu#U@ue_hx_NjgOB{pWh_jR`l!m+fB*TBk8*}?j#3d!Byyg zepHudeaIpIpg$da%E0Rno#IORIWP;6%Dle!1tfS4(k-we&@-=w;aA*%iV|dwHi)-l zDbJdGK2m9h>SGzBQ~RrYSCG#b-tIea{hS6Pd-Z1y>9MBaqa(4Q9>iTyh=@-;{F9jK zBVF+Oz25MqKdYLlRb*-V@ZlAPn}%)C*>=vSH-(db$bU`^>0+Ics!m^-_u@I|FLoPT z`09*yn(@7Cu6yG&1PmVK- z_M@^JvuoIXMy4>$Bg?yhGx3XM#gNXnj@F^2RY)z0>GU3mp3smW?jv~ua&P`r*Z99) zz}faL<7k*tsJ1Rm20bDw5~ex1R&MxVN_uVQ*a*x={3RBk+G#eBWgf{*DuidRaYa%o zG5X8bGqB+Dplr19qDl#MT-}2XiIw!g{I+(CPdrd^KD3VQ!#>?Fh}eYfEQn5m7M^oy z1M6xt7AhNV?+QFREez7ulP36NxBDr??i2LRZX6XT+4WyxYUNT1=HIQ2qQ)WrN`dT? zuwYz&9~MT2e?-P*?x~X!E}u4s7%zV6mTmQMiIkBL{-8(&jx8CQ9<%(bSG9Q~Hx-`L z>4_{|&BSlRs?^sdHu`C^RQj~(#(9YOu4XO%CD+&Ih|KAwW7$>D&X-Y93SLE<%qvj@ zQ*W^6U2AyFvYK7Aop{+G(1_@d2l0=@gs<rn&)|q+oFd*xcc(FFU#u+fcw&oAYPW$^hf!TM$IS{Tg8hzA zPWO9(k5pPPsu+x|wCDicx<*cRuYYLD;j)2kPDVYzt5Y#4!zJdXyK@jPTWmFI9?(?z zXfEV2V}B^o{6~(IW=J|tNwiPv)b1z#Rn7?i(Py^W*#7<^DGNbn3vDijk)+4CRMTru zcci37h0x*wMA1SIP`EzszA=2<-=1x+J-Q2%)kP?pKQYf(&hEt><#|TiO55!mA+XIW zM0Veqb)ph1j&yn~H|FU{EpD(lb6}mFz+j#Mf6%tb z#Z8hd+~s(%=YiAWmQln}_*0Y=jgY?%eyKZy3X$KbAj~jYeqj^hh~|NWH#I_t3@0>jjrEr@AoQg_OTqKT0OU7nWoEc%p5@A^Y^HMMH|7se;;gZyK;b>Vf=^?+imOyow=7qtZGgh5ph z?cG{ubKQ}PtWhk+)^d}a@;(3M9IPNgi~<+Wc9`q2j!sNx2Fx#04Y(i*8QBd=mU11g zV>O(YG=KJevI2mFOAQh`S<@k%%jNFu1jQo<|1u83nAqirb825{-e-nvLXJKqsMBG9 zH4Gs1Y@WGa;+l|Wm#UMwsyM|}psR==e|;^4BC3Qi!HaXJ2v6aZqh-)suK`$8K&3lU zM+kn-s8v3P&*+X?GW>NN6^M2N$H%(|A(pKwm(o0@VrGd%QW44eaEUIPD5N#ntRo&L z)7f&aF}Llz165`KSuLBPO0f{xC9gScPNR=dg97rjScFCQ-bLMt>#^R8G`ybklm)A= z><`4uU82s=Y&ADLNe$0{PkgUtfa--e1?R1a)XAL~&I2Xhl}5P%xJxYWbK=0>Om#JK zQ_Doq))L-@&a%07+N4~Kg0TCbzZhD;DCUeH*Uq)Tv@7v2x~`6e&67D-{^pg7$n-d&hSEO8x>nPLunFnKTH0{+GOG|tikx<}h=lD>S=6SvAJ zm-fX@0wx4kA|!_1je++_J3JJa$R3{(EP3=?!DKAnI8L`KEw2<3n>$q}CGScW>!F9% z&ed0H=*JqUV34+rvHhObf`@GN_w`6sN2;I}AE9VCdidGX>9Wavhjq7XI7P)N zQ!5A~rfP?45zjZRcsJiNh;l#3@xF08!+)W%27u&Eyi;|>c)N(kA~@Nmf~vAf>geqJ zN$h-!G7^2wq0LO^5up|iGsSw`Jm!9T*R%1p$F8>xgcrr?)`9WRcyi_6gWT5dV8RV% z1u(>9Ctl)Ht`2X$GJc|z?WOsH$sv0PnBY0L8zr69Agc*GQI zsM`0EhB~9FU$5;vmoMg8jnQB1SbH`a?Y(bZi!Tj=J3Dqwa|Z0IF`9Splvu9ugY$xW zD6%E^R($Gs+In@JYrZK7BY%+$#efShsZABAa>=8UoTVDGKp$AAMADmRTK@8L#~ZfE z>OBRC#QizYw|=Y*W$dReZY%PV1o(V4H}_#_X?+GJ3&3i= zc1`eMct-(07PD8Be5I>$7irHq5@%Ao`Yi0Pd*e@WR-}X6jY|G~V;`PAg*mU3Mg&$4 zh1;9vp5Beuyovbr;{1-F>+rWu@1ape@aqJ5I@5R4U8MnHSx zmr#1=ZyvOtV^j;J!pLQ}{Cg6tOq;pk(L3_cOvK}D+W$lspN@j5Oo#BMCfjE7MthQc z%QDFZPU%d}i^lz~_?*Jk(WwLJNX=9Eg(0JGmc>Gi#R8#f>zsQ&TQ=d}jhC zxix}YYxYtU<(KfYz^?oOYV`aQqhn*XX)c>N^||+g;dlY;mn;_%vF18%D1)a}=H4Se z?Q_A0FuhCgRRqwM32-oCWx6s*4szjQupsyENW z4`<&pbaNRt!wLG7yjDrO8Ixo8JTqex)MZxGA`APdrAn}@0d`XX*l?Xx zVUD1D>a=_qWz4|!%`nwg((Ty)tEGb(d8!p-n+tSZyBgcOvBmV!>}oX5ZqK)mOXF_5 zuDjdzD+i-nxBXg*Otv3+PX=tQsZtn}B4I4yPJ3XG$#s`?kKwYes*Re9uQ?RLoS<;} zj@hyFPGT{n#Q$n9;6wC`W0IpyS@n6PYONyRQX^hu8XV9N+;T>?wQPG|mumQNgbQlcHFVe|87{eqI^+t!%;{ zEODEgvf*oURVNNi{T(A5qF2exXJ)$}`m*PS^3c&M5qAN4!NaQIk2fuNesf(3Wl9dF ze>E^$BdF+R1VF+BjYBVBD56;r%@bK#!{kY&w~A}t!3&^m6jM%bUYy-GZzR=hc~8HI z>x|u)bM=r$Yldn_`nVpppEd$N#u?fh# z`tqtA8@Wvn>fZ7{GKr0nCM1%4^g(}}bJN)DRpwUV=jw37_2a?Ec51Q{^&F|e zO%U`VxuIsDq57F@V3T!aoA|yp9|ZKik^ikmbtEiAi9O?Zm<0 z!P-D|{?Gi*JXMuzVSz39{ycKQ`{)rk&(eREc&C1N(bh!azejK(b|C=~za#ZZuZC}V zdgIzyFXd+(axn_TvbS2SY3j~0Kd41$nb*J;<`$2FLPvTTD)ZEEe@GvW8=3HAmx^j4 z>#!sgghJ_aPo5QMDM!zWVSEgkX-#=UxRv?@SoqWOC8bcl9fVF^p5SX`(Psp_3#7;o zh#3p_uDXpZD#RHq=snx2hAf4Vb3e?*VMm4UseeCuefOaDlpr5-yIN;YiXN{RZY1ng z*ym~T3_5(yQ5Mr~$H(Dd^0fn22te6=Zh2zyWh>Ct!BHleSet7-4H7D(railaV$%&K zutJn6#I=QwEHW?HHH+-2?~v#9U9K5I@t4G;;1zTWd!ie_=r{QYO8+&deWQ8Ag+Y_l zfTYI_*2ehi4K&CKUq?1OG$um|T&5h9_CVUw!jc-p{W5Jh0^D58i4-bIZJOi%! zVp*)6PU@N0TB^E3GmjBExa;AN5M45-F()F?d*C~Tq-}j=J00?>Ya?{#sw`hba8NmE z!2{lw`n9gQs9LJ3*7)2~X&vb*^j(L>1U3$TQL9#tC5v>dCse5_O^b{q-QuaD?*G`IQ3^OL}GGZeVioi&3 zQvLLAQ>X}Ii+4eS==HqY+LiOn2jVZWKcvaS?_TFHb?&`Qqt(3e)?ei|ufmUI2}X6u zmUoP{50glTVb1lZv3Tx3YCOz%1~+EZGZ+PfLRpUG7BC1`lAEz;7+S4)I?MUTLrc5X zD3e}cnwi#DKSr#$)kceVZz|ciq1MdAtSRa^pLWw~3YQMuu-EA zQZhVJC@`+r##RXHVC?B_Ecd^8<$NFG`^w;yNyWwZIhq#76!T+WVJ|;l%T>}%JCDJ` z*d7H)3Y9q?K@^_se(9Z9=)BkdYb7SqG~jSY{5D``>_Kdc(oe9YDKcYzV2fEaCZD;p ze4hV~5L19BGEO_2Htq&?3K>(O9MEM7j8O1FcHU+FN$Vr;IcO-c(F5y9+c4lbyFmve z=s(y7KQj46U-nVHz8ZTXJ2TQgiN#0D5w9z0)3eo>3l1X2ABBC~jr|uG!%81dgZ3yD zt+~y$zMKBhX<@-Txsg$KjXy#cqhXTO_K@VJirpDUROK>hWVB1fRfg6G+=>-;?!H+IH z%)Al)pg5AI1{!m?50K5*tNQg3_l^uY;EObEkI?8v^*5e16*1$-P03$?;XdJvra-0<*H`4k`NN@MisXL8Y{-P(BBV@-3eltbRSSwfCRFr z?{tkQgZ7Pw#1EoUy(XCXo;n}MM>BH}B($(m-Xj{&CFW0%$?~#FN0Eaw?1nDQV$Bl! zs3zsE^VGkkp^LDYu<)Z*!|cm&g|hjn)Nvuz7@wBTw-qg#bFmbB6W3D8unWd2FF^UO~HFird8Wr9j> z6~htGT$J{Ah9mS!@Oys<{<*v5A_>824i~1p-TOFnNS5#ijw`n!U|=4{;VkWlTy7Ji z7r1F?{e|ctDOIjzV&Se#YH}~;QZ;2xlz*z!+)?1b9%%7sM#;`m`A~EjLuH0JEw56X z4v(6z)rd)Id5dq&<9#bIURC;>K+F6GQ1A?urQ?vh*%VO?%yC^tx|$yT;aV;IscmK= z``pdNZO-ypL2Ut2Mwa$mfnD)#N}Lg$o$QF{gzs+|6k=|4GVo5nW23aIJjUDS z&>Q45tRn-bV_x0W= zl-dzFanq~lWa`E8QUlc^Eq**jL;EgB1+908stxW&q^g}Z&h<=S0{mW`eLv(&V~eb^ z#W>WNY|DC7@v{@U+*q5p{9U2u1b-F_^$s7bQoIM@KZkgruL=`Au@H%ot|(-)``_UZ z#(_uXp9EJ?BWlUR3|$sd0%h#E;BUVh-vz8@v5iIHbfhxqYg_KCs*h!eDRgKy69f#|3yy|CQF!esm();T zca`li^H7$Rzh0jEom8sL)J;!;+Oh#OPx0~dy;mG^Ik1y2gYNZ-T9D~Lz~)I%GPpVI z7=DgAwEdS*%xdB~Ssp!`-k1U>Z!+}#8hl{FA+axIDkAzjdxeVcHn&0$o`6-7kC=tH zRTM|jftzNrdWSZ3si#Okq;YHA`ow3kUgvwcT7MIiY#sht$1kYwrS>RX5;$EwVWne==odh!5$Qi%TS7N zwXWrflD;q`>=Ln8Ohio~-p=<<6xSkPCMlaJ9y(Um@e~@j%)@xw zdL-?_?=88!;H}N>kqkqVtoH2obd}Z1V);SGf#i!E7wh(NNvr0eWr5+eJKl$V67S1W-TbG>#}U~08bI{C zx9u$Kl7U=?F}R61u)U-KZ^X7&kQD8@3XJRQd2;Fvk_csBF#_y_Y4*$OprXZJkqr~R?W9}RYt{cB5h|MD^FbThcK@L1dr z>51!|lj~&8w>+6Zf5_VdSm5s;Ba;0+ecQI^LJK7kUaE%=0&y z9x<_2`M-gNq9?01jK6p4gtSeeVutOd_mRlKVp?zIlz&|JASJLxUt^tB00qk2x-5oL z=xvlcj@Q9TH`zj^^bANF+V1&+_-6xY2*@_^+M$~R37!wDg=CAy$mP;d90Yzm@q5>p zoVe~^)%8y=(P1nEt{Z&9A$v1*#|NSiYP` zeuEOXCnSb{pYUQC$qGKKT3Sfhs=R)Q6rK_~-QQ#K^KU z+%DN=zMc3#C)}}-zo$5-ui<*&Wc;4aUWQ{%*!)!`n0keH=Am;`JNJIV&B!_yiCMA@ z&ra$KQGyg5l6QXxa{@au2uKI9_DFBSpY^p}91xuQK%v^uGDUq?bdpXw%CI44h$KF{;`5NvGE&=S+7Z&tMTU3GVj9HV(YMhUAf{7VDGtTc+`@H=4Uo}4+aQ9MGNZrUuM?F^kj|bC;($OBQfg9p9A|GMr_1dfGa=Qn0!^o zcjTUeFoQYK|6>eINtF~@_57%>->T=V*X#a(wxsmYp}3~VLB(Tw)#vx8m5udxpL&GO zv4XUe*|Smp9r_l$jux%;u&u^;f%;Dpj;L76Iz_#7V>b0m-WJL4Z`atR1M{~+>YPU< z-#)qDYZjL@fVF+eId2M0;;^++@aB=!4HnqWY(FhMGsI`Em^1zBh=xaQm?mT>971za zVV_Y85Cl&zE>B(lUQBQOJv;CZqOV~EIgn&$W$}q)I-iFLZC+iysnY~{VYzk5LH?@1Tu(4h|oQx7TUwm+pLvnfg(P;Gq6eAa;fOgZPkL>k_U08ptN{H(b3&ZCXp}znyX0g?sQX6!&Q^F%B zxT9_BGToURdVq)!WyP}$XEtFR(ONKocrmO<|H=KXCyVvX1!MYA*jC!~S@g!r(gQ`8 zLfP?0eWHA;-SJvZkGgQ>If!qTeko+KWpEnrteM4f{DTWZKfd`22X8#v?Kj}^R#6~M zK6)CqI12DG;%-3r?7`ka_qJ**( zGx?ZL_)~R7d>*dWpp+}hz?bUr<3DL#q>bZVCzNn+g}t11Y;ZO1P57iUAGzbh+1yQA zyzMS)9P4FzYM&O#c!>tL6)*X|MPQzQ8+Y^mJMm1u(?uUH;3sgH!-f`2uk;(KJGaY{ z2Ez}wbEb5soan=?1V*{@*2Vwl$XSvqd$7Dt8K%pvDQ(nt%aBKqHxvBA3w2>7{SD-Z z$hHuqIbaG3M**wQGlA%B8&Nlr)m?vo^>743lC^Z9=^_5jj8q`;yrflE2%?0@wh>Cq z{e_sZIBU6*VuQ}qFNnSH0!>!}nv9V&VQGU z!~EUvqZ~cD;+ZV0reC!WW^r?9b38%C9Seuk+oiuYfWI@b4%2)7>3cP`c(;kGXKY#iR+ zy7z2^qABJ@ew!md$^VXAP$qpWrcDR4Jgjc}(Ms1j_AzTny3)ep)r|Q0ZS~>f7S`Av z_YGUHrW8B$V#TX?HkBspqk|je)vk!*;L^l@^1}5Y#=<{p_O2c<+w#|naiCH3A-Zk zK+PzF01ENme>qfVlYt+PU$Xada|>l2=fhawyMIL)9S}+*Q0JztV(I%QQQiD=J+xMC z2hr)zYof7kr%8??hDC^0SBZrk2<1QPuCFF_mz(yv}PTtRf4qO8?_pD>g#3v!Mq0>eorAt~XXCM?~ltzpT2~@LNRrg#Ctv zOIJr>6E)%%(L8P9!8PA0I1G&)Vl7n>OihCqD~6UWE^=q!$?Kxe^_VQ8@IT6>Z%PqK z7)jLL#Y?xdU!Pmkg&+IUw*3`r#^TYuB~2o{BubQC945Q^-M>1%f;mD!4p4E*8^&A} z%rrEBmYBj2W!W%Wp}4*C*bgN?;F~s$lv;{SMPjp4z|Xm=O{e?O+uh)x{tgS_WPjfO z>jem=sxoIb#-JzTD>8(;E1K8#D>Ic5-eDwTf)G@!Bxa3i9Jk;@(-u z2{5TNPOS6DCqc8O^7f51{8?bxaz3l3hy$)h(qk+b)-=NkGR)`z2h~i{*U#y0%#WSQ4v(+9c1Mgdyqg;KCPHFbaGHj*_P>gY&Sjroc-dr z-_p-wF`}jTC?G)g$%rhH-kWxgSjn&9rfgY2+0ir-e+zaqlqqi7+QZFlj*rz5E{qmU z8g7A4$Y#tE-!V@lqO>< zv9xwW^2wAc9xm*ptWop;uDEfxvIY@=i%l1a~)>rw`YJwGsDQ%HD@9#r{zXkc%wAmORS#`X+)EFNMNs7K%Vp z5~5ARmfabrooMQV2!Wbn0 zFYwlo7@#N-S{26_0OB^3Ej0x%^EU`eEx8d7H=&hwNI^XuEEx8sIkoLb_vHukt^^3N zynGjNfxicJ=WTatJ;GxxXtsl%U*Ai}fu!hb2?^{8=x-R!+y^@QYY9eE@d|l)Ka;UP z$^i*#vli6*bwk>ztZ6249aLpO{rvm3@sYMb*&lgY=2Zx6+3A0VO&W(oA?LW!uZCyt zk$RJCRD0Ux?oE%BA_>3rs6B}M3XjRE?&HSL$C7!NV|`3rTAqmF>-4yO3eYF0}y??55D}7?Ek8uKm_v^RpOcRZ)9Icj&VmG+?KYYEDC6J-IQ1RTs*t? zIqUtb1#QKc@i|LG?Hx0yBRTi?kJ8z&$YH>h)$MkJGtf&h@^1p&153C(cRH0r>A?hn z(riHtRngVeC7!7=uKPb59$_Q^C}4XqRG_A*<|#MBl)dLTjxha9!K@<9Pyn|sQ;?qA zDxb5=mPS?}rSM2%L4zxs+GZW*0mVV%Pp4F2>t0j9W0fRNm0L2^8-8#B1&mmFu^_U_ z#ofjg_|3TAIEpqBpCoBv8&ns=Ij4Vy`A<$r6vby&gep@Y5HaiFOe5mUS)Ov`qUaR+ zyKDi0N)`Y5l3mvG`TzT6kRMY~FufTFx^%Ym&0n~)=+16vbLYvRXntH`y3QZP!m&FtvvhMg}uI@>#*RM#hRDdt$YIuXP@KRw6m96-%lrw>JzC4GNFX! zrJzd2TG=p)Mln$#Q$z)H=0~NLM6ki=41yWC@t;*Y4aT&5CX>i8AoTHp-EAgjZV@&g z!Eul;@t8CA3wE}Vf){Hl3>>O8g2gu=IA{x6tBQm=`w0YrNfdOd7&Ht_t?5!izSb(_ z3TQ0CXSGXqu{1ufd10v}c!9uo4==AbuB%wmHY%Hj3c}@OD(4UJc>ywktmXab2+{BG zU-8ee`=)=(xmq-e5z2Y8WX?Bhzv9bD%2X&6>FBj{LA~wJbso)6EvKUFCynDcKxm<1E zac5ltBFoJ;{5a|iNJQ^paBM@DyGT0q_1y5y+b#Bq0{yXPt>-ws80mJ`TkHk-J(peUn3Ma6|j8vt3tYC2{B26OBN?IY|+ zc|J>aQ?z1I$NE@?NweXSeK^GzyZ046M|}_!>;OWN-A%<5n4HyGl38v#GSAsOHK}{<8jeh7dVXmFYVD{?Uv5ht;G#=F zivWaZ5~pY)bSnZ+3Z36dniz@wi3_1lSn`eUy!I(9d}uwl(p!%)pPpQ1}#r;O3#kj#A>_ zQZ=b6CbpNq`f(cyDWtBiB>nTbs$Ug$BRpPPN6cZcx(&M~7LD0l%x!V?u?aBC#~?#C8?lVk$h} zU8FYxLEDG+g?eihKUOR3OsD1h9<9E5-&Sk@qI7N+QlfJt9xL-~TJ~*^J0F`3Qzxtv zo>j?#mO5P2Mfc_19iN8vSo|2#&yJDEw(ovj3n+Y0W0zt37)Wx=w<>jy6lyLFoaf@z zA^n4*$cxkbt7i;@-M*`+bPn9P#IB!_S9mdfrabeb0Vu@H@3S>=Y~`hWqcLcH&1cgB z)sdoRh*_XELxk!~stNyu4TRBRJfT_h1OM!(wtZr_@wBhMHMoP-eSs6*q`tnhT9aNU zi=QMFv{xP54r>xXQd&*=ACYN>&+s0w;i6G;Sb|X~w9u%f7Eth;wLNY53bof;-IhnX z?L6?l_|_6NZB9X8Ua4FMzYp;W_ST{%!ZXXDDC(!aDPK}LsaO!wG776ObF(zJoG!Gt z#!EXSg@6m1qYV#|i(Uk58V*qCxFJPi72f{C+yGs3El|O27AXK?)2PjN-z0NXffi z{FqopE^_LVGsUqZdqFPFh5c)RMjAKpR9Xpi8vZ*V5xefliSAxB4!nD8R&dFYlH9C^ z)YB5$`<#R3FTqGjWyxy%Q0=a~HhUwDM;Tpmt84Jb52V=azMo)pJP%^+`w_@va=)gm z>dUqx$W#5SUarZAqA@YWJ%(e9PmyIAMk1`SN{=!RJsJKg3wy=Nic5x>CNEiv5BX#`38BEa^&MI{BDJVOld7ybumQB_^F zaLCc$6SVtN)f9(ExS|bte|n_Dn@}+1ni1?jFeY){mp4wVR9q(6k;|CSnW0Cb!Q2f-Vt5MN zd+9&j`cDeJTGHFx+_bS@nyrZ0>~L5jc`d)Ns=m{%mhqPji%Aluew7Tbi=`XcJlbcLPJuv-B=8 z2|)2&W>)EKPt$sBT5<@O1x_^uKS4#0*tBkA;I1 zsg)-wV@m&Rp*(vo8E%SlLbvaZ0*_R6l4v>P=ZEtw=g1$1_+A7nO|>qs7bZzi>wv3> zX)Q~bup+tm?3{QyxiAhjviKq#4Fxxaf298ZGr)=?Jk&tzW!O*YOZv;6@QK4jIHGbW zNTP&SBZ3cn;~)LuM7htvt|MURTNscx$B;13V%`!}Y=Gtfmk;XEklwE3VM#G3rd33? zE-Z=E$KlPYq4alnwLj9b(pC{RrHeV^qm`NKwP`u!&C}H4sw|VS5sBlQY0CS*XDnx2 zmDi5TY`A0FxdhB0|z9T=S2 zMl1lNwfsih&*@MHY9{c8&A)JIorI3)VJ|g}7QW zbJVZ5ep#8(nDPsOroy3^5b1|1;=DcD!3ZFM^3N5O-ZL$+&|4%)6-lB?^WswVW_6b1 z)!BF2;dUxe8Jn~d#3yDq-Z{BUicdn8PIG%spzQ>1zUxL7leX!E{AbZNt)4P%iu zOrxd~!;vJ1C{;nOsbT>AE8Sp(k)a`XHDT?wz}Y+r&nHwPochyl>8mfOJ(rC;6g`)6 zkBU$^*N2)$Bxa7F%uAiW==I_H_NEsv5@@j~~q_?_Uk3ZpKWJ2Etb#pzB1|#9^)9jFAOFHTsP~Ann)sUBS+? z?+pehIN%1kv;|F+etbqt*gp88^aX`UP0^??ZJ|&L(q)kMe7l1O)mNM0uVE)&KN?yJ z=}Lf2LO0jl4o$zfvjjB!d%z*@AnQ!b0{3ueV?Y)8)c4jk_@Z}kHt~wmT0@ISiH3Q! zACC~N%P6jQJhE9AJThRj}E(b1mtw?o5zOaaAh;Camw@Lz=$#~QV9+3%$qO!^1B((2aDQV zyoSKE-Rvg?HB=vEnY{jR=~Pq#{e?4V02(*OqpnHt1E=LremJ-Ckt;YZdo3w@m|yhL z`CiJ!#iI93A6T~YN6ebskwXRkg0&A{1v_RwLVSTd1U+P@C0ZFA4ksai zF~9zu4BvFO;Mii&S`?#@_}o5v$jvKSzK<73(1>_8N_7psUE|`HnWMfB5fFSG0{OF) z)qL4#AB7s=Hd66`LmUiNAtJf>X0Us(y$H4y`!~gmjg?X^crVhrlFLw|Zz`*80sriZ z`Rvah9RFejG!X&JMMF$mCK!eA)!!0BL~Uwh2eo|!Qg6{r>b=cGAC-l7u1=7)WHFX1 zvtlUDYqB|aFuH!ws?%)50uTEOd%Y zP=2}J@1BRN=6}Bk&p|X-RdNge`a?Ev+8*V6REG&#!{CPzgk_9-e)gmCQD6T+<>O#9 zYuDY=^LAZr75!C7uyk>^k>7f{@4JPxFA7ROH%{p%ubw!(er&g&U%h&S0GChwEZG0a zO8@&q9K>^!z(RxRy^}9CUkGmK+yIz}TD-u1?9}d%jVq`+OsI#nJ0sS10vALe@{?+< zY&Od;v|@qg^C=DaEa>tFzohqcJ)-w{%ns~-4pJ$<`iC_6@91?A4uhD^u~J`q9JYv= zlznpX@)=Ejl~)S9#qu|{sh2-@e~|fHatjy4oLLQ7 z%=RN$R?;JJ!X{^)(fxbepuN*-(Awz$#<~awd01-jbrupU!WjH-VqHjRr7nh-wfYet za~gz)>JBzkdmMIl+XTP=DM1xk7*U>A{)Re=fB^YFwVeNpmq$yn0PsO%6CQYy)lX7d z`AoC)76sJ6wa+6i3tQRB4?`ef36)|@dm>m-rY0TDyl=}5&kUOjLJ*#C~R&_Oh z9^1z=&YuB6mUQo{|A%t_{l~-;N7~f^&pWR>58`@n3^~E@`3L#WrsppCW3!2U_hTDO zK6%I~y*E0%90Ran6qS_WRi_!Cj&A)hUIi+yR5=WL-pe}T=V!Y$M4?x!>aHEcwAA$k zil7$*BmM{Xo~^CT-kyO0i+|L>{|=vZMmSlp2?BYTj@FO;KfnK=-i9iow+Ki4ai5If zG4g(%+Py2<+8s+YqJD2EXAd~9*?X2-mm{fD=im4>x})9Gq23{hf}9%`GtC|R4cPw& zv-O9q49cDO`(|eYoBN*02&fX7vGX9v=SnY?aOM}KP!Zm&i_{9 ze2@342o!n@B@_x=OQyiy}BAR&KHv*7y6n<8H60 zVi6pcy9-ycY}^Hs%e5PE6yDB%dO&=p{AJZDcFg&hhZtf60Iw54+wi!pIS0VmjIy zNm?lgU~Yf#s7bnb7em`!0^#S!WDHfnDvu!Vf0Aw3R+Q3mOrL6__vpx_gB!SM$w!pLG^0hfM4=sWe`<8qR*SQT0VviC+Np^?b-RGr^H)8EQy4C1rtP^4D`C*O8EYVfy;sri>_3j zp|P=JhY-`DdN%!`WjG$k`#~57hOgqblK`nOI;wn<_Ieh_{tYKr{AlB50>a%(s6+1a zz3tjnoX_)kg*U{1cgM!(6qSfc$zjqsp=ry!FH&!6rjj>#~ z=hx7RO+Y|^udkjKL+JkNE4j?mZm_aXDlp);m7cih_YD2M`JO-ebq(S!a^);^4)`p} zR3tUt&S%Rit97ck46T+CcfEnncWnBsTe{RbyULS<*vfH6reNNLePFSfo_eu3%cnyL zUkFaEHj7~*zjI?03X53*tqQoiUWhzSLHhr@<_B<~Hwi)5wfxJSKo6K4Y8TT^Wq~rB z{4h_n8-DCk??9F|m%SJ(B{PC+hV37Z(SQ|k{LM9?PjlKHB#k!4b$m^>LeMy9dg7|C zt27kHx!imFAjmlvG0c%V5;opYCg*+>U@mRi242WSiKM72`auDi8e=Iek%r!KKt;zi z+uRJBc6*W!_-*ug-*`ap@qK12hpp(!RF+k9l)jRzw8A*0C`Oqg^C?X-;Vp#>42IRN zveY7=3gZHL$glx}k}eSMoj$*)0yYWZhP*AgUb1fzI&8E3dQPnbcwh;CxEub$4%<0K zJkXnJ?X==_Im-`m_nX-*{s>%tF~SRLf;X*(%@^61_kwC2b@JGL;KYtu8)`ZmyY=8?qf zN`QZ$EmtT{7DvdzYiS z`q4Qu8#Q~3fEIS&X(}%kh>_hkT1kU~ibQKMafNV-8531gn-rf&u#nOxlGf#r!e@A#dAa&(Vw03r46&rVysC zH@7=c+UgColG0Gr62|6JY)MHKVn6hPdRIU=c;FOjQ9NihrcM39EI+g<#1~L+ zvDpNTG)b>VTwVL^fI8+ado?mdbD*Si&gS|gulO;zg?XgPYJmLk!f<^gvhqC2&kDDl zsdE{q)98YPWiZsGEAu;+VhS1Q5Wyb@kEA8!s86N-*_Khq!;cs+=w*v>2C*%!8>2>J7kAE&J_gN?f7k0>cm4m{}|VKDe3eD%zAEVewqH8*FBMTOb^; zgykYIQCWjQ4f8Igr~hA+hq5INLr}6ockf-ZEPoJ|l#DR7P;?&UpGH-;q*t{&g$mg+ zYx|jz@^9~I9Nd3#Q(eLF3>?akF$~Eh0Ul#|bE}es-#l;zhQPpY%=pz``2) zNcU@-t#+-QXE`ZdYpSQnZL&_f7AI zgH2p`p^ZFHzJ34GGjx)r+O&(O7?;c0&$$BP^phO{lRtZ5cKz-652Sr{glakI@Ajdd zVwBcZsYP1dRji2&oZtGB5eXWQ(9U@iR#b*LGiwHsLMi|I3DmySDN!FP4mHg5epIrv z9inpKMi?$^i?>RorJ{xXEzZ*Jw0@~Bvg2g3u4B@bWq<^3<@)9uL7%?BgXFKARza_n zm3S6+WM0h?e$Z3q?aHuKb@sL0E}tmO>dc9znppsQe59f*&5qsUxffY!X}1JD%Xo>< z;NJh3?;V`^KBq@1v14$@XQzb_L}OR&di3Q#?k(XQ~78p^mBg8`z3XsUkNG8iE;}$; z01z7)1NPZ6-T|JOzKH|qu_`yhqrWzDy+=?n`c^uKWYM$!qG-}5XQtT$>g?~2xLDC& z!#zmN%d2taJv^TK-`vt)s+Fk2VIXl+eVlgK@0QA=dl#T42nQ$IICv&PfSPV`ynMU4 z2nU}S$L9BF*w?)|;MOp3JFrb}QDawIkQO5_>txQi?v&5I4<{Lp;zX94t5`p*0?&}Y zZSr9x{`z=^DPYtVO+7XDpET6sPmIY3Zt4Mz4u14=AC8Iihx_i4Yethq}ZAy{t6Uy zW>6BGfRVj6Bl=j7AoHWF=C-%S4PhJ(264KBy0vc4VEq$b8y>}sVF~x<=H?*s>dyoo z#8?KTK;-0i;tIkZQCH%ctSHi!3&Yt6^cVQvQMP{0vXPm6x+ySWSfS7!Un^bRcCwl7 z$k}h$@viU|7Hsj0aIig=E>)v8h_(9YcYTC|J(}%hG)pA0;3WR} zjLZ#*bXV2F$S(5g9R(9Lf2lzDj0B*o88+jW-?@LENV{(@lC28PKB%2{+=;d6dD2@m zikxC=smQJVrjJF;x=+uQ<{14AF*=CuxbCRVT)lA+7;eWNIW|tRQDqtOK1Lyaz6g|% zsjd03qrsblzqYR2kNsk5q=Td5{8yq0FJ;$K8vgzWCPPh<{54R@IjlJ(Y65N(Ktqm# z7A%c+d3{8YpHo&JvBc!f4F78?Vf^HwPN1JG$^cr!B6I9`u<#m{JNJxX!{nCHxG9{zc3eFPzS_5@uI!A zD?C@(d3+UI6NN7dij1C`W|&avrbN%UG1R2ub(*4m^^dg$(PHp6oy(j6#FJQDu z30~kms!5)(O#eR!h%QR;Ljs7$@U-;LABZ=9$zb~2njbF5#NZ7{^+OI>^E0yGilCVS z2%N$8=m45l%^ygf*r>uXmt- z^AyT3zN^-jf+ZlU_8tkHinuqWI;R@KhNnoG;OJ?U2YnsfmS#CswU>0)u`uCn8jv$A zOhJ3&f z^D?)H8$D|G&cQi~niYTfQ)`$}jr*<7Y(1Utrm5pD1MQc=P$+L;H-n1lLvE&-;MTA7 zStjHx)W&6YaMl3<5gG8`Z3rjv!n(;47IwIT53LoKE70kjx9o``si9Ah=grU)o)&#k zq+1hk*dBCeLC2VyTRTj>iAJ3z%4JIC(FIvenz|Z)j4lpWCHhkV&}NFRX+=^%AP-mE z6grPaZWwy&0+8~WiAdJEL}&v0&Dvw}iJ!g!!?mN1x>D(DD}c%sl+Pqc<~{8_&KK(3 zsD1c=(;Q|8oKGK2qtBK8{2KW4rwmV8t+P2Wgb9CJqL=(7x)6Kz$&~AlP2!Z^O|XlA z5F-O#v8OFlif-85CML`XIwssB z(=hvc};8&T{B~L{rq@KOCf6wFdfPnQVmC9 zEQQDD_LVO6i&rwGHsp-ioZLSdEp1QjBAc{>5y?ca7DBJixT_@^7hN4A2~Y1rmUk0d z9*Z1<&z^cXlH?yIi>8^Z%`}ZZueE1(UC>T4YdCa~Zz)L(z=TCX2Yasm2}X}_cQEU1 zd|=44KI+T`d!mPwFVyqjw3$up>E*dQUg{2=;22eI&hFQLzVRIzdLr(R1_ESfgm5)H ztb=zDUK7=^Ic_P4kd>To9)*rLrnc>ZdsnhqVdL&+3kJaViF2D5zH0JokH|ZI;{S(S za5n;7QG-pfaEEWFE|_)e4d(TaM}GBKHhogR60@yQO!+NHgPW)ovJ{)d?u31^UrVZd?YTkvy~EJqBQH;1rD6YP&d z%eH{|bCcB`9m7-B?U^weMi}$SIq&_O1hS+msG$vd;esE@cvA0h&wdLz;nauU6NBmq zi2s3b=m`=-y}yM_B#^@7QU;f(_42x*%KNkNH)CPl9eDf#qLMsT{qg~dKa?qbC|FI1 z>oHXZ04fZsqCw@l9jO+)G14pwnsssQKNb%vlKqTw&&fXvrvawa4K3MkkcT?vuk*q> zyN>kZbkrCxvUBOTRaqO0y+3W!B?bt{I7dOuwuCsrR1nf>m&Hf^j+>{!c&k~Bh%aFw z#w5n8&nACX|75uWl$Y2Q*hcHEHc%>5Y*e6Z#*EKPeb4Jt_#+}c!dxKr$)?@jxNqtq zGbN(Jx}m@4Bg3DW*P0;uYNHWqJotfp1$rW_je)Mmr=8KC&M+9I3Dd_i4JQmib1i21 z<9B|D?P&CN|6+-M;3b{Qb?R3P92qq(w_+MMZ+xu8hJ+S>r=n>RkJY8%?+nnof||=8KWeyLp4fEfphq>?h8hJwIJX z<88lTfnTO|bGjO6C^k`IU1*6T5!L)09D%=7OS%rX$VYqlzTn;Qnw{DI5?);!kWbhb} z=;^&E7+n$(rE~hF68un#Two@6%XX~XJgY})7_FPHuD@=*j~F{ADzX+0`vZgT`M5a7 z$#OqUT>*63`q`&>5>trZ(d~+KhE{MibXM!!v85ap;rqH^Yr0I`vN~38)F^AqPdIri zejv);M=FIR{6f;16_?sJ>sv@zW2r@d(8#idzx)#q1!!3#0lfC z$WoQ6R2N1>ZauB)YI`7kl4Z`dmFZ*2hfR6>L#Nxp5;28-wnr_Pcghjy)+}o_L-oxx z@ivU7N9QjJ15|&JS(N3T07#k2^qZBkFhovXA!q7UXFLIpqd-O0$8*v`b!yiaT?~BN z8;7llDtcGhB$lYf?KqceH9w|1TCAs@&?qDV`gx!y3@?iCl^fE6FiMqawJndUiDXEx z0b+exTaoCGrItD@?c>%?82^1@?JT(kDsi105-ok_Tsz=Z8*>X!n00LzF!%-pGMrLy zQLrjwFNDiZHOb3f}Tm+vQG8O>Kdq3R(3UC+6EGS};h{ zGp#A8I`g#-3f`}ygM0~*2CODU-%#T1TzNx{$W{D+0I2Oa=m;@9yr#tiKS;LH;kgLfYeTZ@|GnM?$^FIt`9} zdv;3c0>SY&o}Rfy{3t6K4l7}i=+0@&N+zh21sk2=?=h`ffmtz7pt2fv$Cab2uhIRj zhuL@ei&-^B&uKa>#RJslXu?uyje;Pw5`3B_zj70qAhg})D5w7X@tBV^h5n==y^o8G z6ywq(t)g??sBCiR73>Y_b-Qz5@RFBjXPJfs2R{fehV%Rr`*+F3tfK7MH*MUukBQcg z@pPuYMb}^3+YPqkg@I3e+S|JwjU)8j3hr+Dww{?&u?_~~xLx!D_SRyBKpa;%8~Y3?aJwPc~W4j;{Wk@4a4FM4#o4oJjm3wgQ_ z+wk|0!Ff@?yO+Z$9Zn!)K(x9E!uv1oMO%$aS)nAQ}t!C^UjiK&B0OZ;~gU(>2}@FYdca4|nt{?B8wtQKo(zn!%XFf4Km4 z^$x5b<=g0srVv!Fy-$2UU@Z$GW`w2_agamZNH7F5>(f8Coe z&W_Qg_6xkyd!*Ht-nX$bpMkE8xNy6TBFFTQ)(yvRSsW(4fxk&G5U37(gguS;l@U}% z3+d^mB4(UCnlusdNGWpAryncF^PQ7|+&K!tbbe0l+A{H1S{|gE4C`h;J zBow=%I4f)cSa;E*cxH8jCTG`kQ1P}}`1y2;^9kLbiA5?jHj5|8EqiH-C+Q`z5<|?b z1ofF|nFx{`bAEFU9%^#7!*3a2>@02Q^9FU$vr6a+MVVFc5?shg7U5iZ|u{H*%D z5=X&EgX`S1D^T(XFKpDu!V3vr0;TR9rwG+9Ic1u>fKG$>Ph)#Vg>G4pEeg!Ib;pKt zhrt@+o_p~D1@aA?K^3QVY;|*`^6lFLG@=ws7e_s@^4Z4i;xTOV*Y%;<&(X3!lA54x zz5z?wl3d^9M&)_W6#VO*cR!=~aqWaq2mxS9S9xbJ)`zN~VJuyx`-xquueUn?Ul!nj zxHD={%^zjOZw=-xrimiT?U)vvfDZrBp^vcwo;U=^#WyJF?2TfL_FesplY)pMwYMI4 zIRIP=k$~_30cjT+eAg3Gf39WL#NZ_b!6hSmkuTI)K7jtZV=Qq*O@641lfL)CVmc&& zD11p*FfCi&$1us2Y^BPl8O_H>!5-ngP{wzntZ8X$7@JP`8HKuexQ-tF{y0}~i@3da&*^T_Mg@A5t&)o$j9cs5qU zOJQkdDNteB0$k8+-xu4S-&4927a;b+S)isOq6th;bbXCZ8~Ym(jvOBc(lK8hy1qzg zdzK1MnW;|jV=?LSPS0E-7K-3KAgn+x0wjG?9vn@l0eu1i_x#|yYEbyn%8xYp-y@qI zOGgeOfrQ0d2f_*m?m|(Ct z!T5)VFZ;kk6$YZF{K1kqPZclggmstnEY_rRfFT?PE9w_do6!dPbj1(q;t=xo!9jh8 zm0mWPf0F=rmn5{rdvbrYtCfJwU-X|GV@#;K^lEs1^Z$7@DYq@JF0ZGoEi}vppsw*g z2$^k%@6Nb%=g;Iu+5)K~2u(rCa%F!8o&WC6 z+3_Ah6Dv|sB{~Fs-z6XbULBs^nK6b8YWY|f7pDCsq_OCH{i-#+%90^5+aa_OrmEV$ z*eUPA3l{eEqGPAe_Xquy46fn31>nCYK(EszZ%s^c%hZ7|;boz85jYXH58kD8krVSY z`IGlY=veJUhPj||koGYAP2~7(aexTKv@UC#O`)o_*(w zGz+B;oO9|$sE9QGtvc@*B<`NP2Uz5WGQHUmY4sZh0fo1Cq13uvAjiq$+L?=*O~fjW z8|I!f+XdM)s{X9!5{Y4skIa%=;a}=$SOhNddF; zC4*s&A~;oTbMdpgIbWwRbi;rb5=S$hS924JN76g;Ag_-8lr|kbIIFp zkzY<_y6`P9d%rX)+S&CU1TfG;8wR0do zcUJ|d7y=Y?skKeEGHWu#GT8M-vspQ30Sc}kwB^;Au-(|x`}=Bk5NZBhi+JH>@|+P| zxG?LjrH0q@fzV)sPYhP05+B7i(8E7#2A<-AuzS-yX{_!hk_}OI$M$zGoVz~6pbF)yW8~t-?W`uk4%r$X#N^k4 zvob~eZy?d-W#td9oZ7i{>4?~Q3DX6^3*WAfkr56Uxiv39?vG~|Ee+`)cQy<@E_s2l zVYH}yQh4qtepoNL$EJRIpbzIZMf@=X%R34QkKaP=y6a{+e2W&|v{jL&h!}ls%BcCcVcfet@PxW`F3y%(&72FnnNZom zIWc@vcQRk(nL(FHWu!VBJE(T*O^}uLPN>x5Bm1z{nMVulp!7=Uj7%{D=LIz6nc>LM@NFfeiLW$Dq-7`sSU+<1hfZ$58z`B1Ey zpKz@e9|1+foM_vF2e6|(W30V88Ux#JY^39~vEr%GtG^nXS|V%uUe|*SyIiW=$9KX| zGW~f8=s<=RsP(DKAte?`+5*`N_Jtr-XksRC65b@o2Ssbt4 z9(nh!pP(rtP*AcFaE__$l<9z$f=qS${jDfDMNhfn>i6c|TaFHTor9$Ao`uDnT{nhNRhR*DC7#NHaC8cQz3iU?+%pooR;6y-d= zI=M{c->A-l8x)cI7{(#j#2yJ3Uiatg(u04Gd0yl`(gl zGSn|T_z~d~eG@q93SZw*UV}CWmJ(7;1_f5C8>J!9?w_Os5nsYcDLpz?A|P(*i6Z9E z7pz)r=H4RBQ_=5$obxKk#+%an8X08Ur$4A`a|$tyNWfBQUc z9i`>yHw2l=gu%@Tx#568jK@Kn@LqxF!EknTtwjAmV^HF(!W#hdWg|-)%hCAbkyu$aRuHYfcJenA3TOS5l{Ku<2M@sd z(zq*18n`xea}5758IT-SKR;CWC4I8RLoUZg&Gk@xLm5m-6csfKU#C1dJMl{9*0FKr zWzZ?{b=%r)Jua~O1mPM?rl!@;*p7+KA=HZ*UORUr~1CJm;l@x@|V2JB%Q+fB0tVJ0f-Yjz+u)OEN?B z9VaE{bg}D_=OF+IKu|B)E|k)B%u+EHyz-W&YaOpa8<`O14(v*(szXoxcMDAIlEcXA z=elQB9v28TO+)JWZS=3!h2S3@l#!<*V5#o|#4+C^*_(xQvc4NHZ?YlaOq~c}iTv=$ zb`3jXP94*p8WRI(MNUl7#c;PcpmH(nvJOE_qI%a0=P>WWTK{Ar`U*H?(k+Ty+6zcR`}E7pkL_Yo$SsAd#| z&!-$;rmC@Ui>V(K#B>+OSQWz~gKPI|P+&>kOqL$5i5iC1_bkw)Zp$%I{oD?~;h)e5 z5H1er=|Uk*&6&gBKMt3OAn*)+h%(jq$t3i7sGtoY5|6j|yqAmLYo_#Iinvn#_|q`< zw3v|Eivk2^@Gw~MO&9_V;(oqjxcX{=n^^AP-}r+PT5qOusg0E}elS|tB-F)7ay!s_ z3aJ2)6f{jB9HLgS+Ud!!!EeNTWQdYav=tKI&hWu^>HDUY5rONYyXdvqHA3fwuH{K*iu{d8RGCNx z)$GT3yx8{zi5Kka$6L?JJll`QrzG_XkTm)EU;@urqAH4uHD96f&2>ELEu~uawa_`<@N(Q12PsNKUcdTD}bS z$pvt!Ls0c4A)~gGUT^h?hXALEu7$wB6&D68A*uhslLshn9Y6xqu9yZW)*O!Q%%HFP^%3-|~hm6s)4(@KEHetId zlFlYgPAIco<#findo97!ihlojR`pt?TP;s}g^iJANJTOXGz92(S}~ij`bjlth7aC2 z+xgShA#)mwTF_}K-I1#@JaaWR>}?UWU&)RT7t;2l%fnm*ToA{m6u)rXTJM?T+VyIV z5460aT^7jZP{>(&N>3x~l%TgTRjpMQ;OPCxO^Xp4R`9fYz4d83v62mq9+A$Oc<$t3 z#nZVjBE`eb%R-qGIQ*3dK@grLEHeXjiA&)f3VGr;dBZaFOsm8m(RaSIdTQ@l8j){J zvnwY36rT|O-u_}7_Y)9EO;#zE6YAMh8MEV>3BN1;Lyn$&R_aK`Ao!Z!Ra&0ZpEB-XM+la;Oxwq%)>rKhd^T5XpT; z^$MocC1-a`%OxYRi-;U?SbE6@9?$+zNNq_nV(fC|JtraX=U#rpSOo#IZ@w2CPUSxr z^00Z~T$i+Q&)xv}_>I!rEZL4Iqu0A54wqozKLG*g%t*6~wT0=z5n^i_5Az`B3k)6bBE2Lab#{1np`f=iZijU4s>>Q_VxzT-2h&$-{l45#$zEO zmDjdi!6kGJu+-Rl-Q@Q@B>1;)wZAU28@l8)twAZl0N+zOG0c&-!g99(Am&DsSD_Dged>fwl1`=HhjV;6NMtu%0|Oys9l(9-&5lkiB3; zczo}HipOljWcj)ql^ko^Y^eSBEJqiG_@!6X7Luqd)In2;jf?vFxIwT2MQUvrM9{ZA z@WoVw&_ZeSlx?FwdBdos;7;gAJWHVml2*FtP@Z@hy@tkQU8YlAb@kClnrieck}%z$ z5J(1gBQ!hae|d!8S>5C`*wSaKtNIBtxiSXn8Ytcye#?q+HUX`lkqy{V_SZlyEn_HD zv?Rp1qCT_KfwVw$y`xi<|7R+qwfAyVou68K=7Kq)l8-BEn$hAFE(78O-(o zasOtc&?bb2I0bp-qSA6-u)ou3_sT_9f8NP+9Xhp5ArGn~eAZgG1k0!5ukiFk`=ZYFIMTy4@qL|$GX|CiSS596rpqchXMXPCWpZa$E{(*o z4tGWNYTOvG(%tFkf2GwvJ&Y4LH`_K9_9N-%NGi~0GD`3{!u9SoDS^W&ZpGCQRd?1) z`S|%bY7t&;{XQ#uAOfwhJ%P@L$^FzGtf%PZj9!cPR>33{Dq3t$VA0@7aCBZ40e{QZdx zy&gY!`>5{g`qk7n1i9eM&VJkL^@coFnybbh@(dWj-O>0B2x%XCiX98p(~ND4{EE`q z^`j6TO`-i8ImYd769Xd5eO>5Xu9x3Xt$v26U!QJ0s7&MHqNa3>0LHB`BulC&^>AEZ z=}PR|^8yyH^<`#uGxM{y?flJhsygYJ;X~wKS%&~0ZWSi&Xr%~kf*1)X-Jx(JvMNfiBud-4 z;t8sEmOK3)qSM@C0k@rsDQ8z4kF(r6BD$okK65;n8u8^KdlV3Nf7D)UkiY#GBsr3wGpa13 z)YL$9JQjT>O9_qb6%*#Y_zKC+~4!KwNayNq&0BV)1KmqHYs}!;lvm}t8otW z7T$_JP9sQIA$3L*D;!xyhm|g~8v&i^zWeoANQOfCFn|W;xbTrFn@M-rXYh!PJ0VR3 z{qllqtMGbp6i0<;PXg$y*G&7+%i-R8oaG9-ZHy*4ahzK>NN3B;J0{5fH}wmB7L-&-=hP?S|w#H3<#p+=YUFO(qdWsUT~VYEx-B2%j$Z}KW{ zPvQ8m-<33OWl{e49j1688#@h0V7M@rV3(T>NBsWX%qUBPUY|qwhk1QsBZC;59+FT~ zpN{{>)>}rk-F4mG1%kU@CsUQoF|g9NsFHG#b)|@qa%jy3Z**))3*lz1v0Rlj zR!W^28Rdbv911`OJc!sfM70+Nr@Sig&3VqGS>qGifB!Fh@CzWW35KyMQ%nzu?VF1U zDs^-j)atGC7c<_kOy~(%4sf6)4s_`7J5zRS)zpXzNX}l#Lh6)&Tuk75>pu6`p@*A- zOL&eO-ca%5*5&Ky@e+IYdrvmK%hF^^>oO1fhHER8SD9tvxw`Ew1s0!H-NHq%}G)GW`easWTwBtfz@87i#xQ^cOqb}l&L7^I%P^b4}3-08I z4_TVkG0cI)4=jrm2)PrthNhY zU2@%-T=g={ij|j}nk0vvRCokKG_V)y27mx8-UGZc=n4V1cr zA!2d7UwgCf`4HJR>@Ib#Bl7+S3Y4i5)oCENT={Qo?_0MM2bCj}qu^-eB}(Bf$5A+s z6Y9hAvTYY7>Q4$|!u!yi$gMa!@EICc)_5T61feneL%YarjOwP8+8!3(_m0&o&30Mx znCrEYgBgs)#tfwYA}x_W{f}CKMF@nI9f1#DRaqlAWHqB7R{XmU`}#B=6aZ*IUXG31 znq3Rg{Lo(Ud**!sFXlD*U^1z zUBF!S4?A5LBbap$i^kFpb`D0~3Wgfc2WLv{S()%+y>0xFikXLH9j9=R_M2^|NOgK@jcA|hLsUsG7_eBo6> z*(x}_P|0zLSI(LeWmRfHp-c+E5tD&HCU58Nu;~(3_Lg|_w&|+z7e`S{Q1@fysL)6G zP)5zavVg}>$9QIXA#%vOWB4`a3UJdR{6Puugc9NX*e>cxa+PQPj7#tmFi0P_93iTu z6D=>}G-l0BUoVcO!III`G^LZ71b$^Ptjy{W#LqZ|ey~+$v*0kui*ZLrqzsus1N1SQZqf^AJAh)i2mB1I7 zMxk-w_|!whVZODMPc{qAl;V;W-`+24s&`@5C#jga=%)ejEkFYp6P{S0 zyz(P4AIZHLQ%e{(zm*4)>hO)bK#S-owRZYyX3|5Z!o^(a-M^3I&aE)yyIAgZ#1Fc$ z^uI9_o3G45R=49SdCxi+`u=<9Y>)(1C|41O*i}tUMTy;MJM)a26=6rn99>I>gjZoj zW6Ec3og2Y4GT;ZhC2}((o9wdudM&8ny{rj_AEUo)2|BuM`{F74zsnMR|66O9hc ztk1&Wa)n(Zpyp#Ory-$U_!yp+4l_!fl6BKavP<$*3^*8# zEq1G%Zc}#{ykDl3JrUXnnV=K7Bgk}YmNwiOS*er7EoG7SC5!t#@suWFIhY~x<(>Ns9-+W2$x~+ z8+1Y=8{!y5$sJEIXw<>nPxLF%3ivjpVQy0dA;9wW^=@pCsC?8yZXX@K_xk(%20cFU+n->iivt_G^d z!uqLk6sx3T!X9+hiCAbNDwZyte)xQ;(W;%d29MnG3O#FjOnDCh6iU8W#W_j)dpJDG-AJ3*8&z*blhiDQY z`@YwiHg={$TP@{cnh_RC3`)#_`)a=yZgg_aA(jh^K_d&@2%p;2!Mj9L4FMyy@l-mz zLJ6y&>u?(+Z}14jnABMco=*^#{;%>^P_VeysYb)c?EK}dgcV-IiaTcFCkkWfcF$p8 z#Pmh;R*ghL24C1g>!tmoSNhI3ki*U)X=N)p-tgf5+?8T+EyiWyYAaG6cT*Yfcb?9Q zOiL?gN95qhA-F@aEAoT8w;cmI0K5duuV|pcZBh|bA~!@uTs)6p%y~p~h4U@S1RR*k z9MgA?RcSenC@1nc%e}#>3*A?!@f>O@6I&R?Kgt+XfhUbvb+OFl(_t)AUtz*Mu<>of z8K_7)gH*)&*6LY|i-IsB$-3C^L0U&oWVb^Id;=c9N;`Aw7j7PTX22<`SAq?~EF-PO z1jN1g<;$wIx7%09=rVNT?{)vJ?gkF`k`aNGg~}v8X11y;e2iAuKI`11Q_8$PoUSQN(RA`d8OP$CB?kk%bmGm2V`=^IfKOSe!?w(xl|}M zyY;J68WEf zH)48J5fdahF$KCLZ5sm~#`k!<-MoXI(A$o$?04z+u|Fb9J&KYF2%do0RSE34r zfkm^KF$TBQazbsZtGC!`F5>D6lgrRSoJBH6aUP?27Nc^>c`m&Hf!>+EtKohx?&2^vV<@gU~t24FV z+$La|bu``9dwcs0=0fy88-1U3gB7QMOu%>_&suBB&69bD`EQ+h-PYRDdu>nx_bj|l zYjaFh%NXvHG3k`3wrwx%t2yXVh8z0 z4mK`WyQDOoend`28t;GjQHGWfgdagvASpE!RcfPr2f*-%EZJ(K^0pfBh<*aW0>onM z{sXLx$6)671EeB(G#H;r(HH5oPP<5Q;++HDtvOpL`hCoJH46I>a>`a%d<2Tq)YQaK zKK%AB4^`X?aeUiMyTFl`de{YwLO1%JmyO(u)c9k8a%fg8Xsfs)2t(j~JbWuE_+6Bg z6M^p+B6vUZjA?fu+#@qk!(IZ<+BURadyHUgmSDoETLe z6&op+msJkHaO4mZS7C~H8m_8E%V_G(i&-OtnW`k;J>sntQ|~-^tplpNFf;lfVZIs} z@-ReENFt(T7W!sTg0WH_lK;q$&pZ*ohZbwGa6>ye zf{k9JhqjLtgAL7ce%FWv!j$kHg^(l0t5fU!j`PNV8r~XW)S|@GUUa(}bg-{cW*!i& zW>4DZK~mf`kxHJ*@jSe#OZu+t8oxFb_8pPS+|!uUMr5s*lQ2cNED`DNCY7I_pVZg4 zK$~2r-b%awQu_%FT@MWi&INDla}OioV|=lW7~?!bv1{10Kharns-ohsm_LWaVlVT1 zYcuG3V}NopV9_##gIE)TL$(Xis!=-V?ToM6l?yfMYapZuE=Vg|e5J0@O~rwGZqUAp zfrD_y<(W0Z#_wR>RyN)!jF`%h0{@opfxT)_rpP#wJ22+qhuyCoTe9s*y9Mv|6a-= z+qNle+^uVjiM3LiqwLoR8Wro7ReilP@;yR0E%l3GC&uPbTdw;YeK99x0$-eFd~1(o zTaR?RJKLfbT=cn7w0=d=#^>KV#T)+WOQ z`|l#thA>9Y@4aSqq8KjWqXbPF&o8fcr;F<9n`?St`kJQZGea{pgCtOtQjlyf($Cm* z|90>DoqAjro*fk_`wG?&GwkmykFTL?uSoq{^z9!D?=b)&gLL(DPa|Ej%3faEzZj;O z*HIrfKYCoH)~`mpKU-(hcQsA7+)M0br+56a&cBbXyZAql4yrQGz_OfH7#`q%n2u#^ z%WlitanHEEfaB}eaND?yB9A`QDHOJ)ke{e*FHQ=yHg;-pE!rB@Q^+Mz)zl1J_=+qD zQobML*3|*1yC*H8WfUB&g6Ss#p8(%I=Tc2b?#nx1s<{ix_`6l3hoaINt%3jc5qBCK zdr;8QWR+zu;O>{yJUz>)KWABVtV8S+?KP!V6Ez7tK1?3We=w4y1N-bcDqA|%2VZZT zJ!ZzDHS~@~s?b-&ht*xmo71h|ss^2)(3-Ox7e55VO* zPHim45ldL!|fIZA)UFpI;u)KB^rXlX*=}jhu(@CPVHYvca>0PXugoSqLw-h_d#~Qz&vH0x2CjaU)M>7f8=U`C$^ z6+Jri1okFphv5tU8(+deYZU>@P(GPgr$f{}6vc_;qK8f{UUMa~?>V;bX1uB0FawQH;TsfKFtQm70J#~{Ef?D2NnCAHCtrUK zet$c;;qgaQf&U{+xTq4CFf5Fh6Svv@^!zrHHS>!mkDn;!rcLl|mXos6{N1Iaw9SyoKbYbQUXkT-Kt9?eQSXCBnB;cjwT0*%+f+n%b} z6bZt$mUI79)`&e&AMC_P-lL-=g#8ReQe_7%0->96Y|S*p86?c)ap=EJQ(UOjsj-nK zi(d{>MxjGha7G3qK|8r^B^~B91Yb6WvJ`09i;g*W$jyRCpnt_Cw0k`rzV+)4pUBoU zBXu0rN+P@b!MjILy)04vwGp%wT9G-yR!^IUwqJqMG11t}(S`i&@LS*@YN1|#6Juyy zgG}X(myEz5Js4MPjV7rt5L)V|;AYS7VV2jk{K|V?G1TwSnBSoT#iF-=UzTnkT&-^+ zl$%5qZ@^o6a8oehnqK0iuGPIRMWc>&SkM|Cd1C$N+q(YsL}zE>a;v~2k4+M9Kuo|H zn4{bd*0C9Oy4hgrQ^e$5%IVvFf6C|nJS2ZJfab7MJy+GW=Aahzj)}k&-Gad6uw|I~ zJ@GoX&o6Dp$O*@T51NdQJl9Tgqj8e1k_v$|rhAT9rqkPu|8gwk_D}j8p!hOV$0C=a zhvZ=&Uy}dDu|)FG=XpTK#OS>g9_3$#Lw`;xEa+A@CM|7qE>&0PRMD$&efnHHUszMo zY*$%fz%QanBOlXc90%L@L0;QlRrKi0dwg-Ev+)W;)&VoVwVq9CokCN2&?Ex69XQdA z@kf4mEcrQ8*Ueo4=4J^tht3U zMT0GcCy8X{!?umvv`HpK_r$eN`cE@6-`@o&;(yzSrn`R7@Bogl_QC@uF{AFpa9}zO z(XkZ6kPP^J^dBF$Mu}+l$Y@O5LpaV{Q`h!VTep+t=L%-Nw|aL)XH&y+tYn{Ve*tA$ z4(sSQt=eVl;p|iefOK{l~WhZUfScx(TleB`?+kTEbxGQLVY7_5~Hw((N1~%Iyj|{XY2v z&i4r4vP-%;eVR87&A=-dE|*Ix^stLqJC;hzTSt>{W(mzT#Kn|A|@-p)DabFb{LW}%> z3e!(GLX7D;a_-)+X?Wr8eP#&JXeZu~O}O(qs(>u-(T6&y%q^&8Gs%iZSRDDMAAj&r zzC929+jonQnt~`kxNdZ*i+RD@1z^OXNE%2z5pV@Va zNsHa!kO9b*Ft+x{yY>CXnmaj=nZ=$Z-y5BV2=Nme;$R*nww$M+$m zTxpWnF`n6OPu&&t)eK8LrwRcsa3-&_`|unXIW2fCy*?N1c>?b( zs^MYZ{|S<3%95dBj)`9=B8A76F`9|8(AtE}*3u6)a((*qG|nzAkrJW|t<1jqE}FlS z)x<4Td)KE<2_>v&S$t?$gwSY}$gvhx?_y10JnG3+wWyK^51jTAG5WL!|OYD07Jpko>k#*w6oC z31*ktx}~8KWNWa2(Gl)#QuM<5MjInbUEAll%Nvq_DEk34ty(gIjgclM+)eP&=mlwD z4#S86Hj$e@g7^n_v*Y3cKXi(a(V-9gLw!wl`+|+LNR6e4u=Hq?#uNce!*uLg-i^(?N*H-B>&__I5B z+Z$o!*;Zj>xdde}dB-ZTzC~uX1^a|G>;l`(MQaHWQ{S+VtUbKYDf1Eh2akCES_7Lk z{xSTMbnl;+t4xxUUgaO(9;mCTfmTm+W1j|Kq!1G~6SnP5s4}r7PKFybZOpAtO$#(V zO(BpYrA7`^uTr<|k#cKex zE>_IZ?<9(9Dpdp$8I)L!$xKdx5d*~!1yHasr>d@XCt5Z|vuni}`#1nJzQZcOOtbu| z{g#t^tO!qL_hp5QP&ER#X8aZlQa4phDKdW_C3;~t0j=k7Vr<+qDEoBEO*ltWClwG| zNQ!HjT&SBSVC+qzm3tbnCHh$Cl(KDh7X5x2_t75g*xsI$o<40{pQ{j_o!ugFZ1nFD zZgN56ShY-edjHFQcl0(V?ymQ4yMicZSO7y^MBLhG8~;MM>qlafAnmRXPi{!f3X*1= z#Fa59bQen0 zNxGkVW9DPSjoIo$;EyJ^OmO-DPFYw3dvgR`u@YIru`r?!YFO}Q_rA1)G^a4AA0_?h ztMAl9MZ7n(teI656kF%EWGM4PF(+jHr$+Dh9VH5a;mH<5JIEjQs_KT6JSNS4{Nb&z~jd|{^6^ZYACv$C>GHE_NetHM3!jU<*O#pML z&_|>-94&w-spl|6;ld zjN<<1ljKVqVm>AIZ3*QbV9tzANqK(OHhVgN%gbF4cs9&}r7||UK3l~h<9M@V)jwjG zr$z|Gla}ya?Yr?2T6i#7_|_l5gZyjXl+7C6nZ;NLAc zq5AK}$L4a0g?nH0=J5tbi6boqc?g3jH=Gf=hR9>F;Y=4I=BiN?+}tj($YB-PG7%dw zI8l!DT8~wKs#%mxDl3X@^^a}PM|9*|bs+>d9M5xvqpDWC4s7`3{?5i}C-@yu4#SOz z0b(uQ%xxci`ZV5vj;2UP*H->^-t(gAxUY^1Ewx)zFKApn=8E)kY4XrST5~qvhY~>- zv+L;Q#wB0k`XMZ!bMO5gT1izSRai!+nO91v$B+d>hBKSXRM1p85~HrsN6%9v3$%~s z))W3C3$4Sub*Bnbu=kLudB{RJ|Hxo^AV!~`x~|0PEAVW;&E7YFW7}Sc7kdyb*?+G(Rb}w;vK-=1xZl%l)MHYW-d;zvrjw)oIGct+;ihQo;WYLN2=hg~U70nDs z(jWu{%6M*os3f!V*8|>LjFiCk?VzC68onDV85K%6Dac>>53JUXFP)H`Pb^FihX~NK)nei47&( zft+mdPEx%ZqyEuQ(xHEzZ_bOaIt#Xp_%r`A;>beXQ`NFwvgPGU+CsZj)*9^8c41q+HZx;|qZw}!<@ z1r06)U|WLJS}YCt8YPD%lQI7X{{#H6%X$4T$o!UnKV}m0G5mRB?iF=!C|iX+33mr7 zJ6AG!~8cY9viXLG-ThJl+S3Wt8w@^B^WNz2D>n4h zCN*e7&t=& zTn#3=E~kuA;VM#*Nl9U;H{IP29xOY!HjQ!vb-v0Y#vO95dGg7>#Ii;)DNs2^OjMN+ zOBB$m44TySrIT<*Z%U`J+)SN*5BV;Z&UX`~K2M8J#ZzzWRrZ(ulL=xA^}xelM+b^+ zF{t03DZUYNM%gh-G?mv5G6c7-#Vum(-j=1Xt2zubgH#vq{)rYS0qhn3DJUbnTB1NB z>E-3jQkoDjb9rY-aSxn3{7MoRmK&H;-zO`VSLAf|+t_)0&MHgPlcGBVQJzK3MOo;% zVe<4%g~vPWJdFO#nIaRXQ?ScvDt^5>`*%oCVmQkhCu)r4s=YIDmWl*cr<7gkk+|a{ zy?XCEBqy4Py>rl`wgQ$mX1^f!6%B*Zk_KKL_>+#!7L)<;FGcd$f31eo07T%xA%(Ff znl=~9>r4+IGw@Wlgj>CsXp)EP_67HT+X%{J|MijE6F=A{`yR^+?)%<-QFmixs3Q@{ z!wV})*F%BGN^@>@YX6H48&n<72&s%!1lah{n1K8jvoYVmu_I&Ne8*h5Y1_kaGA0N_ z3sjj;pKK7?^tsdg;*u%6kdUeZ$v{$>0QTgCsruhG9e*$4VGBS=ynlWfPycSj->?G% zEk#>xAQBx=N`~Gi%rwfrL;^cs$o~yVGG;%oL*gcY541p_6hciP=BWz85S;rbZnFH+ z+q3rvJt%3K_TTi@VZ6^Ih*+yDF&;+mptvb2W(GEgFuEfeB?D1SJl%adD0ykCwa zs^-?UY1sMY4vWG%p98hNH}Ji(NK9D;nu&A7^s0Nq>N$6|d{+YT*c3E8f2ar4{!U7u zBgq_p%9LHCufoUL+Fj0A(VQh!a{so9<%Q?(?ksPjb_M|(eXyT->ov-U?CC3(-@5D{ zWEP>ur38ZuM1uy~n z!UoXfVBUO=&p%#wT|f2~)16?&Fwv4JO0fLv&qCfh!~&^U9Xnp6UTu#b=XRqb27UC* z6D%PdaNZE=yj`aGlwUsyxP}^>6hXkCpwAZ9m#uD71M=NFV;4tLP$ymy?S?X&V~UgJj^vZ?07IHPzL@_ZXc`QzkJ& zX`SfzY9p|qub{@%75fScRVVFPS^zD!pcA$czt_Y?VI>!$&jUXh5+JUVaE?K^lXg=e zKBZryJ2G|Wy5K)%(#N|N=m#a@ zw#vQnTorJnBHi~iiAsZtHI;|7Y^yH2 zpy6Y9yN)Lr7A$8h`Z4y*3@fJejxNMj51JlMMizvYv65IVv-QO@U$`}ZWojw+UU>jH zjY(8COqO|7`U(l-L@m1+L@serSf}zPk~nT9;r!t(TLYWY)^-r(Q$MP(;#Ih z5E@;0{ph)Q2!)U_tzby}?{&gQ0Rry6H5ep5thv;%88@UPET%f`XMnK;s!(P7$Xh4r zE?Vm+j1mdcE>%;Y>B{!DtEqL-{nmiLYPZ$AEVxspEgl`tqT)+N1R&&Scg(9fwRdnZW*v5dJ}={p{wpO5 zdgNad+tLyx@_Th14Q%zUJwdmjiQa##vii1z`0ko;poN`Ei*v!P+JjGD(}chn*7M5C zEkhl5O?az}T2*46wCWT0B=j)p@2amkj&R1cH6kG8iG|TmeK`w|$-*_MZgxVAwHW8S zy^d`{Un!EdAYO?9L{c*u#Zu8oH|kX*(c*`MH>8%(56%Hdh~^Wv3S&#>tbp<|ic+lq z?xM#o=z&F_aBY6v)3b=|wmb25n>pfKDx$=JI{ChTD_be)UgB9r4XMlZ=p%q< zxa=&~o-4zs$k2)4uiK=205%9N)Rt3*Q07(R5c*5~4hYcFtg>hA-S3nZL3XI1Z_ZY- zt2AB-scl(+N2^?F-I9mc6XX|$$t(od4UEyzu+>qWgVC0fQlz|p9UKYoW++T4U?c|< zDbK=xPWphmG{4u?!{Mcqf$=J0M? zE&sQffVf4Gn!vEgAc;(6|yFH3m_wu*9!(Fr0 zd3S}oJSr50t;H0|XQp2LocBndwjO`&`9y7<|Ga$r5Ynx3DgG0oW}K1@{L}GvwY;ZZ z_0q)_Wi|IU$Dj7&w|!{eGl`%ET<|!%zIo(0{%z!1FrIfge{oFk9~X|@@{Xsjs^<0$ zwt|cw(B5CSJmX3oN_TlSP^j=r{-78Gjk4a3yyh}FroxMjBxL*3)7|NpUjgH~10VZ~ zrK%nRvHn}^=J-_gDm$-eO6)R%a(01fV44JOvaFz1PCm>b=MhGiZ#ljNHqHKh4=ktW z_in2GKj&Gvf4b{ly1VI*JGp*0?9*wN&l=55V5+KCJUfrn&ksT_v9g`}Qml={FQLQ+ zP*myHPVQ3x`ec!jxp0v(usKuN-A!;$8)VzasSvg$<{V54d0M;-{oS-X1qYW+}+DC$$NtG5f(7F3G9ARbmvD@FB-OH=B6`*;=bqUaVgOi z;1ay(bb-mbyY~K`rWfC#n0TsAaH}nX)h769uK<Wan_IW$Tfw zcio6h7PDVw?9diUYByKc1-ZH6MJQ>KG}-BJsT9Gq_I&PVWC3~2C$)+2H3Mp0L?@bZ z+#RfXA*#qUX{qYOG&TtRX0Awu=U`laY|2Z@{4I`;@eq|LtK(3p$6Sm5?ROW|__YVK z^0;)+h~h-ngv9hdbn75YoBI@K1CF@}%HL&kaZqZj!;^VJvZed;JwvF(9Md8H?m zHROY)8{<|J9(GDNq;Ru=U~nkCe{C#Udq5!<@`wdFEZj|)?3D}>+w-U&(Uhf8iz-C2Sz4qBr4YrSYIEskQruMi1cm3zdf?;Dj;-W~%M!Lur(qW>$@ zQsE-8PkA0S6-u5$vuq^iM_&|_nO|=_`?W`HD}3wb(87BjD| zS6prio;c?Y;{@*DL$V;MAW`BDcR_hU8Z=IPfIf5Pj@)PNpKG5zg{Fw;vXCfDF=UBS zn6~V?esMn@-(}p95n@sfGW82r~rDqAe>$uBkr=uEuq=!* zuwYWojTkGl)ud}|9y#u3GIdq1CKc&VG$LHQYRseWpoe=;2F&yXX+n+iN%Blm?(P@g z&feb1;AyT>@~}qJ4_Z^LIlA3Gzj+qD3ZQfn)|$XtV8ZPSEn52SiGUQz9Os`G@q1n? z5B+~@*0%+Wj&D5_2*aA`+#Fv`wzLRv$o}mG_&Uj8sr|RQ z$9C-Du9Lk)OyQ2&!`#h@Fqn^B3skZ2hHbMZv9;?&+QvO1^y1C@NsdbPSsY(nM&9hI zXAF)9*0l4kcHq+M3I$n-qO-sP={^0nXCi<2m4Y?1HKHOI;Wxs7`;|OB-iP?0=n-Mq z$iY-$GY8p6HOz;kE5c9}QAxV3uuX9nZ4Lu438L=u0Sh<+KA-_d#Qe*Bc8}{+zC{W_^C6G2vN36xn7>BNYn>l^Dw zId-FPTxFi;c8mJ`I^1$hX%V%9pnRXCJ_eeQhM8yjZ~7)M%}U#FlsJ<72n~f~WX$lz z<<>;%Trvy@o#Z=s?N}9XRLD3O8OBFUlJ*;~kSxyS&j1+UVE?R^ zCJx`Wxz%APY6HD1?e?CGc_BoJ=LCwxYr{ z(mkqO8P9L=k$t#O7C-d~lNOcxQLMJ-p(y$f4`cbr33Iuak}nS5kO#j&aupt3RIeur zZ*!N3h2YC?U2ss79 zeuk@H+gH;S8bP*=2Auldf0QbH?4(NlTb_!iyMQj{@9m9@6!8$>DQ-TM3EhS;R0|g=Hr`%QtB88fAsQ++Vggl#Ev8D0@t>Xz zGfO@$FMFCO*$?Nc;8N|5dDd@(&faag+eBp3!BE1~bliRRXCnrsYgQ zF82a4rH)gFr-L#c8x#_Mog*SXIv44E%8iI&1<3c(bqjkZ@%0Jg3nziVp;|6fzp1UQ za$pt}AYLS~iwo=_<`D8DNFUIAY2tP&fluCTK5e!Wg^X*8TZohgi;$Fay(EHzgMv6y zjxt4Lne0}O58=N04n731+2T8O>y4>NA`8leK3Hvvn5J5%A|I3k8CqLv`$o4`ahe(1 z+6ZAGy~=)-T{5#l*sQ*VCg}aXK^%&By}mmOEz1J7RSH>bJ6%IP{^yg*@504nUQiRf z9Q!!PtqJC$7Q4DJ6D}s0hDG*uo*QXr!8fZbgd^oHAgV)(%*lLQw* zeC4|x4X)jirpEvQ=t&m((fMVG2i00DPKhpVjS9osO57Z6J9J%96L?tL;4Y$X(azwd z`j*>k4wu5bn6!#e{-P%`L4k+yt&tbQTsD4qj#f3~dRPD}hL1HWIR)dbjHg~%Z|u9Q?xj{oYg_&APA|y=W0Z9lKxyBuhgavSYqDbJb<3@pi!3pNSV*xy(V{AH z$tK?(0g{ASoN|=0Q{m0%6zJJCJfki0D4~VrbxmrFb{(y{cii0fIcz5>3dU$TuWd7_HKx*vUxe| z9Pd|@6aW1%WH?CpE?pS*t|2ltkKKyl(73NYPkNC4O=GG;o3cF56`j4kqQm!io|ar< z^BcQgO*MZGcINA`J)AnrB`Y(R^b7?3-Jc+~7iq0>5-EGsxg@*Oc@3-jD`V47)Fy^H zH=CZqQMHLM=Ln)|7;DJsS`JGH>E=d7!LkYXPhN3j*Y7eLI50BIS&L*YNf1UBaSE_9 zSx|jdGCf#%Ri_rUBE_yV6!LjC>%jU2Wk*E-_j$cHSH9mBnSeTzjCo- zKaSSgn+!*yqrqib#_KagN2;Ci zjwwgisOhPCj-HGR0X@me^5y4(F0{YUv&n4!+Yan&^?-wCbjIfqiSS#mCX7`Ngo`H zH9p|ycJ5wC@vx))d7w5i2Gb!^P@Vb~EeVjq(hHPfRV#+K?xXxp_-F*m9i+PUqd<&K zZvXQtUWpCc7;IgU8C$KC0(~%`M+|-UxEgk}?}?LlBlg(cOy8jdajr~8L9Q-UTk@vH zOU9j?uAHFWtgkm7RDe6lACS=itCNB;9{9O2QMJW$L1u>@Za=?=Uf`Q73-J=+JSxFn zAp`D6@V^f({0>CxjFratN_2T;u=1pm=4{`Kxttp+1qn`D0(0944@U5kn*Dl}r1SQM z{Lab5@cHlYSepz`&ODJF&@it=L}yh!kzY=rp(d+Gv*|c>&geS9_&SuGDJ7n*L&p%ip?Dl>c2mUPM2WH5S1!ZqQ23(?_ zWZ2%T@GzJ6ecNDNH5}eGECnxKxSGmqe({!@bA=pRnCxZfyv1ZG0i9aymRNG zWBYiAH;sjkiZ1a`Wvf#Oo^4OGVTZHp7Qc2>KNHMz%g$&p>)OV~9vh}?B%z_sb%mZ) zp^SlC!DCqe2uofcMfT+clP&$XFtF@6?xRvMT3Lk}9{Uyad*S*sJ{$d49&(jZt-q#R zk~oMpT1KlsEheUI#BVg&5PxVo6x}_oyKaEPoNc+d%0~DbXDorZHgY09K!2T60nE8? zz+fUceg!ctKdyoeGpJ{0&MOI|OQh8J-aXaC-O&3=PFf~(jVtw2;> zPRKdj$mze5KkK>vfB^u5))Vx80(A#Uq3*5AbQ!J8Y1zU1+1<0cIlmV@+l!Sw` z7R4dIR8D5$nj%Qa#^}^Fk1mz#sKmZqhJ&{wP!pVL1b4(?2tu~P=R9^=-ja_U)S57{ zR)0K_$&o1XZLEMdJ6`2$KY-_P3DErbNsQ&TUe|!7oXh&FlT|Q$mJxfHOwjPUNuZm{ zcG?e1!Ek$0sdhc6++1 zQDb1?f$Tq?u5)bKU@W|f-mP4PQe%SX(36{U73ms!6=lNaKPP{pEu%MD?uCqP&M|c5 zg|(Lb7TQYq2Mjr54msszRZzVCYbsTONK(ur%`R-|7lh4yt$f{5xu-beBn|?MB2%e$ z?&My(T6Cvk(om21GlS{hVDeF?!(YfOl)=yDw?62y>uC08=(T?MSRj%JcG<#gxN_hG za^NwHGg?Wou^)>4FMAyt-DdAAQs3A3a@x$~s3ol2bn##yq>q7+?5r#~aWm}GYlg zxy04}!o<|kP77xK1+}<=)QZ!|VtWr69;(O>#QT5Pc1MLgui)>6h^IRYCzDP>O|?nZ z&R_a^aR2fRjQkL9SLG*GYA=@H-46!zQ2V54c^B-Uskc8%ubU0AzVii_=Wk+`9|WPw za1apL+SJq=mcjmdClsWgetK~b6hyzlcwf15V+7KWll|$=w!K!^Y<=!MOO)JwWay`6 zg)n-dX=o|f3QVzvq=(_#E|xn;b^iY`b(H~8Fl$%3yF(hJVaY|1?(Xhx7LXK>?(SAP zrE3WR>6UI>x>KaVZ|{3wz2E-c-RYTU&Ybfc9q)P3`;JrnB}!_ezoGY&88mMpc0VOj z&7MNZZS4zSn0$Uue9=JhZI3>ISvXm>HOL~G;-xr{k9@gF-6jXU{y}WVxz^SLykfkk zpX~K*k6th&BhWXh`d(cniBKVHOXjVOJ#w#vEVwH&A!g+=A1qY%%IFUkFkS@XudUTw z;aST!^;>hEjEUttP|`Cy=&_>vCUd}*MQJGghW_&hTk^>nBrgx#uE%(APZ$x|wA2?} z?$&6Hks}hJ#k^kNZVa~r<8jeUT*tm9&(`P?O((W$l2t<9D*p#I&yGuw5;Z-H-ru`3d8T`ik$b?>l$pNNv2Iw zRqb2VcZIUWjN>#m;XoWW1ly*BiE1!g_^INvXSK+7c<|Rh(SjVW6hi*0L zxA)cP5rKJYS>7uIfF)Pha1Bg&KmZ1Uu$o%l|nZ|sm#4=vbj>=PiV z#o$_+g)#%0J&d6-ah@)8c@%e0bY>~sb zGjN(Q8U8?!5C#Fhm|loN*@-P4rCjzxxTL;D{q61SgheqVDcE4-DDX1kay(m>_1R0} zLZLx=oGpMP7riCrf7y3K#G$Y(c=-5MT$`x&<=ax!AzEn*HlquV1MjWA%JZ-H518je zDXDMWrg`QAxQF3EH3mR2V;l})@2Xc)t3ymu8Rvnn38i;uZs zU+-Ym5tg(guW(n#&Oihbax$eZE#%$dYb&v}NoSB3mb%%t&2a4r3Ov_ebOKE3zU`F8 zmW1ZE{z7ho*qw{?vWErFh16NBT@+`&jk;fPZ0-6y{P<3}H}c;(8(D_+4-3UWUtAO& zRz}sWG0kJbX=}Y-8IR0~i`|D(?6d9~2SBiBPD%9Ow2MQVRBD@XLN(?gQG=Uv332zE z0206_>T9FBjNC#GVV(E|dAUU0sr#K#gNUY)gsh1ZUk)h+pk>{eIyu534=-k-f15>9 ztZ}LsArjC0N94M85AhtqC!y}wy5~!;whuLK78rf-8gb+(2obz?dFl|pesE=*&ioA% z()a*250I(Ra@8Bl98-^;>DN`$<&y)YaWb~TBP#$U+f(G zpAqZbN9>iCq~De$m*KK-wUvh}pKP-UoD(^M%N=&;tr+O|AF`nMG zY}K}O0B0Fiap>0qY2-_6@GP0L)oVd13Te>m9|tOY{NEqB|?rQ?;`rrG}iSw+?w^F?2}= z^W#Qpqd`(e!8j~r?pv{=*{RSaouuBEWyX0A8*O-R_`lOB{gW6(*2gEq|D5@(;o0xg zwK3ZFTThFAJnB{HV&aE0J_Izf>L0|lr2vG!!s9N1too3gMuyuR*=?Y)QCCuzj`W^5UQ3%kpndMM*bn~(lk z+H@#xdy@gd#z>Pk6371PB9{9D>g+Tol3;!(nZ|qS@S0<&{Qa=albFp(WAw-T7dL0L zm^VXvwb-&#r&?ErEEC2Vuo$dG!yN;;CRFZnVfy59Y0Z1yLc!RkVobe?5qGjhuH>Ny zd9Q~y-wU-xX5p*rP^~DkyAD|%w2`Uuee0EE!BLHXR0UPL1IeT9Q@Tl6qNVE(bs4qT z?Cc)(QPm|$!hc?lS5Sf~_3W7GIm5W}sR&+Uwhm^V?DkT)=#c)oe&h>_cp=IpG0RVg z;z2`*yD~{B7Z)@g zapyUD57)QzfJ8k7bA?~n@s@l5F^!q0_@!iq4|%1#Pyf#}wQQdPc1T5cG+;lmu>s$k zvADLTs#WL#X8YfRXmf$Fm1-J#LksMLq<1 zjg8{LJ|c(!hv502zKzQ#H~JMz9`%9<=T7qBfJRjEW&fa7B}W5f(PP)OezkDUEd|HX zH#xKK7!7@4Klf~&-mU+5afoaLSBq|$*JXavf_IUgHBl;Sg@KQUsH0j@yfdUT#3gj= z`4mkiwSlYfaaP=w)jxFFyTuekuGO>Nl=Vt`^MAq>~V7HD%YKqz3lbe37L?(tIX zQGqF=y}*5$hJbPwJ37aXv6)jLnK0_FubmJwB@3upf3O|uF8tA@_1EU(<5b)`g%a2Y z9KM{1m-|Nj<5w{|lW#3V!GS|H)f5>sa3#94SI-o}wkb;+z+Lj(6?bbjMl=P~^1RFC({6lb#InIU&;-3XaEAI*sm z;_6_@@v2`CBi)a)O-_~uzFOOr9d%XD^VnM33p-_!IW^(6#uF^|351&W(}wM{Gh4T1 zefku!(dcp_C@8WvVCWtr-1c$bqAMl%Ix`b`g)Q{*qP%+?O!Ckfkt=GY!07F?Z}6kSAJJZ(gW7())m?+_NQ)Y zZ@VAn8y9n!<2bf-Bsf$00!Vx7Oxc8D2K(V{oXNgcY=$g+aq^Ug(!Nbde0ck}CxT3j zxV;3C3h@Qrxutu1gH@k~ysQT~AZp<6L^mq&BiZ*JOUO;UWJ@|Oc z{+=yZeedKob=kp4K}9vkYu>O{7npbS$hNl#E(`3?n21iTiOEyt z^RL>Lj}42g{g(dDxtl2$)L^sg^^w~Ug(Nhf7riB}8___jH*s*X9EJu^`v;xH(&ex_ z*693ph6JGOGPYTNh=cHALOjqZu~g`c zze)2M!8W9=_|Bsi6>soCq3_qQsU_+m5wnQPg-)501KQ^$e3; zO`3e=RzVt#`L?dJT5F==LFg%GR;0m%XY4u4q}Y0S*3Vc$DD3g>{9aY~yMbRQ<==6J zzbtWuCev(0Iv~!bM`wrEkxzpqOkbR;-?q`_-@pNmP6OV!!skenRbx$lc!O6?jR_wg z`9-%*E(ZTz6ayBCFV_;l->ZmQWnP!0P;I#){WWDx!I}OOyd0TI5EtdBklvfY>_d&c zc`$o@B(=j&jkRPiWvi)%+qcV0v@HmK>2XvPsnC3JmROht9!cCl_;imi$L-6Ge6Yvz z=E`fxP!rDB)CL}P9~*%#U67`b(S>GA@%v){wgG)x$zTBSx-|$9-zQHvQ zZ|!#txtGcms_9TMs*aCMZqKBEgA#H;o=a-)-%+|$*xsOLrUIq<#i=8!YI%5~I#KJ! zp)IsCHO@7r4&3Hi6#yLsR^2?Q@3h^%%TrY&yq1tcSV6WW?>r!&adpbt)4NlRm6*$! z0OF#OLvPQVn6NT%G{gOEBa{j7@iLgkN|URea4YaP8x@s82CTzo7xqTm>D9h#Y7N{= zC$2Hs`YjE=I1AjS%rWrHv!%V~GwXLiJE`%quzwA0`#GXNsTKy`T4lYaSoFX+8gy=D zGt#8eMKGe}Pui{8{3b}xOj94-h!F~=(Go&kirD@p%t-dxrRO8{9&;!&!-(n_HfIDD z`X4L+^(J^5$hzC7P_G*xSxVzTGn-^4piqdLR`$wJC-V)bSyMWvt0*a4bKx-Fg?$Ve zpZ@WTOBQR7YJWDi zvHo#o^sYX^I?pfb#^uu+Y_*$bRl=P-_o}{w$I@h`N5=kCfBsnRXC46;^wJN&p(c6# zdikPSBrJJiRc^xz6wQQwA-td}{192~h8-b=q{XCDZ(M=nKJ~JtAq>O*+}`P6c*GU> zwbUyh4rHb=IZ3Uzm^nj(A6g#?&`aJ1JZ zb{MQnvcs8fXc-9&&vm=@KWEQXd=Bs`*UF8UG+)zYhChC?@QGzYSPZH|72A@h% z#20?DGuwnCR}{N&QsUZDX>fI&i(MYP@gnU)>D($@M;_xRQw3BfPnwY-3yyhP`dUHQ2BfO@jkatY={xV}J4VvnH($iQC4!;J0pemXD8%n`LR~PhIBRLZ0cpqDOk1oD~=P?u+e@p!w z3U2@Kzuf}?ErZ~iBI?r1*DA;qO=orZ>n;}*1d;FgA}g%Tn!bK243Y91VtI3 zu`*b9FwuXKDk>6XtC{_KTN(M&8gRq2&oUy@QTfN`o|`0%xf(O#28VF38rUvJawH2y zLJrdwcvY6%pXEjak+9hdRPH^N1`lODilAl7)crjsTaD}~)6GyRt;ev`azD$mOv4ok z3f@1Psoy=6R#?w>IBsUiiX|P%8gY4Zb1}jHqi0Z}^c*QtL=0jY!^#z5w)8?*56KiL zAh0Zt50AjBomPf(A}&-h%*$-ws#N3BN~^_Rar8#&1;LupA=!gM@DLo!VQa5bPG!(w zW#kzmT=7TVSvU0HI6K$4BO;Yr_Xq)o;oVW;W2*fxXsqyM)K$NWLKyc*(QWWa-={8X zWfS&I&W2L34}dM$VjsTwOD}ThcFJ9Gu>I~)r`XejZ2rXKGWxR`22B1kGg zMfa+sU?2q+J!+UNOKa_eAQe+|2=AS{ADsIupg&;Ze!n!$kQm z6vdj78%s|twiN6a!g*RRWfUom9Fuzl_-m#Z(oP}MeYW@p^#1hX3Qc3W^@Kk-1ypZt z1FGwAOY6}2F*0`tNi0!v)C0vYJ;J{rzMla7`0f1j>L+e~eZsxpPZMb&V{bWrRo-oy zAja@^Vj*<-Akm zNQU!BXY9y{i25Ll;QCJKXyz|`inpJ3GpOGDL1-`O+CCu-VM%d`G(G1*%8HHf=eMyK zabol@FI_d{DZQ+>_TfvAD)=(GgB|F#N{T1R)aoxhb00!T%rBg8;(A8<++I<-J1JDC z>$!)>SEc$W2>U-#cSkimD@6CXf<)(ft_j0#anIe^5;F7r0Xd_Aru~K8-1q*kWY_=g z5#+5TXhxg($E!&-n*@;%JYu={ngT(Me8(9zx z$$fFt6x}ac(;V_q^4fsAqtj#~fxY%L!|J4Uy#@jqfUTaf?*-Lw_h1uT>9Q5=oc;DL z&Gw*zWX|HdU(-VjnPx&=N<%Irq_xuDW8wSgu;RXW%+J`C&NV|&bT-S;nGN(eEG<%0 z^S{}Rc@NH?&>0l^xrkx^IlcRB!lB4dBMh??e*5yv!>11pc(p0j%xt6+d<5`25x$L1 z*+yPJe}Q~gDQni|Tv~I+#-K`cb{%8Ua-&>e^lm642?@5T!Etpnz&G8XYKNj}THrXB zd(fPF`N>|+_fA~&wfI6uMn~<-;my6tuy0Nqp}IwVG<mw zYe!5BS{sLx*K*z%ipj6fC#LExoG}uSaGAIG@^a@P%}X~7tyg(UVI$#xL*SuT|G;v! zw`lVxAD=mfTtS_fipTP2{3mXGU_qYKuTC7<6K8uJqhxsNP3z9x4@bYMbZSddsY7vP zi{?W$&A$vFn@J)@wo`LWVfe%M@6=gk*Tr3Oa-#P?6KNHG0}?*Yt=8UjKaA~vyy?c7 zw=#w0p=I(Z($GM0eJZqog7v^$m|e>h*FiL3`7uT_UlLTuy+ z_b%5I-Av{SZ>*p!#r6{1Hc)SD!4dQS5wDm3lY7>1hf&`&YSbk1H?U@@r=&e2@gwZWkOI?LJQVj5(n)$|I2I;p=fbsU&9P{3bo} zWSL#C5!8OIg1n?-n1~?MrlM@+#51EC3{{jRoyJ7MBH3f7DW+}7FP2q(RQ;uF%|<); z3T~E1i9|(}MLZKt1(H}u7}O4vK}A&jxdN9jv*WhJR692@GOXSQMhQ`!u{K6#1D z--#~!51PLd{zm*liQXeweP0uuso0dd9s))iM}hG7RL1L!yMv{@SR;}~*_d-P7_+7Y;7N@1hhj0&oxx$%H|M4Hg!rG8tJh&g{i_0~{mH=UUNQh!?^26_dus94H6lP%duh8&;z#}Orl~mu6to{e8_bdI- zUr(G3+rx&kfV~ZXot(*tuNsL8HfuvPpd)?9k%)x0lcKT7EII^*T&EY?Mht4#ClFql4qI&k%-XQ_$9}!^u2sK>|0a30|li#A-G1N<1#Su2HugvfkR0gVkCkUyKU=<35 znw7?{b%yMZ$Mc4mDxEPd;1<#`_*IAjwKF1%B`dY;Jyz!IW{Z1EdOvp|?zyHG#4L$f z3)oVqU;|7!;{ZM&QCOHP+H~`jCworBJiW%AVtM0nbz;pytsS%dxs0qor^-+t)Ireg z=uyT==;Lde3S8`xPsGF%LlZ7doj-0refh^da26|I{7Js>^J$Q*4{9+_Q1NDPYA*sl zu$?I`orI`i1d)LvwWbE!4ol+q-UL}XFItMl*$gsa&Y1i<57a;V;(hj@UAEg`5R_N4 zkPQ&DB<1!w|2j;H`hEf#XAu5t2Sph%olu_8Cq-14@Tqh%S&|XK^kA#Y_iz1g*INht zY567U_2|^KO58oi*OciKcy8oIFkg3Gt1umMg2p#Nf%U&OrkW-18^0%n|7q5zyiYWs z+*MS<=Fe-j4ZXLIn3G4+;*Wuiyt~}qFC6v1=5KGu1TSvq;`(PJY;w}@9r=}w(# zw|KKe%zZY`mYz_{K&L@Hy;Aq)oEtf&7T=`<2LUTQ0(*vT)P-Mr>l$D^!+_+lSGCZRc4@3p0oGW1$}tA;F>BpgMs5}qMfMVL!OXJ^caxM@SQasJ+?#l zt)NWmLJ4z5Vd`Y*(s9!`UUi}An!v41g0vtjXb9Ax>wKS~y@5O2hOLT=&^wWlO$zOw;9J-U<`kP5Zk%a@X$2DZ zZG}DmZyEncV*t1gn-#;um+9iQDwo z^P2WRbBiOk(9Nml{Ex(g0>w0Q9SBi!{2NNL5Wec?vW%)<#|br!Gl;RP8bZ) zuPCi)5!`*(GStMkBf8v3GtapNBMW=Y{ExeriQO0UQC>-~AIhVDAWu-T6o|92l1# z>key&!T;R5VOPfxk<)TA;M~i~>d$_Goe%_-I@Qf&akXj(v_e3Zs*C0AM!nwk4~-I*OWZ0VqJ~S zOPT1jqOAL>^nui|!L&}6T;>d@DzT1ul!&ZViQ)@6MCII<=0wrHS;Jtsjb%tFgsl@_ z{jB85|MF*6?`guo(*CN*IK0mh%IikYkaYUlThf~bZtko?#8U3toLl9A$?)U8OCh2J zVe+3GiUR)=SGr*Z(PkVJmBY-*BK#)Ekx6>}y0M^$AMsHevk!Z_pSXJ#D32I{U;Sm- ziskmvsl&fzy}R67QOo>oommdw2UozQKUtNHoC)H0>eAwTcaO}@uFgdMkleu@|EW_s z$uYjirVo>=Xx0eFH0Krrj*Yc^wK+Xj+Z+ZTNhE(d9)CK2Y6(hMxb1W0>Vm$9tVo{f zney7iBPH^YZwr51m4zLW2t=T7Uw$4jdHy6e01>CJ5oMpvROu@sD?774s);yTxo)Lh z!x}nwX=%Ke6+b>_%J&V<^}iEwBu9D)w}b1!-ZC1p7Wm)PGUv1}L$aYHDY&{cUv z7ndAYlo%Yymn3nGCnjjwWXXn#hHpX%X;!?lS$p!Jc9Z5rWIjIAd>K=#`?U^Pb*Lq% zZkcz^sZ+1Jm!cj@W~MefU9Vm;pUmpczEyTj7hQf^8@`OYkXSLk*ss<5aOeUCOp=r} zuN$>=)V5UA@ZBJ+;XAL^*@z+N;Ys&^RT_!sH2~xJ;cN7~>{$9Tf{GV4-uqV;eUvI-{idNqvtGo-@ z78Y!zoECe5R0Q}TCG-8E+IiEh6~)Nw-5Os3-)qe~t@ik)uR-PX15p=JE zT#8VYX3Mk8^BAN#(AmjuVGLOGVa)!FBGz)+xS|`*;(c4S{-IJD!TlFPgS*DmCiV z3^>GxNh2)!C3+is3XYzSKbn_`l}nGx+fCbkt!U%rx9!8JZtOaADXDa`Ay?BPIIt=4 zQmF`KRtlb)pqi|v(I$$<--l&tY0>DtVyZ68_WC>r_vghlk|XM|Im#$&Re4W4>A)K3 zwbdV}QK4S{ZAwXcYBHI7Z(4*a+R-nwW5V18|9x6&-6Sh`&ej4odJsNGtOGe6?Tywo zNOC6X&|0IpmcAUP!Ms6PEfD+Lt>JSt8vQSAw*uO#uzo5MVdQLgTlTs*R>x&Ve>Hw* zqWUPAqNU*uz~>$S;-FG|5|pJz4Ox!h+x(R{dW32TC}}Py7$=$R9G%*v#}L;^r|i*dI5I_uIL53Be{NhT)MDNSQi?ODS zQrG`uvH~yW2eT#^VxjlIe!RUTH1i>nqaGOncCK;;icnw2owo{zl1-5xZ*lqZW%bu( zgk|~-6R^?9bP2njgR^M7#JJy-XmBkT>%!(0I=B3?u4U<^O5_DBf7Y7I_{Iy{w~Uza zf>+fxc!FEdR^1l*fjXr+b>*Qyd(eHPk^uu`+LosMcF1?k5`aqWu}v*oBEw|3B|lPG z<6#suO5JRUx))TdNhl-=f%v@iq^&u(LLI^%=BpM#uN87~%t0*l?W^f!oN!`|nWZR} zn2vMFyl9DhrbX^cH~i=5i;HU;qt!!T>@!DsroX&r{2CHIy$Bf z&5WOTJ>QqRuLn4iIN!N(v2Z@T?ZKpRpum1+2pW5|l|qTR5{@0jvcTPF`Nji_Aqt1a zuD}v&!7R-ZEH@&p3r=7aMXzE;gGC}r2EI7$n*d~p_^CsS0@~j5d9Iv+O;pz$( z9TGOEzK>Jf*jM!%r)+mR4HSbddaWX>Sn#!HP%#2l#!?w?5+ zWk3w7NO%Kid-#4ButTHA;h!8o=4xq?kS))mY={M;edhn}Ar6HgC-wx>{(w`AYLqCJGvRKqI%< za*BN<){G@MKoO@uAv~sOb4jAVG8So z-^j0kp%Dyrs;PaiCC19~e%G59qlQvX_Up=!FQtHfc#&UdkBz>wk?Uvb#M^keXQ%(bcjpS7YLB?E?)7(jJI;0V7>fMnYqD1A@^QEJ?^*03TH|P43GtgL2uvd#D{AD7CpVb84;=2Yd3lXC+V^|4` zhf#0UHt@zDt9CyYi;k?fxI_)0yiOs|E7zcRxaJZj^!MIH^_3XP&#iMDZL1^$lMd_? zT-Bw+aXOl+&F}|My~n>VRX3f?cU)W-@3e2`O2gDYY^fpDwyWmH=1ow%W5R^e>~nW% zoI{rA7LbkkwF3y2g?%t z7+utjP|H(?K^IDrttQ61!pH(&JN+c)lZ701z8KR2av4L4vOc9qiXcv6} zB7OS4+)^W@&eSu3*&?Fs&+jvsmW_WNHm%6{#3LlneN>S$C|O}d(80pjKxKzH~STJW9O!NaWAHYO>jc2H^|LdYO)6#=nARbSyqOlDEf$~ zEm#0bR|x;6kNs;iYSeL@fvixqebD;L1ko(UqyiaXbITRe8OxBeMexpPK-24)ls5{Kq&d8E4gax-2tgxQR z>KQu!oa8?=d&oRM9WLw}8DNBq#O?@1rJhqCqtvS(A+jaVT-zU?bbc?+D3?5C$ZM%y z_v&F!s$Y=5eTJe* z0qW8#`*>y_6#0z7+{34(E2Q%-3vA1504JcqmP$J8m5yn3j)gJ1WsC0c*mEa*33b}+ zWs=1V!dIbg%2N1Zpu!u&)DmA{U?Xyl1dlLe@T`9bCtd;l<`=p$a;^K69+HhUpl6Y~ zabyan^e6leqmR!}>_A&4i@jto^!Y+cZ?}cgx5%pXZi5}_(EXRR6nv-NCKEN|N*&A8&>|f4gDQD~$U)Se&5%SgOjqTTE7Z-m~Wfc_BtC23ajOvdN*R*RN^V zz8H4vY~O{95DkPBm6M2Ug8nodd20mv;2ZDp>yh?8A8M59BP2|zg6b;*M;Qxx=zW&~ zCwwM!yBfsK^Jnn;Ga~Npj6RC%-o;b7dEU{+axfh{qd%!ijr6^i{WJH)p2XW^1`QkC z|6l=7c;${(k4=B6TCZ3N{=*PW>V(0vzJ>S|-k<-4zuf*0$6r|f2{so1@mzwh31gp-lg{&RG1!#lJo?#DD6jTqjxL#80Je`=ta*m0+ab1auZ_B4DKk4;dnN z2Ayr@ZW;!T_72Y6BzEZJw@9!zR@ z3&zsgAtF zviAs{kdICJrm$7O6c;c__J9wHpSk{*0vkCrv5ya|d&6i@xTfMRuDi59<`X5OGR>r1 zrZEW-J){XW#pwf?UpS7#xZ|=3bb1XEJG>@+zccXDabB$IpdU^>Io7z#S8I`Ne5Mm) z&!D~i0n?iHf0Y~eQw}QXM`Yqy|2>S!T3gU?z8YtfX1VNslb747zH@oU6g_z9JqD69 z{8k7ww2P1~!mQ!7B>^i{j|W+yQwKwp(}Tnd*BH^9Q4w!~Mi+Q6#^1J-yM6wU*!IUn zDIs_2Q*ZAS7x3=NMBmd?AQ9qFA&w(>#uMAW_-^b+e?|&+LOw1FMS@IHj7l*+2qh10 zn$~i+YOXSp2DC$mc~TFnqR{m!ETdl{rOdVs46ZyztSY7{C0$=LRGHO9t@wNIZGxuW zYFmWeyFE2zmZvHWqxaQ1AxI4uQ3SDsS&Rz~#Sv^2A%v)t!V(RdPO{8Mm*?C!_hTK>cf~tcGK;$d!jD~ zl(d)6J-WRj!c;bE8^+y!_XJP0yzzaP-YINATl9ZZSZ=BPgl@KZ!F6+S)zBQdYjG~? zy5FX~#Dh;VdU4@Vm122`+9X$a+G|qO^U~i;O8kh?D0?tAi}tRnB&84yJT_w!K^lU+ zM%P_W7?id!kF1-wTBc+7A;%9Ea&8ErMJ8o*2!tk!LVrExw^?<6uyr$ReHv06$34nf ze;;2$xt=n3y3O<(6!gkVXk+0*MY9nM9e%ntLjkF`IR7qQA$zD_%-zPXpB;(U&S(Zj zUv5K!z~hqi+U{Rd8onIacU1A`=-L@CO4FeomrNeoRi@VDXuGte&3(35>Str$m+1|W z$9#`L0a_Nh$P`^c7Wm$$($v6$P8mhGc( z=EIY-329G)b)L7&j{pNY0rfvTp)ENOl;WBGyY{19KySJmoN+837fctGKi{6k@z$e} zX5uy{F#lLdeQM6LwX531n1`rCmq}|exFl{NxkP@Hv?*b1|JNCADkg9re>v53TI2w~ zaz{OLkmr{f>EJYa3WNIwf1$W)u7gSvARzv-ISi@M2POqGdKRI`LT7CgM1H{weREswka5h^>nphoy#stH>^!#>e~o3XamP3-zsBP1Wb0OmyUZNBYf5UDFfVtzeYWg z-ZN`XiYMc1z9E(}__%s&3GN8%TFSVyGT{;(1;8b)wFVB4jaYWFLC$tp@(wkG(=Hn7 z!a=nUR>{Ghw(6&Gw`Sxc>E6C|qmOF$+8<6Gk2MAP`aJlJb$>I5k}3ZX^&d^*Ho~Gj zD8IP>)%)1_I1<`X4P^uV^HE9ZumX`Q2hn$njRqUINsi%+y?_r9RmfEr+RcbJmUCBQ zNhuLz_}br-&l4k(kyeRok__I{@fma4r4K#R4`xBUWty^OoV%{u&G97hqk`0LfChabB^oN+_6>KtGX9KuM z$oCbbcfeV_b@ZC|66Y&R^-UMT`|%|xUI6-`O^u@DyKr{k`GHxnzrYox<=c}ba6L&x zX{*ucsdShyC;@8;<4;)-osm2);Ef#lOt=IDg*hw!r`or*Qj2V|$9TwvVIl4>NkQiI z+sflu7Y&mm;JLa@lTkjMz;ZIHT!T=&!N?3GS2>R1BiB)XyCo>fYg9KU+^K-Qp-xG& z7FI9i86D+MIj^2j!66W;FzS_Hn~GwDK3a!k=!))ZsY1rqL%S^zAJI zN^%MN=v?ZhU4E%l;h5q+SXpBQ>a)m3Ler(Z@;+caok!#auIpLJe5#zz;nPy8Y}W*9A_!pE zaYbit193WBf#SL_7syG5eA?}(|1B0Iw8j<^LOhft7$x5~4gAIZ5CJ6B9{l#;N?z^3 z<+z&{2acAUJ`(uN+NolzvH!r?!YhYSyOycx)G)5`4nKs0?9{+vs9h^(g+Gtx~T~&dS z845TqR9zc~Z5Zr6vSvcwmnP3)7*TkJwNprYXb@%OIG#Mu%sI>wzl(pnS}et#kGNPy zErc*Z>Mqi?zG-Xd^PC%wtz%!BH_dZ?IC8I8 zS+wh?KtNwcT1!ucYaEY?$qtZ7OQefk$T{j$<=9awoYh|m;fm*)u-)639ZBG;TKsqI z_Tac7^#TOZ2AY}a-X6H(lFL`D4i+{UGHY){!7N2F3RYT^Ey~X3xfws^wnUyv**W1| zFC4R!#3&urjMa=H`eu|Wtn|W{alM;Km<~`K`P`Va(dMi)oA~}v!uAjups*`D9f1LK z&Y+QmPk^aW2cJ@Kvq@(d{yPC;I?~FAQ+l@54|E)UjQq$)7}`g)Y*X_v#)_LSRV&!8 zBut{qw)r-5IsaK(wwC$g(C zwfbO!dFr1!-&R!%utuz4Fo3@ZseFz_2tH zX~Imm-0dBK?M-SIh?`cl(}FZqu=fgbm&LJE@fgmUI{0q|0%^CP3!$cUO(egUT4lb~ zdPTrIzGx@!EdxR?3)!@bW0ONRHp3D2hz5_zNsvu? z(M`~Nm4B$V3H|pAKzZozySS%t7gp#{5@6zKEeJSJaNkl8!j2mZr-VF@Pgvg0Mq20Zda+L++e=6ug#kfRymKK&>{74qUS83FNuy*drR844x=N8|tZk0H82kXKl* zNZ?fh3K*j+D@PlK8-$c*Sry760lo+hhrQF?z8@0|RRY9hC~>9OAc^TAY5|_I*z%qPJy1$mjWJk%dyJ`EN`3 z{%OfCtGQx6Wo2a*6&1o5DYaCoB(fAnDGKo<4dQTDV#NKE)U5)6vA(*M$Ppqra|ZWK zt7lj8VX2E(D?RCSiuXhtjZdGu;&5{Im+$ZImzS5_z+9alaOj)daj87IR-O4JjrjFj zo3c{p887g&uA-cW9@Yrn*}(L={2ODh^y>yNYg%y`=3M{ z#!ue9?WONhAgZI01_fIDIbBil;DpF8pXOKhR(yx4lfcQ@*_NZN!1aGge=C`hslu4ei=Hwpbl_u-^Yr2n9 z*E;?>bNI>iJgE?Ie73Ek&Z6%xH09^~gUVpyoZ}09*}EQRA#x3o>AS8ZGe~hP-56Ii zT_fu*v71V@)beqxe-3(yrgxc>?Hu_v+A2ocNnGR}KDrD?JndmZP$!~PHE#0^Szc~# z_2O|ubtwzCY@WgoET`4_^H-AWQeLY4IUb4DhyLYGcfqT;RtSmN-4WBqmtS*Jvt zv4&uFWpLYYv4_!Y%PHrz{%n}UV^RR1?au@y{Hh7+{IIG4JL$80iW(uk%?bDPygorf zj^rshl#9+Q)$pie<<%J+NkCEwz*x=X0%E#=DJSPM!;rfR$T$5QeSa%Qs#3t;i;sUT z85EWYp&4NvqxT55sXlr01(Y0?Q5RQ(?ZCKej`n-|+OHy&;MPR5I-tlxv5(Tbq54mYI?nMIG} zH3{Po_Ou38Fd4g%9upHryS7$m?6c+@D>MFommTw2VsAm|YJPG+FWQq~VWD|LtL2LW zxVA?4J%-p7o3~tYIV&2zdNvOlHJWe?_gl8-JJZ)v_;!2@;7ei3a6fY1uo}57yzM5} zHQkvJB|m{UU^4Aq)~o^6nqM+(vK;8U|4QmcQ2aY3Bk2!Huh;j=jAop4->P>lz7bQ2 zKst*MaJAr|&5el;`U?B7(5CqL^M^gX^yu}(T+FXa!J7HsAFj2ov^-be2D!i6;rno+ zLrP{#%(2VX^nE2%L32>f4s@LP~U>q)I*d%%y&j{o*SAT0zlxG&Quf8Z+tELr%fFcH_0_!g4c zhBi}kEkhQw#zA_!KI@#lQ*@!5vy+n)|EklzBVJ=~V>Q!ajiFVD(OJuz4x=scPo)xi z=qvp-N&X@eNNHzj%f4O4Y&tu_Egh$xt+c&>FiJY0TM1EgsQd=U|1tH|0c~c@*X&j( z?p7RvTcNlv5=aWcifge#aCa$C+=FY8;8xtB6n87`#ogV$?AvyKU;a;?JGu9nJ9EyN z8A6C=qk#$p(o^2Rmz##P-~B)n=!>Szg+pe^x4lQ|>Sx)ibhu_v>YJDyT&7N$>yc*DHhBv%#2mT3ffWv){%Z#PbT;k=V#+i;)vN#eSCwFws9FXEA zcJAeq$qSDRI0MKPoeIOf-i}~87MQgHB9X9j+W~w`?4cc>9 zZ`e&}b^u&_+gZ?b!|X7G%Ilvic7G$4!U$MN_DU{+OlImapi1ztlu#oN-QEg!l zz4Z95IeG@k#>^yjfpQ%xBPEl=YTE%Cl5WJXaOVe7kw)r)Kw(l`BPQDmJ8o$+p~>o^ zy|b=tK@m0ud3T{a&3EH)tJ>iy>jh;;Ls&mx0H8}W0Ibp4%4MshCvoYjFLqMLqJ6O- zdc1ltqT*{4Eaiuf4Ku56ZOvZ!%F1G$472lw4E{}H+LbPTSIK%q?~M{q`N?S6uUPZb+NwMW z*@@2;lOijzb$`-(el2_x)%bI7+@0@9I`MswC4H6jVF}B)IW3{% z)jl~QV_Q${yt3*s!-WOLT4J=uk01w-7!kpI=SO_-c$Xwm5-u$vqW(fvH3pWsF@I27 z=CV%T>+*GF1`BD^yQZ#zVnIsMAp-=VW?`eA2ii!fL*qztawoHIS47$E{*sNf_IuI8 z7@$6$F7BJ(wIHJ6y^%)Fhfc05{$8u6wP8f1dwe({Aqac<@1|cd@i!&AEnET$Ekt=u zcT&Ij$re{-<}^SQZsywrqIXypP1gK+g-oxcS=jGX$5*B{G-G zX~xOwvgxP_sMd>Xrow!Kc)?luI7W1CHb0TdgDWR(h^4i zAXS}3cBiYj#Y)d{I}-6ymg+m0N?itLU#Z^`Zqs_{RUs0sE##4-KXyEDDk95;0i zEqTXx<$0Dg#sOgy=A{lIAFY#vfW)zTc@48xpXy5&g?p z!;RDw)j6F42@i@u4ND1GkO4PDX7}^mn)E|^Az6-N%(`8NygA-}hPZ@&Zgl&}^O(Kk zTE6HEp`*`G_K^eGDvP^F&0mxmreaJ}kfZnN!^!9Qvw?C=6kB?_=w~ zuV!uAZ&q*{9Vi*NFulyQr^CJUc&#U!fUEuO2@e|hbEd<2-snaOoYr*~GF?o7fmpa) ztn1&rV^*&cs)HRSx8*3euUO$lI&@(s4TGLb48X)2-TH>ZTAQW&i=Pr~31O7pb*_&k z=Np1h_1j9m{vTu3qgaLsHeo;9d*gGm=Yk=U5hM}NJ~i7oMwkR-O(|{=v|7u-$srk7 z8ttL@<&~maRz?>xA4!d&WN-MfJPhp5Nb-jDb>tq-r7B8no5S5yuKlbZLysp4`ECf* zGb+(y_f5#!F)Y=0@t1F2nW@(fL4Dypao_2cg3yR?4$%e&APbv)Xj43pDUgdnYKY=2 z5G`OYpk_pscuOE$y8L1qYsw{O2iF7x>yy)5517cwz(UN~>+PuSy|3X?Bcxx@PIT4^ zQU#f_0`*6;>TqGQTX{6?rN7f9fJL)y$FpvKXJ9AUUh=9dt+Oe=XaM_+PTGSx;&p3x zAydVb>L`CFcu>MYiD$y}-y zpk)FkvsXOY-Gl7K)8@u}mQpWt(mbws3Q`SGg637~tE&xV;;t}XTjw@;F8&$=A{ctkIP!g`q7R%wG0NQ=Zq3lUC&f=Mz0h&ZDR>pJa@R8GWpX^I6NI6GWi&INMX0e9cEumzd`g^Kuu}Ygx#JebZl*P<)j>QcV z5!lm=Q<3%#jlL6*%x`thy{@H|Y%w~B84FE>)zjohB~`h&O)9*Lrkqf-mCK#{<=$<& zllGoXi8;A+!2)d*i=q^6PdULuJKnEFe_LCTeG#;NB-@8F4L|SRE)>nRnI9Hto40cN z(Ix67NiIhdY(-@J&XRDP%NVGU7GR%+8#{^?82<8V=at}l(FsA>8ik0VUI&#~+e(Tr zPapbROXMd?K;r$IaTT~wx9s$!*Yv39uAWnly`Jx#WZCmZd${j*P#W%D}l4}ul;+;{Zx#W5pHB{{}Y3!$!08d$ zz+3+6YLa*+;&Tw10RAF!E_3A5!bqfu*_7*y8ns$Ys)~uMe){a`ARS$DL}!FUutmMB zOj^A}aSUo7?osHEa&<|K2>HYpEk>|$y;Bua0E_3?j}~x`Qu1)@&^EZjvE@LEkj!a* zN4`*ZmZ+6^aA%y=M`N8~Z_+I*_QcTAM#n*bH?{U~ubcP4N>Wy;>FT*Isfp%e{?qxF zZPeA1@-syZp2*q=?sM{ShaG*Pn~JL*2k%X`bqNA1yLt_B&(c-r&vr@N$fx|jjasog z+YsRw<$BT4l|b-#?0rYZ?`_;nV`}S4#888IF)!^h9icRDoN9hJjH6)-ryf0mCd|=L zR(b;5DngiE_q)aBw}PC^J=40fWyCHIhRSvVr`#5!c0O8+SCa%ft2fzE;jIZkzG1Z# zxrnx9ZUIv_REtn^dPwIjyPaLC4r)uuEo~ob1?Zmlcu~>1PVHSho%r0h?O14*D`Nb9=jadz)e@lVD<^8E;(6?+ZGxfM-kQ_-yfJS1Xn^ z&fM}E8fS2Z;Oa3lQG1ZekakPuw2}uZ6_s^bugD_54e|+LLRbD3v#rF~2BAk{<$oZ< zR8v6~!3SimwG>coUt?*8SUYU={i8!jN_ z8F^mu|KwTqt!nS;$U<_S?xaLD4PtL;9ea3FKeP8kD}VD@7!c=Kojs& z(8k5vY<_8q4V*X=wz?vvFVjIOm+Ky^pRv>Kr8ZYCn#;o5qb**5oAelmDanBp>ki_vE`z`Ny41-$pV-v{@5; zp00eZ?hw`Y4LZG(r)MJ^V2}>5Y_AalBQ=6`WxHSQ-`IGcX^-O#Yu;M-S)ofVJ3S-% zO3ZGJI=-J!7QSH*2?%O8_&wB{zm;? z0$a28Gdr>7tD)afdW-`CouoK>Ivl~ET^=~P-o9PO&sI}hYxYz_GjJc}Qd29u(qbU9 z&R%L-9VSv=u z2l&7K=#Eb9Eh^F~oq{uf45OohB|QSOS!Jfo$G_8ly&wkpl&BR?OiWCg&t8og+CGG3 zdnK5N+xuI0O=N&`MseLkEMnmNz!4bceZRmy<@s7v8_NKqh}y>{C8dlUzv$OnYrF2* zvZ8n-@B45(9aVBK-T`u2VLETO`4UCj3g}J3+C-atk)3!a9s23}U*l2EVnA1S?@ya! z%y*}_@<`MeN}bYG(6Z~7h=-->QqL8;lYoHj5ZgKIHA zqTFC;t?plC%AOxBR+);y>~bvDZqAm`JM_2hVf{kCFR8IpK9tBSW!_eR|62R?eY>Z* zm#q&-M&aSFcQ8g#ztABK*H@g>58@MXaZ>UbegI%XS0Z8x*ZTSHn{WWv%tsZSaTogkcx%Ud#`cRjgt{9*>s?7Qt_RJvTC~4Qz{a zyb)YYMLBjQnZi4Nu(`Wic_b78$r2*wMz{) zu;PuReHeFQJ1`{!>j9i}&jRhXEtjt*(ATb~0Q|?n6S{r$fceB*qE;7?vvpsX`#7*}gCtiQ(0E6{26yg3^h!eAo{^hM6$ zuOzTpYOXNms#F1Vsm%QBvIAB0z3F5pt4`AP(AjbmPaTlZVhDQx8vXqWiZ>TchT1>? zW6hR@bG@8I{s%iiTu`!%Q7>C6x!wBD<|CkfWW&Rnig~LY0nPBey*=*5E9>Tl*=En1 z-ObIESbq1OGb`iKzK>O_g%#kG?yRrEOjB;jC3wjmKVSoyPFzd*KXHUAkdc@D^L?OL zp&kzWf}dKCHdIlxVmkkN9%H7ip6F1gL=DE(q5kzuG64ji;~R}jV2_6|re>;td#ZuO zY95hE=;-L_#s1iC6h~DCNrtb1L?v!RLNN^5#f6U3FmdZ5B-Q2KMNvARB=sxemlL{( z^XBZiTl93`5*XVeiI;U>Ilg?C{OcL6_z1g#{Iz{CpU!+9i?7&sLjlRAJ(pf}5&OH1 zSz9zz_%iVe?B~wAp=-}E%ami3SV9L>rH^6@p*ssT+_ua;k8Fn1n5m-(G4|+N0f1EL zO7v_!I7ms8<`HfBH?=N<`5f7mzkXutc;xARSs+l(RX%ic7nU^3X*-YpT|g+(8JA2? z?_wdr$T}@6&pD@>A)}n;nOXe41I08~K2)xs_HsYEg}fDxl(aI?%>ZuHD1mjJdx@c^ zt4OT=xl@wbT8R2d{mVD8je_^gdJ9ol}+Nj&b)prm;{BkQ|B8ZdRpKWl#Bm08#qK*CC{kEDx zsJK{dQ>Nc$%Cn2QPJ}3hlHwEvUogSsg7Rt22d+PWpuWP%W$xJ-!xs*mogiXX(_;!U ze8ZEDBlj&Fdo2N9Zt2BN*zP)-PU>;Ld5o$yYNfL#vJhG^gDb15h#(Uye+=qHh!K*W zo*ozPw(2&Jb`Mv7R>!B%8}28*uuikBSJC_V?%6GE!NYMF^u~jw^^P#;8II`dH~z?< z-m`hC5~|A#Wh9lP z`rp^w@TK*TxZ-s;Zo4HR9k$=bztv~v7iH!V)$yMG?6YJ`32nVo)6xrOr){qC{TUhK z5Zuo)JWCODL~1;7Bjv|m>+kR3wS*oF)X4C)hAD?25;8V!7 z(7V>&i2itf1PuR@@apJ!c6R{)>^7c%GOTIci7hALqNECYz46{=;zRt|l*L{=R^Z`R z=6H*AW}IeUn9Uq<-aKb_#JC0g?rM<-*lKNp36d(&^6 z_Ce?fK|($h-(x7N-uR&fG0@Q1VUU3CPB#~d>p#OyeV2J_K$a8xW|C%9VncSG6=bO~ z9bQEKtPcyqPFoU@HCm@ver`Ye8BW|0GHHS5Sa>UkRd!_K`~Wd~D5#{-W+ie&eBy2NfcnZfVf9y$rtZ?3(o_Cwq&*p}du4lO4Cm51hSA5lyF0Jf+^V%3 z(MJQHdB)w8*WXN!Ot=5K|B)hnh0a%IqGpZrPNQ4CM+@y%z7|Pr+SrY~c{+OaTr2sz zdZU8E3EPWY&c5%0=^u+q&duY^v@g6x!p*;)%jc*Yf#S;K_}}(bvW~~bp4?ZTX^!2* zinoE{H4EIc=Ch!lidJHcEB%!kT^fyYuoT0!EK1Q}XucA~Zn``ssSjrXEJ;4W5EE(AbTQsd6*8%)Ao7L;!BaB)V{` z`9tUV#-%ZbNcYpLy8R-9N4bCyZS7O8;Dik(Ww72c{Kds9Y z>`34D);>P{3rB?DUf5a14@rIWMq-I0 zwA?Syhi9dB&dQ=fvhoV=;!6ZCB+KSL z?WA*Y?nGQsQ(87UrtQ83F7r7mu87X$n?C1Zxb3A>wxr>x;17$^Okg8Kvz}D?jD1I? zA+#AD>Y%}lLq;nJqct&8fD5FB&G~0=B!0NxIMB-@_QSRT;&$B zkdZ~~h5V(Y(LpAtUAg#Hr?5AOND)izFkgsa&$C$yI8ZPw!Gfw-ym5-qG*?}KGjsu7 z^9OVEL!p!QEy6x_u>7sd^TC=Ba)oqjU1G@$xT&B=g2`khziwi&NyPIW9R|&+-#pBLI;$BL-N{ zmj16q&zlt7E4fL=p;tip&&)+$y818OUNdeX|HQE`O`aA(SKSF$}t4=7KP zU42$kX}!9EyC8RKVbiFeK%C*XVhPFhej!T=SV5LqALAJ4=ne=IKS69@7!X)K3wf4tcll8p9YL^!3fAu~Ir>;^zHq)psEuCnpFFOG}q|jrZk#&>7I}FtF;) z$9C8!Vo6&;*|UifVQ^I?HzaE+U{)YD>Z3pka9{YfCt=mwZii)zRtHJaIW3+cjk=R= z@01`v36n(gFQc5iR!5T4SP$41`=#S*Ib+)`nOO9w0|jw0O<3*D0RHIkG z+wd}uMv9UMmgpoHi(;c|^h)%1(Vwegf3N_i*#vzWH-m1@ocwcunixTKP$*f?52t{^ zUOzqH?SFs*-Qj}2zqOY`PY-{D-@Iw3`(L3HJ5F0t?)-@ENDRnWwoRf|al`Ri$@_p} z`JxMVC$+SF=RHHa6jfj?KU2S|Ci_4ajdAW}04BScEGa$y1$&iw^2Zle3d#WW!igQT zB5@-8y*%IH(C=!Ag_S@29js>P`ag>|w8JCDXz!8-M^UW@tGXjKml2a`C9g#1FwSwC zvEcoET35T1EbIa(y3??1>@Hh3x0~I`f#Txg#j?Y@NHsi}sVlFEAC7%soY1)B(P>k; zpN0gXu`hG2=Fue;ipK;ULwF&QLL`APQ@J9bCX7PiZ2eMl*WGtgM#BG@j&exF55P{p z;|kpjc3?G}e%3Lv_TYR;nsHbcwdP^Bw(6*HN-9m4%f+Ia@!1}ye*qt=s>acer;845 z)G2@;=TxkdEfCj5P%~knVCY@(?kKzGc{FN&F_#%JRC_5?swDtnVO~aFX0g&ux#g$h zWs7B9HvzGvcZ#!WGQP(pqrY-G#7!^AQitTnsji4(w~LppetFz^lAP{Ch*kRfz!|3Y zx`>8VUwj^S^1pa{pKTsEH<1VWwvIGfFSU9NttnN51gI8-x7+| zakY|jrT1&vKN?d(X;f7#C2t1?EZjp#*A7#=s6w9oy7`ePgj@zzlAcLG4ZfND?Uq7M z!#~c=g1W<#Lh{zr)<(w=bVAE1r3%FvS7q!qQ)y%#q|uCCVVqK3^=y1Y&$C2lfL<-R z^k!dMg}J;ZbABvJki2T}BT841=q2BUsI&EG4oX7yH2XGv(ilU$!Z-jjP%^4nSgfiH zDAbD2>i?lpFt}{Yej;5%8m~b}#;DYQyzaNtc=&WL_C)H2;JTC&2y}%Vup$vvC$p9* zdDPnCYJRQTd4`6cH2 z+_%V%QM?1A5cHOn*mfwXW1io%Je`qZNK_UVIXAgk0dss{Hj8rXL~8>}u(Vgd$an8{ zT^*fKlMW&UQ9crKnfY3_ohUmplifGkQHQs4N6r!WA`m~?Ic{FdJ73Z9uabgopnxB7 zanuLGxOxL})9@|p`kWGa>p!mSo6(lFpJZ1BQ)rKE9#`pmY1QC?BrTBgV7DO&YI$|d$EIAD98%|p;(?5-UGBwn29yd+1Bgwt zdqP>pRu_$IwL-J3r9w=}iCPfNFs17KO8jaqRqpGG)Dro$TOzE zV4HX7+Ig*<*L<2OG?OQ|ZG&5|V;n)5S`( z0RFgnHDhHFa|D$|omp)KL9N8_rM?Z!w?5>wO9WqWi)M&=q8lLs3_t6{PVBXq^VdR!%J#)KsayLe2{ zn0Pu(qXep|=}*789HdVS-_r97I-QC1{3K~}8Fff;PrOs?IDt_|0K4bIVWT1A0prEh z8l`GCXKx?&JFj$?7k(^4Yw37 zL^9NLF8LMkPqQp@@pf%1S3BLD8|i+gPOJuM)P&jw-;^#-`kZ9~-?VIw?%5!g*Y>UT zbhvs=TUkEoEjHPezp+O2%JsvMkAk|acpz)o0dzyTaE~4w{v*p428?@sg!<~{>@qYZ zv8qZjw9PBV;(Zmd&o;Y;&pr@^KL589`i8fLK;k<;qQ;L;n(%*-|N%{!iF?&poIJ7s*jO{8azn(_Go%Ev;_r`=3t zO6OPjhS^j=HJV+A7`2qCkcqaP4*S$iCuL<%?SQG>VdquzSY7K=@9lnIlU4+Hw^{9m zOEV*Pg9c!iK3q%6=jgc)Bl^~b`L9EQhlj8yA;QP8AWwVyccEdPL9ZeazyJVz^K)lM z%X~g^3%+imIf~VUPV4O7%1UwC@5dGbCYh4vl+dTH`vks8ITzM6iL<2Dk{4QW`kN(= ze@&)L18(!j_KAO42x5%G(}HVWA!uY-+0_BiW`eiA@`Ld@{jHVg=Xfz@1*2VBtEmEfxl6c-Sbffs~Q#UmNH}^H%Vn%!`jl;LC3^n2` z<zHKM`2n`oYvP6uY6{$I+}g*(=^?k7&ef)k(B&dqJc+XJS^@0!3z$QS`gf^y zLiPk*ee~L6L+(Vi;x_Z8E%m+ntwp=m#9pcEYWdY@>G6GB3ZW|yGpj1{lu}X;!K(SU zs$WU3{B$H7hte`K*b|Gz?pLFH?$;;@!vd}YCe583s@xuKFXror<`3irr(sD{P2v=Q z0sAF24~5&o{tX$lFq(XF7v1Sv3^tAd^9CIlH+6uWLu~F&f}ZXhuGj!LN-4OBW+;ok zhWbqHxb*k6{4Hk_laBf9;1FB*p&O?-afje;Aqd;Fgp5}(Iwa#v)G*$+&fHA3%1*7u z*<~Zea+|NlJn+qJCzexz!_WC53K~V-gpwj@)`Y{8DfY2zAzU+`5rrjI9PEv{ z2Q6i#K5LRzeh}640B2&$#m2FhKbRKyxDElH=uV?|XJ3&SHBq=I?9wdp$=>B<+jbWUX@Sb+6d35_LD=b{0@_*txpvbbb$NKrr7;r%#S(_+F@GIO!;h4uNuvL_t(^3<3tetD;?LTj?!Wv;6hRZmDEHRf?U zzRrNVGuc440*T)chr*_HtBx!>EliL#y2(xAn97kV4JYXKkoxR3(w48gRIcG;GBmkxSR zhjHA{gm@F6pZ_3`qOaF%-Az-~BxSRjz78j1Rw}FuR)TyW9@sm+wCgS-@!5sK1-N7} zEb-?OJ_aE$EbQ|iIfkfebkgaxlMfONx=*VKj?Xe2{VYG;m};@zM%O3#E02gBS(Cfg zWtawcQ{>%exTm=Oyxv-~wfONc@!;XT-i*Dn#PR-CffZ}Df=L}1qpnKV@D_oIBDxPk zQ>60>dV48uQ|4=DEv-+RSNaK{=CXUm1|T*U3?AtyVa|Z2`EC<1tk$Y&zRNpTSz<%P zEkdenruHDv;Cu-T!_oIn;o#Hx?R1fjgBz+=6l3R-!oSIMNU$Z7A8GizCVG|&EVV?5 zh2fItiR?x-7YgoQ;i!*&@w_WXqGP^_@ca&E1Bpa`$}Eq}Sa)L|;NU3te!O9@CxeUi z+G&u^&+d3c-xkQB#w1!ZxM8J3_Ep?cTKA)X8>Of3m`4?nNX~1m zIBowhBj(nQ(}si(3=DAd2;0io)HNk?=p#O{cT~vK{y{qp4&$`7#;B!uV4@Ue_)M7H zwDzH_d3`uA!bpFbO%q*9xl1B}8GPy2p*7D9nZ8i2ph*^o^B+I_p9`{hj*O)58&?pm z?|O4eAo4NBk=@MPh<2uUVBmiVnD|Rvp+G(6(6XcAvakT=N_~25>`ip#_M# zsME$sueTsmN8N$HX$Gr2KrW-GmNb{?7PFR8ZJZZAI6m2(Nzq-=A|P6Dei-be{PpACVvrEr z1g0I~8b9;!W^^SElTt{BU+(G_zIH#}?C0mmTXyvdF8)rGk?!eNIdLx5di-rhNmwY6 z&j#gy3U$4m7W}_&yvVd500ebgDj(Std|RV+?mcd0JoUNn@!_U-d%Q>FxSAPT zxPp3mdaA0x#BcnV_&S-*1jfx58`B&P&=mX zPHJ4z)8E>=Akp>Joz~N9-FR6i{RfCl;vgXN8Ne8PsEvhZe&qqskJ0l8MsO(dn>z+y z(wG&W7dVpH8Te;4<90MzY@Gyb(J{PqZ#dywg2Hxe{Ma%sYpVjabds#f&_U?*o5lcYj= z09(O>)XhWk@!YF(_^LY_Xw<1mhDjQzw8aOU>>7Iv57ikFYupC(Q+xmi<0&9j-2OAK=@s=Jiyi}Q zjJQWrVzSqxzbqasI2|)} zcg)+7n+_Pe6u+o&?6SC30`OWcVmeLm>K-*uCsmvhM~C^cqn2@>*t?lok8suvCgl>7 zL~PiDBmL!q?%(<4FoqfsZ>v|50+lx0y6-Z5R11$ls|r?q@`AR|J2lG=T-&c}4Mzug+hjK8H#eayGP{dPLrtWjB z#hk?2>D#$&zCD;d)dc(b|5PeZ=L_I!-~#R!f5?^wr`32*H#U;r*`fQA1)&YQrWTAv zEbi6uiM2HB2XY41PlOZLruA;LpV?;P$9AGB8`JRjYL3Egh8s$xYbBU9LAH$SmM2SN zCNk5+RvHNb0I&L2R>i$0qcmE|swNYodDYUQXnz8AB!z!N88B?-JmxS>o#27=8AyvO zzU1hrd&27Mz**9_pr#^4>TuiwO8ri$xKE{ZDvW4$CoGnzn9@h*$ys-MEYSPM6rD*7 z>uGgw6%CVvuJK%yQ4{n|chO~Sy93*gwrTZ_^<1(}7O%=8C5*)=e&Xzy;6)_P387;J zNG9C(J?kbqmAm|$UqsTnU1tXQI{mgXZMzaa0ULFpcp~u)MnkrJf|VAj1=KXKHvTdf z3?m3&Bj%#`Bbr4zwm?*PNFE_;1KcuB6y#3;b*^dV@AFJ`iQWofnra{akRSe zC3J+}kN^jVh8n8Gy2dhZ#nLD+GO|^1DHKVlH`wh&^T)r4&!wG>_)*NrU()B_KUvRO zX#!&v@Qm=U=i%gZk=S-Wk6`Jnt$B5)qsep7 zy5}mODMKIM<3Bs1ox@I`ieypSMwQdF?M=f^%u9w_{%~qqJmilE?o4_J-K_t0_>qt( zh!Eo6_okoulMpFapi1WPwSopn zYg8)p)H`0U-EAPm5hD?l2Q!yzquPxSN|mFU3*OvPvX(bVb|uYXs_oIL$$`CoYf^Ld zj=ERNkMm+NWI`e$8z+p(uOb_lTHG%X0*YxOA|fYU2d~(C21K+L{{ww^C-X?)*omm8 zlOFx*$aYElh+vj4gRA%sq0UK=LcvmoUQ4Kg)_$AtiD7V&i=X)I6=6DQu<|)*mF`7q z_uzX1pp~4T5i=DyeE4k(;|14r!=*7}9Ezx!%q9(^Q43nm8FP5ZaP{k0*S1#5X7cS8 z%TfR73Q^yw%xEXF2!}9i`Hl1$yH7blc5+;@r*nm;IFpLY&$4N-LMfA#hBBw=nuSbf zI3y*nrQTKcP_kdn>vC4J}74eT7OX26;4~e_AIRE$S7RN zM&eJ(a!K;LM(iI$Z~@(E_Acq)-{;?nN2RlCFP2tMfI)H20Df~Tu^~ocS6^ z74&_2S)!?VOs*rA*o>6GP>zb@sQixJj_&C6J3gJybcmCb3`k z#FTy}i;co}wQ8vI#kx=X5cVORT*hK&n)+JwbGv4ajEn__B(e1T{1`M|JMmO5VkV&D z;(X1F)Iw%YXlouj1^bpM4XENiI9m4w&{t);<(Ba!Ee(+*CV%gMNRuX4d_Plcp22YV z=18#UT$auO)YMM^gsc{`=Y5KH6Via3oSMnQoxkvYfX(Eo9YoHPrcOc`V;eR~O7fa8`czjrXTBLkDMm{C7ce}qoV;RRY zCTT2t`;i5=lyx9B77^*aw?3lD8w4jH>nds{#Ew#38CdB^So^8;+H0CNw)}X>x3x9$Nc6Er zD`bUVKmg%Ut_SoVPj@FR`trX{;RD^Aolk#up>g5E=%m!=uy>#~KsaE8H?jqwuQF-a zB3f7kW9=J)$Y1*Lu70F67Ex{_cJpH`rxx0H&Vm*Hvos>y7eQ6dRTfR{hOYfa z;_N7uMo>Z3SSe&2qVDf7m5=C0$gTFLz*-GfL}mC{Gj>Fmdv<=YY{d%W03$!57zvxY zU5PCbO^>)-x={zpfPiT2-QOqJQG-i#lB!we#2T;!VFtu~S);K4lFNxGx5Lo?12nD? zYIY^c5cC)#+~9YnpBs2`IPvSd={%#nj^B?wL(w!Mip<;}-8-nM>WBtJ*z>hd5DJFm z80=t)nN1geaGKlBp6argOATwmuSfE|51fnYJYG1ZoqB!lpS}$8T?;hL*$@ewWp{oBb-$W8-N2C~_uRS#k@`qoFp$S_-#Y6E- zL1;Iv!hKv&!PCtiy}8ok!Ta#)JOje`vJPr+Np0S&jVs>sdCyg*mwtsdwkV4<)Wod zCE;HK5>15Jx=x38LbC=k%F^l`+~cPRYQ#PAS|ASU>$_b}f3Acm|0a}3Nvo59)Pe>k zCXZJ;IoLn<~|aa&ewmgwd$j9_PWbsJnb^%7Cow{H_un^Em;w*#mPZ*E`WNR-<8@y0DNZ zdkIBLybho$c|+9DM_CpJS}Y+G0Q8T17s*u$AqOzgH@7Fkto!*_x=SpMek(gFD#eSE z22b7TH8Zeuv`$h_XRF)UX8xB)cQ-e%p`X;VJB+$TYoFU41}(9XFm9gekWergSFT3a zAV%yc9xfpaiN?zSzHBwmYpe_d6cU$-gv|MEeeD!rUf`#nQXSiv;2v^r%DI3FxVXkt zQw^^F4mm!_bRgoR!~RvZ_ayx-NKGdiR3ZrL4KscD44?+ zZwxie1YD@ddrf+YGh@<`XCr2IP4ua9{3*myH$<>yW)=0A1v(V*MQRB-kAr+<=R?|OG%H8rkN@et( zri6lrlP37qA@my+l$C2Y_uu zmS&{tUt|Oj_03BXOIGDJwfDkWU3Orkp}f2Lf+3<~i`4JY@Y!64F$T%?v){#$2(S?I z-#^Rs=&bo#|7rRu9^i-0mz)}IT{n*q4TSipLMGmIy?Z6TNJ^>7ki_?=lT;Kw;#<+5 zxgkDRP0O!y6ck3(id9pFjSS1T!Mc1+i^Fqv#D+48Oh#jK$20gMHS;qrxFVLT)CX_r zRkIpw3KAd5l>@);feu1oyp+nX&N7DokFS(L{Z|YM?*L{HnP@hD*lu_g*_GYc+Uk9C zYNE8RoA?@U@}&sJ08j~EGeO=rJ|HU<|H^|gl~CL=%GLIWIJ~ddD4#S`<5>ZTC%cpXB3OBFHrxta zH@%FE4D5Ar4L!IadkJ|QmoYdr8y;`MSTcjEMxA#QR9o6qmZJ_p`@9fZBI%q1eSKt< z5p0I>2cSc8{rg{#QnDJDV4@1#{COTksmGdFj4jMY))OOz(8w9In=oZDayH;~wg-q+*j`_dny2 zK*+eQ`z$*bKPJ;YqdAb>Q8&V8Q~&eMQv54rUd4704>Tmct+m=~+;pQKGvS6nxcmmY zssY1b>YSJ@0fETu0trP{S_#<9Hgk1fWjGmfX%7ER2Qe-gv|D5Ew7J&-O8Xj311=e) z(%NgBPg_k^2;@zVMmvjM4B?R?Gs1>48Q?&(Ivo#*uv1pqrn2Ha-3jh$WG4MA2);rnd5`av zO@2rfOzEf6e*%N3Uv5Z>s^Qq@LH}tPp?F2KvbIMM!GRKF&u)Sdez3*!<`f|fKYz}G zqCb6+%15+j=EgI(5S>G%+FtATmQ(KgREO*m@B+7t92V4^Qi$9$^G0`CHsvLo<^1I-Vpz}oy8-l_ zly(swvO7$~q|_tMR-6GezKEy@XMb;yC+N$VL8c37E?*ECF#^K>^$~VPco=^P`7Em@ z?g$>*smKLBZcs9qXvgg^D57dClN32@47Ok4ckj;GQEI}CBoD`_5Au|L0kGsUZ`T-q+M4XH`{Iljb~pB#YKAZW#hwU{hOMnQBt7At+#!UgtBe zI{u!xvxJ=t7R5C)j7DzwJ7U6EDh@{k&_s|G4F`u3`I(A_X{R*#N$EjQ>u;_EQNM=d z_e_`!j@4^+zlcbl>>KV6Y z7?AgM|BtJ;j*IerzK2mtTDp5l2?^|iyFogn<9G8G zKCkEd?7y&kUvPVH0-?pz1x9bA9?YwAcA*0@&H)>aD?V{jrOo27_sv@ z_GnCAFxqPx;HfVRW6I?mfw)rnc?AW%QgiTU;8@YyKHa3ANpxj1WeMPzC6*216#|MC zLKs@RNK%o*t96SfYAKc93!eSuaE$-%>aUVf>p-E^ zV;pi6Ab8&1C0FxHQ;h-VjaGtgEGs4}z9j%Y$u=>> zSNx?P3en%5(G2C|pgP|pgBGUFHZ!FW-yHd@`N3LN+^4G@)nh68b{;;*@OU5hxn+_}U=#Y&JgunAZSX`MZ;R;#DCr! zBZ658?5~Oar;TFVUzwpt;qbks`m8%FY(;5)-DolA?F+1hMZ8-*jQUF`p z-7v;NS$_wL%{-hdD0ssP?9;kSq%pT9!u3RLBu8%Yt@jG9Q=^G)h3`X9FF{$j>w;B&4@1s;gGi~&2` z#=+t4bf~1bq@?GaBpf_ru7hwOH!&b8W-P|xn-n@Ky-pUxQqcy2k*~|z1xicQHI49G zV?#cAuY+y)`xv;gWb=~Xa$sgxYG?)%HxwCy=Unh$J&oNv&4rx*9T%JR{~o;2dU-k| zs9Y#H=|BRj-|)(CED7LTW=1`E(O8Tor7c)#p=z zyMcvF!_PZDZgr-ha1 zFrA|cR{WIeFeH8;x4nhZvq!LaNT%DL9TvR&Lko@}* zF1tsYu;S5udh2zwbWiCQ>;g)XR++5=K&86hzt_#Ep_3rCa>ve}7K@ajnkYnVv~_f1 zjAM-xLT5AdZW=|#H2?h&gy_-2`7ZaE-vVZh`OLjmTTL|<6!Z!prk+kU-K*}Ga~Q}X zE{Mh>L)<7Q^WDb{-do<9NA7S>LgM4CJ#UXM%o43Qrs@~OXUCqgS@cH_Hili+^Ku2& zB@9SFMMpa%Zc=aot<0s&z5oSxj%*N-C7N~oZ5&sEq{y66CLeG>#p?}C`VamYHeL!= zgBj2g83_C`D5Ct~L1B_zD4N?EX+-QdP@jh8+p~+ErlwfJ*Z%xr40-#%bj`nsNWPKB zz%kZLO-YH~p$%4A6<5Lss-bik40OJ-1g!)WpZzfh+OP(<$uYMICsIbFET0iugI`RO?L9LJ53Y>Q~z>C_qvqd^SN(p^c(J zVh&KB3ZMsfT|kHfTvUg+A=$nVue;r*Xot&3kh#%)!a+v|Fe`C=8zHzuY5Z<-Ln$F) zBvh0>x|H%l7t@?cjAp1n;~@;4xDcRBmB(jKe2&9oDT;!dn>(|b(wbHL%h))u-YIT# z4vbQmK$)6I7DC@V7~1jQMg3Lc#ba2~%?i{3-%dST>qUbYgZYL+xcxyF@Bd^J6P6J| zR&>MTfm+8Uz|YHh8C^pymN<{VDk<*I0KDyIhSQ#SbYhXHk)&}yHN-Qf;4Wbfb?|EB z{+*J4Wp*O0%=fojUdr<_XTJhW3;9^0lJz%N=-S>&dUr}(oR8qY`E9oh_v6MBvFuAD z0<)*@qAa=1lLz>f=FwJi8HoZUyEM&}qp2I5*R=fqejOlzLO=eoo!U1OU-wxV2jIZM zz4{+22gT<~#`W~?P*6wPfXDy*Y0m7Tg(3-DGi!X&JVi#SZLJEB8UE=71U=>QmT86H z;GM}fgQ!^RVXC0{aJK7WE#gX+Ju5s9FUOfzi{SVk9Ok}KA%4RyJN zY^tDYxBYt<5jqeDyhvXjrrn73^>-&E@`UE2Xt#*i`NT=HBT?i3&rotbUf9sDqd9(0 zbq-@*JCPFf`n+8JiBQPVI`1LE9>DUP?_REXd?r*!K^$MRQ9er8*rx z%HdsoAHUMmod1)~Y-_0{wD0S@!!Sj)sQ?tvdd4FP#wCh`awwfIpVWpS$iV9iC7QP4 z5i##shfd-heU0Ub+VTPt!|ma7(+#uJAmj>(cZ>P?Z$36EfJuiZt71t18qq2|N|fAA z&e?oXZotBVL&T{4-EPj`r&zbjt_ANofdoN%{QYgS-W=qNX$w?m6q{QaHiKAp{1i`Y zlia5r>3ZBvyo&Y!j5lyKC`ZoU_d9*#7(oB`p$1kx-BLsZ5NJN7ipgze#Q(nAjQ$d^ z9Isdi>}>*Hqx0#u^1;7)8Yw#-Y_rHQ70ZfS0LWig?Nb3HAm;UWgFt~8`n7*hgk;HyHN0V7{3s#&d3_-tXGcAMD-VbD zcXV!r?}eiPijB*m2O4}05l=|1r4bib@*K3N{>IHBZ^}?#Gl838o;O)^1tl7UP#gS% zwzrJF&$~issoHW51)3Z7;@iTjllMu5YJGqNB7{?rQ-psiHu7WftT?FrM4uR(**(Qzjqqom}cGMteGGJG6TNd=9L1xZdDpF_#zfjU@|s?eaRs+ zv03)dn$CURly4GZ99}grTec$6YrVJbsuGSoOy@VzlpAuH`;JCI#V9-0=y4-H4}T{h zZYBNcY0gkYg#WGajeqb0*}yLi1}TlgDVjnWqN%T6JZ^_*L2Iv1)!$pDby-t&MVsL$ z5A5KrH3jg`xnc{)dY#l|L&Eh8p6ciNX^($1HLrFs<4ES||V2W83gARW~Jc9(O zB{Tz`?b^gY%BCC9(PIFFv=Tt-$;ZvTf)R^-6$oN6OZ2q35T zlg-p*Pi?y>gpawLA<~L?epUogm-Ublw?1^fgOVP?M=F{1i%6=*vb#}}?s?zWU>^6K zZxy8F50dID`@Yv1^a}L^U3FqKEekKkJhz9cG}W)7ll0+|^brIa`7>XYDLJM>5G#kN zfyFs~6m?e`@@2PfpbT6Z=*k#`suZIt{ed?UntE3_ z&iA7;o+4=Y*|WCke{}SW1RdYm#CDJKgBj1ifrO_VKm;HkpW9Z0QUHbVINyU!K(#}u z@C``arpxdK1+MxN*s4!L_5_ekbn(m#db6pHWw{T19A9H{R z|08+*`@wI7rp`NeJ&cl-fe84RZx-0IxPO9&$>d8l*2zWDCge>DxmFR*Vb z@Lj+KVH%zORwx}YJ7Wg_%u?@;!s-yPg!vy$_rEE-NqkU|B#L;q>{2kI7HCWsV(WU{ zcIbIgUuC(yHBk_+-4m5XHx<2(Z=wMzBc;=g)Cn%Zlh{q(7|gm6#-0_=b0^>=c{)xxyf%6)^gSum0Rom%$CQKG;$aXTDa%zwbxSGe$_n{NHh(HE#!n04y6t z|IX2<4g;Y{pWByP7Fi6G?7Wa^QXh8cBKcLH^0yeNSLRWYA5aYf&(^qtm&qhmZBRlI z{(Sn;8t6bb9|JbeCch#ImdFOpo3LlA{vL96EL=Ae#cj*f-=fZ;m3vz0ubF^71nkPq z`|}pbfmb6JK1#f-#7dGtdfg5|@b1ihYH_^S zP>K_62jYct_y%$_)N=y5YHBLP*$<9=;c~2e20md7j+>uK(6Rluv0Y2{9dCdT9UxPj ztgafA&!Dsg{tsQ_`V3r>4V18SKj3RF6!p0%awlo-3Q1ImKc&Fk5?E zr~o-+e~#0L=j3;UOR@5xm~hk&GXvGWx5!xx&cPqR6m7${Uc=^@3F^#xjlUZkDTvvS`Q^XV%04`sou`{HF1Wu< zdD|%p<3pGcf48Ykr>}r}?Btd~T%>NcL!BIT6`+x_BX1VhBBC#4Gk%so9v-orzNMpn zIzQ8~v$NCFqq&q8l|-f^?3fiY9Kt`98hU0mzmwTr76SvxD!<}E~I3T0BOh<69ioG~GUSPF4AnT-pso(7^F*-~0zc;GpEe)rbc2DD~s#wLe$ zJo*vq|32!qjnfbrF_S=3&bqBBe|&}WC=nlYhfVzOU7)6wrn!{JaN6&Q#vr<>CR(~r z%j$z} z@dNHGPmJMa{>Nw{kQw<@fS&TecU|wNb$h%~ihDP7dxZoxhgX4*%O2D6FRb0Z^0=qn zT!H}>^7U`r8c*?$k`$e1w{IxhtO=Do#l}5;HJT<~=&CxMaEuL}=|g&m1Pdsa+fF?$ z++q}40*Yi>14;&&mXFO*t?&&uYT08}NLXG3Kl#}3kEt-I8#;RPU~56l#t&a^TUzIu zb@{pUQd(Hx|BxOm?+>oW&Ueb%!JuCQi=a6PBNCu!p~0c_lBW=Lb^AG8L!lH|$ig zvR6@AIXTtOOp)(%p4`vHmIp^4x2>ZCel)+Z27YA{{nm^^aLdu4iv_Wm-)V}w8N92r z^sV&jqG4bdmD(0+4(kKexp=mq*>Q^o4kfX2?r9jQ|AqeS3;qnfi`~BI_%{8zvQzQ#Ui&b#&f|KMBNg`ZKtL|Mv3T#)28iX8&-KYzXZ)+n7DLW zGV7>stSP140b@POJss$alB@1NWf;2!atGM|UE?pjS8wL9hPPY*Bzg$=49d}g z;#OgU5q9fl_W#)Kaqr2Sao>GFr(C#-*QB>UyMaBtyvx+%fm6a$RV`9O!r*}w84(cs zi!~5E7`W)OQV8D~u@J!kR|ds88aJrp{ZPEijhmi<_Vt{sBwug)^T{y8r|})n5|v1< zOvKM9HuJgjP3l-St&*vsG(o*0HL%hW#hDZ_jb&CwaD&R`Z- z0(qgK@+XjhM@85_lw1M1%^|4ETd!t4oo>o5Q?He62 zxwt;nL~12hVMl7IifR1oKT_7E%iEv;KQNSs8cb4Qt=z`XrX~5~m2brR8UH-Wqjn(7 zxqu*#r@svsz8)LHM7)%;0lYe_RVA6eQig{0?TNpxQX_lXVPzT-D4M7uT?1USA7b)R zg7@3Tdnj-$z>!slZiwNG_8@N`7!=}%ogI7xNNC1}i@=EyiZYfhLdV4(<;$t0c4XWr zV*5d)lt}P#`n#R6Wd%Kf7lMCjY?Ut%nT-V)Ykf5kPUPs@q1_3TvRkvcVB^UE_1(#{ zq_YLu;ABzp)cCVEL1?Z)jaF6-`0`-_Y5H8`No(`l$p#^|drQp!tjoVZ5e5kowbzLz zcq@6#D0UAnNL$sfB^|2Xy}-Y>Cz5V?%b!iEM2K+|uMeo^Cf&2cAcO zb(-cTq*(j?Nd5@1a&Z+H2=e>MeUnQ*RkOP%X-LNPKm{?^Wajse1@Uw3{LZ;5(`_Hn z4*CJPym?A0{1+>HTXs8)v!EqFT%jv7w$I3oL;Oa$7y(NC;aXQ9%HS#eoC`SAW+x^` zPJZ!=6qmvbT??1b2GrSx#VyZIXCNcf(m2_`^RlL2v|ku`jr)7}L+uFniCwfY0upM+ zJG$Ty=f9f`qu3)?Vu%fm1 z4R|S$Xyqoqe9z*(SXG3@Wz%0sH6PnU`MJqB9aed%hgQKfdTnQr%nVUG8H0_G791~3 z$n$;_^Nf7mg}j$q&7ysT-khYmMONH!1ToF3<&ML^07(-G^}%JY7be%bou%N+*0Opo zf429%X2QE0s&a=1M{325>^jkW!*!2Z7%3_FFqij;DP+>5Jorj@a*((MHKDB=+D5&9 zXQx^5kz(*_CzVX+ZC}}5T`|L(gW6Brsx952$f!Qba!LxLrQR=ZT)g36o9qJ8NUo~9 zx=)*P$S`H!lL!&RV@*g4q15`D9Tml$8VHsS9j23|t+_K!@F-W0c#QZXPi~wB`+Tl> zZwP=6Hnss3Oasoc-mQ@4Ki#bA+YGFUMqR?KJ^+9F+7X4re>m`CF7 z?kPlv{8s@a*`*NNFvl^-0`;N{UWk#aRGWst5N zB3;``N_qo0;SmbkH*z09<37!pHkC3C8(-a*f`z|8`q}e#>*ke@#=qB)r#KBF;9<25 z?X%Tjn$Z7|$l0=Ek;W1j_4HfOhH*ctX%ou8C9b6;)=L+@CfTI- z%t?3(z1is%1+P$o4b2evt1MGM38A==S9Gj!4yn*dLX# zV2j>!UNAE=SI>p1l*#Nfl2X8ITqJhQ|EaCbNoIy$=O-o!$I^Vveg~c9rblnqQUrnM zBv*pg!IJ8VYM|gL_OY}1%Y=wm)BArGtSl_OTwR%b40dz?0((V-z-aOAPCy_3xqDmq z>gkrWxF2d1k#F#w8c~X8=R3CO^hlx@2m^dA{k0ZNOXM#cd?RWm54GD49Etn??{3)~ z9$6mUS-KVu^5yck-?F99xeI&R0ROv9F1GvL|=5n;~351!Ycfw4OtOO%%?87{I#1qex zCnIU8#_WydwZwnQ?K2wOBgI#Q8o66pRcYg~M*StrXih+PBoQfSBu?Yj)6~EA zqS5{u4FG#_Jq#bE`faV&XPWbnTa0@QYe@svU6H#U?pnc5m&Rkl(9L9Ud6|x$Uo1bl zB+{nQKMn)C@=z&{N-h;Hq_YaOg6?7p9M#vXc=oAi>t#G7T8QU5w(sL@jBNS=_jwld z7~he@Az6+u5<0#)>dnS??D#E(7%NMP^KWts-y;V-dGwf5y(98U1M(1W5DF-`xuk{d z-gg_1J21{LMZIX*=gx{XyOtFU9!gw9PvR@%PT%1iOhGrALvayxX*c3-&YP zrm|*4dRgEj=arQWoNK2_axfE920h;; zALgE4aSf^W{Vn`=&Y>iL9CnRU4l?RHd0~%|!>oByPFCCXg*>2fc_wiWojxBL|2ueP zF%;55(T>BkL!plW(}lu=7gcf4TW&J$=k90$-OslAB@m28xbp>Ozvh%3D`UV7p_eV^ zG8lJrCF-)pyVl3MQ^bLmiAB2kcpX(jRxY-2+;*BWm2;{yJfmhDw=oF;mrd4vlXD=l zX_RO+8B%{fC68Bt$BaZU*v+d}8vwj;#LOsJjw}=7gqLh9B=GK7uiNG>udAlIx2pQf zLWeFwDykfo&#$)Vs^ms>HlymBp-U@B&Cc`fq1Ye(drX zvir53iSn}w;1|nd6Y=zoZj=EktI31ahO=>Bmsy2-?ek_*;io!%zjqu|ZMLd}yIuepD+v>T|Rzu6-qj&vn1}A)gZb5^tax#F+Kft5R#EWNx3jFIB6vx8%?B7?#k18StaKkb6_gjzyVCS%dE$v-Oj+ zG*n!d+7(6|&hp2eUvhzj6rh0mwkaP+p4n$j-J$W{0KNjUbnus{{Z5x%EI16>+JOG1 zE>J@az=L{v`;GwPDDC_5vceLYNYl(0Kyqj;Iaa6^oZ}F7`i$3=06A!PdC+xsSCu6| zsSvBaEXX(iUI#(bnHqY>@aI^>WTl~;188J0A~2IYRkAeP^`6G0h_bwV!D>gO`RW-< z&;fD>OVL*c9%B`Q4UM(6a#6m*dfwjp!C_q^0@>T@gYj}jmLFXKA<`@}dK$^_wzq&D zXea#hIzl-C5Qw|{=NA2hy5fmwe{UDV(3thtfAUT(c%OYyCt##}Zx7kEhgpSG>R9;@ zG-lcZq!xaAHU2?JDQtZn%A;95ifB(DSkW1$+*-ymARE%5F@W{|9eAo5o-CijeCJ%E z@bTXp(R>V)K_3tYy}nYEe(<|c2v6Xa`Zo8W8w1hf-QY!Dnl+f159T?JdXyk_3!o4U zM*b^siNY!>Vj(gV<}&`m=KJar-sK7RsMIx`?Tf7&-yu%n|6ycL_T@+&O&CFW$}Nw8Q*^oG7v%hTI(sK7-$-rXnk@TE#V%J zh9=OBFL@>%ek!%%p7!U8o@#(Abr8z%-%&_~dQ35|l);+mFC$n;)KU#*(q{c!VG$3y z2@ahTj zUBLmQTQ@O7xX-3%{vS8t4M6_B_Dpg+xx0GQj0bdBNua*he!Z>#g^!c(U2ex& zSqMZ2YNTKOernmev1V_oA7}0UMl}DRK8By?qm0_L&V24idMJ1CJ&n((@UG`HR(**- ziY6UOz@hPfx7H)*yO{AQ0^UF0XP8rF<*pGS8z$6#+N)cC{kEm?g4q*q&Y}oy>Ev6I z(C?cAH?QLnXfCde@Sh3LwVC5B5-f*1M?G$&$08>d(njxB;hq*4ctLB}qS%i&Y$^_8 zS*3(?C|NoshwoEszxz1l*-n?RRN6<7r<7Ai+-!v=Qb*C_uaSpCBK0PGB(hF&z(3p@ z&m<31K?o@|D|$T_&KAUX!_k*6+n0y#{q)5t1cs=r0^4J3wz#$#0+MJ5d_b)MVHeB& zv5vu^+g}MZhG($$Kd!XP`3sKl+uw|VHJGD0k$Z3*TbfzRT>SpKN(~fdsAt;^AaFaL zUWHg9_3va~Ah8#BfpZ6C$=~;qgPP)%X(itJg~yTuF~5w6OdB+O&zYm0w`N?f*@rEe z@O6gEp-c2({CCJ^2wJph2*i$a9Bprht6X%~UF1xt?-)$gVMXRnuKw&8k~3IV&g~~# zh(h@IC^8OqF#VrJqTCUH9bl6@L>@XP@7LedVdKi-iFuFinHnz|r`VkOA?oF!Wifk@ zd@@qA=2!pQGobg~+{m?k z^WjX&&j8`YkT7vIEUF-cGVC+5p`A#`DZpqO5R*vjvC|ys1y38j0cy2jGvxE~Kkz6@ zN%owAYqdwvEc>?PtR(w-!JV9(gcdqu;6J=914?)2ccO=?DgQPaDiveLqaCz-oS9pk zw(?5^W+$*j68*cYej@uozImw@Bi(Gg3>*$owJHtPP=U|qS8Z#x0nnoidyfmz4oA^C1{(o2k2524gDQLa z^(cGtK_sA-sU=B6`|xd(n-S2%LVCmPG}{#BX}DK6s0DO`F!Ngb*@%0VkQ@0ulY)+V z>^8EwRxp+HBJ4Ab1a$(hIjeBu8>=6~$BW0AX-xkkV>B~ItWMHi;+<-v(UC{a2fMHa zUI!QWS7qaQHRz_K2}Ua+A+B%T6P)?3dF%|6i{Y6cl(i(_mkz)*Ra_8gA4W-{zS?i+ zmiP7{Gk$Mz;8@R{yIh|IHJlNZp;0smFlpAZVv|wh`%%-JJ9DV1LWF2K=|P{3BJRn^ zTfIAngF#55-owyE{RE=tl=wvcesc0}hI{M?`YbJ!{{D(3zC}pN*8 z$8O{(B2}%ywXgNb57w67OpaZjQO)YhGqC*_f=77bnSNz{0o*hGcTnmquvjL8h98<< z+TpCfo7}}aV#dMxDbXd=mt8~+f3>3>-Kq(N(1b;5@SSMNE()i`$}o+gIS5%Pfi-wJ z;(*Y_(?Ns%_-Lv&`4G^52*DMMs9iRSiLo%xn)^u|&*CJSQvV~kJK?flkrV^k%7e>JIW*`VX@c$l-KVwNhG|H~i6 z1+t>~tDp+5!ww1Z(Dexw)yFu%#t2Vc@8o0fPZP}*`M41odK0_Ho8N09%A261PUK;r zw7`azqKI|?-rhg?t-&PqiGS-f488|N4<4OpFzkmlD*WoJ9bK#J3WA_809<9?fi_F@ zzX*E<2b-CrJ(mPvmo*~ch(K85$u%vI_a5)`1#cV#$9$7m+ey+{XJg$$T(gO)-w|ud zaN&QYzZMyX>bgQu&jGO#sL9fQJ4%g#zw(aJTY$g)!yEf^xM$Qw$}XsqMcwaXCIPqY z^?(~s2HtM;Lb^le$Y2^eX&58!CwR|FKwRwlvL;Gmr@kEqaXoU8LemWG_J8mKN?# z?3#b_)_x1)UFC|iq>XPzY#yOjnubEK-zJ0NWDW{>aG3qmseXd3Vv`80KEFGT;m8bH&zNoB@ z`bC?8DR~OIhf{r^dr*Z5EXs4_AO_)sqi%W16kzZwxq{%uo-Nd{*tzL!&cBUYw5 z@mW(BYm|TuZjBY}L(-$L=lIvEIzzINp|8V0GY;GDoRuqPb)}3UnBrbK30F)^IDNM+ z&cr$pJ$>7yymm#uAkj^CFPdx|n&MEZ%f`b)gr;ncF{{!%)#L`oZ(6tw=*=28h?SgE z>SalgYcMgc=hKL?)ma?9<%Zerp$fnFP_;`i`^SySsE0;-s(z|u!m*yRo(2C6_op4- zGWoKV5-Ea`;SV1M1JlN+B&MXmqH_HJTgqoZT4t~kDL0nya0#reU+ z67OVbSSo-nDe@4Xmxg&CGpIngn^^t<%rmd~L6}NA-37s@jb?LH#MKo@8<_EO6d%BF zQbcm*LHKVfeCPcteS#M_N9l@0kiT^kTpP@H8yap$62T+9pqq~L$3^pMJcF!%mz0^G zmoy8C8Qm+FikY3_@lbG}z)eVH=(MDnt(8XV-F~{_^@Ir;UBYh0{ZH)oY1b@n(6d~1 z+4>m|_PSX-aK=D4*$8!A%$-Ve?++bM>h(8Y8(1DCmeE=;GDUC5OYnvz$qut#^&kL*2!U?h=2 zt8Z}>EFHTG-f{Na8!9-_>^&GCNO2EDHr4T;9^DN&X(`H^FI(GTo=RjlVm3K9cCS6{gY%_p z3%Ux|Px_!r82TZRRH|8{weMq=jwI2a#^yWz_LL)rPDP@-vBxk7YD1b0bV zOJ0fdjag^@_2O0^{3leUnsKLb%q0krmwg((BryC8v|E4VBbB~v0e%*#x@k*!j=B6@ z{~up)X*@KkI%6}K!F%t2N%!e!<*{g5&i90sbbAzHdgM&dA0O*-UJ(4!{mT>@*NUhE z${03_!#2~+It$rNDrjunCiv)7cM!WPkg|Tf{{3CMx=HsCAqijYQZdSDYAp<9EP3AO z;97e9dZwXOFn&&N%FJwcjT#k@>W)6y<X&gZ`h7_VF;XR0p9><~gQ~Jro48Zwf;d z9Zu@&>w3A`eN?jfHRRU2oW9^{#j9TvZTkC9Xi$no+IvbLGtpOQ0%5spTbgX{jXfo& z?k;{bZjJV6n$P5DNI(-1wJ$A)o|2W#XNkF%$qng&hP2Y@LVy|s)a+avnr(7{xB?;Oq;^0O$qWM@i>fJ40DfZS4Xvis1?bOESsk8*Dsk;ld zYYTdT&V*MW$3-=juViuv$7Dzi=%>7u8!}qR+K{g@Q#2X!cjtP(coGW%L=Kuoqb@jE zby3?EO2b;~nPn;*8dN!#Nvb6I{ika6b%w&_q{I1^nqg-UXt3w0p-k`j&>}KK31lHQgV(2Z@qMo2A>MfLEbA4;r zAZWE+LRCIqufyeJFf$>>ppUtzjY8{%zwmyRk!e#VMPFglW1||S}T+z?Y@wY)< zT)6BmFuWGmUxqMcX?LzOTNyuk9szd%-A9ik{CfNFXvp3^S1!#z8W*{%4M^U&G@js+ zrEIPZ$^T2SF7F%x`l_t4r=Rw+)1=8wYo*G*xF|)gIiI(kj-5H>&Y11|W;kx2heFC? zx+pS+*!^R^sff)v>P($`2>uoN4i7Px`xV}E9;MWBcu*n7B|h=Tr@yNi3Q#lomkWrr zZe?dtA=VZ8_Ml_hXi`8LHHNCzBGZ!g~Kf9nj` z;w9Z$Sqms3q0zH#G@o5Q>J?o7G<-Ocaw9RM-u0tqd4==e0pOw*py9$O&W-PkzzD3B z>_-jcG`lb~So<>dNmw$p*G^e&Mwm+A`(^aVfZVL~Uf-7cYBGTYqMth}^5-lla_jQK z0a{kXdvThQ--`#@S9V-3b46uxDOD?3gm-mdFIqR{zgP)0UUXbSmA-j8-sF+o*G%So@5R;Gh>-&eB z>7{S?>Vk_BTcd9B57qJ{ltTjsu|=b--$#@BbFoUodX?uBxUNep8j!4H>RXUIcf{&h z>-|p794iMO{zS)rbUQz6JG`Gy-0*w2+g;SoxpyB)RIMA;krJx;=xp4%i1L?9;mmVi z2X}1wYVtUf)<5lwcMs4zVZ%o@_lQosa*YeDLqmsvF^6n+IYPfrO|b zj9an={dQ|~A~Add(rT;)xW)X0Ul;rQq-9vS=?Ckj2$!kl`9~woHx`lI>3RN+-}$jN ze0*-9AZ|7bk_Y31t@qORx8VdG^}lS(Pi^f-IL_weF!jqy{#f1~z3rtcAtWr`?@2nY zSn%K2{dF1Qn54^Zf6eKtQODO4m#18HFq?De)TR;c7^WDBUF^F9~`)g=`0#Vqa#pc~jgV=gQw{DEFgIyU@pIsWY(Sk}dITbf- zS0~HHHvt&L&>MkN+qo)mGkEp7Jj{>;$K&;#=WTRWcv53oety}Phb6KU*c7xLl%UfI z!`0|5UL9x9=I9Sv?iEuOsuI)UpTX1?)pH|Gix+p4+)gOZZM@M>q*{bt^q4!?IXcRf zvU8S)`a%C!6dR>W>_1}9(SWK8o7=j*Up(hn*;Loa!a4g!M5s*GJ$g2!YQIXB*(oHc zjtDcQkf)qz!gM#O&eNjUtsZah10%*w|JC1FlP2i~DRI(Hi{05`wmFvCFI^QMWHO@i z?dlKeNUZ#IFlU+C=gzgwG8$1Ev2U7pNU_pPG+Q@mL(CAQcpOYZk5ktfeukgnV=tjY z-{))H9<`wX%@iM2oSJU-dk{QibB*|GKC~%KyE`~E=$7Q?uU9TVH%dxGL>TPrRG+Au zt+&IzGvh;i%K7a#oQEwyfBeWm&m?JwwP;<<%j0C0`Xd#_m0~EQyqxXC7ND+;X&7`^ zGHeU#I{~sYQ%oKi;RAdBj3^W&P#zH#k&X`QYT?k+%hQv|+sCRDs2+*aUDf)^fzuzr zQnfq`&hG!9jN6<%B6hF9Sn7q{{6>e zZHgl~p`6}`ydbsf+pqkg0H&Q1+1w(gKRiwSUuX+8Ib2oi1oj-wIXON8{KN|LC95dH z47)Fb-)@A8Z*vEatBg0G<7#A#sp&2#yNxh|FAhQ7dQ0H2qlG;n|RU^J&M5CCEA$tEThs=q;;FTpj&;C0Wp`O3u%MdZ!! z5)J5Yzg4wi$n|z^@zYv2;-+B{VL33x?*gXn^0>C*?QG({;GD~Gt*o?mEY{f6+*Fs|fNQ8X(`$IQ zAeUk>wH1P?jPs^k%P2Rme%vE-_svAj2%}?8ox*|!yLrO|O>MPVz3ffPWd1%a&#GhY z&8;t)4(bF0!+Fz(IPYZ5??m0>L96L5&CtGTN}pR5Jv!qkc~C3SJQlce(h!d}{nL|M z6h{Ug01JZF^l*1rvv0~19t503HSQp&IuoY9%a=Ah?4T@S$|Yy6mEG*s&aZ*)sDvrosRDw~>!p&gle0~x8a8@6-3=UifP`ju9QB2);7`n^SR zRE|(}_L{Ft(b>vdUz@Q?#Fpmu#>^hS?GF$#X}2U;UH)jMAWYhEb;W)4&NaoruxBA+ zD6HO>w)mr_;um)h581?R#r95nL3N(X4hlr#G7i-VMjY%Ew=s6>CEb3Eb%gYbOr=#l z-1+m4UkqW6;r9fQbb^a$XL_si%Q(*m7c%q;l@pnNL4&D}u+cbG5oVFyfsoMMagEF7 zi0I2w<&=7sP~G?!kF>eevzBy^65aw#`HLwLFLb!A&dD&J1qesRYft;k?PB-(iGlC! z3b7pNTTCB<(^sdb962YaIL<+T^Ov^A^C~3EvwET!Vb6kqV!r7@vo=ZVOy~w|#;{1k z!jiXVZe;c7uo4(DQ5%{Bm{d_Jb1Gp{>4e=PbD_j3N(%O@T_W75{PMla%>w@J^J;7y zl*`VCYmuq_?-SS3KMT~tXt)XId{r4T>{|2gVt)vj2G3BaT4xvE%cK;zS=`$dtVdQx2DeCd$ge_aIM0@+R zM%nK5m@3dxbYNBZuD-^fAP1U4M;vULPg^>C3B#9UY2O~JEUorI^iUwI6(j9CA~gQd z_tWW^iZoO`2+j5=mw4dUJF`sMMp8+i&`iPMk4V6FVNC_(5u1hLWox#vufHRRpo=0h4*ug-X9OXq(V@^$i^U^B zM?t%C>8=gjU#W=k=m_pVSlNu3xw>MD;xIXT-UN5pbLjw8`-@Hz#r47YT)1)f+;d{~NL zRK-{`{r!a2I~xW=C9RZ$S&O|jwew$#};l^@mA~$9Bzhbc# z$<0Vd*%^?DBy~v7Z5C zISuWS)>&gQ<^+g`JL(5HGpHi+y22G5ZpVw-g2E#L3um4{`;Uj)w1-)CMzKDZRC^U7 zk71yJ4$>vx@(k-8e(arfjEU^qp z(1OS&y?+8%O@Ol8v`?0c?(mj4q0;&-ZC3MMZa2x|{1>3DXWrVUMbpY|5`d!8>Dc{T- zQEa=j9E?W=`ixUA6eqlel%k3i$z)f_ppvQtl?ca*L?4ug$b`cO6m5O10&yj)d*IR% zRF-o42j90uEGvlNtWBnjV6`hnkmgkVKc?O?tj+ED8t$o4ytoA@Uc7kl;_d{O;%>pc zK=I=4MS>(a#l5(@ySux;`8}uSf4%vd4|lTn%Ub9yACT)EGx{V!@>40Gc!#N+S zyeBMSCPm32XCmGi;VIexQNUTCnx(O`8{U@@Y0*a2Q%N0WOW7T2w2ZcI0p`(Jr8kA7 zRr5EIWen;UCrE-=M)t0&As@2j)1$TL7R@^VwuS3Yr*#}%Vc0m&1Fet9PaZx#-FIl% zOw{8nPH^|ATeqisxrJ%$Ynf4CM0|?2-ERE~B$81oZ@Ei`^zHNMQ^(|iBwd(}R-X0l zBzzUS7{xG2sL4S zkcw99uItO@##d^i$uWnYN{)GIG>MU}o8L2u1SqBBfY~8oKH~1Y&L_P+y>RK~aLFKs zgDM7yK5a`vPV8M3KgtaHzBC_lpMj-=!G4l3n@e29^J z6Pl%%1@$X$`%uf`+A@Sh@<9fMgt%C!1zMR&A};I7A!%?K zW&05?gM5@_miI>r2fW2q30|~Po5e4;27^6{+oh6H8OHOQ%13qy&WqjbXFRA%<(pE?y(?Ode5}2pdBSzpMAG|w0XzfqMhA07Fj)B69T6_x6i_mKW6uSkMqOo{Oc;u z{r_?3yzm6(0yglBVhaJ1N^Y?3%xBjXh=;wqStTWHxI=G{z`?qc#(_0nu~fDC{JV34 zIrEElA~BvnZ{zlUWO`tAGbpw#(@^p{&CVPt1h-S+_${QwCYKu=KGf_j44b)gbn0M$ zG<4&oNYbJ_IAZ_UvtW>Qaw#G+qkT~pCq!fnBKT=5{7{Kx~5_Oos40#^LX zQOK=FM1cqcd~>ZC+lTlS!c|dh7hMliI}dF%=Yd{bck)C*J#On+{QB>D{yqNMD$eRr zB1c5lekPvIq4#@mB^!KBZKpE=apl>-cvt~OcDbvg1VxA$+?W9O!M$I}WGs2S@sM)u z6f%wyuv`c~%Z62OFb0si;8S|dgv%rgY3@l+#et{9c;`(D8*M?rDDxQhPZ!l(jtX1x zG}-OZz4}(+p`No%N$qyG!4A!&OJxWdW1+5x5Wu7Aby+( z%DWkfMHAYz+%vT9#>`)VKFGl*;4F;oL#s*eQ~0mPo*L+}HFi6ilv0b_q#wBfs*tqY zd$m3~MecVBdj21k%{p)2YVBnrishASNBQ!#NHgT~!p_Wo2ps)0y0 zHRYF-jFSL+fAVicO_H2Ye9WbS7If#19I+WZznBGjMk(NzucdW^-EN- zO`5%FLPwRHjZ!-^$XX}ANf!j^V&uY@Fduyj5uBH%2n#;s zCL>*LkB+}d?<&CV@I(_Pr8GSSb0J2KG#%O0j?n_9R6Ha5e1GU4HiOM57c;74ZjZcx zyT8vRV}`KFPBbg_~Wd}to} zVaLV_H1nC|o#Uc+Bd2#Wr-cyoFZbcQ5xhw^N~M7c5}yqx8p7ACY}*zJa%OX)0WW&XsB6Hh11bx<<>IrnMUTu=-1Q+Jn7;aT9W z41*K~bIF_EK6xx*xINhd_PANS5{MVnC)=TiL%qLYcD^beP|Xl5|A;lR`jh;e!k#{- zTlmG30qKguk*-6_{$A!ufSLE-KG?@kL0&0lj~w$teu|t_)4_*4VSmN{#_{921HJ{P zC3o03(=vZVAj_D2GE2~=lJ%iyu!kV@wz0;EW=@K_K3{Mv-wI{5r!Lkpb3)|LP4Cie z(5VgrMXs`KlGiZnS?Yv3AA&_~%SIa4dUWc$JET4Bb$4b=UP1!-GfAV>zE}NoMefsO zC_ORqr9l0ww<9+!FM)q+)WlYjN3a?prnepWIxIsb5IU$UCiZG+;>o2U{paG2daQ2l&cZXp$mK>O zmCtE?Uzw2YsRETQ;SMbG@(%hS>GC(oA5p#d0s>(8hV31TMkl+_AxOub(Cgr54V5TY zNOw=tV`_|QMu2T)tl8O68ZsdAXN-ctvyAJ*-V>=sJP@I6-z8_rrf0~V6BW*T&Sd^i z%Ce`sKw5RT1-4y7=waFB;Ppc9I|@*3eK?Sqo@#B{oRL^X$?$HDTr}NzI9~DL{L#`( z)MAH0J`!*ljv9475IvqLg?>a-1l=1?oo`w9$~wHG`?ut@v7DV@;-I} zmBVIDN20#Ul06cPlu*CCAn3g3ilc4Th5bUq%M0^fFy}!Mr&U#p_sN{u33U7`T!#Q- z?T91>(I1ma2}CGq>HSXVD|x{O%KlCIr6hQwxtV+Q22doWUw8;++44mD(}>BM&(M{2!$tc8lmRKt8KtKkv zB33{Zvp|s)UgD6WE*V6X$AjA3@!u!BIt{QdXcH>9S+F{FS5`bVChwm6^eeJ74+g+G z+~L3t4-2-ey5A{8>R>e|{>3|Q@1<#pu7pE7eQ;D|2Dg7oxheG#mO=bFtc;C_L!DQb z-mn#3o`Rlz)KFugr3;kXU>AGpeHdkrKq6(4-vD;utArJe-aM^+Q)u{DyZCo$RwY&g zsOV~S$xQaJAL7>^H#8X1OKDLG`jDwq+HeX$2M{ffem)^+gdssbLm#ic#)bx1WYM(h z|CvTV-{IjaA8b)#E;j7DT_HkN8R;Spgh~HsPBUwd4 zi;X*di@+XrBulSEgdjKaOICbX?~FN)1B0ifFzJVi1oX@(nlnw#911jBEfSR+{mArD}2rP%f_2VqSbWqbq$m?}XgkM?<^l z@B%;?VV|%8+FC*j(hGCe8eV!%$aoCtOq_WSQ5f8SdoDY@xT);7 z8HD_{6F;V)R)hmJ$@vcW;y40{YL&y7Z0mV4srkAk)4H|e7YxMTj5vHtt~fyKN-4R& zi^_?P!_m7Ttpf1MJG# zOtvf!;mK6A6lC2^HJbsch|onQZ1)1o&AjRE?i9vqQ86@W8W?f>Ksy{w{+AbUpaPxF zJ$cioWehQzw>GKT`Y4Oniz{4Z7jWW_p6M7pXRA5eZO{-wjtmR*rx2xj86va&|tFdx#-d23D<}>dnyc8%`*bZAnMrOzB*D z_K7K}Oy$xRWXL4;$Qj1;ePUrmwz*rgpFL7t4N;in`#Z_?s;zO6(SFdG+{wBiXU%*& zRqPXo85#S*(Ej?L9`RhSRPZ<3nU?0$qk0R{BTJ+FXx1RF4}>K*XXOQFpAgPO%sp4^ zqay^ZpRytN5~T3=eL!y3ptHd#lW77lpDIQew;)REUWq+a8DE5orZZ;W_x`$eUu^`{Z zyg9aX;LP6rXe0C5J4?Kl_?C}b*AvM{Ifa7L$I{;t0JXKwH|2jf>`7dEYP;en?}a~5 zcg}aKyugYqf0Y(Z6q8#_t5dKo-jO1~5N^=h)PRj6y5DeqJm{rq+=sIF;G+r&zEgG5 zI25dNso+kzYv5xpi_-2pgK;NLji$S+4ulj>LZs>b|A&IS-$v)VxJ8?rLCaDyf!{~h z*3M@+xzoXbhGJez<~n}IHHJFp9Zve0AkI6c22RegqSxdizr-JRJNj#xPV*P67iRC$ z#rt#fSbDNk-gBW1T}`#`<@kieTlxgjmy+Hef}}7k22zg1N?DJjobJNv9f}9E$AV4b zHx1pD;-mLHveP85OhSYq_(2GLRvOT#SKgZekPAlo~l(;;6-+gehEll|lR2N_&2}$T0!^q-i#@wz|1z zuIWGp_w@0W@ZhQ63oY3)B+FspSShUQb0}Y4r+JGFcro3jNPfHz9)0;t*1*(ce@tHI zn8Ox>Tu~^%ozz52!~_~Zo|34%Ndc0w>dNJ<_d-UA)LUC2)p8JiCPym zL5wcJV8XvF*7LK{K15o>sK*gSHdq;53u_Gvh8%3s>X-r29d8J1O=# zR*WivX#ldh!d8?B#<)#d^(DWj9T?H%kzgqos6+&m0zf7S0RNV?T9%i@3mD}Kdl~vX z#uX`%LxgHGBA^BFh^{cN0ul02nDB(t40hCII_1(Q^OIJb1wFDY0um3jxH@d^r|1%& z0;m>vXO@}}s;){}WGE;3qnYJUgGsv2e&s0Q_l(|d4hDmG5;%ML&7Qj^nEmwMR}u3o z9#g$o&V2@(1OmL)mh}Bgx7j!4#a7+A&*S>}snNMJg!maRekTteU8&1xt<69#db#%0 zL?kw*>%~p?I4;hxe+qVRMdKU0h}KJa_&5C5a;*f8d<5F279}R;x6F$`wW3u?dTV;I zL%K`q_6!$__M_9Rv#asIhlOJw1(S{5&H4X&Em5midys#%%@PyK@zKJlDomgx71Ti( zfmaojXrUd(Jb!*aI5sfIoPM0CU(tQ)HJq1a`R&DjNhUuj{z`KO0ElvNfr}9BVnr}= zJxGIDSrx2J2$yKI;(J-0WY!f+zE%^Gs&0=`XsC&PXqQ%PsMd_^1gJ}8F>3!gfO68u zcujMkn)LS`42XBqDD8>7i*&#-g1ts?jpR)WT}}fCZ+zAj$tdV-A{!WX+q0e=Ins1e zgzo+3eA__YqIM=~)+PWR;ddN=W5(=7&BF*b9TIa&8K~keN+|A>C4!k@JhM?z+;mxb zK`F%BiK|E~*;0F8?-__A!!;#Kg~t|IgIZMl{xe*8OkPx9EwlwVZHR03vyFd5pKK*O zPcy)tXw)Uo zAf*JdZg%)kKlnE%8%I$GjD5T&zow2=LWzdFo;p}wm3gjl*fY@~EG6~sB z3EJHYi?gInUTd=z%X!0$WsTGu=&Id=Y66lagn6?dcFaddqmbubAfiR%nV;niY3yj`(J7zAgIhySeJg5KNW*&q*N?fHX=-p%Iqapm>Q|Qv=bRDdquj zrRF#n8m@vM8r&n$$)-=r z+!nO3&0#c!#k*&_hdq*&@exE=u$ZH2qtP}(jRK13K>6l8yj|*>AhDpUutl{ z7MrYq=HW<$_|&kl-AL|?_EP-)ll?5Z$V%LS?k-l8=hQnx){YOHQ9t!A4cw7fc0%2M zH*0OTnlyfF9g*l9fZS%7; zlt?W|tPGB@Y(>-?RFQrF#SU%PS6fOv)n>^_QF_5K?Yk?7kmliD+j;b1?FV(;?4kBN zg0UTz3t-CGVB?^6G{)g&>gpDl(reVuAl#QJQBd;BEylUsIyL{ij^- z+jwh!L!(Nc+8EOCO)09R=MQ-_z65vCy7NbOQ1v1a zmmGw3nZ)ix!P%5uktu`D9P?~)%vsW>UaG1OXWYD%Q^r1q-gZ`6l$j-o`L{WTq1T35 zgER7Lz-vcFS|a5kb5+rkt5+KOHq|W`r(P0~sUs5U z902SE&PJw&{%LnzVy_X=3M`G-U_V@Uk`$dPpBB!mD-Xh zPYe-}=FVmPVUq6r@q&Ho70Ce7>sNm*=WcyP+Ey3Rg-?$=T(EsFy5vU9s#nWz$fvF6K8@lok znDX;=K%udvUl4{m!=<)zGyxsYMr&P7rc#c-APW0U&x_kC0^ClVkS9s;HatRn=@j((`b?5>%Cks5m<+2FeTnEn2Tt-9A)D293(?AhacGhj4;Hykmz z_qxO?xuR2!BaVbE6}{s-RSg;c(v`ZDxQNPRR6HKk_Wl2g8dcVmnAqoTQ3S^c`)&I* zGgz;tyv9Cy@4U%mNZF;z)Q++QhCa0-rdDvc}?$n3>I^A39#YWLCVUB_|H$s&?DNDJp#xB0U(mXE=^)l5W6zM6G z$Hxt7@{uHqFla5X^55*zIV!hKzKy7l&O5Gf$$L`$c}tVC^6>sfXJ2RB`Y=Ry=DG_NCw6iK41;00wODWTml?vn4Xdj== zNp&M%wF;hu`*krk2jEWSw)pVPeY`@Z`7hB|Vm*@zCr=wSw0QE_z$2QOyw`+2$UTOn z7D^s0CBG>n#RieA@?o>Qx9sLyx}dFlRnK%JPs2%9A=j-3tQ209#eGd##5WG~Bp zJ>nj_$rCNct#awa%VYv@Y|>;WGu&URx#jNYU!tnhv~{8+IcJ9owd9q@3sCc@S0S5l zI-&}cU%A^PtBKO@sE(Nj@=ioCP>H(cNx0`m$*R{#jr}0WhMqZCYO2gQ!>0Nl6pOhB z{n@+!hkAEOn46wSV56!2^?Z5NM!H=ktr`}Z10fu(-|%&OJdr2d)-(P_Uvc{_qS1{!Xqxzjz@?n~-C z^F#(r4GHItRByDtzbR`k0l9?IwI`!m4pg$ln+*>(|ae*bWf7UcW3pz^~a-=s7nRAWY38E2Z8y21IG8hQK zA8Qtly1D}U0b|LRBmcvfD7!Cr|M(0{7ZFI_Y$rGW*Kn<(+n-?Kz)B0Lu<49Xxi4CQ z&-z4qRfnQ3#*FGukE@BGyf0*;fl&by(JghBqK=<*F^EH!cQMIP_k3*^nU~9q^c3!6 ztTk$utM&BcepdwLtHD@fq~9d=oDrw!QZm%~`<@@KXt`#ab%Ch>amBjJtksdKQ2YR* zX2+B?O1b!HxYs!&H*2$j&xV_VsRp$DM6urytr*L2;(YKS%j-5}kE%~Wv&OhX-C#&ke;oNUs$V z=6P=F-V*+m$a(e1a(vQmfF#j@ovbFSJzl7%Ul$3{*P#Mb6cJIDB!DM}A?)L!X$AI* zhyjZ-RcHwjMiSG{syK1OV=1HabHcD0`zBn?gyy^8k0a_55z1~VPZC2)w16s=w0Z|H5!JhiNz zv*kLt;(2SA>r_1gYa${?;>6{gbzPO4=hS=h0l`F+xWC56`4usvYK+Jr;LuR5n^~b+ zL1^{`lt8C#+;b7RC`6A)1j8U002T0~`i;n(fi)nR@oMjXPL|U{#?pBzZ z&g^?9^V9ST)S%T8pnDS~fiIs1g@C*7?&jdu+O_Z@5Z@KsTDgheHo59T!~;I9FIO|Z z&-Vv*WV>9Hr!ir_<;(8IPhKYe!Y3ss4AlbY80AZCIO)r}gM zf;B|POsSc|Awg{LGrQKam~HIP_hW^EGiY+`rXekqTyf;?8`1W3Ltk=qww*rWk)>fc z=yKGxA@>FJnF)s@v;zd zBQ3w-VJ-|-JDk!HLPy+~fi@S*>pwO*BXh9Eb3dMAUh1%BbfM!7JCDX;N+1!VL!Rm@ z?k4rn+!}YNvu&C62MG4Fq<+kW9f+t)_FaEdPpLLp?c-O%WmRxe zYVd7#QHoR@sEU{)jMQ_^gM%`0)wDRn2Y5DPSIO_klYS&tIJFTUeb~b4Z*St1B|(x3 zs}7CS)uVCG0HIV$XPJAuWu+qYR6Nt{5V{ovJ_6tDxdWjBh4#6^LvwR?@U(+lMMErs z&Z2h9)@5a`txwmUCEB$2@5?1}g)QU|jOiN$q| z8I4ah$OmRm8+TY=Xo#WF>PAQ>{Cv{9KZ$J6QUWoM!cLsgJ91)YRd6OQ-%9hQWk|C$ z7!Z^FUp$Iz{4XAd%s-bpB&66HSAG!Gtjqj?HPfA}v*2Z}p|(gRiz_+J-U(&c?tG(N zk{6)y{tX0hRaL8l$;A+!9rBM0wiO4aW{&Oit1wneM>S&Mk#o8o*kJp68^eHv6nm*{ zE{q@Bku~`a(PcSkGQ`Rj9e*ICsArg;5_z|&?u*5X4OzpEMz=?UGKO|V^JDo8wWPSS zXt34JbHJ)fZOX`D<4Q)iIwE^LxRN7c04N5wUoPCS@?|S2>jlnGO}g^X4bEluc{rLf zyu4TcgNs==x9$bez6p(+Mq!}IJ-gNOc+E)IV`{K}gy=oq>=p*q*)Q$XhqH-+1i zccS;^k2;Onn*7^&WeQ}G+3)J=4v2n^5R`taPKku97$xMIX@aVW3s_l33XV)uu~7gg zC&7+m><*cr+It}Dj%2H9dg}FwqF*H3V+`FjT?0Rs@zAcsro&DG3e(Tv z^y>ogiT{mbS$*I~**KW_pK+s1ME6F{_7T8W;2e$J>}&5>xysbr37Wwld5qf>a#KQ3 zUMY^xMMby`qGsLPY9&G(7*9=ni|b`;{nQPMI0k>t{2i(N3WswDgTwHvU-x=0Th~Y* z>EyBLTWLVgl}E_LpO}JbbT!WSlRp$V ze!A)p`eyB8*MffLV2=_nDcv^jlo5_+D1c^=tEj8Er ziii^Sv9g85r6(3@lL$p-R^exk_sUF8fXokQ}zxc6SQpsx9m4N0NJQc1kIXSfU17?&5y)|=r+l=XP0Omn&%9#wjWQ?RbB zn7ic)CScbpb*OB??};gf4SFsh@^6aMon&bYjThR;IVpO>J!nbTWpc<*+t)L7QC~E*~9g4zUL(uD=8gGSkfup4VUI~3i z7$ANvVIim~qZ~N^zBA+Zu8iMsP}2IQjA3iuhv{bay=uDZt)qhFZ9z5W$(^^?+?zSa z`kd{`aHuBWZg)EBQ(_Z8E(oi5D>72aIpoO)K5m#+dZ0=@3vZlqg%lFF5!^;Ed z%h}C}&%@QeW$g;7(^f}zYs>PK@y~fa$aGqvFoy7gvneZd;o7^baq0@zBT+;i3R?Xf zl-sfPWtZA0h9^>2$+9ZJf)HdimQYs8bmisr;-NUDe`!DSZYgipU&CK&7?d9hH*1`_ za)!lX#zqC?lVTSB6%OW;J^l#9wGe?0Dy{4vj3}(Ttqz8DOHGR(X*dvWYJbs_L6UwG zSFjDOGgeR>0%}xhwcIM1rx;J4YHVym6r@`U{C0!KEn6tA;&G><2AH=r#uH>tFz=3P zS3sKZDT^r=&lL5*32NnB0Nw6HjqS8abc&Hv^xeepcNpjpmhCt zucWK5P9I^~Lmo0(F=1n~v@nxN|HNQFIb3zQq13oT9`J8B@IAOM<8^R1yKTjCAr&3& zn;G8IOQ&cmo)QZ}$BpTn?et5=1Rk7%Bi+moJs&-a#8MG7S`U~#er;4C0v?{O$ldw6 zam!tmeW{NNCF32&1Yho=R(xNYsWnGqca?&zO~@ReOL|HCb@0u;K1ypa#8BK;PSO%~ z9>n1GagYcs9o|_#W_i&aIdmf?T}iY#H+0ofI7}{eepEUgd*kdbK>hF-QqfG;1WA(H z;1^o`_uN=D0GowMS4%cc%~!{R`IWShS6(-_m*JMBeJ5!=s{2N+~j zj&FV*6Mon)^_n02u>V)&3_XsQ4d}*V5^ea8=7!e=LCKf^KgRZH%d(1Ksv?620?x+3 z2EQW{6`cZIc}$%BqcO>DIJ#r#2<&_80SGie>ZG|X!CkVopG~D}^gO_npyNnad`qq6 zC&6BZlIqABvg_8&sFw$KsU-qC+-~NQ2vI>Kw-K>39eIBws)^P%eo(Pl^J4$wb&_s& zfTij3FkEnQ=yj*GNEx@g;$AQ5^Pz6I=xGNRwYLR|0M{e@cX@9W@e+)J_=e7s7|>!a zH(7zUnRsLYk$rasCV(qOezM3SA{qWaN};#w?L;#~Ymh~MOP*j|qq&L#Egzw%h`XO0 zlT!v;E~{|b@zAp1e5+GRW2@hvE%*f)!lJwxbvi8 zl<68Jra$%MEyE0Moa1@|zM~r$F|-)sqnB`*6JGwi@j~E&HizODLGcI2?B@w14315w z$!a{xF{Kl?^?!zV<4$p6Pi@qQ)6l*J5-h!YNbHy=VVVTKP+F}jIWVYl=PP_KXj8hD ziOXZJ9-f(aXbo@C=!n ziQMb<;D$5Hpd3(bjZBwx#4`zn%8@CT=R*zmbaH1o9N7%Lw6)>D>h zm<_oO5@umapbx~tRI;{qpHDf^%v-QGAMZ_OpU3%M?1sX99fvflTL#(FGCn<#dbvVV zpw6i&Xcl#{PYZ5O=vL&-FJ{BOcq^-f|L*MSKVUPwgnF8-3bw6@NFD`=+TYA2QuI|D z+v5}dnfN_S+%(g4SB=l>E>PtX>Or9@i+Qt`@Ri5nk)tYK*Q2>ZHl@^nL3h9_FZIY0 zSCjn-w}g8uJRWZ%{U?1H3OIeE=ij2zHnBR)MCSoh?ofhDM+$J3NO^$mR;0&&-Hl*CFTGOr+1apI1>RK5>`Wxcr0WCn-(qNcUhnd%C-(p=Fh z0^4r3XAKH7bX+l}n=d>Mg|S_V{xFVRD``_b#P-JvICU~`2w183_-drltpZq7NTPZ=~w^R zE1!_&ajfd$4In1l7v`rY%51q=u3)A`NC8e+qgN1s!H0P;Um9@z?|)DkvJXF{Rfn=o zQBn=(kizA9Ttf#Y;~f%J5tc0Iuzopu%F<<*eb2~Bh$yGmkIV3S4&(n49=qy`}Q z3Kd-|{iN7{Q`f|h%V!fU6!Xcn4(bpIvjZ8(ih!SD3PO!4du3-7IlenrosB9y{aT>* zmT?U1sGz4As=;t{jMRL(ZPK3GqPDs6F2^4ue~iP#(dt*}&(OglW#7FhwfNIu!6}!U zZOHum4e1|vE7>W>L~n)iId1p&4;GGy4LJ(!GPa%f*8vw$gzAmiNR{OA%_4N$b53r# zb22M)Zlse?G@etRJfB~*iP1Ms-?=EFU9m`SkNuXbb@o-pfRX!C4u|@0Qa}Jyhy|`A z-DQB1YN%#rGEpysdhOFGc#Il14%<6L4q@XeYyqc?clj;PMUxA=uf?2LEK8%*%!K|x zFFTIAQW+2Pm;8+5?Q}}{ zJ4+`!gnGbdlY6DYCEuiQ$Lrt<81DPO01}_#u`O0(o*lr7{je0mA(QZFoO?gD?ZBC* z@r$1k-U53G`?EerXCLc$Q?s2e1ZB~%aIDRn$+9GF@#Zo@vu(OgH?L+!|u4_Ko z;xnHQ9>MyL<-CWE0w`FTo~SU7Bo8Z3L?+XJax(3%9^=yLHo66>S|GeBM=E>Wi|68_ zn(15&{2i4{hiLV+4=XJ;TxnC`aszUXw99WZJ7JV*p=wIOhZ!ci0Oi>prk+yA=Q(LT zr_F#?v>|76qwT8}!Nz5-jah_-!^i9^frl&X1}R8(%Pyml;7^a&ES8U&BPXWc!K~kn zn4SPE0|*cCExfn$gwvXpvKSouKYT#d*+Cl~a(5GUC&3$^`-dW-9Mu+)X^csGYD21; zqSPoZRsx>gc-qfJYgt-8xC|7zK5HV|-sIkSF}H2t&+f!F+le$Zb`mZWq?o$9K@kFR z&)A@)(Vovv8RmF$8kz`t?w-YOiqLX+HrY3ec0?3fk1tuXmyESGqW&}rzO7*>y`z6n zV%Gh)a*%M6T4H%>Eh;#&HU{Ol7_>SVEM(RniFx^8baB{fIWB%^tfD?JT9VwjGH5nM z51w^0@(nR%Dq0U*CbE5Fqdm`F;s{HgVQEbF;5w`$wLm(24QpHTh@e1gR!tkhyfgrNZjR=3Jvm>s1?*C4d>-piMNJ(TSPO} z{MS>6TuM$jVO19wcsulQmc4HyX)j#XFG8o`u~R!3I8Nsxu>ZT5Yq?otfZ6J-#LBr; zhnH%ZGuUy(>B+66Q3GbWE{wE5TiD%hk+k*86E(6Y)OC4yCJBJ4zHiKz;6v%?AjIvS zhEU3N=)Brc8F$B<*0GWkH5i*P81A$h1KdYh#HY^uAgLcw&#RzhEsvt(n-@}{<5`W_ z*-}h?8=uMydmGwkO=_vDo;ksnm*~6~Rd(c7wT(xAe=z?vX}Tm@_G(Ex%Pq+w=`(s~ zhF*aSs^q|A{n*x2ufeK!-VWmnBo~jd+UHo8?Srn^1n?4{+9tWdfPj4AYr~b(YRg)4 zLHzl`vW{z@UBbxY2Zki`qtYLXe{HTwnAVMof;l$+8YV z>y;5o1BGsenykmdtfh`>(3f{VYSWoC2onbwT1`B(S><`A7p8oMz};ZmobR%Ku(X$C zXcqT#RdeF4u?Z?KQ!X>F<;@i;X-EY5Y{PBY-(NA_*)(zs3i@6TT$nACCkClrD#o;B z$vqo_(?TaU*C}bQESjavf`99BJ%V$wI4VX2cVLDY zO=PR(b#OcYu~suME6bVrrBZi7jH|`GAhD559|b(TT&5m8QLB+3dL2A@JGeOMoq*yKF^7eKdf?-5$z_(> z|00{%;-DLgHGNpi)b#BRCgZzS?9rn~n%KEkvpMYajy|$?9VF1_F>pU5X&2i>eP2>Y zv>_2>`%IMiC#=Dys>RI(4xux{J&8(;cEZ4yZ*O< zJ9vJX?l5|SoMoRKbxl<{9=KyCGx5tzkS`cC8dDR`Lpkv7iv+g%A(f5PPZlcT+n1!R zueK5^8f)e8$y61a!A+!k#x%|6jcq&hH9rf!%F(J+oH)e>=m}wwhV;9t%fuD`?vXVE zt(IpcQAri;eobsQCIR?e^y^51w&Rc;b|BFVX$>?nyI;=qoa1B<5=R)k`@t@;&o2EV zG;xR_#+pipLmnM@G5X#`)E8$UES0VylZ)WnD*A!2ssee(9D=ldrmEGFKW2)%T+`{U*&0dBU~~$ z#}FI$-h+)(&L;<)v6`3oJnBobY40Mw$wX^nI^T2rD5xgV~?l>`ngC5Y84eUJ`WYyGc~w$_P@uA|5!H8 zrMCiG;R<&MCqdJg!t)n(KAao}p=bez@8=a*>?m48E{hK~trs#g^a~cvBIF8MxV()( zl`L92x#&ihDjzi?cr;D5S;1`4L}L`v4F6#P2s3X7L=a`^$%+3U_xPS&;*AKt>*ppF zwQG{eRjSBnH8JO#zyZ84j?%$WjZDi4d-E;jwcbVkVza?2l^#zyjoc+YP`nUJ1yzlS%W1r8nbM`#X&e`sB-}kxh>l&7V zM<#hl%|&oz*lI)3Ng5Jd%E~~2wUU|Ih!qA0srjL-f7`aL?W;W80wo-e-P|3IIDPrS zc$UAv#A}-)GPMnQlgq~$I;nU+k*ja4o_JQw11EZB>vJ~q^Yx%NiTTFP*0$F0Crx3f zUE32AW5bA@Glv3o}~WtCf5{6RbV6Gsr#C~ z2OqMG)FL&D{oFP{ACvCWydO%MpLu=Hbzv9<<`*27>m=?D7jRs%uTBiH&19ZefvuHUQR#T*|h87frDwCL73o}n&y+4UgX z)3Y=!?E1cR%XJa2GjjheEEc9)tQe1%2=uZrv|5&gaQ~i!*vgztCPyOKVW;h^nlYC5 zOQPHkPrt(Rb|G?D7ph!q5 z0_*1aUyJxId|<=e8LDx*&0QEDuRv@W+vXeP6FIAnN6Xj*QDmZL&<8t7ZU766oP^W) zJ2$-#NU}ZXkWbc93_So@O(2bmUA}NB$2qX5 zFKM^L!EtjzQ@*QN;GMQzE;b_23_Z97W*aYjSh4tB$bbCc*>2>G!I2`;<1sq$3~Y;$ zd4)r$MIQPgKqvLGi)b`|2}%4^=V70l6&b)PR!bT6%&tM7m%PTrN4LIhlk%cewr|QX z3ZPIq9jAmb{jDSuwUlzA9JnrPZjnz_Us@#6{Ti^SPd~0UR=-+^Nph6YF#K@u_jE!a zZ-ZfR0paH#9-@;@nWf&v=DPAo9n&8LspnIGQu?d6Moo{4$v9vz*WKEZ%V;9h zbjI&+Tdjr|8zwgJAus`6>Oh)`a1u)&r zMd%Oj7+rlB^?@*~r)+`>`iG?x*ae~YCj(HwKbbJ;#3NVGegu9uRG;&~fxP-sR;4RV zdpk&J)O(b_WK`PB=1B>E5=U?I$xum?Qex-EH%qU!39y#bne4u-6>wLD@n|;mJE1It z9M5E)gUi(H$1T=+W@hA0q<@u`WAAk*qO(M^h-^Wa)>zMLSP;8_#6{+Sdhs<{*m;EqY5wh|co@8_} z>rZN0-kE%LMpdB}=3uiIrw~pwuFce+ULit8Ip^cz;Bi_CQsGYF3fJTT%xReE?rxyT{vyNw&*w;Uu3h%qG_Ch9#^p5epp-=>lVuQv*t~- zoM(tzZt`a3ha2oBbwwp*rRXGr?3Zu?zak04eBM3$0P#-R^tkM$DIF1T_drwU21&II zQ4L|;z?EMT+vTftnVhd(PU;DUT)dQw_*z_Qd)Fu;0)l+j%F8t1OSGvWW-UJ)Tat@24bF1&Lhz+%3cB}RCN@k| z3OHA8$VzGVyAxzSS@5ezM_o|T1?9GwwzX>pDQFe7E45D#Jf3-tGyUVJ%(li8;Qf9m zqa_)Sjk$27MUjpcsBXc@5jwTk`*v&ft9{gdSI-1dF0o*uzwEhQfpX!?-5?x)zsRMq zEuYwuy$;wIO*So}o;DnkZ_W8)0@c-l!=@QOvcbP26tc;GSzn_-n#lZXS8zY&Y>+of zma#12HBy=}nWPU6vv>HE5w!{_)*i6c@Xq)K`!2v{hxVZe1`5N#K}o~BJeR{NzK3x% zGyecE2k-tfNikn9KF>E!ys)!xx9GXGF0`AOb#=^4H`o#t!X)d?@QaBa2yVC7|K>)k z_FN{!4+i*Phr7hiY)X8D05wBUGfnmYNmK%0R!~WGBM`_X?FuF{dHIqCHp9Dc%F9UjNk@ui_y}tcfwg zta7_u78}46MD}BtK}d^$K~R)BE0;RQ?MP_Es9@2zI~jXQZffg?M|?=`0--*w6caT^ z-w!@@=@KQ`!_1O+=elvH7~|ctAn+I?WjR(As=A4IU56^%hOQ;Tqc^Pi(9oE(mq3fy z6i9L5JP56wqcO_~czGF|WAhkZ`4R@j?;nGNy~o4$aWnM&Sy=eX`KgbyyD^mkRimv% zm0MLcAwz(9G5bUjUuqRC%Y+<04zjb-s0cI-6yF zDKTlVvLw~NsakA1LgQxFMGNnD&+wC1elm2cGu`vA(QAPDSQXmRjCzol8v^ijJ#`0m zzuBN9ByM{YObfii_*`d(m-;YccYQur3vObYef*sZyG{4NUK>NJ$hB9gXNOv=jdvul zufH+4Jxb~}iTW0158sliFlBe(>Msznnwm^YTFJDs;xfe<=}V|O=~1Mn@B$k5KG!ws zpxx`<;Xfo+8QAFuYx-F$d=pm;r*(WuCo`d=&a`pW!RG34T67k!eRI&@(W;ZFR17>< z_8_N{kx~-P&V%HSdIc)%eUZd6v=aLm)$qU&m)s5UG1r!$iO&h&E_`QwJJ?6nZR_6n zbmp`_GWu8O7d=6B;iQ2u4g;ow7XlxyW4uV0vQpI_0+TX7ei& zR57p84@Xz-Kb|R9aaXVS7_MvgyC@4J9-x|fR59@$Q`R_uiwefJlgJx){}`WT*=P_j ztiSq*ph%o&txgEq*^vN#nrvvMzQ~Z{`SkN^f9TWZ0M4ot^31i!PH>LwIe+g7Gi2&& zSkh&qM6a#8p->)l4}{3+h{qQWvN>zNEVi54a#r^=p&R%3U@pp>lla0tVxM_|Qs8v& z;KP~rYlNn>!B4lO7^vx-{WC37Z?(Km9kEKtPQc3`0-i0oK&-=Bsu0c3QYam zM-fhMKfVDNUzb8iL_gTCtTj3^^0cHVZjmpB3@_x=*%F1QYBKuUSmcq*?MQ1r9sl`@ zG%6)x#2N$;lNW}lM;U0;v7lKkOl{1IdDvJZ_H=Ide|}93Y!t0+*O=+PaVGD^7cl>q z@d2KZ2;{wR)l1>CuF5h8@aB-uI-6j@#Eglp`k1A@aywXVl!l?dMVRaS(w%hP_$o zXy~R8i8)f|Iy1Z^*dYv3YOW}6J4*R>lh^AB zv(Jp^+3r_(sLHb8oTA}bK~zTlYPP%`rpA6^rr`Q_Y(+@+IGo3{U|MZX@fy)3730QD zs=xFyp)7O1-*AL}vkxCBghp|a_J!?KXFl-|wVWQI|SWj?S04p^zk~M75Fp#M&5401U&> zrmNTEHNm3wl$)AhXG&WTCNc8u+|E3Tb4~0|jq<2K8h!S#N5+(RB=Eu8eP{b-Pv3*Z z`oEk_mkP?xWifW}DpIDBCb5X_wGFAE~% zT@#9VnfJ#ODS$pCr*8FAt5uv^8V^?zkFrMl<-`sY`C&>m6G0pPfzEj>Zas^C=X!DJ zNS6#S<*TQ+s=T2X)VHYocdF= zo~K)X_%^ArKswyTj|o`Q0|iE%mLNJTyAR%N4! zFMU;cu{f53+IwOe%9HPGl&+SW*iy*-i@1=NE~b^O$`$lf1EX1nqZd2X&5XMC|< zM*W6a%?))KR9oQ^B*#YaX`ZMX=)WkL>hT$=fNh_Dua2>p*NKzSP5R`!1;c0AR8@Dm zfHaIYsq?d-Y9^*{Ce6lMfU^O=rA*najI(u-w3pzTL^L<%l+f)+c=EjH%9Vl4bHcaZ z{pN;=M~kJ)WsG2jr7x%3yreB>9_@*=9PGVq932%i6QbWPWFdsJ?FQRyl#wo2XU&uU+_D$IES=kpD(jlH^CKTl!+Mr&S|UEGLNDx-^pug+?aVj zZmWyl!xmq#i8sBw48kI=>m0a4wKhA7b)05CWwxR34aJm3Jco0g5ertqVdv%HDp7?dkBKd0RV z|NV-8y8LC+b*|5Rq$a#wrK&6(cjp^AuW&(D#H5w{*`&5${bvCi5yEmsvuL8XMt*9g zmt{z-D@ALz5erArbG3Yv{0|qP^*41UHmPYNjcb?T58Xr(GdF1l-sKi$>ZH1H#khB} z(L>WRTao$ZEq2no5XLxKEPms0Xt80)M9g2fkxNioGR@Uu5E!+ zUXbhf;@%^J3CmcS^{$oA@-VW$U-NCmOZA6=LBZ{N%{8mllBCLmQ%H^af=5_j9hPxM z%Qm14Ht?DZ;Fn)5UE1cBZnNv1IoEXIgrT{Fr_Y$sv-jN|9RhHI`gH|2nKi5e=@G;pdfTAybTABGYyyceK{K5+(VK{mwa-E{^K!?-N5ri#}R5z4* zvdUrCzU(y&i8cqbuhGp^@zTxfmG$T}=M6>+D$f0sgGpxanJtZ2=bxtc7C{db*;eE}fN?n7awWYr@wikYut`sopx@?W%k_dyZNdxn--do#eJ~AR&HnE z@{+*dPgn~}d|pNo%u{ zZ&rQx95iSqqa+_))L8lYGoPT}ydnXxLvE*JZe(#`xQWOs-FfO`1){EB0ki4GLj@RN zug!V+Lg#;7u%2X8b$kEPxD7sf_PK7{B?NqBb)iM2cI)~0wkX8YMCLfGk(V*7<6bjA z^Zo7=G)(}W&vdF*{KJOkEk{OWeh|>esM#ScpC!Pz3C*fBd3GJ%BxwBRuX7!!X!}m! z(r|w7>p3pBKxA$QgMa3+b%4yZ7OSOoD5*pC()KUF0~4#FLIrcn37vRyJ6if8ACbu?TKga(eiv z>T(YyA2&d=-ZeD(SEA9EgM)5MsGS8()T8X8RHg2$_A9sGe|!dks_e$>WPpNO<@M=> zRs36?bDsLbIJd-yXgou&N4~a}F*kpgPCe!TY=@z{nx3ID#iTgtASvnB7m*EvE(<3^ z&;}=>+aOTAKIYd=vtQ`jEBfE%5Ex}YC#@WkYJ-i->xhY#`~2x~&P7p|TY2d@Kk6jvXc(B7Q!uu^&0Qgc9*MrhWui3|8fxqEkw` zC5~XbT`{E|z&~%dA@w-lZ@HcJFr4vhxxG1a0W{*T1!ZZz7QA`3Njob}n9Q75F^M0l|(Otc(6)e=( zSRnX*G4a`-OGsY`q7$>*=U0Ex0-l<;ZkDpRuh$e)2VGPD%5YvP(MGzhl4LJS>5t2@qH&V=`{~y= z(_{sv3kh`skf78NH&%MGx4OkiPAbXRWU6diO%02v)G@y2w)$y3~ zgv{D=L};LZk_&*@uufoe-ZNDfGd5$VulCRXjc_Y|_hD8W!ZwdcT>;fxdqaO7m0YMX zgRLj&!udE7DRoU)vFWh3l4v)dfEJx}YPB9`)inH~= zRfaMZJ8HQ?tC_@iP3Gj>tU;*0@E0fFQ+5S8M40ARatv|q{VK)$sZQ)p-TzyR7v)wr zIS|XTE(?WA=6s0s#7y*~gtt~)>1U`=sU-;5QikU;OO|~@lfBaRKSAVjeh){(bNW|0 zgjXU|u{AmK{oTWUoa67sB+rYXN{#Z-e$L20C?m!@eRd^QX~zYet0OYN1dNdy{MOYW zFq?lhisVh!3Bp@rRYoWQZt@7tL)(9%B}**F@+x)=<* zxS_Pi2*jLkIXcw;>q5MnzYISlt$P`06%nav%O1Ae&%IPW-n-iHO?sv3SL&?vMN~$7 z^3&J?5@^OF02=C9ef7y=@EBCxm1#qPmM|1&+JAfghvV|Qw z$beQZ!a!3hKo{ZMlDwVf0OWVl!OsEtWbQgmooCCjXQ5r3HX4=jLzk=2>} znBhUd#fxs?D`dt}uk=^f1h<2m+E^ZTX2&uWR$uXT{YG{FlN-2)_Jc=v<%}3qcuRr3 zIQ%|%D*cg?$~*#MNODoZM99VFPj7Ubp`1v{;cn`a9O>S1NMa z9b8|GdHAVfQK|XXFG)1-^nV-ianTmo(UIBZ1za}l?%j9TkDdy&W)4^YHRlRXDd1^1 zH#v80RCEXE2UJ5wv)b0?c%}5URZ?J+7u~gb>-^{OxxK);)A?hVcvTU1^L6kBC)%2L zHpb{hU7pkGGKcMm>|m|l-N!_v@83I+@GjEKPH3)R59|8}8^l-)zLy9&aIxf)l8L$a zvV13|fPo(1xVC#@6nEsr|Hkd^a;>@8_y6TO(Qi?SKDz_|V_+O?o-nsgJVZ00fQNSZ$9Z!o`env7~jgt+rX|H4D)hU(Jq>HV4k)w#6LPST)|M_M(NDQNHjYuC5%5RTE=P8taPHKP3~)#B=9p z!Iqss?PA+p2v|cQL7uAH=7pk1O8%B;j2Rau!4aa~zGkkUG`;c|`Pr;y+ka)s=UTq= zljgz9vx)2KP_AhdG3{GeWb^%z!x`<3L-$_Tg!`8#oGv74yF@T&VnITFa z$#C|&*fp&=`%=48+RM+yCA%CPMS`FLT+E(bqmWTtnjpBN5fr*I$ZlQ3@QhgCbIYt) zP~fn~P`x91lZTUz6jhlMRt? zv7gd{0Y+hD=WJnqbo5r)UX743*N#U0mdo+YV^rdd9rTd>+oQ4nTJ}$we#i)p&lCtd zOkx_X4>xl~0|f82BeHGu0`x0cV;NcH_Ex$fSWt9^*26*YO>y`b{c1*+3nHgWAhupo zX-CIXnHl&E-0B+& z#X*-ybRJ@NnXac~4wt^LDTDDZ6yMyf;TV73`|B+hZim?7vI^V3PTxKCZ!p}E9OuRh zmr}^LD`apf0S(uT^M$NGjZ*0zj53lyWj~p&78Rb^UUJvg)}Cyb^N1KWoSUjZz{?E2 zyS?oidEGb_iaNHuZZ!0W*{0;&(Nl)utKZXkaLF~2T^qraTFVgOJQW2iP~=qMru@L$ z{No(fW5I<+6f1oCqp+!K5wBbJ%H_R49CWb8$p2ZuYnygOkYZnt%+0fF-e2Ah32MA` zU1LlNsfoMv&d>dyyK{S|ozOxE>onGRq!#Zi(LqmLa_dr)(@Y)v+EiuK@o}X~2D;1* zKitU78YVumqxq=1IJXJ{2JcNNTe$4R9o68V@j3iLRmmqHaLLIi!yPg$K6Bm8!r7n`(rM3rh%Srp_y=?ICI zS&Tao?$^%`ZYioYkp~I`m%$JL_p#4#&3ot`#`U3ydlHeX87XFNEbi1 ziVz3TaxS&MJ|}R@BYVdnQdy2Xm&%yEl8WrEd<5g2+)xu{Y+Ykp-4}wY3N@c>XygEA z-gq{ePxiU=9vj}k8WH!TqBYdWRaR?INof>Xm|2{)iS6l#0_I6H+X*d{wA+rB&=sW+ zXtE#ps>NVkXhGb15@k134IP(a3aOcfo(E42fWob%g3?#d1v zno%iAw}soXHi`dK=FzLEtr$90Pg2U&g{C?P{I!3E-dT~v&9}pe2;_a*ZmkoQnAYKv zVD9o#gRH15jSpq^B7bMc&_QbEEMRMhTW+Z)K-4xMQp`Q9LL>cY4x|NtnF1kJkic8! zr1O6756!6EHZ~4LjqjEo3{ND=mIi^DQcoZV2coHW&>Ti`Lch4{i$cy{4|IKDRmRk` z@8Cn6Vji`j0dlSg7En@-l}<&ZM=f%^iDOcwG%qY8P+Y6aw4ryNB*h*ozfMF}>|K$& zx!i$vOa2`Pn{~;(g{*i81MAgU-T>q|J6^8kBLt#rd>n=*xA8CRgZR}_`4!DBgygP< z%nH~kj(P_K7@oNa0Ad5Il11?JFo}S56l$2U5+OdO&jnaQ0a}Ea9L6y0BTpHQUdOC6 zr;)vyS)*52-4y-1aiAmf`{Dh=R^xVgS>_A<<8RuffoNCQ35WrWpzpSuWZ3eF8r`}}J4e}*kX zBKj`_O?9n2^aR&+Y-w_8o5t02&{_?M9hDVqf zlLzqTBy6ztn`JcZPCm&yaDb7*;Mb&@^8a&r`Ldn~*a}LG3n&2lHk)*vpfwjM3d4O8 zXe6PO^;3>+2L+?9g434;P1+j6=-*#`Eep_L=5@UYxmIBgbe<1-*Ft408Fv#533Ggk-C# zeU6CSEDh~HA3y*#dmeXh;MUgWEc0nDf+$wA=Ii(8qQd|gtM5#+df$^`%j=cs$WYSi z8u4;r=)_)S1Z@u3U7P7$oo3+qk8u9KH785u5r9$r`}ku57+D4dKDJOKWw=yv zeHRLa>;tR_5R*yUqHDEid%F__whO?FQ5Nr^dzDQ#6iT^6D4o&wj{)6J;}hrDl>rFs z4(|Zu<@H$&q9voez-p(5a~JR13<%&e=QubtU74lLX>NOIqnJ;pqoOH{^P271=N|qT zzrg(R)gOFYX3@}Q^*1sNLPhe*m@G1`?p&QW(JqYhPls1P0BW_ z$F(_mkgFN~lbL{ZjqMxL_egT`3j0eN{Mg*|uEWy3X4y@~Q5qOy z1>mHs{3M0yXmAP80L`yx$**Z~sb6nP`~EuPW%(wGVhej{Z*k^2Wx-i_#Y7x8AQJJ| znfQr9jSlSo2lv{@OPAUHz`T^^fOH)_2JE6eGGt5?Kpg(uDo$ojfR(D7)L<91jvw`k zdw;9;mM-l})LoePu6qdWXDKs&wC#d?)*Z**FhydCrkQGt#(0@WecHR#V(i~?BUaxg z_~du_5xq9Bxn^{=!vs~In$#y5nl;IM2tI9k%*eSmd7XWU%A%Z!ROb#F7U{mJj!O6$ zXO?!#jdFnoLfd;5>c{1G9ZkE_{WATRdr$*=LM@#+d4t3Y?7WtjxOa867#N>1u4-DY zcLFB-m<^X%_%om}KNA2418+dMIw}mt)-@>{a)zF9f9V|r(S{kpknn1b`qkj>9s>A>Ek=Y-YT`;e7{?iki{Ap z_D9`+^Uc|h#o8ep|1RCZqR01{mGAm3-aGa|!|@D*n~fiKUnegFg^71mFofSVV;mUQ zmAC#kU_qY-|L^Rb9R9!b(|@{)_|p6@R$d%_5PS#Oz`*!K_2|F$4a55c9rxZHt+~t} zAKg2+*SF^48@6bBccX)6I0K3pvr0^^7o=_^QYbvm9BlJ{1OWS);0E zl#+rZG6FsV7#J9`v=l%E3=Fye3=A?94&py6E6m_wU|?uq(g0C4&zy_T<=>R!zo{bO z)lG(^0hArZXBuv9itMg4U@u@s{>X|im;$@7U;;)z1;Cj-K|1V$f{W^I+7>XkKo53R za>8RmWp#GcX?6iscO9LK?25{Y=;+Gv)y5g2v-j(OQ3M17fJ~H29u5Eib|AdVuA%gQ zUZhsNH!gJ95@YCHLK+M#c1RaJR&+f(@L$BudG9>Yq+=3>$8P|9?OoVNg|b z7L%2c0^F!tP^1tXOa;~j?t?7J`EU9awuW$5%YvArV5&nM=!e?gS!EvX+ z#F|HJeh~2vM)wo_N|~=3zk%#mi@A`0nyV#}^g+Z|q?1YnsG; z9}O}-f+O_$`wkeqLG(KGta^BI)&%4jVV!&eFq=R4XkkZK0N6ZsBPzlWv zOmoR8swaaKqv*VqTzd~!fOwYHRARrNeWS3W|LeeC)W&vU-hY`U{p$-&1^0gD^m~B>O7=J4MY6T#v`m`HEkn|? zH$qB2VdRGX81j+x;keWsh&$}fc=p`m-Z2%mCFG5l^O?OTSRiEXesoITkLh9SQG$9t z#NN7IPss1!Oyu6Rdq+pb&rUQ zzu^C?@bH7(md!6&#R3p{(LU&8b`~PjnN!JoL)ctLp^c?S@5=lG z<=olB_QTcozUF$f*YEXgzb&QVj6p-7r!3FGPMf`MB7Ld7N&Mpq$6wla)V0?DhgqH^ zKq(<0jxvGSvTdX2zi-|Dht>d%w*|2n7LoH5Fl5pDDlUi;w>ezZbz_w#U6AX zdGiV_a5!T)KHtMk9c)UCb`wk1KW_S!&I4!kp12Z;?j}|~VI-i6ZjCT7-`({})a{}4 zs%;{sHMF7!Xzw{-mU^M8$NEZGwwU%Q6gTm>tFbU1g~tS0ikWNYG!5%nc3vFsF}r9@ zDAGoEt>;g4ZhSiT`nr4c8N5BIhAjG02)>?W4vb$_Ghe%#)J1P6L!7#%7VuQt{6xuw4#EJt2`5Mq(SYs;xThTjtrW!z{ zSXOXI9}FiJcNO|wf8)#=iePcdYPF~ky=Zve&(}S&pDDg#lR7v9VnC49i>-+_t^YoL zIUWq4cVtt5khJVVGtZ^U$S1twaSfX7torP%Z&&89~U2+zkT0sn^G z;{p7QVv_U^&fPFm7C(D@P<5km{gLswJUor^F}@9yWC))0rV;A&Pn(c7!~y-?6YPL)k-%HycT=a@Gq{ zY#x&C9JkINk5ayG$+A!%PC6?<%D`=%v1mg3i5>+BnO|_ z;(FalPGo69U-CPqwDQG$qII1EiNbC+ei~Eqv$riw4mP^8W|}!$hx@h^S>e@qdl>E2 zNXw$POg|qb=>L3d{D~g|qu(*-L&=xIhvvTWjbYCqa)o}Di0xe6L&>HQJGOeWnPW=q z1$!fbOeq|q_coh%f|f4@$KD9(nL4q4RsolYe87Fm`Zra5 zfb{;?)WNJzxM&|vqCoH=vFwoURSItsg7}$Y`X4q}kJ(M=p>MP*Nr_CloKV?}nt`Ov z@)kXH=PA0VFg-KmD-|RuxE*^aIFz5}HC_~0lKTLOJo^#VRt_Y zD^1OgJanYt9iFUYWW9CXEWunyFQ!uP)t&bR3T*Ngq=@54_KY$9$t;BXl{;`hyxeXT$3!&2|ECK0e<>a$&X9MN1yYmr}; z-^mhBcqaD0F(MIYwt^D?MKK}7|Ch!1L~0vPSx?ehqp&HWD?*Osv+8_FG5QB!!QN^2 zHb9}oPGQFR(qppLq}{9T1h7#d(>TN%DnrGiBNP5Mh#Zc=o>6ZFw~~c?wf~ z5(C|9@8?JDM3Nz)W^OsRjCgvrOMld{!sgfM2=y5lbc=*-Y!kmo1OLUPq$bxcu|zE9 zEA+EkS{4_Pom4vn@+g~Z;WrYrtSy~&tJrdAMvcG@rVMst8&JV1B$0#~@ZOS^KT1u9 z=}>Dq1FKP0Yh{?4DOf1;*`)tf1JEXV>*>f1a;QtIW2qvHl+6xiiE~AvvJY@vT)(yA*PB2}Sx=bS&_PQH$VQMEtdd*;Dx6qE-p}!4;85pY)DlVXgZ8lF}=2HA- zjQl_zg_MLJtNwu*+#XY80GTbf6D@^_{>i~=#C%Zco2oesOP=e?Uv=jGxzqJnbiI^) zsZkOaSp(+45C->|j?PTcU`fR=XfPBKQ(>ANU#D+Jz^tjztd}QfmcBi_XzuN8>bLoP z*&e^w-`cCiT_sbFh1DoX2lpc^(yX4WAxX8>J4hG(>sb8GK<%fULY{E-xea#j_Q`Pw_sB)tn(}jf-$t(`6(9T!Z>JAuy3Z6p!;Dw;j_%Y( z{ak?uF&sHRB`8y_e87E8DsencOUPk94sxl2A|YOQh3N?p6rS2n+wtFxicw`f zcXRsKuCfp5WzqNOdVN2Mi6PIquW9&M3-o-Aub$+-9J0On7ar2Qe6T{8HKAzc@m1oj zsC0H1ZQPd5WD9tG*(R?|AA-g0;GrZzDC2-EUq1XAE}d$V;8%CtWKOM38Y4EupGoJ# zOm9$sK^eoSF3k$fqp6du4XD}>iTj^k(f(N@mcGdrg(K$ZR#Tx;LSx#ZtbHD-3B?`0 za(ga+kn*Pw8r{Fns$r$HpWSi}Mja*Z$Q6E9@RpfPXJopPzqY>=o9^&Fhbpe}YTFE~ z9$XEdjb`g-z&58J%N@hpFmz5w`;m!(R${Rz>sFx_VzexBcE7zveyqJ~yBF zJ|x~{q2&4*B)Bz}Yx70$Fc((Mu=S zsYb)8FTO49nt#Gw;tJLgCE%{>dv)uIM3~_Fl*Wu3hJV6&rMiSyr)N_CS$$Z$bR9hZ zjWruCbeQmIK`88JkGaM55sDC%ih?2AwUiFu6Kr0->oKK#*MxI~o>Z6l>ONV+FX`X& zLJ4iLCF#tXlR0+3e{ZjL;5t85N(WnWm;Utimnr*S+-FBKFx51UqXTd6#>AMrRJz&~ z=_`Fv!E_;og*kwuXKKrX)m&Rv4zo9?1$9@Lz)sx$|_hPSo1*ReOZJzA?t`%vP z0!>P(9I_PVf|ymIO|>2a*7080bkjq5*c$0JW|$AIcuqsH%q>+}q#sLZ)QvUTm&5)^ zPRXOncRrz|;tQ@&1ev4Nr1{JD5e$umaa8Rqk-hBOf;SGQAC&>~t6?`H@L?3~HJcSJ zqCjaOO;6nh@*1f6aEIoWryx*Fy1VP-xzr4?-sC)3n`MXWPpx{igqRxdd2V zsM7Hi$u>CtR|`%-4przg>3cW!yU@jQ`^vGe&+lvYsuET-AbszbndU{*K|;$)_4L=`w(#3bfagQk zePx_Qn#Ay*xkW8bQFTz(0^MRe2{_fSIT~AiM_*J**fwwTO0Gi1x!I9InGvWhA6_lt zt>&ZC#g_*|F1}0er)A3=H|r}u*Sk`+5&oKotfNlx{)Sb>u-wMvCLvn+&!{Ox`DJka z-F-y?&+7#{3lCqL)#UmVoPWEa+Qu|ke;_4qWDNJbVoicdyQ z&SM~SVybLFuTWiC`43+fm(y0FM8z04Aie_LPXm?ZnQ#5{ba6?sS#@+{3VjuYZlW$*=9C4E^e@V`iXz$F`CU% z=sajfvRvL>H8vT_B$^G5$&Zar_~eT?M6!MuLdN(ZQZg6`XtU>#tFSdeVxnAR+BhS4 zv8SUB+)wZQfB!m855DOwzlnvr{Lnd3wrKvu^OcfMS>vqI{KvKm%PT>qZNuwW4usug z6$|}DLwkDz*(T|X+X$q+ES>=AiWjo1e;qI1SoILS56*5s72Wo3wqI)N*lWn>MSD_b zK;RFE$U;%-tVP$6!W=g=!4sRJF~F_b_ErLpjEvvG1xd-5SdfzmknI8y{mR~Qn}2Jb zxAQ$O@;&T(`mkT@dg|+3$s!`RZ%piT{?kb@cIMLBvtz@_@|AY7G;yBxx`tRhemxMSqD^}c9va*NgQ#XR)lZYD6* z@S}3H(Y`(7PFtyj&H3yHFl+19eIIo-O~g!fV#m2KSb8BCl+&h#tRrK82RT%><4%&b zl?3L@HyFI4*+(N2Kqh%8R5R+vMAz^b((o6zo;QmeatpJU)Eir{wZPH0Yh_69_vZ_0WGFnMaH0LJNFnj1N-lo9FmL z-7>{rOE$vvznA=mhy=*E{pkst5%6=n(@OC&Q3Gh0H-N2&r!}bYp$Q`e+zzqTB?Z*7 z^vL}aKLF5AzKRAUgUTqxGI25+q9^~rxBsi)OSXJf75Ib*kg1rWX2W~}prwTO04wMD zSEmbzIH}QokwlRoN0pfPsr)ZJ@dh4fDbN6=%>3&P0!AGzbigWe3Tu#XjTKIk$atD@ zEH4tH?3OBSXx33-Hj;J>3)npbEWmD10)z3x6IL1y0}R#+ut&|mu_ULEt2Ds41`oa( zk7ExHsr|$8fP|5{2?Y0!1W%7qoqf$3oYYApY_#MHXLH_StJQ(|_GM}zpA&Vg%t?eM zrR0}V3#8^IwIj@uJ?pH@LdfHM&5@EwspoMW%77rJLpAlspG3%XqhNsv=Yb6-aEv9W z@u(kiQu%I|w666NANX#TgB}1M5FwKNDFf$1DrTmllp{eH@wma`8E(Z?_Pn3U4M^f? z#U+IK8^52Z-lR6)H0IP*{6#vZko|Ta`e$=M^g}kw(|E(u!#N z+xB+Jtw*P3y)|fweI#~212>SpGZ79?s$52$6Dot;XMdno*=h%x%d?nEj>o%26ur(!ru7t4i9kR;7Chfn!@NAL-{6c&$Yo^=hE?T0)3 zbFuD`$Nuioczzx6_wDJTn{bX{PU zi>i7c`unK+_jydy4eFfGiWc3&aJcnu&aH_jbtlbS_W9ZFJ+(VuO}l`sHL{=_&rb;| zq+2L;sCY;wv2{8ZWZ$u%+|5$NLCtk~!Sa2W>CQ;V4MN5oaG174xe`^!sp$?(aj4C# z4I%PP3Ft4v{<`cDU8pVcqT?4#C}FXe7%b^=n6|CSAdtND-X{hVG3)`6t0{9Or46Ie zgxr)Qv>!8&hcUuK^8^1w=fecrj`f1v6^*=W_qe!rS$tq<-!gKdZ7BqlnSQ{ z$q5D}K=HN$219}jF)?4!lD+~7`rr&i4Qc*TV6=@k1UpRaI;02O>|Q12m?%)MFox(R zho$jsHtYn9aQH@Zf`Y~lsOK2_UE@^0D1BRkNjTv>1O<-k-I5;)^H2l8cC#t;{>{aM zYWkVGVi?y^ap5KZmqF1lNzrq+iED9Z6uHEK7dDWQ89ec;9~_bvNv5lILN(A!1`Zy5 z)5=o~Id;@+owkPlNDWWDnFY&38RQ9nc*wF7OjhJZ43Wt3f<9uip|UHK;S+M}rLT!% z!3v8g3Ud)Lz!$)>Z8*1N%mVWe?Sv98J%VrP4HrTJ`jnC!_I!KFB(NQj(-csuoq zI*}?A50zGFy8$1GAGsW;DDAc*9f0;h$Oy7RNtvp$aCzE63O}{4p;zdJjAbx};OW0$ z3Jo>^LJSzQ`N^eN^lith=ULRz};$N@%k>3@4X*tOy1X%(AHJ z%s^CIe39iPOd>NHshHtBz-6pr2@Pqjun9%b^&Kin2nJ!yOf+yduVy_4n?>6?)=qBY zN56N{)9j6g8pSFN{ptclIsSfHAA@w;t%e{>8}UKCP;&2UycSJ&ah zi;U|b^2rD~e%t%w4J_pPc|X(Pg%MsBps(K9bTux-QS~r&ecAVhI`xbiF#q)JB>2I# zapnJUdo*Jb;B&M6#r3t>C%^qE?=rRgz0u~qAdeA1^SUk5TVj2JCz+k+es*hcC3$N< z^;H_Ty##;K)yr*B-)&zxf#~N|NWTNj1AaIAJk1OD_X}=!^_W_s4qSgve+>5V3)g+u zqI`>Ew+*fcUQRWM2jaarG7pmw*UP*Hbl>es+n~HT5}yQo`#shX?*fEa#Fk!ykYQQf zSt_>eSDM&wc`n|C@6_FTdhjb9nIeQg25)W*NxmLJgf1>q@*Vi)bkNm;LY32bF-$V3 zN^fC0SM91QsW~IadnA@5cc}thsd3PZmvq{rni9mmYk{dI}HZj402!E1r> z04qHAtDB+K!m1aS|FjJEkbh(s<#BknoN6|qU5I)Hp5KVlouV(6|KV9Y`WL>;*~Nol z&A|PTo{?_+2tr8&?cVTb>I1x4e*!ufvorC;e%WH?&{59F&+45BI3_c!eE63~@X};5 z^Ehm6pxad9&hZ$@pge=;-!ue~c(7Zd!|2^5?Lpr(2%rtIJA1$L&6ELoc5pHonT?t! z3px4@_aALe%k0I{8mPJ*X9%(WgmE{d@*BLaa<6|${Ra?ef_nY8oT_!7{`E|!K?otJK^ox8PYYszm9HK4%avGuFH z;g!H+?7dJ5p7~Ej&Tow9L^E0w8=O_@pp%Lqqp9%Xal#`Pbs6DqqW4 z#^OC8g`0rViaF9kJvWV+@+bRUytU15OxSaaOVIk22ZauJl|4yNw)c8)3qAo@9=N1DLULMRUbUt3}oCI?e8idr1*saaDYOj-F%2%%X($&{^L z0(kIGgxc(}X^Jkndb*K05Y~~dvD&oyRG{80t2z(wn1gm_xb+}--_~4bP!lh!1%jEu zYO!`dxG^pVbv;3PdiqcjtBkT!hxDpl0N7jxM6Iz;gHV9hDZ(Qi2!&F2v=@PBG7Exk z*2m%x5`L+jv4{Eod)&1S&C@1Yl+;~0gynT@wAKQZ{5%AKO|Tm9zgmE3kIp{>@p3#5 zeovHX?HtOu8+?;7H$V4YKUbIwO+HU|IA1~_&x{212B~euQW0O(fz8jg79G*Ze+v!v zfowd4wPN|5eo*m|x;rSo)Hp)dp{0COgjHHG zHJhHLgw$%(H&zzz)coKEwa``l1(tETDH{ZviqDGWuu_z4dmetx{iZl0T%qzB*W+_f zce+5Y#KPZB$WWtv_M}L1{&pjU#DY+A>9~u7vMmlfLjBdxA^ZY8o6V0hVg-zH>J1jd zN$^$N$5j)gi}ko|jnU(I3?6gg6ESOdaj6U^bhD4yGWtd`@OnQ$WysXLH7G3a)zC_` zxK$7J;8}m49(lN6;7~qyL?3qugH=;S`h_BHeeZp1$T&iKYKP9`a)f7(LGMVY3|&h( z+K1v3#z7M?k0BAA$xlf)+um@fi*4y|yCuCm$3TJ*5oYi8hR$7as#MzAA1@)Hw^E{wm&?H_N8^0K$yau`Rl$w{(x1Kq)D~|_6j-;;v|1D@8VZMh zSd!i9C-tVe8WNyYlz}9H{G_fSfzogpT1mDD?3EOZk#Y)@?Iw8Wnq$mB%~LqN>dKJS zrT2*?p=2P)4N*Uu!&_X6XwlK0BLt*l(y1iHS@F|mff$rD0F8(R2XkDE4=BThht0v- z==@WSuU@xnVyE4;w+3kqo?arz<081VMVyzwt+;=c6-TrYc#CEjABsOd z9y!DgtmBd*NDIwgmRYQshJy8Q18#L1=>v}7w2hNl|9HbphXLkQPpm}v054v)s?a&H z!CO6t=nkd-Wa^rmL=Z=0L_<8|mH;(a_DIfzKx#0!&{mz6Dz`5C!U=T|4p7=*(t&w6 zNI+QQy zDx&?!i=YGvHAc9pr~~y`EM-^&)2o;m(F|InzhYDdkPQQgQ=<4#W7yNkn(?L#c7PV} zU`RTQ0{=kKM<(7Y%BGk7RxCXF|A|YysO(_H{Nek3AGQNxfg}In8Q^>vnn)~W962A9 zwPH8T+iMYyihw=hK34$usqzBI*I)hy2(WH)YPTgffi+&dv2q^fX1WpBc38D9Y zq6>2x7uDwS6S^pbs(1yUkG; z6mGlfmtjACP@jQ3duyOWcPw=rc834sJkPaq0w#Oyi(nD13u>@@Sp~*j7jWg2$4jYF z)QuDv2M8O-%dCRW2%esHIh_i4bL*Nq!?GY9Qok;m~ zxqN~tes#1R<9MoMP%5r~_-Nwg^GH*L!a9UA!oct6fPXPdo1|x0k`OfdSM7Kh+_6m4 z!~4%U-fRw#LsMlSuNzP+**COM)$p3yGz1Acj4ML$0`5r3Bq1B&NVipfi6n#Eq3^P~+I^qxIZ}{?k&k>w%G) zTjA5KKdKdRQE9p#`_dUkpO4NdNnyimMUpIlThAWEE-uo|dE5F7lV!v*X>JM6BMU52 z1-$?#_kpXETuC^=chftjFHx^~_TStpg3eWa=RGHHRWnAp@?{WJ3Ww;1+nh?C_S{eqFU*=4 zJ-ncZ9MUqAX9L{Ms ziNLqO8E^y0)i{>51K&jQo#%U{jY#i`LwBCIx8`0>NTQ2u@1;A9zR@#~d zqhhT7TI!sUNW(2tQx?*MCS$^k9jddO8lSqvwixEEEDHtSK23#;a@4AF?k^08SBN{?u%lzeV>Dy6buO5Tth6j$!c!8&!GB)9TZi*T)&kx7UIYMQv2@{UEmmI`{eiB!U$>MWNXyH$Z z)Js}zpM)QLI;IXe)es&foJx0d!b9N28LN(G97ahHnNk$0E+9V2iJB6|k_?6MOI2gI zONon@T+R&M(&#|;&JEArM*4N7SZd?|CA0CJ=uLPhl}1LO)z-h^P=wkH9wt=HHgaNj z-5NYhAOwVlG}<98QER+|4Ji|#&2CX+xk~S6)n#ACgWERp0nbGwgA0YXJuzT$(c*<+t%k>28(44vj((b5 z1Bebhf%Ip|mGxsWBA zSW-5crQ3kWB1VM}S-;pKqXG*|Q;mNeJN;Jo6)I0z_Vv%3G=Eit4!&P)OPB-O^6W1jH%L3YNbUA3VDudtWufFBQ5v3wB_(>A+YDdn&js!8@m>a} zoCT&>7@Qywq0A0Sn7@lpipz>P8~-T8pF+DigP)}d4a@Z6Ic+hG!^|sWkG9TcIx*fs zBbPu;8F@#mC0z50*V4rDVnpgC_|g^hP+t6p$LJZuj=T*`>uo&yU*wS34`B%u$FPWpNiX~@fKL=9hyP_8Tui0r z7rt2esnGSkQn~&5n7Jy1x5jbhFmf)O5b#k4Q(L#)to|uTUzxFbQyKmqb}E zgxhm7`l;GxhRe-OS<}+0fP)R(-X4ZRU2_7wm9BNYd5e4)I|z7xBE`{JfP_J)lOYp_ zjfOcZ{h)Eu@&m?M=SSd2;uK#Eb7ko&$dTIPrz>+2-{w?j(UAx!6E{~dP}&Cw{@})%HyAY?BX(jAyH9|7R8ZXF&Arza zLa)5TM4%;*X$Nu%d5Z5p7GzD}6z}pQf;aD9T}lBncL#G|SVK$X&yO6+yOrBdrr0dkRSN-lVLM@CmKaA5`dH8N68j+h~>|B2N0rw?9a zB%XUKpcJR*zY&364h5pG-4NL?r`r1L`#wv9GctVODYng6N#zyzGTMyOEU=MmsO0LG zG61orDpZ?jD0_0Zvby#p4u{XUcXKc>{^D)gsGI$Oj3~h-7DY96T>DNdlejY{2ZpVv z3~yUEZs!8nM8uuZf93f|tJiGYFw%XT`L?-75<$l7fPsCU0(=tlA846_A6uQ3vzLxN z4n}-HNX!5pw~?ITojE#K7l-}?G@)N`O|FB%`+251d_qPnQ3Q9_PCV^2phO7bZ@81rq$2Nh#f*aH~9c6E2g;Vb}8GvYlk zp$TYzWc?31x12JvunDnSWn<`pC2alR)yfW9e*~Oclt_6rV)IYWsyB1;^>YOOV}J%- z&d#>v5D;*;jzA)ZI=g0|KrIFWwLc0+<4v)s-NL7vub*eQupYI&Mou7iPX2zBVL?Wt_3 zbFJp6$6qNS6(Bp-{JTHqkC)$38E8ThTrq;Eeh5$O-PNVucxy~5JzVwd;oLM#fne6a z_IAZ381OIZ%iHtmpx)MZ`F;KPcGdqydd*_vy)~g{CqncJ6@q&3Cr1f89u0TPN}Xp7 zMW{mcb8DA(@AjjG$T2DbO55#QgQ}flHjR7DLSo)_sXj^PF6k5h z{z+_A>s!Md&s@AU#K?_hZu{2#=UBFc05PRpl1u6eSd>LjINE03wT@aYoOPG+e8aSWV6kpCO47I}_p-X@B<#u~%BRoKe8a-27qmF552X zc~wF7D87SgEkXGN96i(+k*SQcfxs>8Zi1%j4YCUF)$gE9&PAnUD5R;QVaJ*}5mIX@{fzaUA>7t*ZmRV{9;D2;3j*+OT?ggp+l0SnZxF&3Kmv%;{F>?kP7UHCa z4Z1sNRZQ8Tg(w)ypk%#CCs+kaq0!VaX5EOZvFOajMSz>|JFiPwCcMj_^4$AIr}r&g0(})$Y@Dv`xHuPzsElyMidmI<2sH)nqx2`m zrz6>LUlo_j=^d%)Skud71upPp(9FDlQ~!cw)+20exJcbd!hxMnEq&ov){vF6IGD+! zd^EgBd8_z5?OXdy^KgIcUjMjnKVwO)wH271wyKj^@E^E3i3gaH5Nf@sVkXX zSl*FIpOtLq-l2%kZ_KB!LT>SOdE+$Szgqc^rqn$itNYx!xi5~unr_$+<+yRV(qG4o zXgHf)IuRZ%GI`f3@KxW`=;(c~M-1R8P3@C7eLRr<# zZG!BA)`gY8RUp|Rgu_AX%|P~`I4;K8eK39He~O_Ij`0d`hzF@owW#9|_QZZ6VSe3@ zbYPDX&}nmd3#L@2^wt);8h^r-E8?ZiVULk;9CuMNkZATY>Jiuztqn}3@aV}W8WL3j z;PHTTM>&EdtB`|+=FEtEuV_qTaOa3h%syxb9kxR1(-V9Sg4hhhnPPbOD0IzR zgN&Mj-gpUzJ6IXWk@qsAALcX9bQ#$R+7BS7F|Cp|GcB)xL?aisl zg_ZtZU&0Z7EYxn|gb+)~fi!qhCX3jJ>^l+DTUW*!%uCpW!Q4J={44s)B;kIJu!P3c zcD){3@>WQsbggb{OI9Q+1Sk{+f89ro&4no=bSWJdyVp539`dvqAEKuntwIwJoMR6( zSekKptfN)?c$UiakjbT-#R6nV*aQx>j7lBWarUb9+&Ggs2)BZ0{}Vc;?+?OHAL65@ z?(YAwJO>LMg8&IDf$dtqViZ`Riq~w4yd^c?gd~Vmm=-3>M)SsiF);Kz_c%!mjad|N zpnw%)L^Ew3RDlYbUdMyYu;tqKClo(aImFXJrc|>SIteeXEApLw$V_E`XK!f?+CsRD zO^-#?f}@UCYb2d^xiu8&zr{~c?j9(m#O`&qVdXJdC=o@czsXH;&Xto+``Zw-0_}&=^OOHmQJ5U6D;N0CEHUoJ9ygPj%wv!7mKla)h%-c#$71>mFbXyjpS3SPeastW{a@Rip`prP|M#p?p+SiA=Wr$j> zcZ!D|%F*&ssL;r6j6K6*B~SQ2`LtKO`||(+6(i4-A&51gxmdRhE2$D#z4%cgV?EyQ z3QIj*BeVLiQ0`pz=`0SuhvF$-6Q^49sg;V)o7-Huh5kGXg2E`=@!?{j%yHUmUo%LJ zX9Ze{K#P$-q;PqN#*$P?v~VMU`3Ui2HD_OY+ity0|7OLm7gw;~Wvei)$fXqc#sH~gAi80jQxwVxz=+2DPn(_Kvc|C;s>zPlR71J%VL-MSF51? zd*HlYYOuV)Pf1q;y*s+j;n9qs`7o-c+K?&*Dn;h_3nboynV`T4W0^p4aF_hKG(gWs z$wAj6ERqJsPU+RJS)SSG)fF^ZJ<#&tn5UG4 ziVUO-I>afW5NdxCHF3m*wztxZJ5mSWinTh!w37~Sz`+&@gk$f!jO4NvAuosu^(bO} z4_VzTc9jhMvik<*hMi@QyM9{c$_CASn1-lriVE!0zs^_7nW6nKGPn%E=-{yl&~3% zx`G?9kiR%-MyEus=%xsdd}^fEw-THkUin025(T8PXQ~#eE1P8O&fPcP-m2%P z5Qq$E!(coxurWYGMvWw{o-e~H#80yTIR=1_+-XiTPC#;?*v`qJ%q1c$ht4FXXpww7 z-j4hA&M2x5eg)W>X}NbK4zuskPZcPnn4oR< zWSA?k4So(VMG5={IT_(&qY;9SQ{63rV1nDK#Vg7AGF(~uS@HvFZm&|Y4wvMfS$N{u z;%U3#q>ZyuiGqGX(ue-AK_tseVR;8**yD-|xsSlYF@PAG@TSZ=T^mplT;Xn+AJEjA zg=t4!Ay(?uUgIC8{3u=_a@@yTWsM4$Wj^_FpYg&qALqjNAVP~`9ALYPf9U9@`3TEM~ z)e=A>oy0|AyUMH+%>O`iiO5RO0fwF46b)oLWsHZC4(_bvHTwR0?+87Z@1FE(%DgQ2 zOLwwtQ$umAJoz!|fGUr;IUBzO#y*S{dqD&cN4r2xM&;6m8+%d~ncb}9urh9`#&9*r zfNdQaKs*DK=|A7&;wX94p$iF4En2JQz(L<3o2!ih7$OmZv@zTgfs;V=!P;xy>%x23 z9B>psEU1~Q-tGnDKFFStM)11hY$O!LcU0Si_kJ+zw^cE(kzqJhE$UEWXO%UM< zg)={AX2Qlhx@h&8CA@Y^Jv}OOpq*Eo`{)qJTrC-n45&@ecN;ceBYM#jUuVNtq&XbO* zgvwrn6Cefg$+}>UIie*;IMJ?Tu5T2g2i!xLy%I0fS<46Ri6WU7R)a98r$1Oh#KTkQ z$qsJ!tkUOW=nDvZT>3r|y_dJAUu602xuS1JM2-l#416JaHfc{10iHA|8HUc*A9tP2 zyg!X92m)x<&V52h>~`s=KK=X*Wfr9mgeva7N^=>tE&@ zW{abe@wd`npw5Epf%(l*RT4s7?2E{i?ow?0CF;bzd}d?QR+rKO@~~iWfr9^EVCN%Ch~Ji72D61`J$aEy=ras3F}U3@;Zgv{~zs2Dlf07Wxwu52R6MkfgGP z3_K89AGE#CS6il0p;&!PF%)qiV*-5SRL$E9SS*k(fI#S^^SpYg+r|WqlO~OwHul7gHF46|PTrpPJiYJd%$Gf%_H4|x@W0mjEy&z4_&JwB zJ)D1jzYs|=^nSxjb#N-);nBR(-^~s6ijSQnWZY`}6m{icgDsv5bCltxSeC~!J<1Rv ziX0>15kXH+tb-KFqOfK=zfS|Q(~*y#y67CL!rxp1Au=dx)AD!qdZ%l#ymI&x$1gHU zCHgTJ96w#|;<~wCi%?J_hMeb}l3p7*Q|9eIODQgO$yiO(KUU&)_y%4gtql(1*&AD; z1`_S7DwRCc9AaJI;;p`YBR7#F(2xx4-P673CiVN`rGK>er(8eL)Zk@+P;nsVXDo2@LJ_ri2NWAbj`)RHl1yhRxeM-TGJc;b)Q997; zWh7A-72U#k?PV6L(94WlUEI&m9&v;NyX+ht7Di|bh#*C|qym)?(|0<7qc_-m~p5t^@w-Rg@_#_&o!I_0cAg*6EtFliniD!*mP@IpzX3rBhH2TR4{ zRLvgsg|u=i&b&!$Xe|S>R84`d0r||j6rQ2s1gYI{dEwTHc$6eo0$78Nemgu@+|1?m zYQC(z2)bIksfI$<&L!D22V8E@Hjy~p0B=bvPmk_2nnPngOT)Akcb@cJp4IF@6M z$6Yv2E91yZQUoRN0{v4CM4u$WK#N?r!dl8Sd8wdUzLjidtEq;b&yiopk@XWfroyGI zqq8O+OFv~E(#+aedo1@)D^=J&Ypf#7x(1y0tuP^MNL|PCEAA5fMNeqT7l-ZYKZ)&0 zLik?CHy}^-Xj>$_iFwQW@J@-DMwvn)zJmAc!gBERb{Vv_rMC5c4~HA$7n+S}a;M6W3Jrs#JK5$Dz%U2NX@9F9ZyOA)t-e=J#A|V*w`~$j zv5Aon?Fa{FOT=MshZ6{IE`}^pNau{$i_oLT<-~`v29t%Gr8_NpAR9%(kA7Aj0CHxywK9 zvm>5=Wl!jRha!abLZlVa9sSadDQAmwdzpj4{IAXf2HX@Or7}|RdJL0sYADk!W&#lh zDLJ>H!ZPl!l0!$&`;ZNzYDZL$r*r~^7@FwxhW38mLDq2+!AV_-$1YF6o>)a(Qnz*h z^sQI zDZ&`pzEDD#&79n|quOXc**CToE@$t)HyAG{L(_GU`SU`=g|uMu<7rw+uAS@Tb+KfeBaIUuFgB6|Csei(ns-XDDuS<}=N<-|DBa87#8;Mk`TipTa*XJB( zw#<E%%O8H5 zMTd=|&XiF%zf7IlV`7~6=rWTG*s*z0@aq1yH?onI?_2c82K|J|&vB#dbm{WDxmVZQ z!nSk3%et}Xj~{_GA-qAq2aLCVOZsy-e)tl6@Hqf5@C!syzU<|Hsn|;(E8G%#*?toJ zxcakldFp!ixE*#i`-fwpOUFwYY2a+~ZgO(>aJq2go+Q;%?zI2sj6o@9@evh~D~A#q zq$5?)C%TzltN_FAUCX2n#^u{s*G@1JX+tpMv$Rk1BnJIb=mx=dH0pRuG8jBZ&EKC> zg@pl-F)xm7?q#K>31&#pf#Wk}wB2XU;Kwm31F(#jIk*7Ls&9 zB1JWNhEp8Z(&G_=Jlx$rCHxi|yr`bOfSm$XGurzmX_d_&NyyiG)7$91$ljv9qq4oR zGXJ(ey84f&;Llagb#8?D`5S*GTSmj!7l?j!gbhN$yICpA#BR*-r6LM}%#JKJD;|uw ziy5JiHRvY4gW7;y zn@I#+Vp{hP(wj4?C3S0e%d;t=SR)KeaIN$S38QAK9GW-v*u*MAOjY#Z7ow-lLWoYW zK#v%`Xo8e6Z~R5%4P*jGveDbR2~_8HLJ-ghpqm=vUWjiuE{A2}LR!mla0wP6O=oEK z*+S7gZnGC4Zd^4Z68BG3-$jMLW{)K3v&C?+)>A(WQc354q{u+FX++9@8p-8$}15SVuQa;J*H+}6pBx@#g?^ScORYu;Ou%^J4 z1>*0ktvkOgRHXfm)R4cr-4AYn?>$B<{4x*2Yrv!T#T8L(O~f%O2+Sss3%sNPN0e*~ zHSzlel$2-`*(ZWd4`?U3i<4*V=e%FbXmnOWl;Pq!-kG78py4B6jEW$8_~6!oLB0dC zfUASnLu{MOYacm&ZOS!iiS)w`^@d@F;*(RW++j08>_^NA4pVWa4FIiq0v5L z&Gh25v?l-Azp$FH?9N^Ri?kE_)u^SSN&CEi%TU z@h?yOeuPMjq=h^^0D3CJ8o^gPu%3?+2kMZ-&DS@=pL`w z4^2hrOTIdG{n$c(+jhQ;`tmdAM=(q~&v~_%Z{GWkj_#Ya`&lhYkYjvJFqy1{w5>UM z*P7^Cv)}60W^RDD=ht^cM`F=455L;y8yu(i&W~-ohcusOA>oSnv(dEwV%43P~r#XjMPk!1W9aAWCtaKr)l(UW8f{6-| zNbIhnCTW;W@t0|?@PnVB5)-E44GYE73QL7%;DNyH{pKf};tdS&od5QZ)BrnYm(i=K z5ta`cJ``=5*kR~%$vqJ_4EvUm^B##eDsBD#}ql3J0 zrOjlHinx;Z;((-;7MheBAoZ~H{qcx!2H!wO5;)`oyUoiIjplC4y*&#vorX!vkm}<9 z2M!q7l!B@!9;JD-lX_x4QoKTELvM40rjnOZ@c4QUK%9$m`=dr_!ax__+t!~AI1mq8 zoJm;*_aDtTl8eD?lSqZo1A>jA8RJVBY6pRIpcvJg?ZV+-bOD?UVBE*+eI^9{AZ1Oj7`3hWH7lsa=AJxa2iZM9-X!w zCZ`xV=(-XxuCKz)D<=}k&^!GclKzQ<{khl9c1niM9ydQaGu4*zsZ}fwBEphAsbHDF zC~BWjKXOnF;D2O%WOkls-vl}U>RYpyMJfFTh|byqi8PrR0J1D8`L}yR2w_k*l%aDV z!TJdN9Fg25{n4LPBPpngHnTE9pIl$Yom4qJ8XO8I@yMG#PmS>^f2p^d&QxO=qQV!f z6?m9$cK*@sAFDr!i=TxhGU-#;?hW$e+sbeaqWLz6lQ<0;ZQ%UevUzMk23gem;7nFu z?svbN!5tL%IzqG{0%a>CGB#U20dPY0=NI%A^F|z+O`49{ZXKu|*A;x~5yDjE$*|@| z&VUH*>*L;IbAt-?H-`gv`us#bOC$f{iCs-x5n$SmJMvEp`0bbSPXAVWogr41libUh zdu46o#4b3vYO_lbc`_m@lo`PEu2I2vezrYMYP5A@Xyz>J5q5N}t5Sqs-}@?mx@23K z^O;UcZ1!SYD)w;Ka?cCP;>UN~V~wIhB-s^%-k4`DelE}OB`MJJPp-5*y~b5QeLd40 zUSzykOm(RuPMsGs19fs~A6bUKeli6*b7WV71L-k$)iV+v&%`??;7py+O9XKuWNHL& zlsJ3N%5~@Sl+JE?R1Tp9sZECNHt+uc(L{)R8~_ZRV-cnmd+9tR1y13nDyX|5C^TfnLWVgd4WZ=p$doU+jF3|vr|Qu@ zw_1$3F*hb>tU4$B7U_pVnTeSXD-F_5Vg3p04nYj-J5*5nw zu8==#KN7Ght##g_vizW6llc0heh5meLj-7p)%W3X5&LbT9fA*g$Fz>>sC0P2w(2SL z?np7e57_a={=XP_|eYzXA;5OaNYT{Zt-XeHm{ zMw7>D8kfGC`i2sml_%8(MPnxYv-_E*0a)8K-Q>MAR07`&WZyYp*b*Lj>B&Yv z%aHX6J*FP6K?*JD!gOGLER-&H9#j&ufkcRyTwc{{#)pNZ4hqhLz?(3Kwh>il(BMJr z9aY5+V$c9MVr@xI6T|pLb~0yP*ss9Te{jr7<5iWZ{la)+|3*IvoLgU-8_c*$TT{$c zUAo15BgJf(Ozg?I{LHgum{MP45(fiSO?Jc^|9K8M2<+OmPgc*oo~=J-nMcZ*btEav z9a{dDZKaRB0Vkv$N=6_EVg{$2mPA^V4vxtvVVk$TPRW*9N&LVr=%OqM9eGNf$T63- z+}c+ndpRG&?W-tkT;I&`XZV*!%k8B&35??<3Vi;xhteIMwPmzfgjK=@wL8pqay^

      lF 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 OeNvKBm#vdF5BY!NpQ2j; literal 0 HcmV?d00001 diff --git a/gui-test-screenshots/t3-run-failed-dark.png b/gui-test-screenshots/t3-run-failed-dark.png new file mode 100644 index 0000000000000000000000000000000000000000..3d4c7ee6327b8eec1baaead74103ee2b7205b52f GIT binary patch literal 202152 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%0DBphekD@vZw@9YzIsO3E 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

        L5@AdbdTM$;P_M6BOw*u1P) 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%0DZ

        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

        GCP;<~1J-!# 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 OQ`lE2lZw{#_ra(g2xE>u=GEl7g2h5Bc zt~N⪻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%0DS3ujQ$L=uWKqI;sZHfn* zlP`)|)cI}Ax246cnHy4{SHK#-^hvULY*QYc`bk>-+OaSgV$cgQW^jI9u9YkP=)2^{ r+zToa5|WDxrO5_z@PhK+xl2y+Y-knpqmz07yhEa+X`t~*%_iu7=#kvs literal 0 HcmV?d00001 diff --git a/gui-test-screenshots/t7-360-light.png b/gui-test-screenshots/t7-360-light.png new file mode 100644 index 0000000000000000000000000000000000000000..555cfe81247332c8ec6750a6f737c603ab107a94 GIT binary patch literal 89167 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 literal 0 HcmV?d00001

        hA8W}D}rTn!1XtH-3ps=mL3-(&sS2l-i!YD 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