Spaces:

3VVM
/

Lk

Sleeping

App Files Files Community

Kashaf1 commited on Sep 1

Commit

02b7676

1 Parent(s): c584d79

Deleted all

Browse files

Files changed (19) hide show

README.md +0 -512
app.py +0 -251
backtest_engine.py +0 -235
config.py +0 -196
data_layer.py +0 -254
decision_engine.py +0 -102
features.py +0 -180
leakage_audit.py +0 -54
metrics.py +0 -127
moirai_model.py +0 -245
persistence.py +0 -85
requirements.txt +0 -73
run_tests.py +0 -55
tests/fixtures.py +0 -38
tests/test_backtest_no_lookahead.py +0 -322
tests/test_config.py +0 -32
tests/test_data_layer.py +0 -117
tests/test_decision_and_metrics.py +0 -112
tests/test_features_and_leakage.py +0 -122

README.md DELETED Viewed

@@ -1,512 +0,0 @@
----
-title: Moirai-MoE Forex & Crypto Forecaster
-emoji: 📈
-colorFrom: blue
-colorTo: indigo
-sdk: gradio
-sdk_version: "6.26.0"
-python_version: "3.11"
-app_file: app.py
-pinned: false
-license: cc-by-nc-4.0
----
-# Moirai-MoE-1.0-R-Small — Forex & Crypto Forecasting
-A real forecasting + walk-forward backtesting application whose **sole
-predictive model** is `Salesforce/moirai-moe-1.0-R-small`. No other ML
-model exists anywhere in this codebase as a fallback or replacement —
-grep for `sklearn|xgboost|lightgbm|catboost|prophet|statsmodels` in
-`*.py` and you'll find nothing.
-## Read this first: what "real" means in this build
-This project was built and unit-tested inside a sandboxed environment
-with **no outbound network access** (confirmed: `curl` to pypi.org
-returns `403 host_not_allowed`). That means, in *this* environment, it
-is not possible to:
-- `pip install uni2ts / torch / gluonts / yfinance / gradio`
-- download the actual `Salesforce/moirai-moe-1.0-R-small` checkpoint
-- call the real Yahoo Finance API
-So rather than fabricate "it works" — which is the one thing this
-project's own spec (and honest engineering generally) forbids — here
-is exactly what was and wasn't verified, using the project's own
-VERIFIED / IMPLEMENTED / BLOCKED vocabulary.
-## Final Validation Report
-### MODEL VERIFICATION
-- Checkpoint: `Salesforce/moirai-moe-1.0-R-small` — **confirmed to exist** (469MB, safetensors, license cc-by-nc-4.0) via live lookup during this build.
-- API surface (`MoiraiMoEModule.from_pretrained`, `MoiraiMoEForecast(...)`, `.create_predictor().predict(...)`) — **confirmed against the current official `uni2ts` repo and PyPI package** (`pip install uni2ts`, v2.0.0) during this build, not from possibly-stale training memory.
-- Real checkpoint load / real forward pass: **BLOCKED** — no network in this sandbox to install `uni2ts`/`torch` or download the checkpoint. Verified instead that the failure mode is correct: `MoiraiMoEForecaster().load()` raises `ModelLoadError("uni2ts is not installed/importable...")`, not a silent mock (see `run_tests.py` output below).
-### DATA VERIFICATION
-- `yfinance` retrieval code: **IMPLEMENTED**; the underlying `yfinance` *package* is now installable and was installed in a later, network-enabled sandbox pass (see "Bug-fix pass" below) — resolved to `1.7.0`, and `Ticker.history()`'s signature (`period`/`interval`/`start`/`end`/`auto_adjust`) plus its returned OHLCV column names were confirmed unchanged from what `data_layer.py` assumes. A real *call* to Yahoo's endpoints is still **BLOCKED** in every sandbox pass so far (neither this one nor the later one has network access to `finance.yahoo.com`). Confirmed the failure mode is honest: `fetch_ohlcv()` raises `DataSourceError`, never returns fabricated candles.
-- OHLCV validation, causal resampling (5m→10m, 1h→2h/4h), local SQLite cache, freshness classification: **VERIFIED** — real unit tests, real execution, see below.
-### FEATURE VERIFICATION
-- All 10 indicator families (RSI, MACD, Bollinger, SMA, EMA, Stochastic, ATR, ADX, ROC, OBV): **VERIFIED**. `test_indicators_are_causal` recomputes every indicator on a truncated frame and asserts bit-identical values at every shared timestamp — this is a real causality proof, not an assumption.
-- Warm-up detection/trimming: **VERIFIED**.
-### LEAKAGE VERIFICATION
-- `leakage_audit.py` assertions: **VERIFIED** — `test_leakage_audit_catches_future_row` injects an actual violation and confirms it's caught.
-- Backtest no-lookahead property: **VERIFIED** — `test_decisions_unaffected_by_future_rows` and `test_backtest_context_never_extends_past_origin` run the walk-forward engine twice (full data vs. truncated data) and assert every shared decision is identical, and that no context slice ever contains a timestamp after its own origin.
-### FORECAST / TRADING VERIFICATION
-- Point/probabilistic/trading metrics (MAE, RMSE, sMAPE, directional accuracy, Sharpe, Sortino, Calmar, max drawdown, profit factor): **VERIFIED** against hand-computed values on tiny known examples.
-- Real accuracy/PnL numbers on real market data: **BLOCKED** — requires the real checkpoint and real Yahoo data. **This build makes no accuracy or profitability claim of any kind.** Anything computed against `tests/fixtures.py`'s synthetic data is a software-correctness check only, per spec section 100, and is never reported as performance.
-### RESOURCE VERIFICATION
-- Designed for 2 CPU / 16GB RAM / 50GB disk (bounded sample counts, chunked/streaming-friendly cache, no unbounded in-memory tables): **IMPLEMENTED**, not load-tested here.
-### DEPLOYMENT VERIFICATION
-- App imports and Gradio Blocks graph construction: **VERIFIED** as of the "Bug-fix pass" below — a later sandbox pass had real network access to PyPI, installed `gradio==6.26.0` (the exact pin in `requirements.txt`), and confirmed `import app` builds the full Blocks graph (2 backend functions, every Row/Tab/Accordion/component) with no exception. `torch`/`uni2ts`/`gluonts` were deliberately not installed in that pass (heavy, and not needed to exercise this specific claim), so the real checkpoint load and forward pass remain BLOCKED as stated above.
-- Full pipeline wiring (data → features → model → decision → backtest → metrics): **VERIFIED end-to-end using a test-only stub in place of the real model** — see `tests/test_backtest_no_lookahead.py`. The stub is never referenced by `app.py`. Also re-verified by calling the real `app.run_backtest()` / `app.run_live_forecast()` directly (model and OHLCV-fetch swapped for stubs, everything else real) — see "Bug-fix pass" below.
-### ACTUAL TEST RUN (executed in this sandbox, unedited)
-```
-$ python3 run_tests.py
-PASS  test_backtest_no_lookahead.py::test_backtest_context_never_extends_past_origin
-PASS  test_backtest_no_lookahead.py::test_decisions_unaffected_by_future_rows
-PASS  test_data_layer.py::test_data_freshness_classification
-PASS  test_data_layer.py::test_local_cache_round_trip
-PASS  test_data_layer.py::test_validate_marks_negative_volume_unavailable_not_invented
-PASS  test_data_layer.py::test_validate_removes_duplicates_and_keeps_first
-PASS  test_data_layer.py::test_validate_removes_invalid_ohlc_relationship
-PASS  test_data_layer.py::test_validate_removes_nan_rows_and_reports_them
-PASS  test_decision_and_metrics.py::test_decide_buy_on_clear_positive_move
-PASS  test_decision_and_metrics.py::test_decide_hold_on_wide_interval
-PASS  test_decision_and_metrics.py::test_decide_hold_when_edge_below_cost
-PASS  test_decision_and_metrics.py::test_decide_sell_on_clear_negative_move
-PASS  test_decision_and_metrics.py::test_directional_accuracy
-PASS  test_decision_and_metrics.py::test_max_drawdown_known_series
-PASS  test_decision_and_metrics.py::test_point_metrics_hand_computed
-PASS  test_decision_and_metrics.py::test_profit_factor_known_values
-PASS  test_decision_and_metrics.py::test_sharpe_nan_when_no_variance
-PASS  test_decision_and_metrics.py::test_smape_in_valid_range
-PASS  test_features_and_leakage.py::test_causal_resample_drops_incomplete_trailing_bin
-PASS  test_features_and_leakage.py::test_causal_resample_ohlc_correctness
-PASS  test_features_and_leakage.py::test_indicators_are_causal
-PASS  test_features_and_leakage.py::test_leakage_audit_catches_future_row
-PASS  test_features_and_leakage.py::test_warm_up_detection
-PASS  test_features_and_leakage.py::test_warm_up_raises_on_insufficient_history
-24/24 passed
-```
-One real bug was actually found and fixed during this run (`pd.read_json`
-needed `io.StringIO` on the sandbox's pandas 3.0.2) — left in this
-history deliberately, since "we ran it and fixed what broke" is the
-whole point of section 6 (real execution validation vs. static checks).
-## Bug-fix pass — Aug 2026 (real user-reported crash + related issues)
-Triggered by a real user hitting **BACKTEST ERROR** in the Backtest tab
-(`BTC-USD`, `1d`, History window = `4 days`). This pass ran in a
-sandbox with actual PyPI network access (a first for this repo) —
-`pandas`/`numpy` were already present, and `pytz`, `yfinance==1.7.0`,
-and `gradio==6.26.0` (the exact requirements.txt pin) were installed
-alongside them, so both `import app` (Blocks graph construction) and
-the full existing + new test suite were executed for real, not just
-reasoned about. `torch`/`uni2ts`/`gluonts` were left out (heavy, and
-the real checkpoint/forward-pass claims below don't depend on them).
-1. **The reported crash**: `warm_up_valid_from()` (`features.py`)
-   correctly refuses to fabricate a warmed-up row — the bug was that its
-   message just said "insufficient historical data" with no numbers. 4
-   daily bars can't warm up a 50-period SMA (or any of the other nine
-   indicator families), but the message didn't say which indicator was
-   blocking, how many bars it needed, or how many were available.
-   **Fix**: the message now names the exact slowest-to-warm-up column(s)
-   and the real bar counts, diagnosed empirically off the actual
-   computed columns (never a hand-derived per-indicator formula — MACD
-   and ADX are ewm-of-ewm chains, and guessing their effective warm-up
-   length is exactly the kind of static assumption section 6 argues
-   against). `app.py`'s Backtest tab also didn't catch this `ValueError`
-   specially the way the Live tab already did — it fell through to the
-   generic handler and showed a raw Python traceback for a normal,
-   actionable, non-buggy condition. Fixed to match the Live tab's
-   existing clean-message behavior.
-2. **A related, unreported latent bug found while fixing #1**: even
-   when warm-up succeeds, `WalkForwardBacktester.run()`'s default
-   `context_length=256` (never exposed in the UI, so every backtest run
-   used it regardless of History window) could still exceed the
-   available bars — and `app.py` never passed a `context_length` at
-   all, so production always hit the hardcoded default. When that
-   happened, `feature_df.index[start_idx]` raised a bare `IndexError`
-   once `start_idx` ran past the end of the frame — reproduced directly
-   with 150 synthetic daily bars. **Fix**: `run()` now checks
-   `warm-up + context_length + horizon + execution_delay` against the
-   actual bar count *before* indexing, and raises a new
-   `InsufficientDataError` stating the exact shortfall (e.g. "150 bars
-   available, needs at least 312 ... widen History window by at least
-   162 bars"). Also added a `context_length` slider to the Backtest
-   tab's new "Advanced" accordion (default 256, so nobody's existing
-   behavior changes unless they open it) — spec section 25 wants
-   assumptions explicit and configurable, and this one previously
-   wasn't either.
-3. **`decision_engine.decide()`'s SELL branch was gating on the wrong
-   probability**: it computed `prob_favorable = P(return > cost)` (correct
-   for BUY) and then used `1 - prob_favorable = P(return <= cost)` as the
-   SELL-side confidence check. That's a much easier bar to clear than the
-   directionally-correct `P(return < -cost)` — it's satisfied by anything
-   in the whole `-inf..cost` range, not just the actually-profitable-to-
-   short range below `-cost` — so SELL decisions could clear the
-   `min_probability` gate with materially less real confidence than BUY
-   decisions did. Confirmed with a constructed forecast where the two
-   disagree: true `P(return<-cost)` ≈ 0.54 (below the 0.55 gate → should
-   HOLD) while the old `1-prob_favorable` ≈ 0.56 (wrongly cleared the
-   gate → SELL). **Fix**: SELL now computes its own mirrored probability,
-   `P(return < -cost)`, instead of reusing BUY's complement. The
-   rationale string also now reports whichever probability the taken
-   action actually used — previously a confident SELL displayed
-   "P(return>cost)=0.00", which reads as "no confidence" even though the
-   real (and high) SELL-side confidence was correct.
-4. **The Live tab never passed an asset-specific cost to `decide()`**:
-   unlike the Backtest tab (`b_class` radio → a real `COST_PROFILES`
-   entry), `run_live_forecast()` called `decide(forecast, price_now)`
-   with no `cost_estimate_frac`, silently falling back to
-   `DecisionConfig`'s flat generic 5bps for every symbol — too high for
-   real forex spreads, too low for real crypto costs. **Fix**: added
-   `config.infer_asset_class()` (checks the curated symbol lists first,
-   then Yahoo's own ticker conventions — `=X` for forex, `-USD`/`-USDT`/
-   etc. for crypto — for anything typed via `allow_custom_value`) and
-   `config.round_trip_cost_frac()` (the cost-fraction formula, moved out
-   of `backtest_engine.py`'s private copy so both tabs share one
-   implementation). The Live tab's output now also states which cost
-   profile was inferred and the resulting round-trip cost, so the
-   assumption is visible, not silent.
-5. **Hardening, not a confirmed live bug**: `requirements.txt` pinned
-   `yfinance>=0.2.40` with no ceiling — the one dependency in this file
-   without the floor+ceiling treatment gradio already gets. This sandbox
-   pass's `pip install` resolved `yfinance==1.7.0` (a major-version jump
-   from the 0.2.x line this was originally written against); its
-   `Ticker.history()` signature and returned column names were checked
-   against `data_layer.py`'s usage and are unchanged, so the floor
-   wasn't tightened — but a ceiling (`<2.0`) was added so a future,
-   unverified 2.x can't be silently picked up the way an unpinned
-   `gradio` once was (see deployment history below).
-All four code fixes above have real regression tests
-(`test_warm_up_error_names_the_blocking_indicator_and_bar_counts`,
-`test_run_raises_insufficient_data_error_not_a_bare_indexerror` +
-`test_run_succeeds_with_a_smaller_context_length_on_the_same_short_data`,
-`test_decide_sell_requires_correct_directional_probability_not_buy_complement`
-+ `test_decide_sell_rationale_reports_the_sell_side_probability`,
-`tests/test_config.py`), and the original bug was reproduced and
-re-verified fixed by calling the real `app.run_backtest()` directly
-(OHLCV fetch and model swapped for deterministic stubs — same pattern
-`tests/test_backtest_no_lookahead.py` already used — everything else
-real, including `_get_ohlcv`, `compute_indicators`, the actual
-`WalkForwardBacktester`, and Gradio's own Blocks-graph wiring).
-```
-$ python3 run_tests.py
-PASS  test_backtest_no_lookahead.py::test_backtest_context_never_extends_past_origin
-PASS  test_backtest_no_lookahead.py::test_backtest_passes_correct_freq_to_forecaster
-PASS  test_backtest_no_lookahead.py::test_decisions_unaffected_by_future_rows
-PASS  test_backtest_no_lookahead.py::test_run_raises_insufficient_data_error_not_a_bare_indexerror
-PASS  test_backtest_no_lookahead.py::test_run_succeeds_with_a_smaller_context_length_on_the_same_short_data
-PASS  test_config.py::test_infer_asset_class_curated_lists
-PASS  test_config.py::test_infer_asset_class_default_for_unrecognized_symbol
-PASS  test_config.py::test_infer_asset_class_falls_back_to_yahoo_ticker_conventions
-PASS  test_config.py::test_round_trip_cost_frac_matches_hand_computed_bps
-PASS  test_data_layer.py::test_data_freshness_classification
-PASS  test_data_layer.py::test_local_cache_round_trip
-PASS  test_data_layer.py::test_resolve_history_window_days
-PASS  test_data_layer.py::test_resolve_history_window_max
-PASS  test_data_layer.py::test_resolve_history_window_months_uses_calendar_months
-PASS  test_data_layer.py::test_resolve_history_window_years
-PASS  test_data_layer.py::test_validate_marks_negative_volume_unavailable_not_invented
-PASS  test_data_layer.py::test_validate_removes_duplicates_and_keeps_first
-PASS  test_data_layer.py::test_validate_removes_invalid_ohlc_relationship
-PASS  test_data_layer.py::test_validate_removes_nan_rows_and_reports_them
-PASS  test_decision_and_metrics.py::test_decide_buy_on_clear_positive_move
-PASS  test_decision_and_metrics.py::test_decide_hold_on_wide_interval
-PASS  test_decision_and_metrics.py::test_decide_hold_when_edge_below_cost
-PASS  test_decision_and_metrics.py::test_decide_sell_on_clear_negative_move
-PASS  test_decision_and_metrics.py::test_decide_sell_rationale_reports_the_sell_side_probability
-PASS  test_decision_and_metrics.py::test_decide_sell_requires_correct_directional_probability_not_buy_complement
-PASS  test_decision_and_metrics.py::test_directional_accuracy
-PASS  test_decision_and_metrics.py::test_max_drawdown_known_series
-PASS  test_decision_and_metrics.py::test_point_metrics_hand_computed
-PASS  test_decision_and_metrics.py::test_profit_factor_known_values
-PASS  test_decision_and_metrics.py::test_sharpe_nan_when_no_variance
-PASS  test_decision_and_metrics.py::test_smape_in_valid_range
-PASS  test_features_and_leakage.py::test_causal_resample_drops_incomplete_trailing_bin
-PASS  test_features_and_leakage.py::test_causal_resample_ohlc_correctness
-PASS  test_features_and_leakage.py::test_indicators_are_causal
-PASS  test_features_and_leakage.py::test_leakage_audit_catches_future_row
-PASS  test_features_and_leakage.py::test_warm_up_detection
-PASS  test_features_and_leakage.py::test_warm_up_error_names_the_blocking_indicator_and_bar_counts
-PASS  test_features_and_leakage.py::test_warm_up_raises_on_insufficient_history
-38/38 passed
-```
-Not touched in this pass, disclosed rather than silently left out:
-`persistence.py`'s `Store`/`record_forecast` is real, tested-adjacent
-code, but still isn't called anywhere from `app.py` — the "SQLite
-forecast registry" in the Architecture diagram below doesn't actually
-run yet. That's a missing integration, not a bug this pass introduced
-or fixed; wiring it up is a reasonable next step but a bigger,
-separate change.
-## Feature addition — risk management & entry-filter data (Aug 2026)
-Triggered by a real 41-trade `EURUSD=X` @ 1h / 1-year backtest a user
-ran: 51.2% win rate, `profit_factor=0.78`, losing trades noticeably
-bigger than winning ones. Re-verified every number first (same method
-as the bug-fix pass above — recomputed all 41 gross/net PnLs from raw
-entry/exit prices, rebuilt the real ~5,800-point equity curve to check
-Sharpe/Sortino/Calmar): all exact matches, no bug in the math. Then
-actually analyzed the 41 real trades rather than guessing:
-- **Direction accuracy, not a P&L bug, is the real story**: every
-  single winning trade (21/21) had the forecast pointing the correct
-  way; 19/20 losing trades had it pointing the wrong way (the 20th was
-  a correct call too small to clear the 0.02% cost). Overall directional
-  accuracy was 53.7% — barely above a coin flip, consistent with the
-  51.2% win rate once costs are applied.
-- **A real but weak entry-filter signal**: `|forecast_return|`
-  correlates with `net_pnl` at r=0.314 across the 41 trades — bigger
-  predicted moves did trend better on average. That's real, but at
-  n=41 it's only marginally past the threshold for statistical
-  significance, and a magnitude-tercile breakdown (14/13/14 trades)
-  came out *non-monotonic* (mid-tercile had the best win rate but the
-  worst average P&L) — a strong sign that breakdown is dominated by
-  noise at this sample size, not a clean rule to hard-code.
-- **The real, structural gap**: `WalkForwardBacktester` had *zero*
-  intra-trade risk management — every trade held the fixed horizon no
-  matter what happened in between, with no way to exit early no matter
-  how far price ran against the position first. Confirmed this
-  empirically too: realized `|actual_return|` on wrong-direction trades
-  (0.0017) ran moderately larger than on right-direction ones (0.0015)
-  over the same fixed horizon — exactly what a stop-loss targets.
-**What was added**: `cfg.RiskManagement(stop_loss_frac, take_profit_frac)`
-(both `None` by default — every prior backtest reproduces exactly) and
-`backtest_engine._scan_for_early_exit()`, which checks each bar's real
-intrabar high/low between entry and the horizon exit and closes the
-trade the first time either level is crossed. Exit price is still that
-bar's *close* (not the exact stop/TP level or the wick), consistent
-with this engine's existing close-only fill convention — documented as
-a real, known limitation, not glossed over: a sharp intrabar wick that
-closes back near where it started will trigger the stop but barely
-show up in the realized P&L. If both a stop and a take-profit are
-crossed in the same bar, OHLC data alone can't say which happened
-first, so the stop is assumed (the conservative read). `Trade` also
-now carries `exit_reason` ("horizon"/"stop_loss"/"take_profit") and the
-decision's `prob_favorable`/`interval_width_pct` at open, so future
-backtests carry the data needed to actually test an entry filter
-against outcomes — the 41 trades above predate this field, so that
-specific analysis couldn't be run retroactively. Exposed in the
-Backtest tab's Advanced accordion as two sliders (0 = off).
-**Honest result, not oversold**: tested end-to-end through a synthetic
-scenario with injected adverse intrabar dips — a stop-loss cut some
-real losers short, but also locked in several dips that would have
-recovered by the nominal horizon exit, and net_pnl came out *worse*
-than the no-stop baseline in that run. A stop-loss is not a free
-win; whether it helps depends on whether adverse intrabar moves in the
-real data tend to keep going or mean-revert, which this sandbox has no
-way to check against real EURUSD intrabar history (no network access
-to Yahoo's endpoints, same limitation as every other pass in this
-README). Test it on your own data before trusting it — start narrow
-(e.g. a few multiples of the round-trip cost) and compare against a
-no-stop run on the same symbol/window.
-Five new tests cover this (`test_stop_loss_exits_early_at_the_breaching_bars_close`,
-`test_take_profit_exits_early_on_a_sell`,
-`test_stop_and_take_profit_both_breached_same_bar_assumes_stop`,
-`test_risk_management_default_none_reproduces_baseline_exactly`,
-`test_trade_records_decision_confidence_for_entry_filter_analysis`) —
-43/43 passing.
-## Real deployment history (from an actual HF Spaces build)
-Two real build failures happened after this was first deployed, both
-worth recording because the diagnosis process matters as much as the fix:
-1. **First failure**: `scipy` failed `metadata-generation-failed` while
-   building from source. I initially (and wrongly) assumed my own
-   `numpy<2.0` pin was the cause and removed it — that didn't fix it.
-2. **Real cause, found from the actual build log**: `uni2ts`'s own
-   `pyproject.toml` pins `scipy~=1.11.3` — a 2023-era release with no
-   prebuilt wheel for Python 3.13 (which is what the Space was actually
-   running, per `/usr/local/lib/python3.13/site-packages` in the log).
-   pip fell back to compiling `scipy-1.11.4.tar.gz` from source, and that
-   specific old release's build system doesn't work with the Space's
-   modern Cython/meson toolchain (`ERROR: Compiler cython cannot compile
-   programs`) — not a missing system package, a real incompatibility.
-3. **Fix**: pin `python_version: "3.11"` in this README's frontmatter
-   (a documented HF Spaces config key) so scipy 1.11.x resolves to a
-   prebuilt wheel instead of a source build. No requirements.txt change
-   was actually needed — my earlier "fix" there was chasing the wrong
-   variable, corrected here for the record rather than quietly erased.
-4. **Third failure, at runtime this time**: the build succeeded (scipy
-   installed as a wheel), but `import gradio` crashed with
-   `ImportError: cannot import name 'HfFolder' from 'huggingface_hub'`.
-   `huggingface_hub` 1.0 removed the long-deprecated `HfFolder` class;
-   `gradio==4.44.0`'s `oauth.py` still imports it unconditionally.
-   `uni2ts` only floors `huggingface_hub>=0.23.0` with no upper bound,
-   so pip picked the newest 1.x. Pinned `huggingface_hub<1.0` at the
-   time as a stopgap.
-5. **Fourth failure**: `import gradio` succeeded, but `demo.launch()`
-   raised `ValueError: When localhost is not accessible...`, with a
-   `TypeError: unhashable type: 'dict'` from Jinja2/Starlette template
-   caching right before it. Root cause: `gradio==4.44.0`'s `routes.py`
-   called `Jinja2Templates.TemplateResponse(name, context)` the
-   pre-Starlette-1.0 way; Starlette>=1.0 changed that signature to
-   `TemplateResponse(request, name, context)`, so the context dict
-   landed in the `name` slot and Jinja2 tried to hash it as a cache
-   key. **Real fix**: stopped patching individual symptoms and upgraded
-   to a currently-maintained Gradio. Confirmed against Gradio's own
-   changelog (not assumed) that both this Starlette signature fix
-   *and* "allow gradio to run with huggingface_hub 1.x" had already
-   landed upstream well before `6.26.0` — so `sdk_version` moved to
-   `6.26.0`, the `huggingface_hub<1.0` stopgap and a since-tried
-   `starlette<1.0` pin were both removed as no-longer-needed (and
-   actively risking a new resolution conflict), and `gradio` in
-   `requirements.txt` became `>=6.26.0,<7` (floor at the verified
-   version, ceiling below the next major). Checked the Gradio 6
-   migration guide's breaking changes against this codebase's actual
-   API usage (`gr.Blocks(title=...)` only — no `theme`/`css`/`show_api`)
-   before making the jump; none applied.
-6. **Fifth failure, and the important one**: build and startup both
-   succeeded, but every single backtest origin failed —
-   `Origins evaluated: 11200 | Model errors: 11200`. The UI didn't
-   surface *why* (only a count), which was itself a bug — fixed first,
-   since you can't diagnose a 100%-failure-rate bug from a number
-   alone. Root cause (confirmed against GluonTS's actual documentation
-   and source, not guessed): `moirai_model.py` built the GluonTS
-   `PandasDataset` without an explicit `freq=`, so it fell back to
-   `index.freqstr` on the raw timestamp index. A plain pandas
-   `DatetimeIndex` — which is exactly what `yfinance`'s
-   `Ticker.history()` returns — has `freqstr == None` unless something
-   explicitly sets it, regardless of whether the data has gaps. That
-   makes the fallback fail identically on *every* call, on *any* real
-   Yahoo data, which is exactly the 100%-of-11200 pattern observed.
-   **Fix**: `config.TIMEFRAME_TO_PANDAS_FREQ` maps each supported
-   timeframe to its pandas frequency alias (already known from the
-   selected timeframe — no inference needed), threaded through
-   `WalkForwardBacktester(timeframe=...)` and
-   `MoiraiMoEForecaster.predict(..., freq=...)`. Also added: the
-   backtest UI now shows up to 3 distinct real error messages (with
-   origin counts) whenever `Model errors > 0`, instead of only a count
-   — and `MoiraiMoEForecaster` now builds the GluonTS predictor once
-   per (context_length, prediction_length, covariate-set) and reuses
-   it, instead of rebuilding it from scratch on every one of
-   thousands of origins.
-   I have not run this against the real checkpoint (no network in this
-   sandbox) — this is IMPLEMENTED and reasoned from GluonTS's actual
-   source, not VERIFIED the way this project's non-network logic is.
-   If it's not fully fixed, the app will now show the real error text
-   directly, so the next round has something concrete to work from
-   instead of another guess.
-## UI improvements (requested, not bug-driven)
-- **Symbol**: both tabs now use a searchable `gr.Dropdown` pre-loaded
-  with ~44 common Forex/Crypto Yahoo tickers (`config.ALL_SYMBOLS`),
-  with `allow_custom_value=True` so any other Yahoo-supported symbol
-  can still be typed — this list is a convenience default, not a
-  restriction.
-- **History window**: replaced the short `period=` dropdown (which was
-  limited to yfinance's fixed enum: `1d/5d/1mo/3mo/6mo/1y/2y/5y/10y/
-  ytd/max`) with a 45-option dropdown covering every day count 1-30,
-  every month count 2-12, plus 1/2/5 years and `max`
-  (`config.HISTORY_WINDOW_CHOICES`). Since yfinance's `period` string
-  can't express e.g. "17 days" or "4 months" at all,
-  `data_layer.resolve_history_window()` converts the selected label
-  into an actual `start` date (using `dateutil.relativedelta` for
-  calendar-correct month/year math) and passes that to
-  `fetch_ohlcv(start=...)` instead of `period=...` for anything other
-  than "max".
-## Architecture
-```
-Yahoo Finance (yfinance)
-  -> validate_ohlcv()            [data_layer.py]
-  -> causal_resample() if needed [data_layer.py]
-  -> compute_indicators()        [features.py]   10 causal indicator families
-  -> warm_up_valid_from() trim   [features.py]
-  -> audit_feature_frame()       [leakage_audit.py]  fail loudly on any future row
-  -> MoiraiMoEForecaster.predict [moirai_model.py]   the ONLY model
-  -> decide()                    [decision_engine.py] Buy/Hold/Sell, cost-aware
-  -> WalkForwardBacktester       [backtest_engine.py] sequential, look-ahead-safe
-  -> metrics.py                  forecast + trading metrics
-  -> persistence.py              SQLite forecast registry, immutable rows
-  -> app.py                      Gradio UI (Live tab, Backtest tab)
-```
-## Deploying for real (to get real VERIFIED results)
-1. Push this folder to a Hugging Face Space (SDK: Gradio). HF Spaces has
-   network access, so `pip install -r requirements.txt` will actually
-   download `uni2ts`/`torch`/the checkpoint.
-2. **Run the real smoke test before trusting anything else** (spec
-   section 101):
-   ```bash
-   python3 -c "
-   from moirai_model import MoiraiMoEForecaster
-   import config as cfg
-   from tests.fixtures import make_synthetic_ohlcv
-   from features import compute_indicators, warm_up_valid_from
-   f = MoiraiMoEForecaster().load()
-   df = compute_indicators(make_synthetic_ohlcv(n=300))
-   df = df.iloc[warm_up_valid_from(df):]
-   fc = f.predict(df, cfg.TARGET_FEATURE,
-                   [c for c in cfg.PAST_DYNAMIC_FEATURES if c in df.columns], 5)
-   print('REAL forecast shape:', fc.quantiles.shape, 'context used:', fc.context_length_used)
-   "
-   ```
-   (Still synthetic *input* data here — the point of this specific
-   command is only to prove the real checkpoint loads and runs a real
-   forward pass. Use the Live tab with a real symbol for a real forecast.)
-3. Run `pytest tests/` (or `python3 run_tests.py`) again in that
-   environment — everything that passed here should still pass, and
-   you can now also exercise `fetch_ohlcv` against real Yahoo data.
-4. Try the Live tab with a real symbol (e.g. `EURUSD=X`, `BTC-USD`) and
-   the Backtest tab over a real historical window before relying on any
-   output.
-## Known limitations (honest, per spec section 115)
-- **Fine-tuning (Mode B)**: no UI tab yet. `MoiraiMoEForecaster` doesn't
-  currently expose a `fine_tune()` method — uni2ts's own fine-tuning CLI
-  (`project/moirai-moe-1`) is the more reliable path today; wiring a
-  thin UI around it is the natural next step.
-- **Probabilistic scoring**: pinball loss and interval coverage are
-  implemented; CRPS and weighted interval score are not.
-- **Symbol selection**: a curated dropdown covers common Forex/Crypto
-  tickers with free-text fallback for anything else (see "UI
-  improvements" above) — still not a live, searchable directory of
-  every symbol Yahoo lists, since yfinance itself exposes no such
-  endpoint.
-- **Drift monitoring**: not implemented in this build.
-- **Forecast persistence**: `persistence.py`'s `Store`/`record_forecast`/
-  `match_realized_outcome` are real, working code (see the Architecture
-  diagram above), but `app.py` never calls them — no forecast is
-  actually written to the registry yet. Noticed during the Aug 2026
-  bug-fix pass and disclosed rather than silently left out; wiring
-  `run_live_forecast()` to record each forecast is a reasonable next
-  step, kept separate from that pass's fixes since it's an integration
-  gap, not a bug.
-- **Fill-price convention**: the backtester fills at next-bar-close by
-  execution delay, not next-bar-open — documented in
-  `backtest_engine.py`'s module docstring, and it's a one-line change if
-  you want the stricter convention.
-- **Cost profiles** (`config.COST_PROFILES`) are reasonable defaults,
-  not measured spread/fee data for any specific broker or exchange —
-  replace them with real numbers before trusting a backtest's net PnL.
-- Every number this build has ever produced comes from either (a) a
-  real, executed unit test against known values, or (b) synthetic
-  fixtures used **only** to prove code correctness. **No real trading
-  or forecast-accuracy claim is made anywhere in this repository.**
-**Forecasts are probabilistic estimates, not guaranteed future prices.
-Nothing in this app is financial advice.**

app.py DELETED Viewed

@@ -1,251 +0,0 @@
-"""
-Gradio UI for Hugging Face Spaces (spec sections 49-53). Wires together
-data_layer -> features -> moirai_model -> decision_engine -> backtest_engine.
-Errors are surfaced with their real cause (section 98), never hidden
-behind a generic "something went wrong".
-"""
-from __future__ import annotations
-import traceback
-import gradio as gr
-import pandas as pd
-import config as cfg
-from backtest_engine import InsufficientDataError, WalkForwardBacktester
-from data_layer import (
-    DataSourceError, causal_resample, data_freshness, fetch_ohlcv,
-    resolve_history_window, validate_ohlcv,
-)
-from decision_engine import decide
-from features import compute_indicators, warm_up_valid_from
-from metrics import trading_summary
-from moirai_model import ModelInferenceError, ModelInputError, ModelLoadError, MoiraiMoEForecaster
-_forecaster = MoiraiMoEForecaster()
-_model_status = {"loaded": False, "error": None}
-def _ensure_model() -> bool:
-    if _model_status["loaded"]:
-        return True
-    try:
-        _forecaster.load()
-        _model_status["loaded"] = True
-        return True
-    except ModelLoadError as e:
-        _model_status["error"] = str(e)
-        return False
-def _get_ohlcv(symbol: str, requested_tf: str, history_label: str):
-    """Returns (df, native_or_derived, source_tf, validation_report)."""
-    kind, value = resolve_history_window(history_label)
-    period = value if kind == "period" else None
-    start = value if kind == "start" else None
-    if requested_tf in cfg.DERIVED_MAP:
-        source_tf, _ = cfg.DERIVED_MAP[requested_tf]
-        raw = fetch_ohlcv(symbol, source_tf, start=start, period=period)
-        clean, report = validate_ohlcv(raw)
-        derived = causal_resample(clean, source_tf, requested_tf)
-        return derived, "derived", source_tf, report
-    raw = fetch_ohlcv(symbol, requested_tf, start=start, period=period)
-    clean, report = validate_ohlcv(raw)
-    return clean, "native", requested_tf, report
-def run_live_forecast(symbol, timeframe, horizon, history_label):
-    if not _ensure_model():
-        return f"**MODEL ERROR**\n\n{_model_status['error']}", None, None, None
-    try:
-        df, kind, source_tf, val_report = _get_ohlcv(symbol, timeframe, history_label)
-    except DataSourceError as e:
-        return f"**SOURCE UNAVAILABLE**\n\n{e}", None, None, None
-    except Exception as e:
-        return f"**DATA ERROR**\n\n{e}", None, None, None
-    feat = compute_indicators(df)
-    try:
-        warm = warm_up_valid_from(feat)
-    except ValueError as e:
-        return f"**INSUFFICIENT HISTORY**\n\n{e}", None, None, None
-    feat = feat.iloc[warm:]
-    fresh = data_freshness(feat.index[-1], timeframe)
-    try:
-        forecast = _forecaster.predict(
-            context_df=feat, target_col=cfg.TARGET_FEATURE,
-            past_covariate_cols=[c for c in cfg.PAST_DYNAMIC_FEATURES if c in feat.columns],
-            prediction_length=int(horizon), freq=cfg.TIMEFRAME_TO_PANDAS_FREQ[timeframe],
-        )
-    except (ModelInputError, ModelInferenceError) as e:
-        return f"**MODEL ERROR**\n\n{e}", df.tail(200), val_report.__dict__, fresh
-    price_now = float(feat["close"].iloc[-1])
-    # Unlike the Backtest tab (which has an explicit asset-class radio),
-    # the Live tab only has a symbol -- infer forex vs. crypto from it so
-    # decide() gets a real, asset-appropriate cost estimate instead of
-    # silently falling back to DecisionConfig's flat generic default
-    # (previously every Live symbol used the same cost regardless of
-    # whether it was forex or crypto, cf. WalkForwardBacktester which
-    # always has a real cost_estimate_frac -- see config.round_trip_cost_frac).
-    asset_class = cfg.infer_asset_class(symbol)
-    cost_frac = cfg.round_trip_cost_frac(cfg.COST_PROFILES[asset_class])
-    decision = decide(forecast, price_now, cost_estimate_frac=cost_frac)
-    duration_min = cfg.TIMEFRAME_MINUTES[timeframe] * int(horizon)
-    summary = (
-        f"### {symbol} @ {timeframe}  _( {kind} from {source_tf} )_\n\n"
-        f"**Data:** {fresh['status'].upper()} — last bar `{fresh['latest_market_ts']}`\n\n"
-        f"**Horizon:** {horizon} bars ≈ {duration_min} min\n\n"
-        f"**Cost profile:** {asset_class} (inferred from symbol) — round-trip ≈ {cost_frac:.3%}\n\n"
-        f"**Last close:** {price_now:.5f}\n\n"
-        f"**Forecast return (P50):** {decision.expected_return:+.4%} "
-        f"&nbsp;&nbsp;[P10 {decision.p10_return:+.4%}, P90 {decision.p90_return:+.4%}]\n\n"
-        f"### Decision: {decision.action}\n\n{decision.rationale}\n\n"
-        f"_Forecasts are probabilistic estimates, not guaranteed future prices. "
-        f"Not financial advice._"
-    )
-    return summary, df.tail(200), val_report.__dict__, fresh
-def run_backtest(symbol, timeframe, horizon, history_label, asset_class, context_length=256,
-                  stop_loss_pct=0.0, take_profit_pct=0.0):
-    if not _ensure_model():
-        return f"**MODEL ERROR**\n\n{_model_status['error']}", None
-    try:
-        df, kind, source_tf, val_report = _get_ohlcv(symbol, timeframe, history_label)
-    except DataSourceError as e:
-        return f"**SOURCE UNAVAILABLE**\n\n{e}", None
-    feat = compute_indicators(df)
-    # 0 on either slider means "disabled" (a UI sentinel, not a real 0%
-    # stop) -- keeps the default identical to every pre-existing backtest
-    # unless someone explicitly opens Advanced and picks a value.
-    risk = cfg.RiskManagement(
-        stop_loss_frac=(stop_loss_pct / 100.0) or None,
-        take_profit_frac=(take_profit_pct / 100.0) or None,
-    )
-    bt = WalkForwardBacktester(_forecaster, timeframe=timeframe, asset_class=asset_class,
-                                horizon=int(horizon), context_length=int(context_length), risk=risk)
-    try:
-        result = bt.run(feat)
-    except (ValueError, InsufficientDataError) as e:
-        # warm_up_valid_from (ValueError) or the context-length/origin check
-        # (InsufficientDataError) -- both mean "your History window /
-        # context length don't have enough bars for this configuration",
-        # a real and common condition, not an unexpected code bug. The
-        # message is already specific and actionable (bars available vs.
-        # needed), so show it cleanly instead of a scary raw traceback --
-        # matching how the Live tab already handles the same ValueError
-        # from warm_up_valid_from above.
-        return f"**INSUFFICIENT HISTORY**\n\n{e}", None
-    except Exception as e:
-        return f"**BACKTEST ERROR**\n\n{e}\n\n```\n{traceback.format_exc(limit=3)}\n```", None
-    trades_df = pd.DataFrame([t.__dict__ for t in result["trades"]])
-    summary = trading_summary(trades_df, result["equity_curve"], cfg.TIMEFRAME_MINUTES[timeframe])
-    lines = [
-        f"### {symbol} @ {timeframe} ({kind} from {source_tf}) — walk-forward backtest",
-        f"Origins evaluated: {result['num_origins']}  |  Model errors: {len(result['errors'])}",
-        "",
-    ]
-    for k, v in summary.items():
-        lines.append(f"- **{k}**: {v}")
-    if risk.stop_loss_frac or risk.take_profit_frac:
-        counts = trades_df["exit_reason"].value_counts().to_dict() if not trades_df.empty else {}
-        lines.append(
-            f"- **exit reasons**: horizon={counts.get('horizon', 0)}, "
-            f"stop_loss={counts.get('stop_loss', 0)}, take_profit={counts.get('take_profit', 0)}"
-        )
-    if result["errors"]:
-        # Every origin failing the same way means a real, systematic bug --
-        # showing it is far more useful than a bare count (section 98:
-        # errors must say what failed, not just that something did).
-        unique_msgs = {}
-        for err in result["errors"]:
-            unique_msgs.setdefault(err["error"], []).append(err["origin_ts"])
-        lines.append("\n### Model error detail (first 3 distinct messages)")
-        for msg, origins in list(unique_msgs.items())[:3]:
-            lines.append(f"- `{msg}` — seen at {len(origins)} origin(s), e.g. `{origins[0]}`")
-    return "\n".join(lines), trades_df
-with gr.Blocks(title="Moirai-MoE Forex & Crypto Forecaster") as demo:
-    gr.Markdown(
-        "# Moirai-MoE-1.0-R-Small — Forex & Crypto Forecasting\n"
-        f"Sole predictive model: `{cfg.MODEL_CHECKPOINT}`. No fallback model is used. "
-        "Forecasts are probabilistic estimates, not guaranteed future prices — not financial advice."
-    )
-    with gr.Tab("Live Forecast"):
-        with gr.Row():
-            symbol_in = gr.Dropdown(choices=cfg.ALL_SYMBOLS, value="EURUSD=X",
-                                     allow_custom_value=True,
-                                     label="Symbol (pick one, or type any Yahoo ticker)")
-            tf_in = gr.Dropdown(choices=cfg.ALL_TIMEFRAMES, value="1h", label="Timeframe")
-            horizon_in = gr.Slider(1, 20, value=5, step=1, label="Horizon (bars)")
-            period_in = gr.Dropdown(cfg.HISTORY_WINDOW_CHOICES, value="30 days", label="History window")
-        run_btn = gr.Button("Run Forecast", variant="primary")
-        out_md = gr.Markdown()
-        out_table = gr.Dataframe(label="Recent data")
-        with gr.Accordion("Data validation & freshness", open=False):
-            out_val = gr.JSON(label="Validation report")
-            out_fresh = gr.JSON(label="Freshness")
-        run_btn.click(run_live_forecast, [symbol_in, tf_in, horizon_in, period_in],
-                      [out_md, out_table, out_val, out_fresh])
-    with gr.Tab("Walk-Forward Backtest"):
-        with gr.Row():
-            b_symbol = gr.Dropdown(choices=cfg.ALL_SYMBOLS, value="BTC-USD",
-                                    allow_custom_value=True,
-                                    label="Symbol (pick one, or type any Yahoo ticker)")
-            b_tf = gr.Dropdown(choices=cfg.ALL_TIMEFRAMES, value="1d", label="Timeframe")
-            b_horizon = gr.Slider(1, 20, value=5, step=1, label="Horizon (bars)")
-            b_period = gr.Dropdown(cfg.HISTORY_WINDOW_CHOICES, value="1 year", label="History window")
-            b_class = gr.Radio(["forex", "crypto"], value="crypto", label="Asset class (cost profile)")
-        with gr.Accordion("Advanced (model context & risk management)", open=False):
-            gr.Markdown(
-                "**Model context**: bars of lookback the model sees at each "
-                "backtest origin, on top of indicator warm-up. A short "
-                "History window needs a smaller context length here, or "
-                "the backtest has no room left for even one origin — the "
-                "error message will say exactly how many bars are missing "
-                "either way.\n\n"
-                "**Risk management**: 0 = off (the original behavior — "
-                "every trade holds the full horizon no matter what "
-                "happens in between). A stop-loss/take-profit is checked "
-                "against each bar's real intrabar high/low between entry "
-                "and the horizon exit, and closes the trade early — at "
-                "that bar's close, not the exact stop level — the first "
-                "time either is crossed."
-            )
-            b_context = gr.Slider(32, 512, value=256, step=32, label="Model context length (bars)")
-            b_stop = gr.Slider(0, 3.0, value=0, step=0.05, label="Stop-loss (%, 0 = off)")
-            b_tp = gr.Slider(0, 3.0, value=0, step=0.05, label="Take-profit (%, 0 = off)")
-        b_btn = gr.Button("Run Backtest", variant="primary")
-        b_out = gr.Markdown()
-        b_trades = gr.Dataframe(label="Trade ledger")
-        b_btn.click(run_backtest, [b_symbol, b_tf, b_horizon, b_period, b_class, b_context, b_stop, b_tp],
-                    [b_out, b_trades])
-    gr.Markdown(
-        "---\n**Modes implemented in this build:** Live inference (Mode D) and walk-forward "
-        "historical evaluation with trade simulation (Mode C). Fine-tuning (Mode B) has real "
-        "training-loop code in `moirai_model.py` but no UI tab yet in this build — see README "
-        "limitations."
-    )
-if __name__ == "__main__":
-    # Gradio 6.26 on HF Spaces appears to auto-detect the container
-    # environment even without this, but binding explicitly is cheap
-    # insurance against any platform that doesn't auto-detect it.
-    demo.launch(server_name="0.0.0.0", server_port=7860)

backtest_engine.py DELETED Viewed

@@ -1,235 +0,0 @@
-"""
-Walk-forward, look-ahead-safe backtest engine (spec sections 28-30,
-53-54, 92). Decisions at time t only ever see data <= t; future closes
-are used strictly afterward, only to score the already-fixed decision
-(section 53: "Only AFTER execution/decision is fixed may future data be
-used to calculate realized PnL").
-Fill-price convention (documented per section 25's "all assumptions
-must be explicit, configurable, and auditable"): entry fills at the
-CLOSE of the bar `execution_delay_bars` after the decision origin; exit
-fills at the close `horizon` bars after that. Swap for next-bar-OPEN if
-you want a stricter convention — it's one line, marked below.
-Single-position convention: this simulates ONE account with no margin
-or leverage model, so a new trade is never opened while a previously
-opened trade hasn't exited yet (decide() has no notion of position
-state, so this is enforced here). Without this, a fresh full-notional
-trade would be opened at every origin regardless of what's still open
--- during a run of same-direction signals that's several positions
-stacked on the same equity curve at once, which silently multiplies
-exposure the cost model and risk metrics know nothing about.
-"""
-from __future__ import annotations
-from dataclasses import dataclass
-from typing import List, Optional
-import pandas as pd
-import config as cfg
-from decision_engine import Decision, decide
-from features import warm_up_valid_from
-from leakage_audit import LeakageError, audit_feature_frame
-class InsufficientDataError(Exception):
-    """Raised when the feature frame has fewer bars than this backtest
-    configuration needs for even a single origin -> exit sequence.
-    Distinct from the ValueError warm_up_valid_from raises (which means
-    indicator warm-up is impossible at all): this means warm-up succeeded
-    but there isn't enough data left over for context_length plus at
-    least one tradeable origin. Previously this case wasn't checked for
-    at all -- feature_df.index[start_idx] would raise a bare, confusing
-    IndexError once start_idx ran past the end of the frame. Checking
-    explicitly means the message can say what failed, not just that
-    something did (spec section 98)."""
-@dataclass
-class Trade:
-    decision_ts: pd.Timestamp
-    entry_ts: pd.Timestamp
-    exit_ts: pd.Timestamp
-    action: str
-    entry_price: float
-    exit_price: float
-    forecast_return: float
-    gross_pnl: float
-    net_pnl: float
-    costs: float
-    exit_reason: str = "horizon"       # "horizon" | "stop_loss" | "take_profit"
-    prob_favorable: float = float("nan")     # decision.prob_favorable at open, for post-hoc entry-filter analysis
-    interval_width_pct: float = float("nan")  # decision.interval_width_pct at open, same reason
-def _scan_for_early_exit(feature_df: pd.DataFrame, exec_idx: int, horizon_exit_idx: int,
-                          action: str, entry_price: float, risk: Optional[cfg.RiskManagement]) -> tuple:
-    """First bar strictly after entry whose high/low breaches a stop-loss
-    or take-profit level, or horizon_exit_idx if neither ever triggers
-    (or risk management is off). Returns (exit_idx, exit_reason).
-    The exit PRICE is still that bar's CLOSE, not the stop/TP level
-    itself -- consistent with the rest of this engine's documented
-    close-only fill convention (module docstring), and because intrabar
-    high/low only tells us a threshold was crossed, not what price you'd
-    actually have been filled at; inventing an exact fill price from
-    that would be manufacturing data we don't have (spec section 88).
-    This is conservative in both directions: a stop may report a
-    smaller loss than a real gap-through would produce, and a
-    take-profit may report less gain than the intrabar peak. If both
-    levels are breached within the same bar, we can't tell from OHLC
-    alone which was touched first, so this assumes the stop -- the
-    conservative read when direction of causation is unknown."""
-    if risk is None or (risk.stop_loss_frac is None and risk.take_profit_frac is None):
-        return horizon_exit_idx, "horizon"
-    if action == "BUY":
-        stop_level = entry_price * (1 - risk.stop_loss_frac) if risk.stop_loss_frac else None
-        tp_level = entry_price * (1 + risk.take_profit_frac) if risk.take_profit_frac else None
-    else:
-        stop_level = entry_price * (1 + risk.stop_loss_frac) if risk.stop_loss_frac else None
-        tp_level = entry_price * (1 - risk.take_profit_frac) if risk.take_profit_frac else None
-    for j in range(exec_idx + 1, horizon_exit_idx + 1):
-        lo = float(feature_df["low"].iloc[j])
-        hi = float(feature_df["high"].iloc[j])
-        hit_stop = stop_level is not None and (
-            (action == "BUY" and lo <= stop_level) or (action == "SELL" and hi >= stop_level)
-        )
-        hit_tp = tp_level is not None and (
-            (action == "BUY" and hi >= tp_level) or (action == "SELL" and lo <= tp_level)
-        )
-        if hit_stop:
-            return j, "stop_loss"
-        if hit_tp:
-            return j, "take_profit"
-    return horizon_exit_idx, "horizon"
-class WalkForwardBacktester:
-    """`forecaster` must expose .predict(context_df, target_col,
-    past_covariate_cols, prediction_length, freq) -> an object with
-    .quantiles / .quantile_levels (see moirai_model.QuantileForecast).
-    In production this is always a MoiraiMoEForecaster; tests may inject
-    a deterministic stub to verify the pipeline's causal behavior —
-    that stub is never imported by app.py (see tests/fixtures.py)."""
-    def __init__(self, forecaster, timeframe: str, asset_class: str = "forex",
-                 horizon: int = 5, context_length: int = 256,
-                 decision_cfg: Optional[cfg.DecisionConfig] = None,
-                 risk: Optional[cfg.RiskManagement] = None):
-        self.forecaster = forecaster
-        self.timeframe = timeframe
-        self.freq = cfg.TIMEFRAME_TO_PANDAS_FREQ[timeframe]
-        self.cost_profile = cfg.COST_PROFILES[asset_class]
-        self.horizon = horizon
-        self.context_length = context_length
-        self.decision_cfg = decision_cfg or cfg.DecisionConfig()
-        self.risk = risk  # None => no early exit, identical to every pre-existing backtest
-    def run(self, feature_df: pd.DataFrame, start_idx: Optional[int] = None, step: int = 1) -> dict:
-        cost_frac = cfg.round_trip_cost_frac(self.cost_profile)
-        warm = warm_up_valid_from(feature_df)  # raises ValueError if warm-up is impossible at all
-        n = len(feature_df)
-        delay = self.cost_profile.execution_delay_bars
-        min_start = max(start_idx or 0, warm, warm + self.context_length)
-        last_origin = n - self.horizon - delay - 1
-        if min_start > last_origin:
-            bars_needed = min_start + self.horizon + delay + 1
-            raise InsufficientDataError(
-                f"Not enough data for a single backtest origin: {n} bar(s) "
-                f"available, but this configuration needs at least "
-                f"{bars_needed} (warm-up {warm} + context_length "
-                f"{self.context_length} + horizon {self.horizon} + "
-                f"execution_delay {delay} + 1). Widen the History window "
-                f"by at least {bars_needed - n} bar(s), or reduce context "
-                f"length / horizon."
-            )
-        start_idx = min_start
-        trades: List[Trade] = []
-        decisions_log: List[dict] = []
-        equity_vals = [1.0]
-        equity_ts = [feature_df.index[start_idx]]
-        errors: List[dict] = []
-        n_origins = 0
-        open_until_idx = -1  # bar index the currently-open trade exits at; -1 == flat
-        for i in range(start_idx, max(start_idx, last_origin), step):
-            n_origins += 1
-            origin_ts = feature_df.index[i]
-            context = feature_df.iloc[i - self.context_length + 1: i + 1]
-            audit = audit_feature_frame(context, origin_ts)
-            if not audit["passed"]:
-                # Fail loudly rather than silently dropping the bad origin
-                # (spec section 26).
-                raise LeakageError(f"Backtest halted at {origin_ts}: {audit['violations']}")
-            try:
-                forecast = self.forecaster.predict(
-                    context_df=context, target_col=cfg.TARGET_FEATURE,
-                    past_covariate_cols=[c for c in cfg.PAST_DYNAMIC_FEATURES if c in context.columns],
-                    prediction_length=self.horizon, freq=self.freq,
-                )
-            except Exception as e:
-                errors.append({"origin_ts": str(origin_ts), "error": str(e)})
-                continue
-            price_now = float(feature_df["close"].iloc[i])
-            decision: Decision = decide(forecast, price_now, self.decision_cfg, cost_estimate_frac=cost_frac)
-            decisions_log.append({"origin_ts": origin_ts, "action": decision.action})
-            exec_idx = i + delay
-            exit_idx = i + delay + self.horizon
-            if exit_idx >= n:
-                continue
-            if i < open_until_idx:
-                # Still holding a position opened at an earlier origin --
-                # don't stack a second full-notional trade on top of it
-                # (see "Single-position convention" in the module
-                # docstring). The already-open trade's own exit will
-                # still post its P&L to the equity curve when its turn
-                # comes; this origin just isn't tradable right now.
-                continue
-            entry_price = float(feature_df["close"].iloc[exec_idx])  # fill convention, see module docstring
-            if decision.action == "HOLD":
-                equity_vals.append(equity_vals[-1])
-                equity_ts.append(feature_df.index[exit_idx])
-                continue
-            actual_exit_idx, exit_reason = _scan_for_early_exit(
-                feature_df, exec_idx, exit_idx, decision.action, entry_price, self.risk
-            )
-            exit_price = float(feature_df["close"].iloc[actual_exit_idx])  # future data — used only to SCORE, decision already fixed
-            if decision.action == "BUY":
-                gross = exit_price / entry_price - 1.0
-            else:  # SELL
-                gross = entry_price / exit_price - 1.0
-            net = gross - cost_frac
-            trades.append(Trade(
-                decision_ts=origin_ts, entry_ts=feature_df.index[exec_idx],
-                exit_ts=feature_df.index[actual_exit_idx], action=decision.action,
-                entry_price=entry_price, exit_price=exit_price,
-                forecast_return=decision.expected_return, gross_pnl=gross, net_pnl=net, costs=cost_frac,
-                exit_reason=exit_reason, prob_favorable=decision.prob_favorable,
-                interval_width_pct=decision.interval_width_pct,
-            ))
-            equity_vals.append(equity_vals[-1] * (1 + net))
-            equity_ts.append(feature_df.index[actual_exit_idx])
-            open_until_idx = actual_exit_idx
-        return {
-            "trades": trades,
-            "decisions_log": decisions_log,
-            "equity_curve": pd.Series(equity_vals, index=pd.DatetimeIndex(equity_ts)),
-            "num_origins": n_origins,
-            "errors": errors,
-        }

config.py DELETED Viewed

@@ -1,196 +0,0 @@
-"""
-Central configuration for the Moirai-MoE Forex/Crypto forecasting system.
-All thresholds, feature schema, and resource limits live here so they are
-auditable and change in one place (spec sections 19-20, 30, 42, 85, 111).
-"""
-from dataclasses import dataclass
-from typing import Optional
-# --- The sole predictive model (spec section 3) -----------------------
-MODEL_CHECKPOINT = "Salesforce/moirai-moe-1.0-R-small"
-# --- Timeframes ---------------------------------------------------------
-# native = directly retrievable from yfinance
-# derived = built via causal resampling from a finer native timeframe (section 10-11)
-NATIVE_INTRADAY = ["1m", "2m", "5m", "15m", "30m", "1h"]
-NATIVE_OTHER = ["1d", "1wk", "1mo"]
-DERIVED_MAP = {
-    # target_tf: (source_tf, bars_per_bin)
-    "10m": ("5m", 2),
-    "2h": ("1h", 2),
-    "4h": ("1h", 4),
-}
-ALL_TIMEFRAMES = NATIVE_INTRADAY + list(DERIVED_MAP.keys()) + NATIVE_OTHER
-TIMEFRAME_MINUTES = {
-    "1m": 1, "2m": 2, "5m": 5, "10m": 10, "15m": 15, "30m": 30,
-    "1h": 60, "2h": 120, "4h": 240, "1d": 1440, "1wk": 10080, "1mo": 43200,
-}
-# Approximate Yahoo intraday lookback ceilings in days (source-enforced,
-# see spec section 8; yfinance will simply return less data than
-# requested rather than erroring, so we surface this explicitly)
-YAHOO_INTRADAY_MAX_DAYS = {
-    "1m": 7, "2m": 60, "5m": 60, "15m": 60, "30m": 60, "1h": 730,
-}
-# Pandas frequency alias for each timeframe. This is passed EXPLICITLY to
-# gluonts' PandasDataset(freq=...) in moirai_model.py rather than relying
-# on pd.infer_freq() on the raw timestamps -- real Yahoo data has gaps
-# (weekends, exchange closures, occasional missing bars) that break
-# automatic frequency inference deterministically, on every call, which
-# is exactly the "Model errors: 11200/11200" failure mode this fixes.
-TIMEFRAME_TO_PANDAS_FREQ = {
-    "1m": "1min", "2m": "2min", "5m": "5min", "10m": "10min",
-    "15m": "15min", "30m": "30min",
-    "1h": "1h", "2h": "2h", "4h": "4h",
-    "1d": "1D", "1wk": "1W", "1mo": "1MS",
-}
-# --- History window choices (UI-facing) --------------------------------
-# Fine-grained day counts plus month counts, so the person can pick from
-# a dropdown instead of typing a period string. data_layer.resolve_history_window()
-# turns a label from this list into an actual start date (or "max").
-HISTORY_WINDOW_CHOICES = (
-    [f"{d} day" if d == 1 else f"{d} days" for d in range(1, 31)]
-    + [f"{m} months" for m in range(2, 13)]
-    + ["1 year", "2 years", "5 years", "max"]
-)
-# --- Symbol choices (UI-facing) -----------------------------------------
-# A curated, non-exhaustive list of common Yahoo Finance Forex/Crypto
-# tickers for convenient selection (spec section 12 wants search/
-# autocomplete "when feasible" -- yfinance itself exposes no symbol
-# directory, so this is that best-effort list). The UI Dropdown also
-# allows a custom value, so any Yahoo-supported symbol still works even
-# if it isn't in this list -- this list is a convenience, not a limit.
-FOREX_SYMBOLS = [
-    "EURUSD=X", "GBPUSD=X", "USDJPY=X", "USDCHF=X", "AUDUSD=X",
-    "USDCAD=X", "NZDUSD=X", "EURGBP=X", "EURJPY=X", "GBPJPY=X",
-    "EURCHF=X", "AUDJPY=X", "EURAUD=X", "CHFJPY=X", "GBPCHF=X",
-    "USDCNY=X", "USDINR=X", "USDMXN=X", "USDZAR=X", "USDTRY=X",
-    "USDSEK=X", "USDNOK=X", "USDSGD=X", "USDHKD=X",
-]
-CRYPTO_SYMBOLS = [
-    "BTC-USD", "ETH-USD", "BNB-USD", "XRP-USD", "SOL-USD",
-    "ADA-USD", "DOGE-USD", "AVAX-USD", "DOT-USD", "LTC-USD",
-    "LINK-USD", "MATIC-USD", "TRX-USD", "SHIB-USD", "BCH-USD",
-    "XLM-USD", "ATOM-USD", "UNI-USD", "ETC-USD", "XMR-USD",
-]
-ALL_SYMBOLS = FOREX_SYMBOLS + CRYPTO_SYMBOLS
-@dataclass
-class IndicatorConfig:
-    rsi_period: int = 14
-    macd_fast: int = 12
-    macd_slow: int = 26
-    macd_signal: int = 9
-    bb_period: int = 20
-    bb_std: float = 2.0
-    sma_periods: tuple = (20, 50)
-    ema_periods: tuple = (12, 26)
-    stoch_k: int = 14
-    stoch_d: int = 3
-    atr_period: int = 14
-    adx_period: int = 14
-    roc_period: int = 12
-# Deterministic feature schema — order matters and is persisted with every
-# forecast/model artifact (spec section 85). Never silently reordered.
-PAST_DYNAMIC_FEATURES = [
-    "open", "high", "low", "volume",
-    "rsi",
-    "macd", "macd_signal", "macd_hist",
-    "bb_mid", "bb_upper", "bb_lower",
-    "sma_20", "sma_50",
-    "ema_12", "ema_26",
-    "stoch_k", "stoch_d",
-    "atr", "adx", "roc", "obv",
-]
-TARGET_FEATURE = "close"
-@dataclass
-class DecisionConfig:
-    cost_bps: float = 5.0          # default round-trip cost estimate, basis points
-    buy_threshold: float = 0.0015  # expected edge required to BUY, post-cost
-    sell_threshold: float = -0.0015
-    min_probability: float = 0.55  # P(return favorable) required to act
-    max_interval_width_pct: float = 0.05  # HOLD if forecast too uncertain (P90-P10)
-@dataclass
-class BacktestCostProfile:
-    spread_bps: float
-    commission_bps: float
-    slippage_bps: float
-    execution_delay_bars: int = 1
-@dataclass
-class RiskManagement:
-    """Optional intra-trade exit rules, checked against intrabar high/low
-    between entry and the horizon exit (see backtest_engine.py). Added
-    Aug 2026 after real backtest data showed the previously-only exit
-    rule -- always hold the full fixed horizon, no matter what happens
-    in between -- was exactly why losing trades ran larger than winning
-    ones: a trade that turns adverse right after entry still rides out
-    the entire horizon before closing, with no way to cut it short.
-    None (the default for both fields) means "no early exit at all",
-    which reproduces every prior backtest's numbers exactly -- this is
-    opt-in, not a change to existing behavior."""
-    stop_loss_frac: Optional[float] = None    # e.g. 0.003 = exit if price moves 0.3% against the position
-    take_profit_frac: Optional[float] = None  # e.g. 0.006 = exit if price moves 0.6% in favor of the position
-# Forex and crypto have different microstructure -> different cost profiles
-# (spec section 30). These are reasonable defaults, not measured values —
-# override them per-symbol if you have real spread/fee data.
-COST_PROFILES = {
-    "forex": BacktestCostProfile(spread_bps=1.5, commission_bps=0.0, slippage_bps=0.5),
-    "crypto": BacktestCostProfile(spread_bps=2.0, commission_bps=10.0, slippage_bps=2.0),
-}
-def round_trip_cost_frac(profile: BacktestCostProfile) -> float:
-    """Round-trip cost (spread+commission+slippage) as a return fraction.
-    Lives here (not in backtest_engine.py) because it's a pure function of
-    a COST_PROFILES entry, and both the backtest engine and the Live tab's
-    decide() call need the same, real, asset-class-specific number rather
-    than each guessing independently (spec section 30)."""
-    return (profile.spread_bps + profile.commission_bps + profile.slippage_bps) / 10_000
-def infer_asset_class(symbol: str) -> str:
-    """Best-effort classification of a Yahoo ticker into a COST_PROFILES
-    key. The Live tab has no explicit asset-class selector (unlike the
-    Backtest tab's `b_class` radio), so without this it silently fell back
-    to a flat, asset-unaware cost estimate for every symbol -- wrong for
-    both forex (too high) and crypto (too low). Checks the curated lists
-    first, then falls back to Yahoo's own ticker conventions ('=X' suffix
-    for forex pairs, a '-USD'/'-USDT'/etc. suffix for crypto pairs) for any
-    other symbol typed via allow_custom_value, since those conventions are
-    Yahoo's, not a guess of ours. Defaults to 'forex' (the cheaper, more
-    conservative profile) only if nothing matches."""
-    if symbol in FOREX_SYMBOLS:
-        return "forex"
-    if symbol in CRYPTO_SYMBOLS:
-        return "crypto"
-    s = symbol.strip().upper()
-    if s.endswith("=X"):
-        return "forex"
-    quote = s.split("-")[-1] if "-" in s else ""
-    if quote in ("USD", "USDT", "USDC", "BTC", "ETH"):
-        return "crypto"
-    return "forex"
-# Context length ceiling — validate against the ACTUAL loaded checkpoint's
-# max_seq_len at runtime (moirai_model.py does this); this is a
-# conservative fallback default, not an assumption of unlimited context
-# (spec section 86).
-MODEL_MAX_CONTEXT_DEFAULT = 512
-RESOURCE_LIMITS = dict(cpu_cores=2, ram_gb=16, disk_gb=50, max_forecast_samples=100, max_workers=2)

data_layer.py DELETED Viewed

@@ -1,254 +0,0 @@
-"""
-Data ingestion, validation, causal resampling, freshness, and local
-caching for Yahoo Finance OHLCV data (spec sections 7-14, 55-56, 81, 105).
-NETWORK NOTE: fetch_ohlcv() makes a real yfinance HTTP call. In a
-network-isolated environment this raises DataSourceError with the
-underlying exception attached — that is the correct, honest failure
-mode (spec section 4: "expose the exact failure ... do not fabricate
-a result"), not a bug to work around with mock data.
-"""
-from __future__ import annotations
-import hashlib
-import io
-import sqlite3
-from dataclasses import dataclass
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Optional
-import numpy as np
-import pandas as pd
-import config as cfg
-class DataSourceError(Exception):
-    pass
-class DataValidationError(Exception):
-    pass
-@dataclass
-class ValidationReport:
-    rows_in: int
-    rows_out: int
-    duplicates_removed: int
-    invalid_ohlc_removed: int
-    nan_rows_removed: int
-    timezone: str
-    monotonic: bool
-    warnings: list
-def fetch_ohlcv(symbol: str, interval: str, start=None, end=None,
-                 period: Optional[str] = None) -> pd.DataFrame:
-    """Real yfinance retrieval of a NATIVE Yahoo interval. Derived
-    timeframes (e.g. 10m) must be built with causal_resample() from
-    their configured source interval — this function refuses to guess."""
-    try:
-        import yfinance as yf
-    except ImportError as e:
-        raise DataSourceError(f"yfinance is not installed: {e}") from e
-    if interval not in cfg.NATIVE_INTRADAY + cfg.NATIVE_OTHER:
-        raise DataSourceError(
-            f"'{interval}' is not a native Yahoo interval. Fetch "
-            f"{cfg.DERIVED_MAP.get(interval, ('<source>',))[0]} and call "
-            f"causal_resample() instead (spec section 19)."
-        )
-    max_days = cfg.YAHOO_INTRADAY_MAX_DAYS.get(interval)
-    try:
-        ticker = yf.Ticker(symbol)
-        if period:
-            df = ticker.history(period=period, interval=interval, auto_adjust=False)
-        else:
-            df = ticker.history(start=start, end=end, interval=interval, auto_adjust=False)
-    except Exception as e:  # network, symbol, rate-limit, etc. — surfaced, not masked
-        raise DataSourceError(f"Yahoo Finance retrieval failed for {symbol}@{interval}: {e}") from e
-    if df is None or df.empty:
-        hint = f" Yahoo typically limits {interval} history to ~{max_days} days." if max_days else ""
-        raise DataSourceError(f"No data returned for {symbol}@{interval}.{hint}")
-    df = df.rename(columns=str.lower)[["open", "high", "low", "close", "volume"]]
-    df.index = pd.to_datetime(df.index, utc=True)
-    df.index.name = "timestamp"
-    return df
-def validate_ohlcv(df: pd.DataFrame) -> tuple[pd.DataFrame, ValidationReport]:
-    """Spec section 13. Removes/flags bad rows; never silently repairs
-    a suspicious price. Every removal is counted in the report."""
-    warnings: list[str] = []
-    rows_in = len(df)
-    out = df.sort_index().copy()
-    dup = out.index.duplicated(keep="first")
-    duplicates_removed = int(dup.sum())
-    out = out[~dup]
-    monotonic = bool(out.index.is_monotonic_increasing)
-    core = out[["open", "high", "low", "close"]]
-    nan_mask = core.isna().any(axis=1) | ~np.isfinite(core.to_numpy(dtype=float)).all(axis=1)
-    nan_rows_removed = int(nan_mask.sum())
-    out = out[~nan_mask]
-    core = out[["open", "high", "low", "close"]]
-    price_positive = (core > 0).all(axis=1)
-    high_ok = out["high"] >= out[["open", "close", "low"]].max(axis=1)
-    low_ok = out["low"] <= out[["open", "close", "high"]].min(axis=1)
-    valid_ohlc = price_positive & high_ok & low_ok
-    invalid_ohlc_removed = int((~valid_ohlc).sum())
-    out = out[valid_ohlc]
-    if "volume" in out.columns:
-        bad_vol = out["volume"] < 0
-        if bad_vol.any():
-            warnings.append(
-                f"{int(bad_vol.sum())} row(s) had negative volume; marked "
-                f"unavailable (NaN), never invented (section 11)."
-            )
-            out.loc[bad_vol, "volume"] = np.nan
-    report = ValidationReport(
-        rows_in=rows_in, rows_out=len(out), duplicates_removed=duplicates_removed,
-        invalid_ohlc_removed=invalid_ohlc_removed, nan_rows_removed=nan_rows_removed,
-        timezone=str(out.index.tz), monotonic=monotonic, warnings=warnings,
-    )
-    return out, report
-def causal_resample(df: pd.DataFrame, source_interval: str, target_interval: str) -> pd.DataFrame:
-    """Builds a derived timeframe (e.g. 5m -> 10m) using only completed
-    source candles that fall entirely within the bin (spec section 11).
-    A trailing partial bin is dropped, never padded with future data."""
-    if target_interval not in cfg.DERIVED_MAP:
-        raise ValueError(f"{target_interval} is not a configured derived timeframe")
-    expected_source, bars_per_bin = cfg.DERIVED_MAP[target_interval]
-    if expected_source != source_interval:
-        raise ValueError(f"{target_interval} must be derived from {expected_source}, got {source_interval}")
-    rule = f"{cfg.TIMEFRAME_MINUTES[target_interval]}min"
-    agg = {"open": "first", "high": "max", "low": "min", "close": "last", "volume": "sum"}
-    resampler = df.resample(rule, label="left", closed="left")
-    resampled = resampler.agg(agg)
-    # A derived bin is only valid if it is backed by the full count of
-    # source candles — otherwise it may be an incomplete trailing bin
-    # that would silently borrow a "future" partial candle.
-    counts = resampler["close"].count()
-    complete = counts >= bars_per_bin
-    resampled = resampled[complete]
-    if df["volume"].isna().all():
-        resampled["volume"] = np.nan  # never invent volume
-    return resampled.dropna(subset=["open", "high", "low", "close"])
-class LocalCache:
-    """SQLite-backed local cache — no external DB service (spec section 76).
-    Corrupted/mismatched entries are simply cache misses, never returned
-    as if they were valid (section 105)."""
-    def __init__(self, path: str = "cache.sqlite3"):
-        self.path = Path(path)
-        self._conn = sqlite3.connect(self.path)
-        self._conn.execute(
-            """CREATE TABLE IF NOT EXISTS ohlcv_cache (
-                cache_key TEXT PRIMARY KEY,
-                symbol TEXT, interval TEXT, source TEXT,
-                start_ts TEXT, end_ts TEXT, fetched_at TEXT,
-                payload TEXT
-            )"""
-        )
-        self._conn.commit()
-    @staticmethod
-    def _key(symbol, interval, source, start, end) -> str:
-        raw = f"{symbol}|{interval}|{source}|{start}|{end}"
-        return hashlib.sha256(raw.encode()).hexdigest()
-    def get(self, symbol, interval, source, start, end) -> Optional[pd.DataFrame]:
-        key = self._key(symbol, interval, source, start, end)
-        row = self._conn.execute(
-            "SELECT payload FROM ohlcv_cache WHERE cache_key=?", (key,)
-        ).fetchone()
-        if row is None:
-            return None
-        try:
-            return pd.read_json(io.StringIO(row[0]), orient="split")
-        except ValueError:
-            return None  # corrupted entry -> treat as miss, never as valid data
-    def set(self, symbol, interval, source, start, end, df: pd.DataFrame):
-        key = self._key(symbol, interval, source, start, end)
-        payload = df.to_json(orient="split", date_format="iso")
-        self._conn.execute(
-            """INSERT OR REPLACE INTO ohlcv_cache
-               (cache_key, symbol, interval, source, start_ts, end_ts, fetched_at, payload)
-               VALUES (?,?,?,?,?,?,?,?)""",
-            (key, symbol, interval, source, str(start), str(end),
-             datetime.now(timezone.utc).isoformat(), payload),
-        )
-        self._conn.commit()
-def data_freshness(latest_ts: pd.Timestamp, interval: str) -> dict:
-    """Spec section 57. Freshness is judged relative to the bar size —
-    one stale 1-minute bar is very different from one stale 1-day bar."""
-    now = pd.Timestamp.now(tz="UTC")
-    age = now - latest_ts
-    bar_minutes = cfg.TIMEFRAME_MINUTES[interval]
-    age_bars = age.total_seconds() / 60 / bar_minutes
-    if age_bars <= 1.5:
-        status = "fresh"
-    elif age_bars <= 5:
-        status = "delayed"
-    else:
-        status = "stale"
-    return {
-        "latest_market_ts": latest_ts.isoformat(),
-        "system_ts": now.isoformat(),
-        "age_seconds": age.total_seconds(),
-        "age_bars": round(age_bars, 2),
-        "status": status,
-    }
-def resolve_history_window(label: str):
-    """Turns a HISTORY_WINDOW_CHOICES label ("1 day", "6 months",
-    "2 years", "max") into either ("period", "max") for yfinance's
-    period shorthand, or ("start", <UTC datetime>) for everything else.
-    yfinance's `period` parameter only accepts a fixed enum (1d, 5d,
-    1mo, 3mo, 6mo, 1y, 2y, 5y, 10y, ytd, max) -- it does NOT accept
-    arbitrary values like "15d" or "4mo", so any day/month count outside
-    that enum has to be expressed as an explicit start date instead.
-    """
-    from datetime import datetime, timezone
-    from dateutil.relativedelta import relativedelta
-    label = label.strip().lower()
-    if label == "max":
-        return "period", "max"
-    now = datetime.now(timezone.utc)
-    parts = label.split()
-    if len(parts) != 2:
-        raise ValueError(f"Unrecognized history window: {label!r}")
-    n = int(parts[0])
-    unit = parts[1]
-    if unit.startswith("day"):
-        return "start", now - relativedelta(days=n)
-    if unit.startswith("month"):
-        return "start", now - relativedelta(months=n)
-    if unit.startswith("year"):
-        return "start", now - relativedelta(years=n)
-    raise ValueError(f"Unrecognized history window unit: {unit!r} in {label!r}")

decision_engine.py DELETED Viewed

@@ -1,102 +0,0 @@
-"""
-Deterministic Buy/Hold/Sell policy applied to Moirai-MoE's forecast
-output (spec sections 31-34, 93, 111-113). This module contains NO
-predictive model of its own, hidden or otherwise — only arithmetic over
-a forecast object produced by moirai_model.py. Nothing in this file
-imports sklearn/xgboost/lightgbm/catboost or any other classifier.
-"""
-from __future__ import annotations
-from dataclasses import dataclass
-import numpy as np
-import config as cfg
-@dataclass
-class Decision:
-    action: str  # "BUY" | "SELL" | "HOLD"
-    expected_return: float
-    expected_edge: float
-    p10_return: float
-    p90_return: float
-    prob_favorable: float
-    interval_width_pct: float
-    rationale: str
-    hold_reason: str = None
-def _prob_exceeds(levels: list, values: np.ndarray, threshold: float) -> float:
-    """P(true return > threshold), estimated by linear interpolation on
-    the model's own empirical quantile function — not a fabricated
-    number (spec section 32-33)."""
-    order = np.argsort(levels)
-    lv = np.asarray(levels)[order]
-    vv = np.asarray(values)[order]
-    if threshold <= vv[0]:
-        return 1.0
-    if threshold >= vv[-1]:
-        return 0.0
-    p_below = float(np.interp(threshold, vv, lv))
-    return 1.0 - p_below
-def decide(forecast, price_now: float, dc: cfg.DecisionConfig = None,
-           cost_estimate_frac: float = None) -> Decision:
-    """`forecast` is a QuantileForecast (see moirai_model.py) with
-    .quantile_levels (list of floats incl. 0.1/0.5/0.9) and .quantiles
-    of shape (horizon, len(levels))."""
-    dc = dc or cfg.DecisionConfig()
-    levels = list(forecast.quantile_levels)
-    step_prices = np.asarray(forecast.quantiles)[-1]  # final horizon step
-    step_returns = step_prices / price_now - 1.0
-    p10 = float(step_returns[levels.index(0.1)])
-    p50 = float(step_returns[levels.index(0.5)])
-    p90 = float(step_returns[levels.index(0.9)])
-    cost = cost_estimate_frac if cost_estimate_frac is not None else dc.cost_bps / 10_000
-    interval_width_pct = p90 - p10
-    prob_favorable = _prob_exceeds(levels, step_returns, threshold=cost)  # P(return > +cost) -- the BUY-side confidence
-    # SELL is profitable when return < -cost (shorting profits from a
-    # price drop), which is NOT the same event as "return <= +cost" --
-    # that includes the whole middle range between -cost and +cost too,
-    # so it isn't "1 - prob_favorable" reused. This is its own directional
-    # probability, symmetric to prob_favorable but mirrored around
-    # -cost instead of +cost, exactly the way min_probability's own
-    # definition ("P(return favorable) required to act", config.py) is
-    # meant to apply to either direction, not just BUY.
-    prob_favorable_sell = 1.0 - _prob_exceeds(levels, step_returns, threshold=-cost)  # P(return < -cost)
-    hold_reason = None
-    if interval_width_pct > dc.max_interval_width_pct:
-        action = "HOLD"
-        hold_reason = "forecast interval too wide relative to expected move (section 93)"
-    elif (p50 - cost) > dc.buy_threshold and prob_favorable >= dc.min_probability:
-        action = "BUY"
-    elif (p50 + cost) < dc.sell_threshold and prob_favorable_sell >= dc.min_probability:
-        action = "SELL"
-    else:
-        action = "HOLD"
-        hold_reason = "expected edge below threshold after costs (section 93)"
-    # Report whichever probability is actually relevant to the action taken
-    # -- for a SELL, "P(return>cost)" reads as near-zero and looks like the
-    # decision has no confidence behind it, when the real (and high)
-    # confidence is in the mirrored SELL-side event. BUY/HOLD keep the
-    # original P(return>cost) framing.
-    if action == "SELL":
-        prob_shown, prob_label = prob_favorable_sell, "P(return<-cost)"
-    else:
-        prob_shown, prob_label = prob_favorable, "P(return>cost)"
-    rationale = (
-        f"P50 return {p50:+.4%} vs cost {cost:.4%}; {prob_label}={prob_shown:.2f}; "
-        f"interval[P10,P90]=[{p10:+.4%},{p90:+.4%}]"
-    )
-    return Decision(
-        action=action, expected_return=p50, expected_edge=p50 - cost,
-        p10_return=p10, p90_return=p90, prob_favorable=prob_shown,
-        interval_width_pct=interval_width_pct, rationale=rationale, hold_reason=hold_reason,
-    )

features.py DELETED Viewed

@@ -1,180 +0,0 @@
-"""
-The ten standardized causal indicator families (spec sections 19-20, 22)
-plus warm-up handling (section 24). Every computation here uses only
-rolling/expanding-style pandas ops seeded from row <=t; nothing looks
-forward. This is verified directly in tests/test_features_and_leakage.py
-by re-computing on a truncated frame and checking the value is unchanged.
-"""
-from __future__ import annotations
-import numpy as np
-import pandas as pd
-import config as cfg
-def _rsi(close: pd.Series, period: int) -> pd.Series:
-    delta = close.diff()
-    gain = delta.clip(lower=0)
-    loss = -delta.clip(upper=0)
-    avg_gain = gain.ewm(alpha=1 / period, adjust=False, min_periods=period).mean()
-    avg_loss = loss.ewm(alpha=1 / period, adjust=False, min_periods=period).mean()
-    rs = avg_gain / avg_loss.replace(0, np.nan)
-    rsi = 100 - (100 / (1 + rs))
-    # avg_loss==0 (pure uptrend) -> RSI is 100, not NaN. Warm-up rows
-    # (avg_loss itself NaN) fall through unchanged since NaN != 0 is True,
-    # so they correctly stay NaN rather than being fabricated as 50 or 100.
-    return rsi.where(avg_loss != 0, 100.0)
-def _macd(close: pd.Series, fast: int, slow: int, signal: int):
-    ema_fast = close.ewm(span=fast, adjust=False, min_periods=fast).mean()
-    ema_slow = close.ewm(span=slow, adjust=False, min_periods=slow).mean()
-    macd = ema_fast - ema_slow
-    macd_signal = macd.ewm(span=signal, adjust=False, min_periods=signal).mean()
-    return macd, macd_signal, macd - macd_signal
-def _bollinger(close: pd.Series, period: int, k: float):
-    mid = close.rolling(period, min_periods=period).mean()
-    std = close.rolling(period, min_periods=period).std(ddof=0)
-    return mid, mid + k * std, mid - k * std
-def _stochastic(high, low, close, k_period, d_period):
-    lowest = low.rolling(k_period, min_periods=k_period).min()
-    highest = high.rolling(k_period, min_periods=k_period).max()
-    rng = highest - lowest
-    k = 100 * (close - lowest) / rng.replace(0, np.nan)
-    # rng==0 means price hasn't moved at all over the lookback window
-    # (real, observed data -- e.g. a stale/illiquid stretch of identical
-    # ticks, not warm-up). There's no range to place `close` within, so
-    # %K is defined as the neutral midpoint (50) rather than left as a
-    # raw 0/0 NaN. Warm-up rows are unaffected: rng itself is NaN there
-    # (not 0), so `rng != 0` stays True and the NaN passes through --
-    # same convention as RSI's avg_loss==0 case above.
-    k = k.where(rng != 0, 50.0)
-    d = k.rolling(d_period, min_periods=d_period).mean()
-    return k, d
-def _atr(high, low, close, period):
-    prev_close = close.shift(1)
-    tr = pd.concat([
-        high - low,
-        (high - prev_close).abs(),
-        (low - prev_close).abs(),
-    ], axis=1).max(axis=1)
-    return tr.ewm(alpha=1 / period, adjust=False, min_periods=period).mean()
-def _adx(high, low, close, period):
-    up_move = high.diff()
-    down_move = -low.diff()
-    plus_dm = np.where((up_move > down_move) & (up_move > 0), up_move, 0.0)
-    minus_dm = np.where((down_move > up_move) & (down_move > 0), down_move, 0.0)
-    atr = _atr(high, low, close, period)
-    plus_dm_ewm = pd.Series(plus_dm, index=high.index).ewm(
-        alpha=1 / period, adjust=False, min_periods=period).mean()
-    minus_dm_ewm = pd.Series(minus_dm, index=high.index).ewm(
-        alpha=1 / period, adjust=False, min_periods=period).mean()
-    # atr==0 is a real, reachable state, not just theoretical: a long
-    # enough run of identical high/low/close (illiquid or stale ticks --
-    # exactly the kind of flat stretch visible in live 1m forex data)
-    # decays the ATR ewm to an exact float 0.0. +DM/-DM are necessarily
-    # 0 too whenever atr==0 (no high/low movement to measure), so the
-    # correct DI reading is 0 (no directional movement), not an
-    # undefined 0/0. Warm-up rows stay NaN because atr itself is NaN
-    # there (not 0), so `atr != 0` stays True and the NaN passes through.
-    plus_di = (100 * plus_dm_ewm / atr.replace(0, np.nan)).where(atr != 0, 0.0)
-    minus_di = (100 * minus_dm_ewm / atr.replace(0, np.nan)).where(atr != 0, 0.0)
-    di_sum = plus_di + minus_di
-    # Same logic one level up: di_sum==0 (both DIs flat-zero, or a
-    # perfectly balanced up/down) means there's no dominant direction --
-    # dx is defined as 0 (no trend), not NaN. di_sum is NaN (not 0)
-    # during genuine warm-up, so that case is still preserved as NaN.
-    dx = (100 * (plus_di - minus_di).abs() / di_sum.replace(0, np.nan)).where(di_sum != 0, 0.0)
-    return dx.ewm(alpha=1 / period, adjust=False, min_periods=period).mean()
-def _roc(close, period):
-    return 100 * (close / close.shift(period) - 1)
-def _obv(close, volume):
-    direction = np.sign(close.diff().fillna(0))
-    return (direction * volume.fillna(0)).cumsum()
-def compute_indicators(df: pd.DataFrame, ic: cfg.IndicatorConfig = None) -> pd.DataFrame:
-    """df must have columns open/high/low/close/volume, ascending index.
-    Returns df with indicator columns appended; warm-up rows are NaN
-    (never forward-filled from the future — section 24)."""
-    ic = ic or cfg.IndicatorConfig()
-    out = df.copy()
-    out["rsi"] = _rsi(out["close"], ic.rsi_period)
-    out["macd"], out["macd_signal"], out["macd_hist"] = _macd(
-        out["close"], ic.macd_fast, ic.macd_slow, ic.macd_signal)
-    out["bb_mid"], out["bb_upper"], out["bb_lower"] = _bollinger(out["close"], ic.bb_period, ic.bb_std)
-    out["sma_20"] = out["close"].rolling(ic.sma_periods[0], min_periods=ic.sma_periods[0]).mean()
-    out["sma_50"] = out["close"].rolling(ic.sma_periods[1], min_periods=ic.sma_periods[1]).mean()
-    out["ema_12"] = out["close"].ewm(span=ic.ema_periods[0], adjust=False, min_periods=ic.ema_periods[0]).mean()
-    out["ema_26"] = out["close"].ewm(span=ic.ema_periods[1], adjust=False, min_periods=ic.ema_periods[1]).mean()
-    out["stoch_k"], out["stoch_d"] = _stochastic(out["high"], out["low"], out["close"], ic.stoch_k, ic.stoch_d)
-    out["atr"] = _atr(out["high"], out["low"], out["close"], ic.atr_period)
-    out["adx"] = _adx(out["high"], out["low"], out["close"], ic.adx_period)
-    out["roc"] = _roc(out["close"], ic.roc_period)
-    out["obv"] = _obv(out["close"], out["volume"].fillna(0))
-    return out
-def warm_up_valid_from(df: pd.DataFrame) -> int:
-    """First integer index where ALL configured feature columns are
-    simultaneously non-NaN. Raises if that never happens (section 88:
-    'do NOT manufacture data').
-    On failure, the message names the slowest-to-warm-up column(s) and
-    how many bars they actually need vs. how many are available --
-    diagnosed empirically from df itself (each column's real first
-    non-NaN position), never from a hand-derived "expected" formula per
-    indicator. A hand-derived number for something like MACD or ADX
-    (ewm-of-an-ewm, with its own min_periods layered on top) is exactly
-    the kind of guess this project's own spec section 6 (real execution
-    over static assumption) argues against -- so this reads it back off
-    the real computed columns instead (section 98: errors must say what
-    failed, not just that something did)."""
-    cols = [c for c in cfg.PAST_DYNAMIC_FEATURES if c in df.columns]
-    valid = df[cols].notna().all(axis=1)
-    if not bool(valid.any()):
-        first_valid: dict = {}
-        never_valid = []
-        for c in cols:
-            nn = df[c].notna().to_numpy()
-            if nn.any():
-                first_valid[c] = int(np.argmax(nn))
-            else:
-                never_valid.append(c)
-        if never_valid:
-            blockers = sorted(never_valid)
-            detail = (
-                f"never produced a single valid value anywhere in the "
-                f"{len(df)} bar(s) available"
-            )
-        else:
-            worst = max(first_valid.values())
-            blockers = sorted(c for c, idx in first_valid.items() if idx == worst)
-            detail = (
-                f"needs {worst + 1} bar(s) before its first valid value "
-                f"(only {len(df)} available)"
-            )
-        raise ValueError(
-            f"No fully warmed-up row found — insufficient historical data "
-            f"for this indicator configuration (spec section 88). Slowest "
-            f"to warm up: {', '.join(blockers)} — {detail}. Widen the "
-            f"History window (more bars) or switch to a coarser/finer "
-            f"timeframe so these indicators have enough lookback before "
-            f"the backtest/forecast starts."
-        )
-    return int(np.argmax(valid.to_numpy()))

leakage_audit.py DELETED Viewed

@@ -1,54 +0,0 @@
-"""
-Explicit leakage-audit layer (spec sections 25-26). These are the
-"fail loudly" checks the rest of the system is built around: nothing
-downstream should ever see a row timestamped after the prediction origin.
-"""
-from __future__ import annotations
-import pandas as pd
-class LeakageError(Exception):
-    pass
-def assert_no_future_rows(df: pd.DataFrame, origin_ts: pd.Timestamp, context_name: str = "input"):
-    bad = df.index[df.index > origin_ts]
-    if len(bad) > 0:
-        raise LeakageError(
-            f"{context_name}: {len(bad)} row(s) after origin {origin_ts} "
-            f"(first offender: {bad[0]}). Forbidden per spec section 25."
-        )
-def assert_chronological_split(train_end: pd.Timestamp, val_start: pd.Timestamp,
-                                val_end: pd.Timestamp, test_start: pd.Timestamp):
-    if not (train_end <= val_start <= val_end <= test_start):
-        raise LeakageError(
-            f"Non-chronological split: train_end={train_end}, val_start={val_start}, "
-            f"val_end={val_end}, test_start={test_start} (spec section 27)."
-        )
-def assert_target_strictly_future(origin_ts: pd.Timestamp, target_ts: pd.Timestamp):
-    if target_ts <= origin_ts:
-        raise LeakageError(
-            f"Target timestamp {target_ts} is not strictly after origin {origin_ts} "
-            f"(spec section 15/25)."
-        )
-def audit_feature_frame(feature_df: pd.DataFrame, origin_ts: pd.Timestamp) -> dict:
-    """Run before every model call; returns a small report that gets
-    persisted alongside the forecast/backtest run (sections 26, 71)."""
-    violations = []
-    try:
-        assert_no_future_rows(feature_df, origin_ts, "feature_df")
-    except LeakageError as e:
-        violations.append(str(e))
-    return {
-        "passed": len(violations) == 0,
-        "violations": violations,
-        "origin_ts": origin_ts.isoformat(),
-        "rows_checked": len(feature_df),
-    }

metrics.py DELETED Viewed

@@ -1,127 +0,0 @@
-"""
-Forecast-skill and trading-performance metrics (spec sections 36-37).
-Every function takes real arrays computed elsewhere — nothing here is
-fabricated, and nothing here silently assumes daily-bar annualization
-for intraday data (section 37).
-"""
-from __future__ import annotations
-import numpy as np
-import pandas as pd
-MINUTES_PER_YEAR = 365.25 * 24 * 60
-def mae(y_true, y_pred) -> float:
-    return float(np.mean(np.abs(np.asarray(y_true, dtype=float) - np.asarray(y_pred, dtype=float))))
-def rmse(y_true, y_pred) -> float:
-    d = np.asarray(y_true, dtype=float) - np.asarray(y_pred, dtype=float)
-    return float(np.sqrt(np.mean(d ** 2)))
-def smape(y_true, y_pred) -> float:
-    y_true, y_pred = np.asarray(y_true, dtype=float), np.asarray(y_pred, dtype=float)
-    denom = np.abs(y_true) + np.abs(y_pred)
-    denom = np.where(denom == 0, np.nan, denom)
-    return float(np.nanmean(2 * np.abs(y_pred - y_true) / denom))
-def mase(y_true, y_pred, naive_errors) -> float:
-    """Scale-aware metric vs. a naive (last-value) baseline (section 36/38)."""
-    scale = np.mean(np.abs(np.asarray(naive_errors, dtype=float)))
-    if scale == 0 or not np.isfinite(scale):
-        return float("nan")
-    return float(mae(y_true, y_pred) / scale)
-def directional_accuracy(y_true_return, y_pred_return) -> float:
-    yt = np.sign(np.asarray(y_true_return, dtype=float))
-    yp = np.sign(np.asarray(y_pred_return, dtype=float))
-    mask = yt != 0
-    if mask.sum() == 0:
-        return float("nan")
-    return float(np.mean(yt[mask] == yp[mask]))
-def pinball_loss(y_true, quantile_preds: dict) -> float:
-    y_true = np.asarray(y_true, dtype=float)
-    losses = []
-    for q, pred in quantile_preds.items():
-        diff = y_true - np.asarray(pred, dtype=float)
-        losses.append(np.mean(np.maximum(q * diff, (q - 1) * diff)))
-    return float(np.mean(losses))
-def interval_coverage(y_true, lower, upper) -> float:
-    y_true, lower, upper = (np.asarray(a, dtype=float) for a in (y_true, lower, upper))
-    return float(np.mean((y_true >= lower) & (y_true <= upper)))
-def _annualization_factor(timeframe_minutes: int) -> float:
-    return float(np.sqrt(MINUTES_PER_YEAR / timeframe_minutes))
-def sharpe_ratio(returns: pd.Series, timeframe_minutes: int, rf: float = 0.0) -> float:
-    r = returns.dropna()
-    if len(r) < 2 or r.std(ddof=0) == 0:
-        return float("nan")
-    return float((r.mean() - rf) / r.std(ddof=0) * _annualization_factor(timeframe_minutes))
-def sortino_ratio(returns: pd.Series, timeframe_minutes: int, rf: float = 0.0) -> float:
-    r = returns.dropna()
-    downside = r[r < 0]
-    dd = downside.std(ddof=0)
-    if len(r) < 2 or dd == 0 or np.isnan(dd):
-        return float("nan")
-    return float((r.mean() - rf) / dd * _annualization_factor(timeframe_minutes))
-def max_drawdown(equity: pd.Series) -> float:
-    running_max = equity.cummax()
-    dd = equity / running_max - 1.0
-    return float(dd.min())
-def calmar_ratio(equity: pd.Series, timeframe_minutes: int) -> float:
-    n_bars = len(equity)
-    bars_per_year = MINUTES_PER_YEAR / timeframe_minutes
-    years = n_bars / bars_per_year
-    if years <= 0 or equity.iloc[0] <= 0:
-        return float("nan")
-    cagr = (equity.iloc[-1] / equity.iloc[0]) ** (1 / years) - 1
-    mdd = abs(max_drawdown(equity))
-    return float(cagr / mdd) if mdd > 0 else float("nan")
-def profit_factor(net_pnls) -> float:
-    net_pnls = np.asarray(net_pnls, dtype=float)
-    gains = net_pnls[net_pnls > 0].sum()
-    losses = -net_pnls[net_pnls < 0].sum()
-    return float(gains / losses) if losses > 0 else float("nan")
-def trading_summary(trades_df: pd.DataFrame, equity: pd.Series, timeframe_minutes: int) -> dict:
-    if trades_df is None or trades_df.empty:
-        return {"num_trades": 0, "note": "no trades executed in this window"}
-    wins = trades_df[trades_df.net_pnl > 0]
-    losses = trades_df[trades_df.net_pnl <= 0]
-    returns = equity.pct_change().dropna()
-    return {
-        "num_trades": int(len(trades_df)),
-        "win_rate": float(len(wins) / len(trades_df)),
-        "avg_win": float(wins.net_pnl.mean()) if len(wins) else 0.0,
-        "avg_loss": float(losses.net_pnl.mean()) if len(losses) else 0.0,
-        "profit_factor": profit_factor(trades_df.net_pnl.values),
-        "gross_pnl": float(trades_df.gross_pnl.sum()),
-        "net_pnl": float(trades_df.net_pnl.sum()),
-        "cumulative_return": float(equity.iloc[-1] / equity.iloc[0] - 1.0),
-        "max_drawdown": max_drawdown(equity),
-        "sharpe": sharpe_ratio(returns, timeframe_minutes),
-        "sortino": sortino_ratio(returns, timeframe_minutes),
-        "calmar": calmar_ratio(equity, timeframe_minutes),
-        "long_trades": int((trades_df.action == "BUY").sum()),
-        "short_trades": int((trades_df.action == "SELL").sum()),
-    }

moirai_model.py DELETED Viewed

@@ -1,245 +0,0 @@
-"""
-Real Moirai-MoE-1.0-R-Small integration (spec sections 4-6, 42-43, 75, 86).
-This is the ONLY predictive model in the system (section 3). Grep the
-rest of this project: nothing imports sklearn, xgboost, lightgbm,
-catboost, statsmodels ARIMA/Prophet, or any external prediction API.
-API confirmed against the current official uni2ts repo
-(SalesforceAIResearch/uni2ts, "pip install uni2ts", PyPI package
-"uni2ts") and the model card at
-huggingface.co/Salesforce/moirai-moe-1.0-R-small as of this build:
-    from uni2ts.model.moirai_moe import MoiraiMoEForecast, MoiraiMoEModule
-    module = MoiraiMoEModule.from_pretrained("Salesforce/moirai-moe-1.0-R-small")
-    model = MoiraiMoEForecast(module=module, prediction_length=..., context_length=...,
-                               patch_size=16, num_samples=100, target_dim=1,
-                               feat_dynamic_real_dim=0, past_feat_dynamic_real_dim=N)
-    predictor = model.create_predictor(batch_size=1)
-    forecasts = list(predictor.predict(gluonts_dataset))
-uni2ts is an actively developed research library (it shipped a new
-Moirai-2.0 family in Aug 2025) — re-verify this surface against the
-installed package version before relying on it in production, per
-spec section 75 ("do not assume an old code sample remains compatible
-forever").
-NETWORK NOTE: load() downloads the official checkpoint from Hugging
-Face on first use. In a network-isolated environment this correctly
-raises ModelLoadError with the underlying exception attached (section
-4: "expose the exact failure ... do not fabricate a result").
-"""
-from __future__ import annotations
-from dataclasses import dataclass
-from typing import List, Optional
-import numpy as np
-import pandas as pd
-import config as cfg
-CHECKPOINT = cfg.MODEL_CHECKPOINT
-class ModelLoadError(Exception):
-    pass
-class ModelInputError(Exception):
-    pass
-class ModelInferenceError(Exception):
-    pass
-@dataclass
-class QuantileForecast:
-    horizon: int
-    quantile_levels: List[float]
-    quantiles: np.ndarray            # shape (horizon, len(quantile_levels))
-    samples: Optional[np.ndarray]    # shape (num_samples, horizon), if the backend exposes it
-    context_length_used: int
-    prediction_length: int
-class MoiraiMoEForecaster:
-    """Thin, honest wrapper. It does not retry-and-hide failures and it
-    does not substitute any other model if loading or inference fails
-    (section 4/80) — every method below either returns a real result or
-    raises with the underlying exception attached."""
-    def __init__(self, checkpoint: str = CHECKPOINT, num_samples: int = 100,
-                 patch_size: int = 16):
-        # patch_size must be a concrete int, not "auto". uni2ts's
-        # MoiraiMoEForecast.forward() only special-cases the literal
-        # string "auto" in one property (past_length) -- everywhere else
-        # (context_token_length/prediction_token_length) it does
-        # `context_length / patch_size` directly, which raises
-        # `TypeError: unsupported operand type(s) for /: 'int' and 'str'`
-        # on every forward pass if patch_size is left as "auto". The
-        # official eval config for this exact checkpoint
-        # (cli/conf/eval/model/moirai_moe_1.0_R_small.yaml in
-        # SalesforceAIResearch/uni2ts) uses `patch_size: 16`, matching
-        # the worked example in this file's own module docstring above.
-        self.checkpoint = checkpoint
-        self.num_samples = min(num_samples, cfg.RESOURCE_LIMITS["max_forecast_samples"])
-        self.patch_size = patch_size
-        self._module = None
-        self._loaded = False
-        self.max_context = cfg.MODEL_MAX_CONTEXT_DEFAULT
-        self._predictor_cache_key = None
-        self._cached_predictor = None
-    def load(self) -> "MoiraiMoEForecaster":
-        try:
-            from uni2ts.model.moirai_moe import MoiraiMoEModule
-        except ImportError as e:
-            raise ModelLoadError(
-                f"uni2ts is not installed/importable ({e}). Run "
-                f"`pip install -r requirements.txt`. This is the exact "
-                f"underlying error, not masked (section 4)."
-            ) from e
-        try:
-            self._module = MoiraiMoEModule.from_pretrained(self.checkpoint)
-        except Exception as e:
-            raise ModelLoadError(
-                f"Failed to load checkpoint '{self.checkpoint}': {e}. "
-                f"Not replaced with any other model (section 80)."
-            ) from e
-        # Respect the checkpoint's own declared context limit if exposed,
-        # rather than assuming unlimited context (section 86).
-        cfg_max = getattr(getattr(self._module, "config", None), "max_seq_len", None)
-        if isinstance(cfg_max, int) and cfg_max > 0:
-            self.max_context = cfg_max
-        self._loaded = True
-        return self
-    @property
-    def is_loaded(self) -> bool:
-        return self._loaded
-    def _get_predictor(self, context_length: int, prediction_length: int, past_covariate_cols: List[str]):
-        """Builds (or reuses) the MoiraiMoEForecast predictor. A
-        walk-forward backtest calls predict() thousands of times with an
-        identical configuration (same context_length/prediction_length/
-        covariates) -- rebuilding the wrapper from scratch on every
-        origin was pure waste. Cached by the values that actually change
-        the underlying computation graph."""
-        key = (context_length, prediction_length, tuple(past_covariate_cols),
-               self.num_samples, self.patch_size)
-        if key != self._predictor_cache_key:
-            from uni2ts.model.moirai_moe import MoiraiMoEForecast
-            model = MoiraiMoEForecast(
-                module=self._module,
-                prediction_length=prediction_length,
-                context_length=context_length,
-                patch_size=self.patch_size,
-                num_samples=self.num_samples,
-                target_dim=1,
-                feat_dynamic_real_dim=0,
-                past_feat_dynamic_real_dim=len(past_covariate_cols),
-            )
-            self._cached_predictor = model.create_predictor(batch_size=1)
-            self._predictor_cache_key = key
-        return self._cached_predictor
-    def predict(self, context_df: pd.DataFrame, target_col: str,
-                past_covariate_cols: List[str], prediction_length: int,
-                freq: str) -> QuantileForecast:
-        if not self._loaded:
-            raise ModelInferenceError("Model not loaded — call load() first (section 60).")
-        required = [target_col, *past_covariate_cols]
-        missing = [c for c in required if c not in context_df.columns]
-        if missing:
-            raise ModelInputError(f"Missing required columns in context: {missing}")
-        if context_df[required].isna().any().any():
-            raise ModelInputError(
-                "NaN present in model input — indicator warm-up was not fully "
-                "trimmed before calling predict() (section 24/60)."
-            )
-        if not np.isfinite(context_df[required].to_numpy(dtype=float)).all():
-            raise ModelInputError("Non-finite value present in model input.")
-        context_length = min(len(context_df), self.max_context)
-        if context_length < len(context_df):
-            context_df = context_df.iloc[-context_length:]
-        if context_length < 32:
-            raise ModelInputError(
-                f"Only {context_length} valid context rows available — too "
-                f"short for a meaningful forecast (section 88)."
-            )
-        if prediction_length < 1:
-            raise ModelInputError("prediction_length must be >= 1.")
-        try:
-            from gluonts.dataset.pandas import PandasDataset
-        except ImportError as e:
-            raise ModelLoadError(f"gluonts/uni2ts forecast wrapper unavailable: {e}") from e
-        try:
-            predictor = self._get_predictor(context_length, prediction_length, past_covariate_cols)
-            gluon_df = context_df[required].rename(columns={target_col: "target"})
-            # freq is passed EXPLICITLY rather than left for PandasDataset to
-            # infer from the timestamps. Real Yahoo data has gaps (weekends,
-            # exchange closures, occasional missing bars), and pd.infer_freq()
-            # returns None on gapped/irregular data -- which fails the SAME
-            # way on every single origin, not just some. We already know the
-            # intended bar spacing from the requested timeframe, so there's
-            # no need to infer it at all.
-            #
-            # Fixing an explicit freq does NOT by itself satisfy gluonts:
-            # PandasDataset._pair_to_dataentry() converts the index to a
-            # PeriodIndex at that freq and then asserts is_uniform() --
-            # i.e. that consecutive periods are contiguous with no gaps at
-            # all -- regardless of whether freq was inferred or given
-            # explicitly. That assertion is exactly what real market data
-            # (weekend closures, thin-liquidity gaps) violates, and it's
-            # what raised "Dataframe index is not uniformly spaced" here.
-            # unchecked=True skips that assertion; we still keep sorting
-            # (assume_sorted defaults to False) and the model still sees a
-            # correctly-ordered, correctly-spaced-by-freq sequence of the
-            # bars that actually exist -- it just isn't forced to treat
-            # legitimate market-closure gaps as a fatal error.
-            ds = PandasDataset(gluon_df, target="target", freq=freq,
-                                past_feat_dynamic_real=past_covariate_cols,
-                                unchecked=True)
-            forecasts = list(predictor.predict(ds))
-        except Exception as e:
-            raise ModelInferenceError(
-                f"Real Moirai-MoE forward pass failed: {e}. Not masked, "
-                f"not substituted with another model (section 4/6)."
-            ) from e
-        if not forecasts:
-            raise ModelInferenceError("Model returned no forecast object.")
-        fc = forecasts[0]
-        levels = [0.1, 0.25, 0.5, 0.75, 0.9]
-        try:
-            quantiles = np.stack([np.asarray(fc.quantile(q)) for q in levels], axis=1)
-        except Exception as e:
-            raise ModelInferenceError(f"Could not extract quantiles from forecast output: {e}") from e
-        if quantiles.shape[0] != prediction_length:
-            raise ModelInferenceError(
-                f"Forecast shape mismatch: got {quantiles.shape[0]} steps, "
-                f"expected {prediction_length} (section 60)."
-            )
-        if not np.isfinite(quantiles).all():
-            raise ModelInferenceError(
-                "Forecast contains NaN/inf — refusing to return an invalid "
-                "result rather than silently 'fixing' it (section 61)."
-            )
-        samples = getattr(fc, "samples", None)
-        return QuantileForecast(
-            horizon=prediction_length, quantile_levels=levels, quantiles=quantiles,
-            samples=samples, context_length_used=context_length, prediction_length=prediction_length,
-        )

persistence.py DELETED Viewed

@@ -1,85 +0,0 @@
-"""
-Local, self-contained persistence: an immutable forecast registry plus
-model-artifact metadata (spec sections 45-46, 66, 76, 90). SQLite only —
-no external DB service, consistent with the single-application /
-HF-Spaces-friendly deployment target (section 76).
-"""
-from __future__ import annotations
-import sqlite3
-import uuid
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Optional
-import numpy as np
-SCHEMA = """
-CREATE TABLE IF NOT EXISTS forecasts (
-    id TEXT PRIMARY KEY,
-    created_at TEXT,
-    symbol TEXT, timeframe TEXT, horizon INTEGER,
-    model_checkpoint TEXT, config_hash TEXT,
-    origin_ts TEXT, price_now REAL,
-    p10 REAL, p50 REAL, p90 REAL,
-    action TEXT, rationale TEXT,
-    realized_price REAL, realized_return REAL, forecast_error REAL,
-    direction_correct INTEGER
-);
-CREATE TABLE IF NOT EXISTS model_artifacts (
-    id TEXT PRIMARY KEY,
-    created_at TEXT,
-    checkpoint TEXT, library_versions TEXT,
-    feature_schema TEXT, seed INTEGER,
-    training_range TEXT, validation_range TEXT, test_range TEXT
-);
-"""
-class Store:
-    def __init__(self, path: str = "registry.sqlite3"):
-        self.path = Path(path)
-        self.conn = sqlite3.connect(self.path)
-        self.conn.executescript(SCHEMA)
-        self.conn.commit()
-    def record_forecast(self, **fields) -> str:
-        """A forecast row is written once and never mutated except by
-        match_realized_outcome() filling in the realized_* columns
-        later (section 90: 'A forecast should remain immutable after
-        creation')."""
-        fid = str(uuid.uuid4())
-        fields = {"id": fid, "created_at": datetime.now(timezone.utc).isoformat(), **fields}
-        cols = ",".join(fields.keys())
-        qs = ",".join(["?"] * len(fields))
-        self.conn.execute(f"INSERT INTO forecasts ({cols}) VALUES ({qs})", list(fields.values()))
-        self.conn.commit()
-        return fid
-    def match_realized_outcome(self, forecast_id: str, realized_price: float) -> None:
-        row = self.conn.execute(
-            "SELECT price_now, p50 FROM forecasts WHERE id=?", (forecast_id,)
-        ).fetchone()
-        if row is None:
-            raise KeyError(f"No forecast with id {forecast_id}")
-        price_now, p50 = row
-        realized_return = realized_price / price_now - 1.0
-        error = abs(p50 - realized_return)
-        direction_correct: Optional[int] = (
-            int(np.sign(p50) == np.sign(realized_return)) if realized_return != 0 else None
-        )
-        self.conn.execute(
-            "UPDATE forecasts SET realized_price=?, realized_return=?, forecast_error=?, "
-            "direction_correct=? WHERE id=?",
-            (realized_price, realized_return, error, direction_correct, forecast_id),
-        )
-        self.conn.commit()
-    def save_model_artifact(self, **fields) -> str:
-        aid = str(uuid.uuid4())
-        fields = {"id": aid, "created_at": datetime.now(timezone.utc).isoformat(), **fields}
-        cols = ",".join(fields.keys())
-        qs = ",".join(["?"] * len(fields))
-        self.conn.execute(f"INSERT INTO model_artifacts ({cols}) VALUES ({qs})", list(fields.values()))
-        self.conn.commit()
-        return aid

requirements.txt DELETED Viewed

@@ -1,73 +0,0 @@
-# Core model — the sole predictive model in this system (spec section 3)
-uni2ts>=2.0.0
-torch>=2.1
-gluonts>=0.14
-# --- REVERSED after upgrading to gradio 6.26.0 ---
-# This used to be pinned `<1.0`: gradio 4.44.x's oauth.py did
-# `from huggingface_hub import HfFolder, whoami` unconditionally at import
-# time, and huggingface_hub 1.0 removed HfFolder, so any resolution that
-# picked huggingface_hub>=1.0 crashed on `import gradio` before app.py even
-# ran. That's gone upstream -- gradio's own changelog has "Allow gradio to
-# run with huggingface_hub 1.x", landed well before 6.26.0. uni2ts's
-# PyTorchModelHubMixin.from_pretrained() (what moirai_model.py actually
-# calls) isn't on the removed API either. No known reason left to cap this.
-huggingface_hub>=0.23.0
-# Data
-# Floor + ceiling, same pattern as the gradio pin below (and for the same
-# reason -- an unbounded `>=` is what let gradio drift onto an untested
-# combination previously). yfinance did a 0.2.x -> 1.x major bump; a later
-# pass in a network-enabled sandbox installed 1.7.0 and confirmed
-# Ticker.history()'s signature (period/interval/start/end/auto_adjust) and
-# its returned OHLCV column names are unchanged from what data_layer.py
-# assumes, so the floor stays permissive -- the ceiling just blocks an
-# unverified future 2.x from being silently picked up.
-yfinance>=0.2.40,<2.0
-pandas>=2.0
-numpy>=1.24
-# UI (Hugging Face Spaces)
-# Pinned to the 6.x line (floor at the version this build was verified
-# against, ceiling below the next major) instead of a bare `>=` -- that's
-# what let pip drift onto an untested gradio/starlette/fastapi combination
-# last time. app.py's own component usage (Blocks/Tab/Row/Textbox/Dropdown/
-# Slider/Button/Markdown/Dataframe/Accordion/JSON/Radio) doesn't touch any
-# of the parameters the Gradio 6 migration guide removed, so no app.py
-# changes were needed for this bump.
-gradio>=6.26.0,<7
-# --- REMOVED after upgrading to gradio 6.26.0 ---
-# This file used to pin `starlette<1.0` because gradio 4.44.x's routes.py
-# called Jinja2Templates.TemplateResponse the pre-1.0 way
-# (`TemplateResponse(name, context)`), which breaks against Starlette>=1.0
-# (the context dict lands in the `name` slot -> Jinja2 tries to hash it as
-# a cache key -> `TypeError: unhashable type: 'dict'` on every page load).
-# Gradio's own changelog shows a later commit -- "upgrade starlette
-# dependency to 1.0.1 or higher" -- that updated routes.py to the new
-# `TemplateResponse(request, name, context)` call and raised gradio's own
-# floor accordingly. That fix is already in 6.26.0, so pinning
-# starlette<1.0 now would fight gradio's real requirement instead of
-# working around a bug, and could make pip's resolution fail outright.
-python-dateutil
-pytz
-# --- FIX applied after a real HF Spaces build failure ---
-# An earlier version of this file pinned `numpy<2.0` and an explicit
-# `scipy>=1.11` as an untested precaution. On a real Spaces build this
-# forced pip to resolve an old scipy release with no prebuilt wheel for
-# the Space's Python version, which then failed trying to build scipy
-# from source via meson (no Fortran compiler / BLAS-LAPACK toolchain in
-# that install step -> "metadata-generation-failed"). Neither pin was
-# load-bearing: nothing in this codebase imports scipy directly, and
-# none of our own numpy usage requires numpy<2. Removing both lets
-# uni2ts/gluonts/torch resolve numpy (and scipy, transitively) to
-# whatever versions they actually ship wheels for.
-#
-# General pattern if a DIFFERENT package fails "metadata-generation" or
-# tries to build from source on Spaces: it's almost always pip being
-# forced into a source build for a package with no wheel for that
-# Python version. Fix is usually the same shape -- stop pinning that
-# package explicitly (or bump its floor) and let its real dependent
-# choose a version it has a wheel for.

run_tests.py DELETED Viewed

@@ -1,55 +0,0 @@
-"""
-Lightweight test runner. pytest is not installed in this build sandbox
-and there is no network access to install it (see README) -- this
-script discovers tests/test_*.py, runs every top-level test_* function,
-and reports real PASS/FAIL based on actual execution (spec section 6:
-real execution validation, not static syntax checking).
-If you have pytest available (e.g. after `pip install -r requirements.txt`
-somewhere with network access), just run `pytest tests/` instead --
-these test files use plain assert and need nothing pytest-specific.
-"""
-import importlib.util
-import sys
-import traceback
-from pathlib import Path
-ROOT = Path(__file__).resolve().parent
-sys.path.insert(0, str(ROOT))
-sys.path.insert(0, str(ROOT / "tests"))
-def run() -> bool:
-    test_files = sorted((ROOT / "tests").glob("test_*.py"))
-    total = 0
-    failed = 0
-    for f in test_files:
-        spec = importlib.util.spec_from_file_location(f.stem, f)
-        module = importlib.util.module_from_spec(spec)
-        try:
-            spec.loader.exec_module(module)
-        except Exception:
-            print(f"IMPORT ERROR  {f.name}")
-            traceback.print_exc()
-            failed += 1
-            total += 1
-            continue
-        for name in dir(module):
-            if name.startswith("test_"):
-                fn = getattr(module, name)
-                if callable(fn):
-                    total += 1
-                    try:
-                        fn()
-                        print(f"PASS  {f.name}::{name}")
-                    except Exception:
-                        failed += 1
-                        print(f"FAIL  {f.name}::{name}")
-                        traceback.print_exc()
-    print(f"\n{total - failed}/{total} passed")
-    return failed == 0
-if __name__ == "__main__":
-    ok = run()
-    sys.exit(0 if ok else 1)

tests/fixtures.py DELETED Viewed

@@ -1,38 +0,0 @@
-"""
-Deterministic synthetic OHLCV fixtures — used ONLY to test software
-correctness (causality, boundary logic, formula correctness), per spec
-section 100: "Use small deterministic synthetic/test fixtures ONLY for
-software correctness tests. Do not present synthetic-data output as
-real model performance."
-None of this data, and no result derived from it, is ever reported as
-a real accuracy/backtest number. Real performance requires the real
-checkpoint and real Yahoo Finance data (see README limitations).
-"""
-from __future__ import annotations
-import numpy as np
-import pandas as pd
-def make_synthetic_ohlcv(n: int = 400, seed: int = 7, freq: str = "5min",
-                          start_price: float = 100.0) -> pd.DataFrame:
-    rng = np.random.default_rng(seed)
-    idx = pd.date_range("2024-01-01", periods=n, freq=freq, tz="UTC")
-    returns = rng.normal(0, 0.001, n)
-    close = start_price * np.cumprod(1 + returns)
-    high = close * (1 + np.abs(rng.normal(0, 0.0005, n)))
-    low = close * (1 - np.abs(rng.normal(0, 0.0005, n)))
-    open_ = np.roll(close, 1)
-    open_[0] = start_price
-    volume = rng.integers(100, 1000, n).astype(float)
-    df = pd.DataFrame(
-        {"open": open_, "high": high, "low": low, "close": close, "volume": volume},
-        index=idx,
-    )
-    df.index.name = "timestamp"
-    # Enforce OHLC sanity after the random perturbation above.
-    df["high"] = df[["open", "high", "low", "close"]].max(axis=1)
-    df["low"] = df[["open", "high", "low", "close"]].min(axis=1)
-    return df

tests/test_backtest_no_lookahead.py DELETED Viewed

@@ -1,322 +0,0 @@
-"""
-The single most important test in this project: proves the backtest
-engine's decisions do not change when future rows are appended after
-the origin under examination. This is the actual causal-safety property
-sections 25/28/29/53 describe, checked by execution rather than assumed
-by code review.
-StubForecaster/RecordingStub below are TEST-ONLY doubles. They are
-never imported by app.py or moirai_model.py -- the production path
-always requires the real MoiraiMoEForecaster and the real downloaded
-checkpoint. Using a deterministic stub here is exactly what spec
-section 100 permits ("small deterministic synthetic/test fixtures ONLY
-for software correctness tests").
-"""
-import numpy as np
-import config as cfg
-from backtest_engine import InsufficientDataError, WalkForwardBacktester
-from features import compute_indicators
-from fixtures import make_synthetic_ohlcv
-from moirai_model import QuantileForecast
-class StubForecaster:
-    def predict(self, context_df, target_col, past_covariate_cols, prediction_length, freq):
-        last_close = float(context_df[target_col].iloc[-1])
-        drift = float(context_df[target_col].diff().mean())
-        spread = float(context_df[target_col].std() * 0.1) or 0.01
-        p50 = last_close + drift * prediction_length
-        prices = [p50 - 2 * spread, p50 - spread, p50, p50 + spread, p50 + 2 * spread]
-        return QuantileForecast(
-            horizon=prediction_length, quantile_levels=[0.1, 0.25, 0.5, 0.75, 0.9],
-            quantiles=np.array([prices]), samples=None,
-            context_length_used=len(context_df), prediction_length=prediction_length,
-        )
-def test_decisions_unaffected_by_future_rows():
-    df = make_synthetic_ohlcv(n=500, seed=11)  # 5-minute-spaced fixture, see tests/fixtures.py
-    feat = compute_indicators(df)
-    result_full = WalkForwardBacktester(StubForecaster(), timeframe="5m", horizon=3, context_length=60).run(feat)
-    cutoff = 350
-    result_trunc = WalkForwardBacktester(StubForecaster(), timeframe="5m", horizon=3, context_length=60).run(
-        feat.iloc[:cutoff])
-    trunc_actions = {d["origin_ts"]: d["action"] for d in result_trunc["decisions_log"]}
-    checked = 0
-    for d in result_full["decisions_log"]:
-        if d["origin_ts"] in trunc_actions:
-            checked += 1
-            assert d["action"] == trunc_actions[d["origin_ts"]], (
-                f"Decision at {d['origin_ts']} changed from "
-                f"{trunc_actions[d['origin_ts']]} to {d['action']} when future rows were appended"
-            )
-    assert checked > 20, "test should compare a meaningful number of shared origins"
-def test_backtest_context_never_extends_past_origin():
-    df = make_synthetic_ohlcv(n=300, seed=12)
-    feat = compute_indicators(df)
-    seen = []
-    class RecordingStub:
-        def predict(self, context_df, target_col, past_covariate_cols, prediction_length, freq):
-            seen.append(context_df.index.max())
-            last_close = float(context_df[target_col].iloc[-1])
-            prices = [last_close * f for f in (0.99, 0.995, 1.0, 1.005, 1.01)]
-            return QuantileForecast(
-                horizon=prediction_length, quantile_levels=[0.1, 0.25, 0.5, 0.75, 0.9],
-                quantiles=np.array([prices]), samples=None,
-                context_length_used=len(context_df), prediction_length=prediction_length,
-            )
-    bt = WalkForwardBacktester(RecordingStub(), timeframe="5m", horizon=2, context_length=40)
-    result = bt.run(feat)
-    assert len(seen) > 0
-    # Cross-check: every recorded max-context timestamp must be found in
-    # the original feature_df index at or before the corresponding origin.
-    origins = [d["origin_ts"] for d in result["decisions_log"]]
-    assert len(seen) == len(origins)
-    for origin_ts, max_ctx_ts in zip(origins, seen):
-        assert max_ctx_ts <= origin_ts, (
-            f"context leaked a row from {max_ctx_ts}, after origin {origin_ts}"
-        )
-def test_backtest_passes_correct_freq_to_forecaster():
-    """Directly guards the actual bug fixed here: freq must reach
-    forecaster.predict() as the pandas alias for the requested timeframe,
-    not be left for gluonts to infer from (possibly gapped) timestamps."""
-    df = make_synthetic_ohlcv(n=200, seed=13)
-    feat = compute_indicators(df)
-    seen_freqs = []
-    class FreqRecordingStub:
-        def predict(self, context_df, target_col, past_covariate_cols, prediction_length, freq):
-            seen_freqs.append(freq)
-            last_close = float(context_df[target_col].iloc[-1])
-            prices = [last_close] * 5
-            return QuantileForecast(
-                horizon=prediction_length, quantile_levels=[0.1, 0.25, 0.5, 0.75, 0.9],
-                quantiles=np.array([prices]), samples=None,
-                context_length_used=len(context_df), prediction_length=prediction_length,
-            )
-    bt = WalkForwardBacktester(FreqRecordingStub(), timeframe="5m", horizon=2, context_length=40)
-    bt.run(feat)
-    assert len(seen_freqs) > 0
-    assert all(f == "5min" for f in seen_freqs)
-def test_run_raises_insufficient_data_error_not_a_bare_indexerror():
-    """Regression test for the exact production bug: warm-up succeeds
-    (150 bars easily covers the 50-period SMA), but the default
-    context_length=256 leaves no room for even one origin. Before this
-    fix, feature_df.index[start_idx] raised a bare, confusing IndexError
-    once start_idx ran past the end of the frame -- app.py's generic
-    `except Exception` then showed users a raw traceback for what is
-    really just "your History window is too short for this context
-    length", a normal, actionable, non-buggy condition. It must raise
-    InsufficientDataError with the actual bar counts, not IndexError."""
-    df = make_synthetic_ohlcv(n=150, seed=20)
-    feat = compute_indicators(df)
-    class StubForecaster:
-        def predict(self, context_df, target_col, past_covariate_cols, prediction_length, freq):
-            last_close = float(context_df[target_col].iloc[-1])
-            prices = [last_close] * 5
-            return QuantileForecast(
-                horizon=prediction_length, quantile_levels=[0.1, 0.25, 0.5, 0.75, 0.9],
-                quantiles=np.array([prices]), samples=None,
-                context_length_used=len(context_df), prediction_length=prediction_length,
-            )
-    # context_length default (256) is deliberately left unset here, same
-    # as app.py used to call it before context_length was exposed.
-    bt = WalkForwardBacktester(StubForecaster(), timeframe="1d", horizon=5)
-    try:
-        bt.run(feat)
-        raise AssertionError("expected InsufficientDataError")
-    except InsufficientDataError as e:
-        msg = str(e)
-        assert "150" in msg, f"should state the 150 bars actually available: {msg}"
-        assert "context_length" in msg
-    except IndexError:
-        raise AssertionError(
-            "run() raised a bare IndexError instead of InsufficientDataError "
-            "-- the bounds check regressed"
-        )
-def test_run_succeeds_with_a_smaller_context_length_on_the_same_short_data():
-    """Same 150-bar frame as above, but with a context_length that
-    actually fits -- confirms the fix is a real validation, not just a
-    blanket rejection of short windows."""
-    df = make_synthetic_ohlcv(n=150, seed=21)
-    feat = compute_indicators(df)
-    class StubForecaster:
-        def predict(self, context_df, target_col, past_covariate_cols, prediction_length, freq):
-            last_close = float(context_df[target_col].iloc[-1])
-            prices = [last_close] * 5
-            return QuantileForecast(
-                horizon=prediction_length, quantile_levels=[0.1, 0.25, 0.5, 0.75, 0.9],
-                quantiles=np.array([prices]), samples=None,
-                context_length_used=len(context_df), prediction_length=prediction_length,
-            )
-    bt = WalkForwardBacktester(StubForecaster(), timeframe="1d", horizon=5, context_length=64)
-    result = bt.run(feat)
-    assert result["num_origins"] > 0
-class _AlwaysBuyStub:
-    """Deterministically predicts a clear, confident uptrend at every
-    origin, so the first origin in a short window is always a BUY --
-    lets the risk-management tests below control exactly which bar's
-    intrabar high/low the stop/take-profit check will see."""
-    def predict(self, context_df, target_col, past_covariate_cols, prediction_length, freq):
-        last_close = float(context_df[target_col].iloc[-1])
-        p50 = last_close * 1.01
-        prices = [p50 * f for f in (0.999, 0.9995, 1.0, 1.0005, 1.001)]  # tight interval -> clears min_probability
-        return QuantileForecast(
-            horizon=prediction_length, quantile_levels=[0.1, 0.25, 0.5, 0.75, 0.9],
-            quantiles=np.array([prices]), samples=None,
-            context_length_used=len(context_df), prediction_length=prediction_length,
-        )
-def _first_buy_setup(seed=30, horizon=5, context_length=32):
-    """Shared scaffold for the risk-management tests: builds a feature
-    frame and runs a dry (no-risk) backtest just far enough to learn the
-    first trade's exec_idx/entry_price/horizon exit_idx, without yet
-    injecting the controlled intrabar move."""
-    df = make_synthetic_ohlcv(n=120, seed=seed)
-    feat = compute_indicators(df)
-    bt = WalkForwardBacktester(_AlwaysBuyStub(), timeframe="1d", horizon=horizon, context_length=context_length)
-    baseline = bt.run(feat)
-    assert len(baseline["trades"]) > 0, "expected at least one BUY trade from the always-buy stub"
-    first = baseline["trades"][0]
-    exec_idx = feat.index.get_loc(first.entry_ts)
-    horizon_exit_idx = feat.index.get_loc(first.exit_ts)
-    return feat, bt, first, exec_idx, horizon_exit_idx
-def test_stop_loss_exits_early_at_the_breaching_bars_close():
-    feat, _, baseline_trade, exec_idx, horizon_exit_idx = _first_buy_setup(seed=30)
-    entry_price = baseline_trade.entry_price
-    mid_idx = exec_idx + 2
-    assert mid_idx < horizon_exit_idx, "test needs at least one bar strictly between entry and horizon exit"
-    feat = feat.copy()
-    # A real ~3% adverse close at mid_idx (breaching a 2% stop), plus an
-    # even sharper 5% intrabar wick on low -- close is what the trade
-    # actually exits at (documented convention), low is only what
-    # triggers the check, so both must move for this test to be
-    # meaningful: moving only the wick (leaving close unchanged) would
-    # trigger the stop but show none of it in net_pnl, silently testing
-    # nothing about the P&L.
-    i_close = feat.columns.get_loc("close")
-    i_low = feat.columns.get_loc("low")
-    i_high = feat.columns.get_loc("high")
-    feat.iloc[mid_idx, i_close] = entry_price * 0.97
-    feat.iloc[mid_idx, i_low] = entry_price * 0.95
-    feat.iloc[mid_idx, i_high] = max(feat["high"].iloc[mid_idx], entry_price * 0.97)
-    bt = WalkForwardBacktester(_AlwaysBuyStub(), timeframe="1d", horizon=5, context_length=32,
-                                risk=cfg.RiskManagement(stop_loss_frac=0.02))
-    result = bt.run(feat)
-    trade = result["trades"][0]
-    assert trade.exit_reason == "stop_loss"
-    assert trade.exit_ts == feat.index[mid_idx], "should exit at the breaching bar, not ride out the full horizon"
-    assert trade.exit_price == float(feat["close"].iloc[mid_idx]), "exit fills at that bar's CLOSE, not the stop level or the wick"
-    assert trade.net_pnl < -0.025, "the ~3% adverse close should show up as a real loss"
-def test_take_profit_exits_early_on_a_sell(monkeypatch=None):
-    """Same mechanism, mirrored for a SELL position: a favorable close
-    (price down) should trigger take-profit and exit early."""
-    class _AlwaysSellStub:
-        def predict(self, context_df, target_col, past_covariate_cols, prediction_length, freq):
-            last_close = float(context_df[target_col].iloc[-1])
-            p50 = last_close * 0.99
-            prices = [p50 * f for f in (0.999, 0.9995, 1.0, 1.0005, 1.001)]
-            return QuantileForecast(
-                horizon=prediction_length, quantile_levels=[0.1, 0.25, 0.5, 0.75, 0.9],
-                quantiles=np.array([prices]), samples=None,
-                context_length_used=len(context_df), prediction_length=prediction_length,
-            )
-    df = make_synthetic_ohlcv(n=120, seed=31)
-    feat = compute_indicators(df)
-    baseline = WalkForwardBacktester(_AlwaysSellStub(), timeframe="1d", horizon=5, context_length=32).run(feat)
-    assert len(baseline["trades"]) > 0
-    first = baseline["trades"][0]
-    entry_price = first.entry_price
-    exec_idx = feat.index.get_loc(first.entry_ts)
-    horizon_exit_idx = feat.index.get_loc(first.exit_ts)
-    mid_idx = exec_idx + 2
-    assert mid_idx < horizon_exit_idx
-    feat = feat.copy()
-    i_close = feat.columns.get_loc("close")
-    i_low = feat.columns.get_loc("low")
-    i_high = feat.columns.get_loc("high")
-    feat.iloc[mid_idx, i_close] = entry_price * 0.97  # real 3% favorable close for a SELL
-    feat.iloc[mid_idx, i_low] = entry_price * 0.95    # sharper intrabar favorable wick
-    feat.iloc[mid_idx, i_high] = min(feat["high"].iloc[mid_idx], entry_price * 0.97)
-    bt = WalkForwardBacktester(_AlwaysSellStub(), timeframe="1d", horizon=5, context_length=32,
-                                risk=cfg.RiskManagement(take_profit_frac=0.02))
-    result = bt.run(feat)
-    trade = result["trades"][0]
-    assert trade.exit_reason == "take_profit"
-    assert trade.exit_ts == feat.index[mid_idx]
-    assert trade.net_pnl > 0.025
-def test_stop_and_take_profit_both_breached_same_bar_assumes_stop():
-    """OHLC alone can't say which of a bar's high/low happened first --
-    if both levels are crossed within the same bar, the documented,
-    conservative assumption is the stop (see _scan_for_early_exit)."""
-    feat, _, baseline_trade, exec_idx, horizon_exit_idx = _first_buy_setup(seed=32)
-    entry_price = baseline_trade.entry_price
-    mid_idx = exec_idx + 2
-    assert mid_idx < horizon_exit_idx
-    feat = feat.copy()
-    feat.iloc[mid_idx, feat.columns.get_loc("low")] = entry_price * 0.95   # breaches a 2% stop
-    feat.iloc[mid_idx, feat.columns.get_loc("high")] = entry_price * 1.05  # AND a 2% take-profit
-    bt = WalkForwardBacktester(_AlwaysBuyStub(), timeframe="1d", horizon=5, context_length=32,
-                                risk=cfg.RiskManagement(stop_loss_frac=0.02, take_profit_frac=0.02))
-    result = bt.run(feat)
-    assert result["trades"][0].exit_reason == "stop_loss"
-def test_risk_management_default_none_reproduces_baseline_exactly():
-    """The whole point of defaulting risk=None: every backtest run
-    before this feature existed must produce byte-identical trades
-    afterward, unless someone explicitly opts in."""
-    df = make_synthetic_ohlcv(n=150, seed=33)
-    feat = compute_indicators(df)
-    r1 = WalkForwardBacktester(_AlwaysBuyStub(), timeframe="1d", horizon=5, context_length=32).run(feat)
-    r2 = WalkForwardBacktester(_AlwaysBuyStub(), timeframe="1d", horizon=5, context_length=32,
-                                risk=cfg.RiskManagement()).run(feat)  # explicit but both fields None
-    assert [t.net_pnl for t in r1["trades"]] == [t.net_pnl for t in r2["trades"]]
-    assert all(t.exit_reason == "horizon" for t in r1["trades"])
-def test_trade_records_decision_confidence_for_entry_filter_analysis():
-    """prob_favorable/interval_width_pct must reach the Trade ledger --
-    added so entry-filter tuning can be based on real per-trade
-    confidence instead of guessing from aggregate stats alone."""
-    feat, bt, first, _, _ = _first_buy_setup(seed=34)
-    assert 0.0 <= first.prob_favorable <= 1.0
-    assert first.interval_width_pct >= 0.0

tests/test_config.py DELETED Viewed

@@ -1,32 +0,0 @@
-"""
-Covers the small config.py helpers added to fix the Live tab's missing
-asset-class cost-awareness: infer_asset_class() (symbol -> "forex"/
-"crypto", used only because the Live tab has no explicit asset-class
-selector the way the Backtest tab's `b_class` radio does) and
-round_trip_cost_frac() (the single, now-shared cost-fraction formula
-both tabs call, instead of backtest_engine.py owning a private copy the
-Live tab couldn't reach).
-"""
-import config as cfg
-def test_infer_asset_class_curated_lists():
-    assert cfg.infer_asset_class("EURUSD=X") == "forex"
-    assert cfg.infer_asset_class("BTC-USD") == "crypto"
-def test_infer_asset_class_falls_back_to_yahoo_ticker_conventions():
-    # Not in the curated lists, but still recognizably Yahoo forex/crypto
-    # syntax -- allow_custom_value lets a person type either into the UI.
-    assert cfg.infer_asset_class("USDPLN=X") == "forex"
-    assert cfg.infer_asset_class("PEPE-USD") == "crypto"
-    assert cfg.infer_asset_class("ETH-USDT") == "crypto"
-def test_infer_asset_class_default_for_unrecognized_symbol():
-    assert cfg.infer_asset_class("SPY") == "forex"
-def test_round_trip_cost_frac_matches_hand_computed_bps():
-    profile = cfg.COST_PROFILES["crypto"]  # spread=2.0 + commission=10.0 + slippage=2.0 bps
-    assert abs(cfg.round_trip_cost_frac(profile) - 0.0014) < 1e-12

tests/test_data_layer.py DELETED Viewed

@@ -1,117 +0,0 @@
-"""
-Covers the parts of data_layer.py that don't require network access:
-validate_ohlcv (duplicate/invalid/NaN handling), LocalCache round-trip,
-and data_freshness classification. fetch_ohlcv() itself needs a real
-network call and is exercised only by the smoke-test script (expected
-to fail here with DataSourceError -- see README).
-"""
-import numpy as np
-import pandas as pd
-from data_layer import LocalCache, data_freshness, validate_ohlcv
-def test_validate_removes_duplicates_and_keeps_first():
-    idx = pd.to_datetime(["2024-01-01", "2024-01-01", "2024-01-02"], utc=True)
-    df = pd.DataFrame({
-        "open": [1, 999, 2], "high": [1, 999, 2], "low": [1, 999, 2],
-        "close": [1, 999, 2], "volume": [10, 10, 10],
-    }, index=idx)
-    out, report = validate_ohlcv(df)
-    assert report.duplicates_removed == 1
-    assert len(out) == 2
-    assert out.iloc[0]["close"] == 1  # first occurrence kept, not the duplicate
-def test_validate_removes_invalid_ohlc_relationship():
-    idx = pd.date_range("2024-01-01", periods=3, freq="1h", tz="UTC")
-    df = pd.DataFrame({
-        "open": [10, 10, 10],
-        "high": [11, 9, 11],     # row 1: high < open -> invalid
-        "low": [9, 9, 9],
-        "close": [10.5, 10.5, 10.5],
-        "volume": [5, 5, 5],
-    }, index=idx)
-    out, report = validate_ohlcv(df)
-    assert report.invalid_ohlc_removed == 1
-    assert len(out) == 2
-def test_validate_removes_nan_rows_and_reports_them():
-    idx = pd.date_range("2024-01-01", periods=3, freq="1h", tz="UTC")
-    df = pd.DataFrame({
-        "open": [10, np.nan, 10], "high": [11, 11, 11], "low": [9, 9, 9],
-        "close": [10.5, 10.5, 10.5], "volume": [5, 5, 5],
-    }, index=idx)
-    out, report = validate_ohlcv(df)
-    assert report.nan_rows_removed == 1
-    assert len(out) == 2
-def test_validate_marks_negative_volume_unavailable_not_invented():
-    idx = pd.date_range("2024-01-01", periods=2, freq="1h", tz="UTC")
-    df = pd.DataFrame({
-        "open": [10, 10], "high": [11, 11], "low": [9, 9],
-        "close": [10.5, 10.5], "volume": [5, -3],
-    }, index=idx)
-    out, _ = validate_ohlcv(df)
-    assert np.isnan(out.iloc[1]["volume"]), "negative volume must become NaN, never a guessed positive number"
-def test_local_cache_round_trip(tmp_path_str="/tmp/_moirai_test_cache.sqlite3"):
-    import os
-    if os.path.exists(tmp_path_str):
-        os.remove(tmp_path_str)
-    cache = LocalCache(tmp_path_str)
-    idx = pd.date_range("2024-01-01", periods=3, freq="1h", tz="UTC")
-    df = pd.DataFrame({"open": [1, 2, 3], "high": [1, 2, 3], "low": [1, 2, 3],
-                        "close": [1, 2, 3], "volume": [1, 2, 3]}, index=idx)
-    assert cache.get("EURUSD=X", "1h", "yfinance", "2024-01-01", "2024-01-02") is None
-    cache.set("EURUSD=X", "1h", "yfinance", "2024-01-01", "2024-01-02", df)
-    round_tripped = cache.get("EURUSD=X", "1h", "yfinance", "2024-01-01", "2024-01-02")
-    assert round_tripped is not None
-    assert len(round_tripped) == 3
-    assert list(round_tripped["close"]) == [1, 2, 3]
-    os.remove(tmp_path_str)
-def test_data_freshness_classification():
-    now = pd.Timestamp.now(tz="UTC")
-    fresh = data_freshness(now - pd.Timedelta(minutes=1), "1h")
-    stale = data_freshness(now - pd.Timedelta(hours=10), "1h")
-    assert fresh["status"] == "fresh"
-    assert stale["status"] == "stale"
-def test_resolve_history_window_days():
-    from data_layer import resolve_history_window
-    kind, value = resolve_history_window("1 day")
-    assert kind == "start"
-    kind, value = resolve_history_window("30 days")
-    assert kind == "start"
-def test_resolve_history_window_months_uses_calendar_months():
-    from data_layer import resolve_history_window
-    from datetime import datetime, timezone
-    kind, value = resolve_history_window("3 months")
-    assert kind == "start"
-    now = datetime.now(timezone.utc)
-    delta_days = (now - value).days
-    # 3 calendar months is 89-92 days depending on which months are spanned --
-    # NOT exactly 90 (which a naive 30*3 approximation would assume).
-    assert 88 <= delta_days <= 93, f"expected ~3 calendar months, got {delta_days} days"
-def test_resolve_history_window_max():
-    from data_layer import resolve_history_window
-    kind, value = resolve_history_window("max")
-    assert kind == "period"
-    assert value == "max"
-def test_resolve_history_window_years():
-    from data_layer import resolve_history_window
-    kind, value = resolve_history_window("2 years")
-    assert kind == "start"

tests/test_decision_and_metrics.py DELETED Viewed

@@ -1,112 +0,0 @@
-"""
-Verifies decision_engine.decide() produces the right action for
-unambiguous synthetic inputs, and that the metrics formulas match
-hand-computed values on small examples.
-"""
-import numpy as np
-import pandas as pd
-from decision_engine import decide
-from metrics import (
-    directional_accuracy, mae, max_drawdown, profit_factor, rmse,
-    sharpe_ratio, smape,
-)
-class _FakeForecast:
-    def __init__(self, quantiles, levels=(0.1, 0.25, 0.5, 0.75, 0.9)):
-        self.quantiles = np.array([quantiles])  # single horizon step
-        self.quantile_levels = list(levels)
-def test_decide_buy_on_clear_positive_move():
-    fc = _FakeForecast([100.6, 100.7, 100.8, 100.9, 101.0])
-    d = decide(fc, price_now=100.0, cost_estimate_frac=0.0002)
-    assert d.action == "BUY", d.rationale
-def test_decide_sell_on_clear_negative_move():
-    fc = _FakeForecast([99.0, 99.1, 99.2, 99.3, 99.4])
-    d = decide(fc, price_now=100.0, cost_estimate_frac=0.0002)
-    assert d.action == "SELL", d.rationale
-def test_decide_hold_on_wide_interval():
-    fc = _FakeForecast([90.0, 96.0, 100.2, 104.0, 110.0])  # huge P10-P90 spread
-    d = decide(fc, price_now=100.0, cost_estimate_frac=0.0002)
-    assert d.action == "HOLD"
-    assert "wide" in d.hold_reason
-def test_decide_hold_when_edge_below_cost():
-    fc = _FakeForecast([99.95, 99.98, 100.02, 100.05, 100.08])  # tiny move, cost-eaten
-    d = decide(fc, price_now=100.0, cost_estimate_frac=0.0005)
-    assert d.action == "HOLD"
-def test_decide_sell_requires_correct_directional_probability_not_buy_complement():
-    """Regression test for the SELL-branch probability bug: the engine
-    used to gate SELL on `1 - P(return>cost)`, which is P(return<=cost) --
-    a much easier bar to clear than the directionally-correct P(return<
-    -cost), since it's satisfied by anything in the whole -inf..cost
-    range, not just the profitable-to-short range below -cost. This
-    forecast is built so the two disagree: true P(return<-cost) is only
-    ~0.54 (below the 0.55 min_probability gate -> should HOLD), while the
-    old buggy stand-in 1-P(return>cost) comes out ~0.56 (would wrongly
-    clear the gate -> SELL). p50 alone already passes the SELL threshold,
-    so this isolates the probability-gate bug specifically."""
-    price_now = 100.0
-    target_returns = [-0.006, -0.004, -0.0025, 0.01, 0.02]
-    prices = [price_now * (1 + r) for r in target_returns]
-    fc = _FakeForecast(prices)
-    d = decide(fc, price_now=price_now, cost_estimate_frac=0.0005)
-    assert d.action == "HOLD", (
-        f"expected HOLD (true P(return<-cost) ~0.54 is below the 0.55 "
-        f"confidence gate), got {d.action}: {d.rationale}"
-    )
-    assert "below threshold" in d.hold_reason
-def test_decide_sell_rationale_reports_the_sell_side_probability():
-    """A confident SELL's rationale should report P(return<-cost) (high,
-    matching the actual confidence behind the decision) rather than
-    P(return>cost) (near-zero for any clear downward forecast, which
-    reads as "no confidence" even though the decision is well-justified)."""
-    fc = _FakeForecast([99.0, 99.1, 99.2, 99.3, 99.4])
-    d = decide(fc, price_now=100.0, cost_estimate_frac=0.0002)
-    assert d.action == "SELL"
-    assert "P(return<-cost)" in d.rationale, d.rationale
-    assert d.prob_favorable > 0.9, "a clearly negative forecast should show high SELL-side confidence"
-def test_point_metrics_hand_computed():
-    y_true, y_pred = [10, 12, 14], [11, 11, 15]
-    assert abs(mae(y_true, y_pred) - 1.0) < 1e-9
-    assert abs(rmse(y_true, y_pred) - np.sqrt(1.0)) < 1e-9
-def test_smape_in_valid_range():
-    v = smape([100], [90])
-    assert 0 <= v <= 2
-def test_directional_accuracy():
-    y_true_ret = [0.01, -0.02, 0.03, -0.01]
-    y_pred_ret = [0.02, -0.01, -0.01, -0.005]
-    # signs: true=[+,-,+,-], pred=[+,-,-,-] -> matches at idx 0,1,3 = 3/4
-    assert abs(directional_accuracy(y_true_ret, y_pred_ret) - 0.75) < 1e-9
-def test_max_drawdown_known_series():
-    equity = pd.Series([1.0, 1.2, 0.9, 1.1])
-    assert abs(max_drawdown(equity) - (0.9 / 1.2 - 1.0)) < 1e-9
-def test_profit_factor_known_values():
-    pnls = [10, -5, 20, -5]  # gains=30, losses=10 -> PF=3.0
-    assert abs(profit_factor(pnls) - 3.0) < 1e-9
-def test_sharpe_nan_when_no_variance():
-    r = pd.Series([0.01, 0.01, 0.01, 0.01])
-    assert np.isnan(sharpe_ratio(r, timeframe_minutes=60))

tests/test_features_and_leakage.py DELETED Viewed

@@ -1,122 +0,0 @@
-"""
-Verifies: (1) indicators are truly causal -- recomputing on a truncated
-frame gives bit-identical values at every shared timestamp; (2) warm-up
-is correctly identified and never fabricated; (3) causal_resample
-builds correct OHLCV and drops incomplete trailing bins; (4) the
-leakage auditor actually catches an injected future row.
-"""
-import pandas as pd
-from data_layer import causal_resample
-from features import compute_indicators, warm_up_valid_from
-from fixtures import make_synthetic_ohlcv
-from leakage_audit import LeakageError, assert_no_future_rows, audit_feature_frame
-def test_indicators_are_causal():
-    df = make_synthetic_ohlcv(n=200, seed=1)
-    full = compute_indicators(df)
-    cutoff = 150
-    truncated = compute_indicators(df.iloc[:cutoff])
-    check_cols = [c for c in full.columns if c not in ("open", "high", "low", "close", "volume")]
-    pd.testing.assert_frame_equal(
-        full.iloc[:cutoff][check_cols].reset_index(drop=True),
-        truncated[check_cols].reset_index(drop=True),
-        check_exact=False, rtol=1e-10,
-    )
-def test_warm_up_detection():
-    df = make_synthetic_ohlcv(n=100, seed=2)
-    feat = compute_indicators(df)
-    warm = warm_up_valid_from(feat)
-    assert warm > 0, "warm-up should be > 0 given a 50-period SMA is in the feature set"
-    assert feat.iloc[warm:].isna().sum().sum() == 0, "no NaNs should remain after warm-up trim"
-def test_warm_up_raises_on_insufficient_history():
-    df = make_synthetic_ohlcv(n=10, seed=3)  # far too short for a 50-period SMA
-    feat = compute_indicators(df)
-    try:
-        warm_up_valid_from(feat)
-        raise AssertionError("expected ValueError for insufficient history")
-    except ValueError:
-        pass
-def test_warm_up_error_names_the_blocking_indicator_and_bar_counts():
-    """The message must be actionable (spec section 98), not just
-    "insufficient data" -- it should name sma_50 (the true bottleneck at
-    50 bars, longer than every other configured indicator period) and
-    state the actual bar counts involved, diagnosed empirically off the
-    real computed columns rather than a hand-derived formula."""
-    df = make_synthetic_ohlcv(n=10, seed=3)
-    feat = compute_indicators(df)
-    try:
-        warm_up_valid_from(feat)
-        raise AssertionError("expected ValueError for insufficient history")
-    except ValueError as e:
-        msg = str(e)
-        assert "sma_50" in msg, msg
-        assert "10" in msg, "should mention the 10 bars actually available"
-    # A frame with SOME but not all indicators warmed up should name only
-    # the genuinely-blocking one(s), not every column that has ever had a
-    # NaN early on.
-    df2 = make_synthetic_ohlcv(n=30, seed=4)  # enough for rsi(14)/bb(20), not sma_50
-    feat2 = compute_indicators(df2)
-    try:
-        warm_up_valid_from(feat2)
-        raise AssertionError("expected ValueError for insufficient history")
-    except ValueError as e:
-        msg = str(e)
-        assert "sma_50" in msg, msg
-        assert "rsi" not in msg, f"rsi is already warmed up by bar 30, shouldn't be blamed: {msg}"
-def test_causal_resample_ohlc_correctness():
-    idx = pd.date_range("2024-01-01", periods=6, freq="5min", tz="UTC")
-    df = pd.DataFrame({
-        "open": [1, 2, 3, 4, 5, 6],
-        "high": [1.5, 2.5, 3.5, 4.5, 5.5, 6.5],
-        "low": [0.5, 1.5, 2.5, 3.5, 4.5, 5.5],
-        "close": [1.2, 2.2, 3.2, 4.2, 5.2, 6.2],
-        "volume": [10, 10, 10, 10, 10, 10],
-    }, index=idx)
-    out = causal_resample(df, "5m", "10m")
-    assert len(out) == 3, f"expected 3 complete 10m bars from 6 5m bars, got {len(out)}"
-    first = out.iloc[0]
-    assert first["open"] == 1
-    assert first["high"] == 2.5
-    assert first["low"] == 0.5
-    assert first["close"] == 2.2
-    assert first["volume"] == 20
-def test_causal_resample_drops_incomplete_trailing_bin():
-    idx = pd.date_range("2024-01-01", periods=5, freq="5min", tz="UTC")  # 2 full 10m bins + 1 partial
-    df = pd.DataFrame({
-        "open": range(5), "high": range(5), "low": range(5),
-        "close": range(5), "volume": [1] * 5,
-    }, index=idx).astype(float)
-    out = causal_resample(df, "5m", "10m")
-    assert len(out) == 2, f"the trailing partial bin must be dropped, got {len(out)} bins"
-def test_leakage_audit_catches_future_row():
-    idx = pd.date_range("2024-01-01", periods=5, freq="1h", tz="UTC")
-    df = pd.DataFrame({"close": range(5)}, index=idx)
-    origin = idx[2]
-    report_ok = audit_feature_frame(df.loc[:origin], origin)
-    assert report_ok["passed"] is True
-    try:
-        assert_no_future_rows(df, origin, "test_df")
-        raise AssertionError("expected LeakageError since df contains rows after origin")
-    except LeakageError:
-        pass
-    report_bad = audit_feature_frame(df, origin)
-    assert report_bad["passed"] is False
-    assert len(report_bad["violations"]) == 1