Delete files * with huggingface_hub

MERGE_NOTES.md

@@ -1,115 +0,0 @@
-# Merge notes — MAYTHOS engine integrated into Rinking_out
-
-This project is the result of merging the standalone `maythos_patched.py` decision
-engine into the Rinking_out forecasting dashboard. Rinking_out is the base project;
-MAYTHOS was refactored to live inside it as a first-class model. There is **one**
-project, one live signal generator, one backtester, and one model contract — no
-bridges, adapters, wrappers, or duplicate systems.
-
-## What MAYTHOS is vs. what Rinking_out was
-
-- **Rinking_out** forecasts the next *close price* with statistical / foundation
-  models (ARIMA, Auto-ARIMA, ARIMA-GARCH, Moirai, TimesFM). Every model returns a
-  numeric forecast series; direction is derived by comparing the forecast to the
-  last close.
-- **MAYTHOS** is a tick-driven decision engine. It ingests OHLCV candles one at a
-  time, maintains internal indicator/regime state, and emits a discrete
-  **BUY/SELL** decision with a confidence and rich market-state metadata. It does
-  **not** predict a price level.
-
-These are genuinely different output shapes, which is the central conflict the
-merge had to resolve (Rule 13).
-
-## Decision 1 — One unified model contract: `Signal` + `predict_signal`
-
-The two projects had conflicting model interfaces: Rinking_out models exposed
-`predict(history, horizon, features) -> list[float]`; MAYTHOS exposed
-`tick(candle) -> dict`. Gluing them with an adapter was disallowed and would have
-left two contracts. Instead the model layer was refactored to a single contract in
-`models/base_model.py`:
-
-- `Signal(direction, confidence, predicted_close=None, horizon=1, meta={})` is the
-  one value every model returns. `direction` is always `"up"`/`"down"`;
-  `predicted_close` is `None` for models that do not forecast a price.
-- `BaseModel` is abstract with the single required method `predict_signal(df, horizon, features)`.
-- `BaseForecastModel(BaseModel)` keeps the price-forecasting family: subclasses
-  still implement `predict(...) -> list[float]`, and the base class provides a
-  concrete `predict_signal` that runs `predict`, takes the last forecast value as
-  `predicted_close`, derives `direction`, and computes a confidence from the
-  forecast move relative to recent volatility (`_confidence_from_forecast`).
-
-So the ARIMA-family code path is unchanged in behaviour (it still forecasts prices
-via `predict`), but every model — including MAYTHOS — is now callable through the
-exact same `predict_signal` entry point. Nothing downstream needs to know which
-kind of model it holds.
-
-## Decision 2 — MAYTHOS as a native model, not a bolted-on engine
-
-The MAYTHOS engine was moved into the package at `models/maythos/engine.py` (the
-engine itself, `MAYTHOS`/`Candle`), with a thin `MaythosModel(BaseModel)` in
-`models/maythos/model.py` that:
-
-- converts a window of the standard Rinking_out OHLCV DataFrame into MAYTHOS
-  `Candle` objects (using the DataFrame's own timestamps, converted to UTC epoch
-  seconds), replays them through a fresh engine, and returns a `Signal`.
-- maps BUY -> `"up"`, SELL -> `"down"`, carries the engine's confidence, sets
-  `predicted_close=None` (MAYTHOS does not forecast a price), and surfaces the
-  engine's market-state fields (`market_state`, `regime_label`,
-  `execution_suitability`, etc.) in `Signal.meta`.
-
-MAYTHOS is registered in `models/registry.py` and added to `config.MODEL_NAMES`, so
-it automatically appears everywhere the app iterates models (Prediction tab,
-Backtest tab and its per-model verify-log sub-tabs, Live tab, and the CLI logger).
-No separate MAYTHOS UI, no special-casing at call sites.
-
-## Decision 3 — One backtester (Rule 10)
-
-There is a single backtesting system, `backtest/backtester.py`. It was refactored
-to drive models through `predict_signal` instead of `predict`, so it works for
-both price forecasters and MAYTHOS uniformly:
-
-- It passes the full OHLCV window (not just the close series) to `predict_signal`,
-  because MAYTHOS needs OHLCV; forecasters ignore the extra columns.
-- Direction accuracy is computed for every model. Price-error metrics (MAE/RMSE)
-  are computed only where `predicted_close` is present, so MAYTHOS rows carry a
-  `NaN` predicted price and its MAE/RMSE summarise as `None` — correct, not faked.
-- A `confidence` column was added to the per-candle results.
-
-## Decision 4 — One live signal generator (Rule 9)
-
-The live path previously existed twice: once inside `app.py` (`_check_live_impl`)
-and once inside `live_runner.py`, with subtly different logic. Both were deleted
-and replaced by a single implementation in `live/engine.py::poll_once`, which does
-the whole fetch -> verify-matured-predictions -> stage-new-prediction cycle via
-`predict_signal`. `app.py` and `live_runner.py` are now thin callers of it. The
-live log gained a `confidence` column.
-
-## Decision 5 — Single indicator period source
-
-MAYTHOS and Rinking_out both computed RSI/MACD/Bollinger with their own hard-coded
-periods. The periods now live once in `config.py` (`RSI_PERIOD`, `MACD_*`,
-`BB_PERIOD`, etc.) and are imported by both `indicators/indicators.py` and the
-MAYTHOS engine, so the two never drift. Column names (`RSI_14`, `SMA_20`, …) are
-unchanged so the feature pipeline and its tests are unaffected.
-
-## Error handling (Rule 7)
-
-No broad `except Exception: pass`. The live engine catches only the expected
-`DataFetchError` (transient Yahoo outage) and surfaces it as visible status text;
-unexpected errors propagate. Per-model failures in the Prediction/Backtest UIs are
-shown to the user as explicit "failed: …" messages rather than being swallowed.
-MAYTHOS's internal per-subengine fault isolation (it records faults to its
-diagnostics and keeps ticking rather than crashing a live feed) is an intentional,
-documented health mechanism of the engine, not error hiding — a single corrupt
-tick must not kill a long-running decision stream.
-
-## Dead / experimental code removed (Rules 3–5)
-
-While porting the engine, the standalone-only scaffolding was removed: the
-unused bounded-cache class and its tuning constants, and the `__main__` smoke
-test (its self-test was re-homed to `tests/test_maythos_engine.py`).
-
-## Dependencies
-
-MAYTHOS needs only `numpy`, which Rinking_out already required, so
-`requirements.txt` is unchanged.

README.md

@@ -1,10 +0,0 @@
----
-title: MythosLive
-emoji: 🚀
-colorFrom: blue
-colorTo: purple
-sdk: gradio
-sdk_version: 6.28.0
-app_file: app.py
-pinned: false
----

app.py

@@ -1,413 +0,0 @@
-import pandas as pd
-import plotly.graph_objects as go
-import gradio as gr
-from config import ALL_DEFAULT_SYMBOLS, CUSTOM_TIMEFRAMES, MODEL_NAMES
-from data.historical import get_historical, get_historical_with_features, DataFetchError
-from indicators.indicators import add_all_indicators, latest_signals
-from models.registry import get_model, fresh_model
-from backtest.backtester import run_all_models_backtest, run_comparison_backtest, BASELINE_LABEL, FEATURED_LABEL
-from utils.helpers import drop_forming_candle, future_index, infer_step
-from live.engine import make_empty_live_log, poll_once
-
-TIMEFRAME_CHOICES = list(CUSTOM_TIMEFRAMES.keys())
-DISCLAIMER = "**Educational / research project — not financial advice.** Forex and crypto trading carries substantial risk of loss."
-FEATURES_HELP = (
-    "**14-feature input** feeds each model Open/High/Low/Volume plus RSI, MACD (line/signal/hist), "
-    "Bollinger Bands (upper/lower), SMA†20, EMA†20, and Stochastic (%K/%D) — computed leak-free "
-    "(only data available at each prediction\u2019s own point in time) — in addition to the Close-price "
-    "series every model already uses. Off by default; this changes nothing about the original "
-    "Close-only behaviour unless you turn it on. See features/feature_pipeline.py for exactly "
-    "what\u2019s computed and how each model consumes it."
-)
-
-
-def make_candlestick_figure(df: pd.DataFrame, symbol: str, timeframe: str) -> go.Figure:
-    fig = go.Figure(
-        data=[
-            go.Candlestick(
-                x=df.index,
-                open=df["Open"],
-                high=df["High"],
-                low=df["Low"],
-                close=df["Close"],
-                name=symbol,
-            )
-        ]
-    )
-    if "SMA_20" in df:
-        fig.add_trace(go.Scatter(x=df.index, y=df["SMA_20"], name="SMA 20", line=dict(width=1)))
-    if "EMA_20" in df:
-        fig.add_trace(go.Scatter(x=df.index, y=df["EMA_20"], name="EMA 20", line=dict(width=1)))
-    if "BB_Upper" in df:
-        fig.add_trace(
-            go.Scatter(x=df.index, y=df["BB_Upper"], name="BB Upper", line=dict(width=1, dash="dot"))
-        )
-        fig.add_trace(
-            go.Scatter(x=df.index, y=df["BB_Lower"], name="BB Lower", line=dict(width=1, dash="dot"))
-        )
-    fig.update_layout(
-        title=f"{symbol} \u2014 {timeframe}",
-        xaxis_rangeslider_visible=False,
-        height=480,
-        margin=dict(l=10, r=10, t=40, b=10),
-    )
-    return fig
-
-
-def fetch_and_chart(symbol, timeframe, lookback_days):
-    try:
-        df = get_historical(symbol, timeframe, lookback_days=int(lookback_days))
-        df_ind = add_all_indicators(df)
-        fig = make_candlestick_figure(df_ind, symbol, timeframe)
-        signals = latest_signals(df_ind)
-        signal_rows = [[name, str(v["value"]), v["signal"]] for name, v in signals.items()]
-        status = f"Loaded {len(df)} candles for {symbol} ({timeframe})."
-        return fig, signal_rows, status
-    except DataFetchError as e:
-        return None, [], f"Data error: {e}"
-    except Exception as e:
-        return None, [], f"Unexpected error: {e}"
-
-
-def run_prediction(symbol, timeframe, selected_models, horizon, lookback_days, use_features):
-    if not selected_models:
-        return None, "Pick at least one model."
-    try:
-        df, features_df = get_historical_with_features(
-            symbol, timeframe, lookback_days=int(lookback_days), use_features=use_features
-        )
-    except Exception as e:
-        return None, f"Data error: {e}"
-    close = df["Close"]
-    horizon = int(horizon)
-    step = infer_step(df.index)
-    fig = go.Figure()
-    tail = close.iloc[-150:]
-    fig.add_trace(
-        go.Scatter(x=tail.index, y=tail.values, name="Actual Close", line=dict(color="#888888"))
-    )
-    mode_label = f" [{FEATURED_LABEL}]" if use_features else ""
-    summary_lines = []
-    for name in selected_models:
-        try:
-            model = get_model(name, symbol, timeframe, use_features=use_features)
-            signal = model.predict_signal(df, horizon=horizon, features=features_df)
-            direction = signal.direction.upper()
-            conf_pct = f"{signal.confidence * 100:.0f}%"
-            if hasattr(model, "predict"):
-                forecast = model.predict(close, horizon=horizon, features=features_df)
-                fc_index = future_index(df.index[-1], step, len(forecast))
-                fig.add_trace(
-                    go.Scatter(
-                        x=fc_index,
-                        y=forecast,
-                        name=f"{name}{mode_label} forecast",
-                        mode="lines+markers",
-                    )
-                )
-            if signal.predicted_close is not None:
-                summary_lines.append(
-                    f"**{name}**{mode_label} \u2014 next close (approx.) `{signal.predicted_close:.5f}` "
-                    f"({direction}, confidence {conf_pct})"
-                )
-            else:
-                state = signal.meta.get("market_state", "n/a")
-                execution = signal.meta.get("execution_suitability", "n/a")
-                summary_lines.append(
-                    f"**{name}**{mode_label} \u2014 next candle **{direction}** "
-                    f"(confidence {conf_pct}; market state: {state}; execution: {execution})"
-                )
-        except Exception as e:
-            summary_lines.append(f"**{name}**{mode_label} \u2014 failed: {e}")
-    fig.update_layout(
-        title=f"{symbol} \u2014 {timeframe} forecast ({horizon} candle(s) ahead)",
-        height=450,
-        margin=dict(l=10, r=10, t=40, b=10),
-    )
-    return fig, "\n\n".join(summary_lines) + "\n\n" + DISCLAIMER
-
-
-FEATURE_MODE_BASELINE = "Close-only (baseline)"
-FEATURE_MODE_FEATURED = "+14-feature input"
-FEATURE_MODE_COMPARE = "Compare both"
-
-
-def _summary_row(summary: dict, mode_label: str) -> list:
-    return [
-        mode_label,
-        summary["model"],
-        summary["total_predictions"],
-        summary["correct"],
-        summary["incorrect"],
-        f"{summary['accuracy_pct']}%",
-        summary["mae"],
-        summary["rmse"],
-        summary["failed_predictions"],
-    ]
-
-
-def _backtest_return(summary_table, detail, status):
-    return (summary_table, *[detail[name] for name in MODEL_NAMES], status)
-
-
-def run_backtest_ui(
-    symbol,
-    timeframe,
-    selected_models,
-    window,
-    horizon,
-    step_size,
-    lookback_days,
-    feature_mode,
-):
-    empty = pd.DataFrame()
-    detail = {name: empty for name in MODEL_NAMES}
-    if not selected_models:
-        return _backtest_return([], detail, "Pick at least one model.")
-    needs_features = feature_mode != FEATURE_MODE_BASELINE
-    try:
-        df, features_df = get_historical_with_features(
-            symbol, timeframe, lookback_days=int(lookback_days), use_features=needs_features
-        )
-    except Exception as e:
-        return _backtest_return([], detail, f"Data error: {e}")
-    df, features_df = drop_forming_candle(df, features_df)
-    window, horizon, step_size = int(window), int(horizon), int(step_size)
-    if len(df) < window + horizon + 5:
-        return _backtest_return(
-            [],
-            detail,
-            f"Only {len(df)} candles available \u2014 raise \u2018Backtest lookback (days)\u2019 or lower the window size to backtest this symbol/timeframe.",
-        )
-    summary_table = []
-    if feature_mode == FEATURE_MODE_COMPARE:
-        models = {name: (fresh_model(name), fresh_model(name)) for name in selected_models}
-        try:
-            per_model_results, per_model_summaries = run_comparison_backtest(
-                df, models, features_df, window=window, horizon=horizon, step=step_size
-            )
-        except Exception as e:
-            return _backtest_return([], detail, f"Backtest error: {e}")
-        for name in selected_models:
-            for summary in per_model_summaries[name]:
-                summary_table.append(_summary_row(summary, summary["mode"]))
-            detail[name] = per_model_results[name]
-    else:
-        use_features = feature_mode == FEATURE_MODE_FEATURED
-        mode_label = FEATURED_LABEL if use_features else BASELINE_LABEL
-        models = {name: fresh_model(name) for name in selected_models}
-        try:
-            per_model_results, per_model_summaries = run_all_models_backtest(
-                df,
-                models,
-                window=window,
-                horizon=horizon,
-                step=step_size,
-                features_df=features_df if use_features else None,
-            )
-        except Exception as e:
-            return _backtest_return([], detail, f"Backtest error: {e}")
-        for name in selected_models:
-            summary_table.append(_summary_row(per_model_summaries[name], mode_label))
-            results = per_model_results[name].copy()
-            results.insert(0, "mode", mode_label)
-            detail[name] = results
-    status = (
-        f"Backtested {', '.join(selected_models)} on {len(df)} candles of "
-        f"{symbol} ({timeframe}) \u2014 mode: {feature_mode}."
-    )
-    return _backtest_return(summary_table, detail, status)
-
-
-def check_live(symbol, timeframe, model_name, log_df, use_features=False):
-    """Thin dashboard wrapper over the single live engine (live.engine.poll_once).
-
-    Only :class:`DataFetchError` is caught here \u2014 it is the expected transient
-    condition when Yahoo is briefly unreachable \u2014 and it is surfaced to the user
-    as visible status text. Any other error propagates instead of being hidden.
-    """
-    if log_df is None or len(log_df) == 0:
-        log_df = make_empty_live_log()
-    try:
-        status, updated = poll_once(
-            symbol, timeframe, model_name, log_df, use_features=use_features
-        )
-        return status, updated.tail(20), updated
-    except DataFetchError as e:
-        return f"Data error: {e}", log_df.tail(20), log_df
-
-
-with gr.Blocks(title="Forex & Crypto Prediction Dashboard") as demo:
-    gr.Markdown(
-        "# \U0001f4c8 Forex & Crypto Prediction Dashboard\n"
-        "ARIMA, Auto-ARIMA, ARIMA-GARCH, Moirai (Salesforce), TimesFM (Google) & MAYTHOS \u2014 "
-        "each model\u2019s accuracy is tracked and shown **separately**, never averaged together.\n\n"
-        + DISCLAIMER
-    )
-    with gr.Tab("\U0001f4ca Chart & Indicators"):
-        with gr.Row():
-            symbol_in1 = gr.Dropdown(
-                choices=ALL_DEFAULT_SYMBOLS,
-                value="EURUSD=X",
-                allow_custom_value=True,
-                label="Symbol",
-            )
-            timeframe_in1 = gr.Dropdown(
-                choices=TIMEFRAME_CHOICES, value="15m", label="Timeframe"
-            )
-            lookback_in1 = gr.Slider(1, 60, value=5, step=1, label="Lookback (days)")
-        fetch_btn = gr.Button("Fetch & Analyze", variant="primary")
-        chart_out1 = gr.Plot()
-        signals_out = gr.Dataframe(
-            headers=["Indicator", "Value", "Signal"],
-            label="Top 5 Indicators (latest reading)",
-        )
-        status_out1 = gr.Markdown()
-        fetch_btn.click(
-            fetch_and_chart,
-            [symbol_in1, timeframe_in1, lookback_in1],
-            [chart_out1, signals_out, status_out1],
-        )
-    with gr.Tab("\U0001f52e Prediction"):
-        with gr.Row():
-            symbol_in2 = gr.Dropdown(
-                choices=ALL_DEFAULT_SYMBOLS,
-                value="BTC-USD",
-                allow_custom_value=True,
-                label="Symbol",
-            )
-            timeframe_in2 = gr.Dropdown(
-                choices=TIMEFRAME_CHOICES, value="15m", label="Timeframe"
-            )
-        with gr.Row():
-            models_in2 = gr.CheckboxGroup(
-                choices=MODEL_NAMES, value=["ARIMA"], label="Models"
-            )
-            horizon_in2 = gr.Slider(1, 10, value=1, step=1, label="Candles ahead")
-            lookback_in2 = gr.Slider(1, 60, value=5, step=1, label="Lookback (days)")
-        use_features_in2 = gr.Checkbox(
-            value=False,
-            label="Use 14-feature input (Open/High/Low/Volume + RSI/MACD/Bollinger/SMA/EMA/Stochastic)",
-        )
-        gr.Markdown(
-            "Moirai and TimesFM download pretrained weights the first time you use them "
-            "(needs internet on the Space; a few hundred MB each, one-time download)."
-        )
-        predict_btn = gr.Button("Predict", variant="primary")
-        chart_out2 = gr.Plot()
-        summary_out2 = gr.Markdown()
-        predict_btn.click(
-            run_prediction,
-            [symbol_in2, timeframe_in2, models_in2, horizon_in2, lookback_in2, use_features_in2],
-            [chart_out2, summary_out2],
-        )
-    with gr.Tab("\U0001f9ea Backtest"):
-        gr.Markdown(
-            "Each model\u2019s accuracy is computed and shown **separately** below \u2014 results are "
-            "never averaged together. Raise **Step** to speed up Moirai/TimesFM (slower per-prediction "
-            "than ARIMA on CPU-only hardware).\n\n" + FEATURES_HELP
-        )
-        with gr.Row():
-            symbol_in3 = gr.Dropdown(
-                choices=ALL_DEFAULT_SYMBOLS,
-                value="EURUSD=X",
-                allow_custom_value=True,
-                label="Symbol",
-            )
-            timeframe_in3 = gr.Dropdown(
-                choices=TIMEFRAME_CHOICES, value="15m", label="Timeframe"
-            )
-        with gr.Row():
-            models_in3 = gr.CheckboxGroup(
-                choices=MODEL_NAMES, value=["ARIMA"], label="Models to backtest"
-            )
-            window_in3 = gr.Slider(
-                20, 300, value=60, step=10, label="History window per prediction"
-            )
-            horizon_in3 = gr.Slider(1, 5, value=1, step=1, label="Horizon (candles ahead)")
-        with gr.Row():
-            step_in3 = gr.Slider(
-                1, 20, value=1, step=1, label="Step (skip candles between tests)"
-            )
-            lookback_in3 = gr.Slider(
-                1, 60, value=10, step=1, label="Backtest lookback (days)"
-            )
-        feature_mode_in3 = gr.Radio(
-            choices=[FEATURE_MODE_BASELINE, FEATURE_MODE_FEATURED, FEATURE_MODE_COMPARE],
-            value=FEATURE_MODE_BASELINE,
-            label="Feature mode",
-            info=(
-                "\u2018Compare both\u2019 runs every selected model twice \u2014 Close-only and +14-feature "
-                "\u2014 on the identical symbol/timeframe/window/horizon/step/period, so you can see "
-                "whether the extra features actually helped."
-            ),
-        )
-        backtest_btn = gr.Button("Run Backtest", variant="primary")
-        summary_out3 = gr.Dataframe(
-            headers=["Mode", "Model", "Total", "Correct", "Incorrect", "Accuracy", "MAE", "RMSE", "Failed"],
-            label="Per-model accuracy \u2014 kept separate, never mixed",
-        )
-        status_out3 = gr.Markdown()
-        detail_outputs = []
-        with gr.Tabs():
-            for _model_name in MODEL_NAMES:
-                with gr.Tab(f"{_model_name} \u2014 verify log"):
-                    detail_outputs.append(
-                        gr.Dataframe(
-                            label="Per-candle: predicted vs actual, correct/incorrect"
-                        )
-                    )
-        backtest_btn.click(
-            run_backtest_ui,
-            [
-                symbol_in3,
-                timeframe_in3,
-                models_in3,
-                window_in3,
-                horizon_in3,
-                step_in3,
-                lookback_in3,
-                feature_mode_in3,
-            ],
-            [summary_out3, *detail_outputs, status_out3],
-        )
-    with gr.Tab("\U0001f4e1 Live"):
-        gr.Markdown(
-            "Polls Yahoo Finance for the newest candle each time you click the button, predicts "
-            "the next one, and verifies the previous prediction once that candle has closed. "
-            "For continuous background logging run `python live_runner.py --symbol BTC-USD "
-            "--timeframe 5m --model ARIMA` from the project directory."
-        )
-        with gr.Row():
-            symbol_in4 = gr.Dropdown(
-                choices=ALL_DEFAULT_SYMBOLS,
-                value="BTC-USD",
-                allow_custom_value=True,
-                label="Symbol",
-            )
-            timeframe_in4 = gr.Dropdown(
-                choices=TIMEFRAME_CHOICES, value="5m", label="Timeframe"
-            )
-            model_in4 = gr.Dropdown(choices=MODEL_NAMES, value="ARIMA", label="Model")
-        use_features_in4 = gr.Checkbox(
-            value=False,
-            label="Use 14-feature input",
-            info=(
-                "Uses the exact same feature-generation pipeline as the Backtest tab. "
-                "Toggling this mid-session keeps both modes\u2019 predictions in the log below, "
-                "but running accuracy is always computed for the current mode only."
-            ),
-        )
-        live_btn = gr.Button("\U0001f504 Check Latest & Predict Next", variant="primary")
-        live_log_state = gr.State(make_empty_live_log())
-        live_status = gr.Markdown()
-        live_table = gr.Dataframe(label="Live verification log (this model, this session)")
-        live_btn.click(
-            check_live,
-            [symbol_in4, timeframe_in4, model_in4, live_log_state, use_features_in4],
-            [live_status, live_table, live_log_state],
-        )
-    gr.Markdown("---\n" + DISCLAIMER)
-
-if __name__ == "__main__":
-    demo.launch()

backtest/__init__.py

@@ -1 +0,0 @@
-pass

backtest/backtester.py

@@ -1,178 +0,0 @@
-from math import floor, log10
-import numpy as np
-import pandas as pd
-from features.feature_pipeline import slice_features
-
-
-def _round_sig(x, sig: int = 6):
-    if x is None or not np.isfinite(x) or x == 0:
-        return x
-    decimals = sig - 1 - floor(log10(abs(x)))
-    return round(x, decimals)
-
-
-def backtest_model(
-    df: pd.DataFrame,
-    model,
-    window: int = 100,
-    horizon: int = 1,
-    step: int = 1,
-    features_df: pd.DataFrame = None,
-) -> pd.DataFrame:
-    close = df["Close"]
-    timestamps = [
-        ts.isoformat() if hasattr(ts, "isoformat") else ts for ts in df.index
-    ]
-    last_i = len(close) - horizon
-    rows = []
-    for i in range(window, last_i + 1, step):
-        window_df = df.iloc[i - window : i]
-        feature_window = (
-            slice_features(features_df, i - window, i)
-            if features_df is not None
-            else None
-        )
-        current_close = float(close.iloc[i - 1])
-        target_idx = i + horizon - 1
-        actual_next_close = float(close.iloc[target_idx])
-        try:
-            signal = model.predict_signal(
-                window_df, horizon=horizon, features=feature_window
-            )
-            predicted_direction = signal.direction
-            if predicted_direction not in ("up", "down"):
-                raise ValueError(
-                    f"invalid signal direction: {predicted_direction!r}"
-                )
-            confidence = float(signal.confidence)
-            if not np.isfinite(confidence):
-                raise ValueError(f"non-finite confidence: {confidence!r}")
-            predicted_close = signal.predicted_close
-            if predicted_close is not None:
-                predicted_close = float(predicted_close)
-                if not np.isfinite(predicted_close):
-                    raise ValueError(
-                        f"non-finite forecast value: {predicted_close!r}"
-                    )
-        except Exception as e:
-            rows.append(
-                {
-                    "datetime": timestamps[target_idx],
-                    "current_close": current_close,
-                    "predicted_close": np.nan,
-                    "confidence": np.nan,
-                    "actual_close": actual_next_close,
-                    "predicted_direction": None,
-                    "actual_direction": None,
-                    "correct": None,
-                    "error": str(e),
-                }
-            )
-            continue
-        actual_direction = "up" if actual_next_close > current_close else "down"
-        correct = predicted_direction == actual_direction
-        rows.append(
-            {
-                "datetime": timestamps[target_idx],
-                "current_close": current_close,
-                "predicted_close": predicted_close if predicted_close is not None else np.nan,
-                "confidence": confidence,
-                "actual_close": actual_next_close,
-                "predicted_direction": predicted_direction,
-                "actual_direction": actual_direction,
-                "correct": correct,
-                "error": None,
-            }
-        )
-    return pd.DataFrame(rows)
-
-
-def summarize_backtest(results: pd.DataFrame, model_name: str) -> dict:
-    if results.empty:
-        return {
-            "model": model_name,
-            "total_predictions": 0,
-            "correct": 0,
-            "incorrect": 0,
-            "accuracy_pct": 0.0,
-            "mae": None,
-            "rmse": None,
-            "failed_predictions": 0,
-        }
-    valid = results.dropna(subset=["correct"])
-    total = len(valid)
-    correct = int(valid["correct"].sum()) if total else 0
-    incorrect = total - correct
-    accuracy = round(100 * correct / total, 2) if total else 0.0
-    price_valid = results.dropna(subset=["predicted_close", "actual_close"])
-    if len(price_valid):
-        errors = price_valid["predicted_close"] - price_valid["actual_close"]
-        mae = float(np.mean(np.abs(errors)))
-        rmse = float(np.sqrt(np.mean(errors**2)))
-    else:
-        mae = rmse = None
-    failed = int(results["error"].notna().sum())
-    return {
-        "model": model_name,
-        "total_predictions": total,
-        "correct": correct,
-        "incorrect": incorrect,
-        "accuracy_pct": accuracy,
-        "mae": _round_sig(mae) if mae is not None else None,
-        "rmse": _round_sig(rmse) if rmse is not None else None,
-        "failed_predictions": failed,
-    }
-
-
-def run_all_models_backtest(
-    df: pd.DataFrame,
-    models: dict,
-    window: int = 100,
-    horizon: int = 1,
-    step: int = 1,
-    features_df: pd.DataFrame = None,
-):
-    per_model_results = {}
-    per_model_summary = {}
-    for name, model in models.items():
-        results = backtest_model(
-            df, model, window=window, horizon=horizon, step=step, features_df=features_df
-        )
-        per_model_results[name] = results
-        per_model_summary[name] = summarize_backtest(results, name)
-    return per_model_results, per_model_summary
-
-
-BASELINE_LABEL = "Close-only"
-FEATURED_LABEL = "+14 Features"
-
-
-def run_comparison_backtest(
-    df: pd.DataFrame,
-    models: dict,
-    features_df: pd.DataFrame,
-    window: int = 100,
-    horizon: int = 1,
-    step: int = 1,
-):
-    per_model_results = {}
-    per_model_summary = {}
-    for name, model_pair in models.items():
-        baseline_model, featured_model = model_pair
-        results_list, summary_list = [], []
-        for label, model, feats in (
-            (BASELINE_LABEL, baseline_model, None),
-            (FEATURED_LABEL, featured_model, features_df),
-        ):
-            results = backtest_model(
-                df, model, window=window, horizon=horizon, step=step, features_df=feats
-            )
-            summary = summarize_backtest(results, name)
-            summary["mode"] = label
-            results = results.copy()
-            results.insert(0, "mode", label)
-            results_list.append(results)
-            summary_list.append(summary)
-        per_model_results[name] = pd.concat(results_list, ignore_index=True)
-        per_model_summary[name] = summary_list
-    return per_model_results, per_model_summary

config.py

@@ -1,29 +0,0 @@
-import os
-BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-OUTPUT_DIR = os.path.join(BASE_DIR, 'outputs')
-os.makedirs(OUTPUT_DIR, exist_ok=True)
-DEFAULT_FOREX_SYMBOLS = ['EURUSD=X', 'GBPUSD=X', 'USDJPY=X', 'USDCHF=X', 'AUDUSD=X', 'USDCAD=X', 'NZDUSD=X', 'EURJPY=X', 'EURGBP=X', 'GBPJPY=X']
-DEFAULT_CRYPTO_SYMBOLS = ['BTC-USD', 'ETH-USD', 'BNB-USD', 'XRP-USD', 'SOL-USD', 'ADA-USD', 'DOGE-USD', 'DOT-USD', 'LTC-USD', 'LINK-USD']
-ALL_DEFAULT_SYMBOLS = DEFAULT_FOREX_SYMBOLS + DEFAULT_CRYPTO_SYMBOLS
-YF_NATIVE_INTERVALS = {'1m': {'max_days': 30, 'max_request_days': 7}, '2m': {'max_days': 60, 'max_request_days': 60}, '5m': {'max_days': 60, 'max_request_days': 60}, '15m': {'max_days': 60, 'max_request_days': 60}, '30m': {'max_days': 60, 'max_request_days': 60}, '60m': {'max_days': 730, 'max_request_days': 730}, '90m': {'max_days': 60, 'max_request_days': 60}, '1d': {'max_days': None, 'max_request_days': None}, '1wk': {'max_days': None, 'max_request_days': None}, '1mo': {'max_days': None, 'max_request_days': None}}
-CUSTOM_TIMEFRAMES = {'1m': {'source': '1m', 'rule': None}, '5m': {'source': '5m', 'rule': None}, '10m': {'source': '5m', 'rule': '10min'}, '15m': {'source': '15m', 'rule': None}, '30m': {'source': '30m', 'rule': None}, '1h': {'source': '60m', 'rule': None}, '4h': {'source': '60m', 'rule': '4h'}, '1d': {'source': '1d', 'rule': None}}
-MODEL_NAMES = ['ARIMA', 'Auto-ARIMA', 'ARIMA-GARCH', 'Moirai', 'TimesFM', 'MAYTHOS']
-
-# --- Indicator parameters (single source of truth) ---
-# Both the batch indicator pipeline (indicators/indicators.py + the feature
-# pipeline) and the MAYTHOS streaming technical engines (models/maythos/engine.py)
-# read their periods from here. Keeping one definition means the two computation
-# modes -- vectorised pandas indicators vs. tick-by-tick streaming indicators --
-# can never silently drift apart. See MERGE_NOTES.md (Decision 4).
-RSI_PERIOD = 14
-MACD_FAST = 12
-MACD_SLOW = 26
-MACD_SIGNAL = 9
-BB_PERIOD = 20
-BB_STD_DEV = 2.0
-SMA_PERIOD = 20
-EMA_PERIOD = 20
-STOCH_K_PERIOD = 14
-STOCH_D_PERIOD = 3
-MOIRAI_CHECKPOINT = 'Salesforce/moirai-1.1-R-small'
-TIMESFM_CHECKPOINT = 'google/timesfm-2.5-200m-pytorch'

data/__init__.py

@@ -1 +0,0 @@
-pass

data/historical.py

@@ -1,106 +0,0 @@
-import random
-import time
-from concurrent.futures import ThreadPoolExecutor, TimeoutError as _FuturesTimeout
-from datetime import datetime, timedelta, timezone
-import pandas as pd
-from config import YF_NATIVE_INTERVALS, CUSTOM_TIMEFRAMES
-from features.feature_pipeline import compute_feature_frame_for_period
-from utils.helpers import feature_warmup_days
-
-_YF_TIMEOUT_SECONDS = 30
-OHLCV_COLUMNS = ['Open', 'High', 'Low', 'Close', 'Volume']
-
-class DataFetchError(Exception):
-    pass
-
-def _fetch_yf(symbol: str, interval: str, start: datetime, end: datetime) -> pd.DataFrame:
-    import yfinance as yf
-    def _call():
-        return yf.Ticker(symbol).history(start=start, end=end, interval=interval)
-    with ThreadPoolExecutor(max_workers=1) as pool:
-        future = pool.submit(_call)
-        try:
-            return future.result(timeout=_YF_TIMEOUT_SECONDS)
-        except _FuturesTimeout:
-            future.cancel()
-            raise DataFetchError(
-                f"yfinance request for '{symbol}' interval='{interval}' timed out after "
-                f"{_YF_TIMEOUT_SECONDS}s. The market data provider may be temporarily unavailable."
-            )
-
-def _download_window(symbol: str, interval: str, start: datetime, end: datetime) -> pd.DataFrame:
-    df = _fetch_yf(symbol, interval, start, end)
-    if df is None or df.empty:
-        return pd.DataFrame()
-    df = df.rename(columns=str.title)
-    df.index.name = 'Datetime'
-    keep = [c for c in OHLCV_COLUMNS if c in df.columns]
-    return df[keep]
-
-def _finalize_ohlcv(df: pd.DataFrame) -> pd.DataFrame:
-    if df is None or df.empty:
-        return df
-    df = df.sort_index()
-    return df[~df.index.duplicated(keep='last')]
-
-def _native_fetch(symbol: str, interval: str, days: int) -> pd.DataFrame:
-    if interval not in YF_NATIVE_INTERVALS:
-        raise DataFetchError(f"'{interval}' is not a native yfinance interval.")
-    limits = YF_NATIVE_INTERVALS[interval]
-    max_days, request_days = (limits['max_days'], limits['max_request_days'])
-    if max_days is not None:
-        days = min(days, max_days)
-    if request_days is None:
-        request_days = days
-    frames = []
-    window_end = datetime.now(timezone.utc)
-    remaining = days
-    while remaining > 0:
-        window_days = min(request_days, remaining)
-        window_start = window_end - timedelta(days=window_days)
-        frame = _download_window(symbol, interval, window_start, window_end)
-        if not frame.empty:
-            frames.append(frame)
-        window_end = window_start
-        remaining -= window_days
-        if remaining > 0:
-            time.sleep(0.1 + random.uniform(0, 0.2))
-    df = _finalize_ohlcv(pd.concat(frames)) if frames else pd.DataFrame()
-    if df.empty or 'Close' not in df.columns:
-        limit_note = f" Yahoo keeps at most {max_days} days of '{interval}' history." if max_days is not None else ''
-        raise DataFetchError(f"No usable data returned for '{symbol}' at interval '{interval}' over the last {days} day(s). Check it's a valid yfinance ticker (e.g. EURUSD=X, BTC-USD) and that the market has traded recently." + limit_note)
-    return df
-
-def resample_ohlc(df: pd.DataFrame, rule: str) -> pd.DataFrame:
-    agg = {'Open': 'first', 'High': 'max', 'Low': 'min', 'Close': 'last', 'Volume': 'sum'}
-    agg = {k: v for k, v in agg.items() if k in df.columns}
-    price_cols = [c for c in ('Open', 'High', 'Low', 'Close') if c in agg]
-    return df.resample(rule).agg(agg).dropna(subset=price_cols)
-
-def get_historical(symbol: str, timeframe: str, lookback_days: int=None) -> pd.DataFrame:
-    if not symbol or not symbol.strip():
-        raise DataFetchError('No symbol given.')
-    symbol = symbol.strip()
-    if timeframe in CUSTOM_TIMEFRAMES:
-        spec = CUSTOM_TIMEFRAMES[timeframe]
-        source_interval, rule = (spec['source'], spec['rule'])
-    elif timeframe in YF_NATIVE_INTERVALS:
-        source_interval, rule = (timeframe, None)
-    else:
-        raise DataFetchError(f"Unknown timeframe '{timeframe}'. Valid options: {', '.join(CUSTOM_TIMEFRAMES.keys())}")
-    max_days = YF_NATIVE_INTERVALS[source_interval]['max_days']
-    requested = int(lookback_days) if lookback_days is not None else 0
-    days = requested if requested > 0 else max_days if max_days else 730
-    df = _native_fetch(symbol, source_interval, days)
-    if rule:
-        df = resample_ohlc(df, rule)
-        if df.empty:
-            raise DataFetchError(f"Not enough '{source_interval}' candles to build '{timeframe}' bars. Try a longer lookback.")
-    return df
-
-def get_historical_with_features(symbol: str, timeframe: str, lookback_days: int, use_features: bool):
-    if not use_features:
-        return (get_historical(symbol, timeframe, lookback_days=int(lookback_days)), None)
-    padding_days = feature_warmup_days(timeframe, minimum_days=0)
-    df_padded = get_historical(symbol, timeframe, lookback_days=int(lookback_days) + padding_days)
-    return compute_feature_frame_for_period(df_padded, keep_days=int(lookback_days))

features/__init__.py

@@ -1 +0,0 @@
-pass

features/feature_pipeline.py

@@ -1,43 +0,0 @@
-import numpy as np
-import pandas as pd
-from indicators.indicators import add_all_indicators
-REQUIRED_OHLCV_COLUMNS = ['Open', 'High', 'Low', 'Close', 'Volume']
-FEATURE_COLUMNS = ['Open', 'High', 'Low', 'Volume', 'RSI_14', 'MACD', 'MACD_Signal', 'MACD_Hist', 'BB_Upper', 'BB_Lower', 'SMA_20', 'EMA_20', 'Stoch_%K', 'Stoch_%D']
-
-def compute_feature_frame(df: pd.DataFrame) -> pd.DataFrame:
-    missing = [c for c in REQUIRED_OHLCV_COLUMNS if c not in df.columns]
-    if missing:
-        raise ValueError(f'compute_feature_frame needs an OHLCV DataFrame; missing column(s): {missing}.')
-    with_indicators = add_all_indicators(df)
-    return with_indicators[FEATURE_COLUMNS].reset_index(drop=True).astype(float)
-
-def slice_features(features: pd.DataFrame, start: int, end: int) -> pd.DataFrame:
-    return features.iloc[start:end].reset_index(drop=True)
-
-def compute_feature_frame_for_period(df_padded: pd.DataFrame, keep_days: float):
-    features_padded = compute_feature_frame(df_padded)
-    cutoff = df_padded.index[-1] - pd.Timedelta(days=keep_days)
-    positions = np.flatnonzero(df_padded.index >= cutoff)
-    complete = ~features_padded.isna().any(axis=1).to_numpy()
-    if complete.any():
-        positions = positions[positions >= int(np.argmax(complete))]
-    else:
-        positions = positions[:0]
-    if len(positions) == 0:
-        raise ValueError(f'No candle in the requested period has complete indicator values: only {len(df_padded)} candles were fetched, and the slowest indicator needs 20 candles of warm-up before the period starts. Increase the lookback (markets that close, e.g. forex over a weekend, need more calendar days to reach the same candle count).')
-    return (df_padded.iloc[positions], features_padded.iloc[positions].reset_index(drop=True))
-
-def validate_features(features: pd.DataFrame, expected_len: int, model_name: str, check_nan: bool=True) -> None:
-    if len(features) != expected_len:
-        raise ValueError(f'{model_name}: feature window has {len(features)} rows, expected {expected_len} to match the price history it must line up with.')
-    if check_nan and features.isna().any().any():
-        bad_cols = features.columns[features.isna().any()].tolist()
-        raise ValueError(f"{model_name}: feature window contains NaN in {bad_cols}. This usually means there isn't enough real history before this window for the slower indicators (SMA/Bollinger need 20 prior candles) to warm up on -- increase the lookback/history and try again.")
-
-def carry_forward_future(feature_window: pd.DataFrame, horizon: int) -> pd.DataFrame:
-    if horizon < 1:
-        raise ValueError('carry_forward_future: horizon must be >= 1.')
-    if len(feature_window) == 0:
-        raise ValueError('carry_forward_future: feature_window is empty.')
-    last_row = feature_window.iloc[[-1]]
-    return pd.concat([last_row] * horizon, ignore_index=True)

indicators/__init__.py

@@ -1 +0,0 @@
-pass

indicators/indicators.py

@@ -1,107 +0,0 @@
-import numpy as np
-import pandas as pd
-
-from config import (
-    RSI_PERIOD,
-    MACD_FAST,
-    MACD_SLOW,
-    MACD_SIGNAL,
-    BB_PERIOD,
-    BB_STD_DEV,
-    SMA_PERIOD,
-    EMA_PERIOD,
-    STOCH_K_PERIOD,
-    STOCH_D_PERIOD,
-)
-
-def sma(series: pd.Series, window: int) -> pd.Series:
-    return series.rolling(window=window).mean()
-
-def ema(series: pd.Series, window: int) -> pd.Series:
-    return series.ewm(span=window, adjust=False).mean()
-
-def _wilder_rma(values: pd.Series, window: int) -> pd.Series:
-    arr = values.to_numpy(dtype=float)
-    n = len(arr)
-    out = np.full(n, np.nan)
-    first_valid_pos = 0
-    while first_valid_pos < n and np.isnan(arr[first_valid_pos]):
-        first_valid_pos += 1
-    seed_end = first_valid_pos + window
-    if seed_end > n:
-        return pd.Series(out, index=values.index)
-    prev = arr[first_valid_pos:seed_end].mean()
-    out[seed_end - 1] = prev
-    for i in range(seed_end, n):
-        prev = (prev * (window - 1) + arr[i]) / window
-        out[i] = prev
-    return pd.Series(out, index=values.index)
-
-def rsi(series: pd.Series, window: int=14) -> pd.Series:
-    delta = series.diff()
-    gain = delta.clip(lower=0)
-    loss = -delta.clip(upper=0)
-    avg_gain = _wilder_rma(gain, window)
-    avg_loss = _wilder_rma(loss, window)
-    rs = avg_gain / avg_loss.replace(0, np.nan)
-    out = 100 - 100 / (1 + rs)
-    out = out.mask((avg_loss == 0) & (avg_gain > 0), 100.0)
-    return out.mask((avg_loss == 0) & (avg_gain == 0), 50.0)
-
-def macd(series: pd.Series, fast: int=12, slow: int=26, signal: int=9):
-    fast_ema = ema(series, fast)
-    slow_ema = ema(series, slow)
-    macd_line = fast_ema - slow_ema
-    signal_line = ema(macd_line, signal)
-    histogram = macd_line - signal_line
-    return (macd_line, signal_line, histogram)
-
-def bollinger_bands(series: pd.Series, window: int=20, num_std: float=2.0):
-    mid = sma(series, window)
-    std = series.rolling(window=window).std(ddof=0)
-    return (mid + num_std * std, mid, mid - num_std * std)
-
-def stochastic_oscillator(high: pd.Series, low: pd.Series, close: pd.Series, k_window: int=14, d_window: int=3):
-    lowest_low = low.rolling(window=k_window).min()
-    highest_high = high.rolling(window=k_window).max()
-    span = highest_high - lowest_low
-    percent_k = 100 * (close - lowest_low) / span.replace(0, np.nan)
-    percent_k = percent_k.mask(span == 0, 50.0)
-    percent_d = percent_k.rolling(window=d_window).mean()
-    return (percent_k, percent_d)
-
-def add_all_indicators(df: pd.DataFrame) -> pd.DataFrame:
-    out = df.copy()
-    out['SMA_20'] = sma(out['Close'], SMA_PERIOD)
-    out['EMA_20'] = ema(out['Close'], EMA_PERIOD)
-    out['RSI_14'] = rsi(out['Close'], RSI_PERIOD)
-    macd_line, signal_line, hist = macd(out['Close'], MACD_FAST, MACD_SLOW, MACD_SIGNAL)
-    out['MACD'] = macd_line
-    out['MACD_Signal'] = signal_line
-    out['MACD_Hist'] = hist
-    upper, mid, lower = bollinger_bands(out['Close'], BB_PERIOD, BB_STD_DEV)
-    out['BB_Upper'] = upper
-    out['BB_Mid'] = mid
-    out['BB_Lower'] = lower
-    k, d = stochastic_oscillator(out['High'], out['Low'], out['Close'], STOCH_K_PERIOD, STOCH_D_PERIOD)
-    out['Stoch_%K'] = k
-    out['Stoch_%D'] = d
-    return out
-
-def _round(value, digits):
-    return round(float(value), digits) if pd.notna(value) else 'n/a'
-
-def latest_signals(df_with_indicators: pd.DataFrame) -> dict:
-    last = df_with_indicators.iloc[-1]
-    signals = {}
-    rsi_value = last['RSI_14']
-    signals['RSI (14)'] = {'value': _round(rsi_value, 2), 'signal': 'Insufficient data' if pd.isna(rsi_value) else 'Overbought' if rsi_value > 70 else 'Oversold' if rsi_value < 30 else 'Neutral'}
-    macd_ready = pd.notna(last['MACD']) and pd.notna(last['MACD_Signal'])
-    signals['MACD'] = {'value': _round(last['MACD'], 5), 'signal': 'Insufficient data' if not macd_ready else 'Bullish (above signal)' if last['MACD'] > last['MACD_Signal'] else 'Bearish (below signal)'}
-    bb_ready = pd.notna(last['BB_Upper']) and pd.notna(last['BB_Lower'])
-    signals['Bollinger Bands'] = {'value': _round(last['Close'], 5), 'signal': 'Insufficient data' if not bb_ready else 'Above Upper Band' if last['Close'] > last['BB_Upper'] else 'Below Lower Band' if last['Close'] < last['BB_Lower'] else 'Inside Bands'}
-    sma_ready = pd.notna(last['SMA_20'])
-    signals['Moving Averages'] = {'value': f"SMA20={_round(last['SMA_20'], 5)}, EMA20={_round(last['EMA_20'], 5)}", 'signal': 'Insufficient data for SMA' if not sma_ready else 'Price Above MA (Uptrend)' if last['Close'] > last['SMA_20'] else 'Price Below MA (Downtrend)'}
-    stoch_value = last['Stoch_%K']
-    signals['Stochastic (14,3)'] = {'value': _round(stoch_value, 2), 'signal': 'Insufficient data' if pd.isna(stoch_value) else 'Overbought' if stoch_value > 80 else 'Oversold' if stoch_value < 20 else 'Neutral'}
-    return signals

live/__init__.py

@@ -1 +0,0 @@
-"""Unified live-prediction engine shared by the CLI logger and the dashboard."""

live/engine.py

@@ -1,182 +0,0 @@
-"""Single live-prediction engine used by both the dashboard and the CLI logger.
-
-There is exactly one live signal generator in the project (Rule 9). Both
-``app.py`` (the Live tab) and ``live_runner.py`` (the continuous CLI logger) call
-:func:`poll_once`, so the fetch -> verify -> predict cycle lives in one place and
-cannot drift. Every model is driven through the unified
-:meth:`~models.base_model.BaseModel.predict_signal` contract, so ARIMA-family
-forecasters and MAYTHOS behave identically here. See MERGE_NOTES.md (Decision 2).
-"""
-
-import os
-
-import numpy as np
-import pandas as pd
-
-from config import CUSTOM_TIMEFRAMES, OUTPUT_DIR, YF_NATIVE_INTERVALS
-from data.historical import get_historical_with_features
-from models.registry import get_model
-from utils.helpers import (
-    PREDICTION_HISTORY_CANDLES,
-    history_days_for_candles,
-    infer_step,
-)
-from backtest.backtester import BASELINE_LABEL, FEATURED_LABEL
-
-LIVE_COLUMNS = [
-    "predicted_at",
-    "mode",
-    "target_time",
-    "current_close",
-    "predicted_close",
-    "confidence",
-    "predicted_direction",
-    "actual_close",
-    "actual_direction",
-    "correct",
-]
-
-
-def make_empty_live_log() -> pd.DataFrame:
-    return pd.DataFrame(
-        {
-            "predicted_at": pd.Series(dtype="object"),
-            "mode": pd.Series(dtype="object"),
-            "target_time": pd.Series(dtype="object"),
-            "current_close": pd.Series(dtype="float64"),
-            "predicted_close": pd.Series(dtype="float64"),
-            "confidence": pd.Series(dtype="float64"),
-            "predicted_direction": pd.Series(dtype="object"),
-            "actual_close": pd.Series(dtype="float64"),
-            "actual_direction": pd.Series(dtype="object"),
-            "correct": pd.Series(dtype="object"),
-        }
-    )
-
-
-def live_log_path(symbol: str, timeframe: str, model_name: str, use_features: bool) -> str:
-    safe_symbol = symbol.replace("=", "_").replace("/", "_")
-    suffix = "_featured" if use_features else ""
-    return os.path.join(
-        OUTPUT_DIR, f"live_{safe_symbol}_{timeframe}_{model_name}{suffix}.csv"
-    )
-
-
-def _required_lookback_days(log_df, minimum_days: int = 2) -> int:
-    if log_df is None or len(log_df) == 0:
-        return minimum_days
-    pending = log_df[log_df["actual_close"].isna()]
-    if len(pending) == 0:
-        return minimum_days
-    oldest_target = pd.to_datetime(pending["target_time"], utc=True).min()
-    now = pd.Timestamp.now(tz="UTC")
-    age_days = (now - oldest_target).total_seconds() / 86400
-    return max(minimum_days, int(age_days) + 2)
-
-
-def _normalize_ts(ts_val, ref_index: pd.DatetimeIndex) -> pd.Timestamp:
-    ts = pd.Timestamp(ts_val)
-    if ref_index.tz is not None:
-        return ts.tz_convert("UTC") if ts.tzinfo is not None else ts.tz_localize("UTC")
-    return ts.tz_localize(None) if ts.tzinfo is not None else ts
-
-
-def poll_once(symbol, timeframe, model_name, log_df, use_features=False):
-    """Run one live cycle: verify matured predictions and stage a new one.
-
-    Returns ``(status, log_df)`` where ``log_df`` is the full, updated log. Raises
-    :class:`~data.historical.DataFetchError` on data problems so callers can
-    decide how to surface them; a failure to *predict* (e.g. not enough warm
-    candles yet) is reported visibly in ``status`` rather than silently dropped.
-    """
-    if log_df is None or len(log_df) == 0:
-        log_df = make_empty_live_log()
-    else:
-        log_df = log_df.copy()
-    source_interval = CUSTOM_TIMEFRAMES.get(timeframe, {}).get("source", timeframe)
-    max_servable_days = YF_NATIVE_INTERVALS.get(source_interval, {}).get("max_days")
-    wanted_days = max(
-        _required_lookback_days(log_df),
-        history_days_for_candles(timeframe, PREDICTION_HISTORY_CANDLES),
-    )
-    fetch_days = min(wanted_days, max_servable_days) if max_servable_days else wanted_days
-    df, features_df = get_historical_with_features(
-        symbol, timeframe, lookback_days=fetch_days, use_features=use_features
-    )
-    latest_time = df.index[-1]
-    latest_close = float(df["Close"].iloc[-1])
-
-    pending_mask = log_df["actual_close"].isna()
-    for idx, row in log_df[pending_mask].iterrows():
-        target = _normalize_ts(row["target_time"], df.index)
-        if target in df.index and target < latest_time:
-            actual_close = float(df.loc[target, "Close"])
-            actual_direction = "up" if actual_close > row["current_close"] else "down"
-            log_df.loc[idx, "actual_close"] = actual_close
-            log_df.loc[idx, "actual_direction"] = actual_direction
-            log_df.loc[idx, "correct"] = bool(actual_direction == row["predicted_direction"])
-
-    if max_servable_days is not None:
-        cutoff = pd.Timestamp.now(tz="UTC") - pd.Timedelta(days=max_servable_days)
-        target_times = pd.to_datetime(log_df["target_time"], utc=True)
-        unreachable = log_df["actual_close"].isna() & (target_times < cutoff)
-        if unreachable.any():
-            log_df.loc[unreachable, "actual_direction"] = "unresolvable (past history limit)"
-            log_df.loc[unreachable, "correct"] = None
-
-    current_mode = FEATURED_LABEL if use_features else BASELINE_LABEL
-    have_pending_for_latest = False
-    if len(log_df):
-        last_row = log_df.iloc[-1]
-        if pd.isna(last_row["actual_close"]) and last_row["mode"] == current_mode:
-            predicted_at_ts = _normalize_ts(last_row["predicted_at"], df.index)
-            have_pending_for_latest = predicted_at_ts == latest_time
-
-    status_extra = ""
-    if not have_pending_for_latest:
-        try:
-            model = get_model(model_name, symbol, timeframe, use_features=use_features)
-            signal = model.predict_signal(df, horizon=1, features=features_df)
-            predicted_close = (
-                float(signal.predicted_close)
-                if signal.predicted_close is not None
-                else np.nan
-            )
-            step = infer_step(df.index)
-            new_row = {
-                "predicted_at": latest_time.isoformat(),
-                "mode": current_mode,
-                "target_time": (latest_time + step).isoformat(),
-                "current_close": latest_close,
-                "predicted_close": predicted_close,
-                "confidence": float(signal.confidence),
-                "predicted_direction": signal.direction,
-                "actual_close": np.nan,
-                "actual_direction": None,
-                "correct": None,
-            }
-            log_df = pd.concat([log_df, pd.DataFrame([new_row])], ignore_index=True)
-        except (ValueError, ImportError) as e:
-            status_extra = f" (prediction failed: {e})"
-
-    verified = log_df.dropna(subset=["correct"])
-    verified_this_mode = verified[verified["mode"] == current_mode]
-    if len(verified_this_mode):
-        acc = round(100 * verified_this_mode["correct"].sum() / len(verified_this_mode), 2)
-        acc_text = (
-            f"Running accuracy for {model_name} [{current_mode}]: "
-            f"{acc}% ({int(verified_this_mode['correct'].sum())}/{len(verified_this_mode)})"
-        )
-        other_count = len(verified) - len(verified_this_mode)
-        if other_count:
-            acc_text += (
-                f" \u2014 {other_count} verified prediction(s) from the other mode are in "
-                f"the table below but not counted here."
-            )
-    else:
-        acc_text = "Collecting data \u2014 check again after the next candle closes to see accuracy."
-    status = (
-        f"Latest {symbol} candle: {latest_time} \u2014 Close {latest_close:.5f}. "
-        f"{acc_text}{status_extra}"
-    )
-    return status, log_df

live_runner.py

@@ -1,41 +0,0 @@
-import argparse
-import time
-from datetime import datetime, timezone
-
-from config import MODEL_NAMES
-from data.historical import DataFetchError
-from live.engine import make_empty_live_log, poll_once, live_log_path
-
-
-def main():
-    parser = argparse.ArgumentParser(description='Continuous live prediction logger.')
-    parser.add_argument('--symbol', required=True, help='e.g. BTC-USD, EURUSD=X')
-    parser.add_argument('--timeframe', required=True, help='e.g. 1m, 5m, 15m, 1h')
-    parser.add_argument('--model', required=True, choices=MODEL_NAMES)
-    parser.add_argument('--poll-seconds', type=int, default=60, help='How often to check for a new candle (default: 60s)')
-    parser.add_argument('--use-features', action='store_true', help='Feed OHLCV+RSI/MACD/Bollinger/SMA-EMA/Stochastic to the model (same leak-free pipeline as the Backtest tab), not just Close.')
-    args = parser.parse_args()
-
-    log_path = live_log_path(args.symbol, args.timeframe, args.model, args.use_features)
-    log_df = make_empty_live_log()
-    print(
-        f"[live_runner] {args.symbol} [{args.timeframe}] using {args.model}"
-        f"{(' (+14 features)' if args.use_features else '')}. Logging to {log_path}. Ctrl+C to stop."
-    )
-    try:
-        while True:
-            try:
-                status, log_df = poll_once(
-                    args.symbol, args.timeframe, args.model, log_df, use_features=args.use_features
-                )
-                print(f'[{datetime.now(timezone.utc).isoformat()}] {status}')
-                log_df.to_csv(log_path, index=False)
-            except DataFetchError as e:
-                print(f'[{datetime.now(timezone.utc).isoformat()}] Data error: {e}')
-            time.sleep(args.poll_seconds)
-    except KeyboardInterrupt:
-        print('Stopped.')
-
-
-if __name__ == '__main__':
-    main()

models/__init__.py

@@ -1 +0,0 @@
-pass

models/arima_garch_model.py

@@ -1,83 +0,0 @@
-import threading
-import numpy as np
-import pandas as pd
-from models.base_model import BaseForecastModel, validate_history_and_horizon
-from models.dependencies import import_arch_model, import_arima, quiet_fit
-from features.feature_pipeline import carry_forward_future, validate_features
-
-class ArimaGarchModel(BaseForecastModel):
-    name = 'ARIMA-GARCH'
-
-    def __init__(self, max_p=3, max_q=3, order=None, garch_p=1, garch_q=1, refit_order_every=None):
-        self.max_p = max_p
-        self.max_q = max_q
-        self._cached_order = order
-        self.garch_p = garch_p
-        self.garch_q = garch_q
-        self.refit_order_every = refit_order_every
-        self._calls_since_search = 0
-        self.last_volatility_forecast = None
-        self._lock = threading.Lock()
-
-    def _best_order(self, returns: pd.Series, exog: pd.DataFrame=None):
-        arima = import_arima(self.name)
-        best_aic = np.inf
-        best_order = (1, 0, 1)
-        with quiet_fit():
-            for p in range(self.max_p + 1):
-                for q in range(self.max_q + 1):
-                    if p == 0 and q == 0:
-                        continue
-                    try:
-                        fit = arima(returns, exog=exog, order=(p, 0, q)).fit()
-                    except Exception:
-                        continue
-                    if fit.aic < best_aic:
-                        best_aic = fit.aic
-                        best_order = (p, 0, q)
-        return best_order
-
-    def predict(self, history: pd.Series, horizon: int=1, features: pd.DataFrame=None) -> list:
-        with self._lock:
-            prices = pd.Series(history).astype(float).reset_index(drop=True)
-            if len(prices) < 30:
-                raise ValueError('ARIMA-GARCH needs at least 30 candles of history.')
-            validate_history_and_horizon(prices, horizon, self.name)
-            if (prices <= 0).any():
-                raise ValueError('ARIMA-GARCH needs strictly positive prices (it uses log returns).')
-            arima = import_arima(self.name)
-            arch_model = import_arch_model(self.name)
-            log_returns = np.log(prices / prices.shift(1)).dropna().reset_index(drop=True)
-            exog = None
-            if features is not None:
-                validate_features(features, expected_len=len(prices), model_name='ARIMA-GARCH')
-                exog = features.iloc[1:].reset_index(drop=True)
-            need_search = self._cached_order is None
-            if self.refit_order_every and self._calls_since_search >= self.refit_order_every:
-                need_search = True
-            if need_search:
-                self._cached_order = self._best_order(log_returns, exog=exog)
-                self._calls_since_search = 0
-            self._calls_since_search += 1
-            with quiet_fit():
-                mean_fit = arima(log_returns, exog=exog, order=self._cached_order).fit()
-                if exog is not None:
-                    future_exog = carry_forward_future(exog, horizon)
-                    mean_forecast = np.asarray(mean_fit.forecast(steps=horizon, exog=future_exog), dtype=float)
-                else:
-                    mean_forecast = np.asarray(mean_fit.forecast(steps=horizon), dtype=float)
-                resid = pd.Series(mean_fit.resid).dropna()
-                scale = 100.0
-                garch_fit = arch_model(resid * scale, mean='Zero', vol='GARCH', p=self.garch_p, q=self.garch_q, dist='normal', rescale=False).fit(disp='off')
-                garch_forecast = garch_fit.forecast(horizon=horizon, reindex=False)
-            variance = np.asarray(garch_forecast.variance.values[-1], dtype=float) / scale ** 2
-            self.last_volatility_forecast = [float(x) for x in np.sqrt(variance)]
-            last_price = float(prices.iloc[-1])
-            prices_out = []
-            cum_log_return = 0.0
-            for r in mean_forecast:
-                cum_log_return += float(r)
-                prices_out.append(last_price * float(np.exp(cum_log_return)))
-            if not all((np.isfinite(x) for x in prices_out)):
-                raise ValueError(f'ARIMA-GARCH produced a non-finite forecast for order {self._cached_order}.')
-            return prices_out

models/arima_model.py

@@ -1,66 +0,0 @@
-import threading
-import numpy as np
-import pandas as pd
-from models.base_model import BaseForecastModel, validate_history_and_horizon
-from models.dependencies import import_arima, quiet_fit
-from features.feature_pipeline import carry_forward_future, validate_features
-
-class ArimaModel(BaseForecastModel):
-    name = 'ARIMA'
-
-    def __init__(self, max_p=3, max_d=2, max_q=3, order=None, refit_order_every=None):
-        self.max_p = max_p
-        self.max_d = max_d
-        self.max_q = max_q
-        self._cached_order = order
-        self.refit_order_every = refit_order_every
-        self._calls_since_search = 0
-        self._lock = threading.Lock()
-
-    def _best_order(self, series: pd.Series, exog: pd.DataFrame=None):
-        arima = import_arima(self.name)
-        best_aic = np.inf
-        best_order = (1, 1, 1)
-        with quiet_fit():
-            for p in range(self.max_p + 1):
-                for d in range(self.max_d + 1):
-                    for q in range(self.max_q + 1):
-                        if p == 0 and q == 0:
-                            continue
-                        try:
-                            fit = arima(series, exog=exog, order=(p, d, q)).fit()
-                        except Exception:
-                            continue
-                        if fit.aic < best_aic:
-                            best_aic = fit.aic
-                            best_order = (p, d, q)
-        return best_order
-
-    def predict(self, history: pd.Series, horizon: int=1, features: pd.DataFrame=None) -> list:
-        with self._lock:
-            series = pd.Series(history).astype(float).reset_index(drop=True)
-            if len(series) < 20:
-                raise ValueError('ARIMA needs at least 20 candles of history.')
-            validate_history_and_horizon(series, horizon, self.name)
-            arima = import_arima(self.name)
-            exog = None
-            if features is not None:
-                validate_features(features, expected_len=len(series), model_name='ARIMA')
-                exog = features.reset_index(drop=True)
-            need_search = self._cached_order is None
-            if self.refit_order_every and self._calls_since_search >= self.refit_order_every:
-                need_search = True
-            if need_search:
-                self._cached_order = self._best_order(series, exog=exog)
-                self._calls_since_search = 0
-            self._calls_since_search += 1
-            with quiet_fit():
-                fit = arima(series, exog=exog, order=self._cached_order).fit()
-                if exog is not None:
-                    future_exog = carry_forward_future(exog, horizon)
-                    forecast = np.asarray(fit.forecast(steps=horizon, exog=future_exog), dtype=float)
-                else:
-                    forecast = np.asarray(fit.forecast(steps=horizon), dtype=float)
-            if not np.all(np.isfinite(forecast)):
-                raise ValueError(f'ARIMA produced a non-finite forecast for order {self._cached_order}.')
-            return [float(x) for x in forecast]

models/auto_arima_model.py

@@ -1,97 +0,0 @@
-import threading
-import numpy as np
-import pandas as pd
-from models.base_model import BaseForecastModel, validate_history_and_horizon
-from models.dependencies import import_arima, import_kpss, quiet_fit
-from features.feature_pipeline import carry_forward_future, validate_features
-
-class AutoArimaModel(BaseForecastModel):
-    name = 'Auto-ARIMA'
-
-    def __init__(self, max_p=5, max_q=5, max_d=2, order=None, refit_order_every=None):
-        self.max_p = max_p
-        self.max_q = max_q
-        self.max_d = max_d
-        self._cached_order = order
-        self.refit_order_every = refit_order_every
-        self._calls_since_search = 0
-        self._lock = threading.Lock()
-
-    def _find_d(self, series: pd.Series) -> int:
-        kpss = import_kpss(self.name)
-        s = series.copy()
-        d = 0
-        with quiet_fit():
-            while d < self.max_d:
-                try:
-                    _, p_value, _, _ = kpss(s, regression='c', nlags='auto')
-                except Exception:
-                    break
-                if p_value >= 0.05:
-                    break
-                s = s.diff().dropna()
-                d += 1
-        return d
-
-    def _aic(self, series: pd.Series, order, exog: pd.DataFrame=None) -> float:
-        arima = import_arima(self.name)
-        try:
-            return arima(series, exog=exog, order=order).fit().aic
-        except Exception:
-            return np.inf
-
-    def _stepwise_search(self, series: pd.Series, d: int, exog: pd.DataFrame=None):
-        starting_points = [(0, 0), (1, 0), (0, 1), (2, 2)]
-        best_order, best_aic = (None, np.inf)
-        with quiet_fit():
-            for p, q in starting_points:
-                if p > self.max_p or q > self.max_q:
-                    continue
-                aic = self._aic(series, (p, d, q), exog=exog)
-                if aic < best_aic:
-                    best_aic, best_order = (aic, (p, q))
-            if best_order is None:
-                best_order, best_aic = ((0, 0), self._aic(series, (0, d, 0), exog=exog))
-            improved = True
-            while improved:
-                improved = False
-                p0, q0 = best_order
-                for p, q in [(p0 + 1, q0), (p0 - 1, q0), (p0, q0 + 1), (p0, q0 - 1), (p0 + 1, q0 + 1), (p0 - 1, q0 - 1)]:
-                    if p < 0 or q < 0 or p > self.max_p or (q > self.max_q):
-                        continue
-                    aic = self._aic(series, (p, d, q), exog=exog)
-                    if aic < best_aic - 1e-06:
-                        best_aic, best_order = (aic, (p, q))
-                        improved = True
-        p, q = best_order
-        return (p, d, q)
-
-    def predict(self, history: pd.Series, horizon: int=1, features: pd.DataFrame=None) -> list:
-        with self._lock:
-            series = pd.Series(history).astype(float).reset_index(drop=True)
-            if len(series) < 20:
-                raise ValueError('Auto-ARIMA needs at least 20 candles of history.')
-            validate_history_and_horizon(series, horizon, self.name)
-            arima = import_arima(self.name)
-            exog = None
-            if features is not None:
-                validate_features(features, expected_len=len(series), model_name='Auto-ARIMA')
-                exog = features.reset_index(drop=True)
-            need_search = self._cached_order is None
-            if self.refit_order_every and self._calls_since_search >= self.refit_order_every:
-                need_search = True
-            if need_search:
-                d = self._find_d(series)
-                self._cached_order = self._stepwise_search(series, d, exog=exog)
-                self._calls_since_search = 0
-            self._calls_since_search += 1
-            with quiet_fit():
-                fit = arima(series, exog=exog, order=self._cached_order).fit()
-                if exog is not None:
-                    future_exog = carry_forward_future(exog, horizon)
-                    forecast = np.asarray(fit.forecast(steps=horizon, exog=future_exog), dtype=float)
-                else:
-                    forecast = np.asarray(fit.forecast(steps=horizon), dtype=float)
-            if not np.all(np.isfinite(forecast)):
-                raise ValueError(f'Auto-ARIMA produced a non-finite forecast for order {self._cached_order}.')
-            return [float(x) for x in forecast]

models/base_model.py

@@ -1,103 +0,0 @@
-import numpy as np
-import pandas as pd
-from abc import ABC, abstractmethod
-from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional, Union
-
-
-def validate_history_and_horizon(history, horizon: int, model_name: str) -> None:
-    if horizon < 1:
-        raise ValueError(f'{model_name}: horizon must be >= 1, got {horizon}.')
-    values = np.asarray(pd.Series(history).astype(float), dtype=float)
-    if not np.all(np.isfinite(values)):
-        raise ValueError(f'{model_name}: price history contains NaN/inf. This usually means a data glitch left a missing or malformed candle -- re-fetch the history and try again.')
-
-
-@dataclass
-class Signal:
-    """Unified prediction contract shared by every model in the project.
-
-    This is the single interface the backtester and the live engine consume, so
-    that price-forecasting models (ARIMA, Auto-ARIMA, ARIMA-GARCH, Moirai,
-    TimesFM) and the MAYTHOS decision engine are driven through exactly one code
-    path. See MERGE_NOTES.md (Decision 1).
-
-    Attributes:
-        direction: 'up' or 'down' -- the predicted move of the next close.
-        confidence: model confidence in [0, 1].
-        predicted_close: the forecast price for the final horizon step, or None
-            for models (like MAYTHOS) that emit a directional decision rather
-            than a price level.
-        horizon: number of steps ahead this signal describes.
-        meta: model-specific diagnostic fields (market state, execution
-            suitability, etc.). Empty for plain forecasters.
-    """
-    direction: str
-    confidence: float
-    predicted_close: Optional[float] = None
-    horizon: int = 1
-    meta: Dict[str, Any] = field(default_factory=dict)
-
-
-class BaseModel(ABC):
-    """Root of the model hierarchy. Every model produces a :class:`Signal`."""
-
-    name = 'base'
-
-    @abstractmethod
-    def predict_signal(self, window: pd.DataFrame, horizon: int = 1, features: pd.DataFrame = None) -> Signal:
-        raise NotImplementedError
-
-
-def _confidence_from_forecast(history: np.ndarray, predicted_close: float) -> float:
-    """Map a numeric forecast to a [0, 1] confidence for the unified Signal.
-
-    The size of the predicted move is compared against the recent realised
-    volatility (standard deviation of first differences). A move of two standard
-    deviations or more saturates confidence at 1.0. This is a documented,
-    deterministic heuristic so that forecast-only models still populate the same
-    confidence field MAYTHOS reports natively. See MERGE_NOTES.md (Decision 1).
-    """
-    arr = np.asarray(history, dtype=float)
-    current = float(arr[-1])
-    move = abs(float(predicted_close) - current)
-    diffs = np.diff(arr)
-    scale = float(np.std(diffs)) if diffs.size else 0.0
-    if scale <= 0.0:
-        return 1.0 if move > 0.0 else 0.0
-    return float(min(1.0, move / (2.0 * scale)))
-
-
-class BaseForecastModel(BaseModel):
-    """Base class for models that forecast a price path.
-
-    Subclasses implement :meth:`predict` (a list of future closes). The concrete
-    :meth:`predict_signal` here turns that path into the unified Signal, so every
-    forecaster automatically speaks the same contract as MAYTHOS without any
-    adapter or bridge layer.
-    """
-
-    name = 'base'
-
-    @abstractmethod
-    def predict(self, history: pd.Series, horizon: int = 1, features: pd.DataFrame = None) -> list:
-        raise NotImplementedError
-
-    @staticmethod
-    def _history_series(window: Union[pd.DataFrame, pd.Series, Any]) -> pd.Series:
-        if isinstance(window, pd.DataFrame):
-            if 'Close' not in window.columns:
-                raise ValueError("forecast window DataFrame must contain a 'Close' column.")
-            return window['Close']
-        return pd.Series(window)
-
-    def predict_signal(self, window: pd.DataFrame, horizon: int = 1, features: pd.DataFrame = None) -> Signal:
-        history = self._history_series(window)
-        forecast: List[float] = list(self.predict(history, horizon=horizon, features=features))
-        if len(forecast) < 1:
-            raise ValueError(f'{self.name}: predict() returned an empty forecast.')
-        predicted_close = float(forecast[-1])
-        current_close = float(pd.Series(history).astype(float).iloc[-1])
-        direction = 'up' if predicted_close > current_close else 'down'
-        confidence = _confidence_from_forecast(pd.Series(history).astype(float).to_numpy(), predicted_close)
-        return Signal(direction=direction, confidence=confidence, predicted_close=predicted_close, horizon=horizon, meta={})

models/dependencies.py

@@ -1,32 +0,0 @@
-import contextlib
-import warnings
-
-def _missing(package: str, model: str, error: Exception) -> ImportError:
-    return ImportError(f"{model} needs the '{package}' package. Install with:\n  pip install {package}\n(original error: {error})")
-
-def import_arima(model_name: str):
-    try:
-        from statsmodels.tsa.arima.model import ARIMA
-    except ImportError as e:
-        raise _missing('statsmodels', model_name, e) from e
-    return ARIMA
-
-def import_kpss(model_name: str):
-    try:
-        from statsmodels.tsa.stattools import kpss
-    except ImportError as e:
-        raise _missing('statsmodels', model_name, e) from e
-    return kpss
-
-def import_arch_model(model_name: str):
-    try:
-        from arch import arch_model
-    except ImportError as e:
-        raise _missing('arch', model_name, e) from e
-    return arch_model
-
-@contextlib.contextmanager
-def quiet_fit():
-    with warnings.catch_warnings():
-        warnings.simplefilter('ignore')
-        yield

models/maythos/__init__.py

@@ -1,10 +0,0 @@
-"""MAYTHOS decision-engine subpackage.
-
-Exposes the streaming engine (``MAYTHOS``, ``Candle``) and its model wrapper
-(``MaythosModel``) that plugs MAYTHOS into the unified model registry.
-"""
-
-from models.maythos.engine import MAYTHOS, Candle
-from models.maythos.model import MaythosModel
-
-__all__ = ['MAYTHOS', 'Candle', 'MaythosModel']

models/maythos/model.py

@@ -1,98 +0,0 @@
-"""MAYTHOS as a first-class model in the unified project.
-
-``MaythosModel`` wraps the streaming :class:`~models.maythos.engine.MAYTHOS`
-decision engine so it satisfies the same :class:`~models.base_model.BaseModel`
-contract as every forecasting model. It is registered in
-``models.registry`` exactly like ARIMA/Moirai/TimesFM -- it is a real model, not
-an adapter or bridge. See MERGE_NOTES.md (Decision 3).
-
-MAYTHOS consumes full OHLCV candles and replays the history window tick by tick
-through a fresh engine instance, mirroring how the ARIMA family refits on each
-backtest window. It emits a directional decision (BUY/SELL) plus a confidence
-and rich market-state metadata rather than a price level, so ``predicted_close``
-in the resulting :class:`~models.base_model.Signal` is ``None``.
-"""
-
-import numpy as np
-import pandas as pd
-
-from models.base_model import BaseModel, Signal, validate_history_and_horizon
-from models.maythos.engine import MAYTHOS, Candle
-
-_OHLC_COLUMNS = ('Open', 'High', 'Low', 'Close')
-
-
-def _epoch_seconds(index: pd.Index) -> np.ndarray:
-    """Return monotonically increasing UTC epoch-seconds for a candle index.
-
-    MAYTHOS uses timestamps only for gap/interval/latency reasoning, so any
-    strictly increasing, evenly spaced sequence preserves its behaviour. A real
-    DatetimeIndex is converted faithfully; a non-datetime index falls back to a
-    one-minute synthetic cadence.
-    """
-    if isinstance(index, pd.DatetimeIndex):
-        idx = index.tz_convert('UTC') if index.tz is not None else index
-        nanos = idx.astype('int64').to_numpy()
-        return nanos.astype('float64') / 1e9
-    return np.arange(len(index), dtype='float64') * 60.0
-
-
-class MaythosModel(BaseModel):
-    name = 'MAYTHOS'
-
-    def predict_signal(self, window: pd.DataFrame, horizon: int = 1, features: pd.DataFrame = None) -> Signal:
-        if not isinstance(window, pd.DataFrame):
-            raise ValueError('MAYTHOS requires an OHLCV DataFrame window, not a bare series.')
-        missing = [col for col in _OHLC_COLUMNS if col not in window.columns]
-        if missing:
-            raise ValueError(f"MAYTHOS requires OHLC columns; missing {missing} in the history window.")
-        validate_history_and_horizon(window['Close'], horizon, self.name)
-
-        timestamps = _epoch_seconds(window.index)
-        opens = window['Open'].to_numpy(dtype=float)
-        highs = window['High'].to_numpy(dtype=float)
-        lows = window['Low'].to_numpy(dtype=float)
-        closes = window['Close'].to_numpy(dtype=float)
-        if 'Volume' in window.columns:
-            volumes = window['Volume'].to_numpy(dtype=float)
-        else:
-            volumes = np.zeros(len(window), dtype=float)
-
-        engine = MAYTHOS()
-        output = None
-        for k in range(len(window)):
-            candle = Candle(
-                timestamp=float(timestamps[k]),
-                open=float(opens[k]),
-                high=float(highs[k]),
-                low=float(lows[k]),
-                close=float(closes[k]),
-                volume=float(volumes[k]),
-            )
-            output = engine.tick(candle)
-
-        if output is None:
-            raise ValueError('MAYTHOS received an empty history window.')
-        errors = engine.validate(output)
-        if errors:
-            raise ValueError(f'MAYTHOS produced invalid output: {errors}')
-
-        direction = 'up' if output['direction'] == 'BUY' else 'down'
-        confidence = float(output['confidence'])
-        meta = {
-            'execution_suitability': output.get('execution_suitability'),
-            'market_state': output.get('market_state'),
-            'regime_label': output.get('regime_label'),
-            'asset_mode': output.get('asset_mode'),
-            'internal_trust': output.get('internal_trust'),
-            'reason_summary': output.get('reason_summary'),
-            'is_warm': engine.is_warm,
-            'raw_direction': output['direction'],
-        }
-        return Signal(
-            direction=direction,
-            confidence=confidence,
-            predicted_close=None,
-            horizon=horizon,
-            meta=meta,
-        )

models/moirai_model.py

@@ -1,103 +0,0 @@
-import numpy as np
-import pandas as pd
-from models.base_model import BaseForecastModel, validate_history_and_horizon
-from config import MOIRAI_CHECKPOINT
-from features.feature_pipeline import validate_features
-
-
-def _step_from_history(history: pd.Series) -> pd.Timedelta:
-    if isinstance(history.index, pd.DatetimeIndex) and len(history.index) >= 2:
-        diffs = history.index.to_series().diff().dropna()
-        if not diffs.empty:
-            step = diffs.median()
-            if step > pd.Timedelta(0):
-                return step
-    return pd.Timedelta(minutes=1)
-
-
-class MoiraiModel(BaseForecastModel):
-    name = "Moirai"
-
-    def __init__(
-        self,
-        checkpoint: str = MOIRAI_CHECKPOINT,
-        context_length: int = 200,
-        num_samples: int = 100,
-    ):
-        self.checkpoint = checkpoint
-        self.context_length = context_length
-        self.num_samples = num_samples
-        self._module = None
-
-    def _get_module(self):
-        from uni2ts.model.moirai import MoiraiModule
-
-        if self._module is None:
-            self._module = MoiraiModule.from_pretrained(self.checkpoint)
-        return self._module
-
-    def predict(
-        self, history: pd.Series, horizon: int = 1, features: pd.DataFrame = None
-    ) -> list:
-        values = np.asarray(history, dtype=np.float32)
-        if len(values) < 10:
-            raise ValueError("Moirai needs at least 10 candles of history.")
-        validate_history_and_horizon(values, horizon, self.name)
-        try:
-            from uni2ts.model.moirai import MoiraiForecast
-            from gluonts.dataset.pandas import PandasDataset
-        except ImportError as e:
-            raise ImportError(
-                f"Moirai needs the 'uni2ts' and 'gluonts' packages. Install with:\n  pip install uni2ts torch\n(original error: {e})"
-            )
-        if features is not None:
-            validate_features(
-                features,
-                expected_len=len(values),
-                model_name="Moirai",
-                check_nan=False,
-            )
-        context = (
-            values[-self.context_length :]
-            if len(values) > self.context_length
-            else values
-        )
-        step = _step_from_history(history)
-        end_ts = pd.Timestamp.now("UTC").floor(step)
-        idx = pd.date_range(end=end_ts, periods=len(context), freq=step)
-        data = {"target": context}
-        feat_cols = []
-        if features is not None:
-            feat_context = features.iloc[-len(context) :].reset_index(drop=True)
-            validate_features(
-                feat_context, expected_len=len(context), model_name="Moirai"
-            )
-            for col in feat_context.columns:
-                data[col] = feat_context[col].to_numpy(dtype=np.float32)
-            feat_cols = list(feat_context.columns)
-        series_df = pd.DataFrame(data, index=idx)
-        dataset = PandasDataset(
-            series_df,
-            target="target",
-            past_feat_dynamic_real=feat_cols if feat_cols else None,
-        )
-        module = self._get_module()
-        forecaster = MoiraiForecast(
-            module=module,
-            prediction_length=horizon,
-            context_length=len(context),
-            patch_size="auto",
-            num_samples=self.num_samples,
-            target_dim=1,
-            feat_dynamic_real_dim=0,
-            past_feat_dynamic_real_dim=len(feat_cols),
-        )
-        predictor = forecaster.create_predictor(batch_size=1)
-        forecast = next(iter(predictor.predict(dataset)))
-        point_forecast = np.median(forecast.samples, axis=0)
-        out = [float(x) for x in point_forecast]
-        if not all(np.isfinite(x) for x in out):
-            raise ValueError(
-                "Moirai produced a non-finite forecast (NaN/inf) for this window."
-            )
-        return out

models/registry.py

@@ -1,42 +0,0 @@
-import threading
-from models.base_model import BaseModel
-_ORDER_SEARCH_MODELS = {'ARIMA', 'Auto-ARIMA', 'ARIMA-GARCH'}
-_CACHE: dict = {}
-_CACHE_LOCK = threading.Lock()
-
-def _build_model(name: str) -> BaseModel:
-    if name == 'ARIMA':
-        from models.arima_model import ArimaModel
-        return ArimaModel()
-    elif name == 'Auto-ARIMA':
-        from models.auto_arima_model import AutoArimaModel
-        return AutoArimaModel()
-    elif name == 'ARIMA-GARCH':
-        from models.arima_garch_model import ArimaGarchModel
-        return ArimaGarchModel()
-    elif name == 'Moirai':
-        from models.moirai_model import MoiraiModel
-        return MoiraiModel()
-    elif name == 'TimesFM':
-        from models.timesfm_model import TimesFMModel
-        return TimesFMModel()
-    elif name == 'MAYTHOS':
-        from models.maythos.model import MaythosModel
-        return MaythosModel()
-    raise ValueError(f"Unknown model '{name}'. Expected one of: ARIMA, Auto-ARIMA, ARIMA-GARCH, Moirai, TimesFM, MAYTHOS.")
-
-def get_model(name: str, symbol: str=None, timeframe: str=None, use_features: bool=False) -> BaseModel:
-    if name in _ORDER_SEARCH_MODELS:
-        variant = 'featured' if use_features else 'base'
-        key = (name, symbol, timeframe, variant)
-    else:
-        key = name
-    with _CACHE_LOCK:
-        if key in _CACHE:
-            return _CACHE[key]
-        model = _build_model(name)
-        _CACHE[key] = model
-        return model
-
-def fresh_model(name: str) -> BaseModel:
-    return _build_model(name)

models/timesfm_model.py

@@ -1,76 +0,0 @@
-import numpy as np
-import pandas as pd
-from models.base_model import BaseForecastModel, validate_history_and_horizon
-from config import TIMESFM_CHECKPOINT
-from features.feature_pipeline import carry_forward_future, validate_features
-_MAX_HORIZON = 64
-
-class TimesFMModel(BaseForecastModel):
-    name = 'TimesFM'
-
-    def __init__(self, checkpoint: str=TIMESFM_CHECKPOINT, max_context: int=512):
-        self.checkpoint = checkpoint
-        self.max_context = max_context
-        self._model = None
-        self._compiled_context = None
-
-    @staticmethod
-    def _forecast_config(max_context: int):
-        import timesfm
-        return timesfm.ForecastConfig(max_context=max_context, max_horizon=_MAX_HORIZON, normalize_inputs=True, use_continuous_quantile_head=True, force_flip_invariance=True, infer_is_positive=True, fix_quantile_crossing=True, return_backcast=True)
-
-    def _load(self):
-        import torch
-        import timesfm
-        if self._model is None:
-            torch.set_float32_matmul_precision('high')
-            model = timesfm.TimesFM_2p5_200M_torch.from_pretrained(self.checkpoint)
-            model.compile(self._forecast_config(self.max_context))
-            self._model = model
-            self._compiled_context = self.max_context
-        return self._model
-
-    def _ensure_compiled_for(self, context_len: int):
-        model = self._load()
-        patch = getattr(model.model, 'p', 32)
-        desired = min(self.max_context, max(patch, (context_len + patch - 1) // patch * patch))
-        if desired != self._compiled_context:
-            model.compile(self._forecast_config(desired))
-            self._compiled_context = desired
-        return model
-
-    def predict(self, history: pd.Series, horizon: int=1, features: pd.DataFrame=None) -> list:
-        values = np.asarray(history, dtype=np.float32)
-        if len(values) < 32:
-            raise ValueError('TimesFM needs at least 32 candles of history.')
-        validate_history_and_horizon(values, horizon, self.name)
-        try:
-            import timesfm
-        except ImportError as e:
-            raise ImportError(f"TimesFM needs the 'timesfm' package. Install with:\n  pip install timesfm[torch]\n(original error: {e})")
-        if horizon > _MAX_HORIZON:
-            raise ValueError(f'This TimesFM wrapper supports at most {_MAX_HORIZON} candles ahead.')
-        if features is not None:
-            validate_features(features, expected_len=len(values), model_name='TimesFM', check_nan=False)
-        context = values[-self.max_context:] if len(values) > self.max_context else values
-        model = self._ensure_compiled_for(len(context))
-        if features is None:
-            point_forecast, _quantiles = model.forecast(horizon=horizon, inputs=[context])
-            point_values = np.asarray(point_forecast[0])[-horizon:]
-        else:
-            feat_context = features.iloc[-len(context):].reset_index(drop=True)
-            validate_features(feat_context, expected_len=len(context), model_name='TimesFM')
-            feat_future = carry_forward_future(feat_context, horizon)
-            dynamic_numerical_covariates = {}
-            for col in feat_context.columns:
-                full_array = np.concatenate([feat_context[col].to_numpy(dtype=np.float32), feat_future[col].to_numpy(dtype=np.float32)])
-                dynamic_numerical_covariates[col] = [full_array]
-            try:
-                point_forecast, _quantiles = model.forecast_with_covariates(inputs=[context], dynamic_numerical_covariates=dynamic_numerical_covariates, xreg_mode='xreg + timesfm')
-                point_values = np.asarray(point_forecast[0])[:horizon]
-            except (ImportError, AttributeError) as e:
-                raise ImportError(f"TimesFM's covariate forecasting needs the 'xreg' extra (scikit-learn + JAX). Install with:\n  pip install timesfm[torch,xreg]\n(original error: {e})")
-        out = [float(x) for x in point_values]
-        if not all((np.isfinite(x) for x in out)):
-            raise ValueError('TimesFM returned a non-finite forecast (NaN/inf) for this window. This is usually a sign the input window is degenerate (e.g. a flat or near-constant price run) — try a different window size or symbol.')
-        return out

requirements.txt

@@ -1,14 +0,0 @@
---extra-index-url https://download.pytorch.org/whl/cpu
-pandas>=2.1
-numpy>=1.24
-yfinance>=0.2.40
-gradio>=4.36
-plotly>=5.20
-statsmodels>=0.14
-arch>=6.3
-uni2ts
-gluonts
-timesfm[torch,xreg]
-torch
-einops
-huggingface_hub

tests/__init__.py

@@ -1 +0,0 @@
-pass

tests/test_backtester_alignment.py

@@ -1,175 +0,0 @@
-import unittest
-import json
-import numpy as np
-import pandas as pd
-from backtest.backtester import backtest_model, run_all_models_backtest, run_comparison_backtest
-from features.feature_pipeline import FEATURE_COLUMNS, compute_feature_frame
-from models.base_model import BaseForecastModel
-
-def _synthetic_ohlcv(n: int, seed: int=7) -> pd.DataFrame:
-    rng = np.random.default_rng(seed)
-    steps = rng.normal(loc=0.0, scale=0.4, size=n)
-    close = 100 + np.cumsum(steps)
-    close = np.abs(close) + 5.0
-    open_ = close + rng.normal(0, 0.1, n)
-    high = np.maximum(open_, close) + np.abs(rng.normal(0, 0.2, n))
-    low = np.minimum(open_, close) - np.abs(rng.normal(0, 0.2, n))
-    volume = rng.integers(100, 10000, n).astype(float)
-    idx = pd.date_range('2024-01-01', periods=n, freq='min')
-    return pd.DataFrame({'Open': open_, 'High': high, 'Low': low, 'Close': close, 'Volume': volume}, index=idx)
-
-class _AlignmentCheckingModel(BaseForecastModel):
-    name = 'AlignmentChecker'
-    RAW_COLUMNS = ['Open', 'High', 'Low', 'Volume']
-
-    def __init__(self, df: pd.DataFrame):
-        self.full_close = df['Close'].reset_index(drop=True)
-        self.raw = df[self.RAW_COLUMNS].reset_index(drop=True)
-
-    def predict(self, history, horizon=1, features=None):
-        history = pd.Series(history).reset_index(drop=True)
-        if features is not None:
-            assert len(features) == len(history), f'length mismatch: history={len(history)} features={len(features)}'
-            assert list(features.columns) == FEATURE_COLUMNS
-        n = len(self.full_close)
-        w = len(history)
-        match_start = None
-        for start in range(0, n - w + 1):
-            if np.allclose(self.full_close.iloc[start:start + w].to_numpy(), history.to_numpy()):
-                match_start = start
-                break
-        assert match_start is not None, 'history window not found in full series -- corrupted slice'
-        if features is not None:
-            expected = self.raw.iloc[match_start:match_start + w].to_numpy()
-            got = features[self.RAW_COLUMNS].to_numpy()
-            assert np.allclose(got, expected), f'features window is shifted relative to history at position {match_start}'
-        return [float(history.iloc[-1])] * horizon
-
-class TestBacktesterAlignment(unittest.TestCase):
-
-    def setUp(self):
-        self.df = _synthetic_ohlcv(200, seed=11)
-        self.features_df = compute_feature_frame(self.df)
-
-    def test_no_failed_rows_with_features(self):
-        model = _AlignmentCheckingModel(self.df)
-        results = backtest_model(self.df, model, window=40, horizon=1, step=1, features_df=self.features_df)
-        failed = results['error'].notna().sum()
-        self.assertEqual(failed, 0, f"{failed} rows failed alignment checks:\n{results[results['error'].notna()]}")
-        self.assertGreater(len(results), 0)
-
-    def test_features_window_matches_close_window_exactly(self):
-        close = self.df['Close'].reset_index(drop=True)
-        window, horizon, step = (35, 2, 3)
-        last_i = len(close) - horizon
-        for i in range(window, last_i + 1, step):
-            expected_close_window = close.iloc[i - window:i].reset_index(drop=True)
-            expected_feat_window = self.features_df.iloc[i - window:i].reset_index(drop=True)
-            source_volume = self.df['Volume'].reset_index(drop=True).iloc[i - window:i].reset_index(drop=True)
-            pd.testing.assert_series_equal(expected_feat_window['Volume'], source_volume, check_names=False)
-            self.assertEqual(len(expected_close_window), len(expected_feat_window))
-
-    def test_baseline_mode_never_touches_features_module(self):
-
-        class RecordsFeatureArg(BaseForecastModel):
-            name = 'Recorder'
-            saw_features = []
-
-            def predict(self, history, horizon=1, features=None):
-                RecordsFeatureArg.saw_features.append(features)
-                return [float(pd.Series(history).iloc[-1])] * horizon
-        RecordsFeatureArg.saw_features.clear()
-        _ = backtest_model(self.df, RecordsFeatureArg(), window=40, horizon=1, step=5)
-        self.assertTrue(len(RecordsFeatureArg.saw_features) > 0)
-        self.assertTrue(all((f is None for f in RecordsFeatureArg.saw_features)))
-
-class TestRunAllModelsBacktestFeaturesDf(unittest.TestCase):
-
-    def setUp(self):
-        self.df = _synthetic_ohlcv(150, seed=13)
-        self.features_df = compute_feature_frame(self.df)
-
-    def test_features_df_none_passes_none_through(self):
-
-        class Recorder(BaseForecastModel):
-            name = 'Recorder'
-
-            def __init__(self):
-                self.seen = []
-
-            def predict(self, history, horizon=1, features=None):
-                self.seen.append(features is None)
-                return [float(pd.Series(history).iloc[-1])] * horizon
-        m = Recorder()
-        run_all_models_backtest(self.df, {'Recorder': m}, window=40, horizon=1, step=10, features_df=None)
-        self.assertTrue(all(m.seen))
-
-    def test_features_df_given_passes_dataframe_through(self):
-
-        class Recorder(BaseForecastModel):
-            name = 'Recorder'
-
-            def __init__(self):
-                self.seen = []
-
-            def predict(self, history, horizon=1, features=None):
-                self.seen.append(features is not None and len(features) == len(history))
-                return [float(pd.Series(history).iloc[-1])] * horizon
-        m = Recorder()
-        run_all_models_backtest(self.df, {'Recorder': m}, window=40, horizon=1, step=10, features_df=self.features_df)
-        self.assertTrue(len(m.seen) > 0)
-        self.assertTrue(all(m.seen))
-
-class TestRunComparisonBacktest(unittest.TestCase):
-
-    def setUp(self):
-        self.df = _synthetic_ohlcv(150, seed=17)
-        self.features_df = compute_feature_frame(self.df)
-
-    def test_both_modes_run_and_are_labeled_separately(self):
-
-        class Recorder(BaseForecastModel):
-            name = 'Recorder'
-
-            def __init__(self):
-                self.seen_features = []
-
-            def predict(self, history, horizon=1, features=None):
-                self.seen_features.append(features is not None)
-                return [float(pd.Series(history).iloc[-1])] * horizon
-        baseline_model, featured_model = (Recorder(), Recorder())
-        results, summaries = run_comparison_backtest(self.df, {'Recorder': (baseline_model, featured_model)}, self.features_df, window=40, horizon=1, step=10)
-        self.assertTrue(all((f is False for f in baseline_model.seen_features)))
-        self.assertTrue(all((f is True for f in featured_model.seen_features)))
-        modes_present = set(results['Recorder']['mode'].unique())
-        self.assertEqual(modes_present, {'Close-only', '+14 Features'})
-        self.assertEqual(len(summaries['Recorder']), 2)
-        labels = {s['mode'] for s in summaries['Recorder']}
-        self.assertEqual(labels, {'Close-only', '+14 Features'})
-
-class TestUiSerializableTimestamps(unittest.TestCase):
-
-    def test_backtest_results_json_serializable(self):
-        model = _ConstantModel()
-        results = backtest_model(self._ohlcv(), model, window=20, horizon=1, step=5)
-        self.assertEqual(results['datetime'].map(type).eq(str).all(), True)
-        json.dumps(results.to_dict(orient='records'))
-
-    def test_live_log_new_row_json_serializable(self):
-        row = {'predicted_at': pd.Timestamp('2026-01-01 00:00:00+00:00').isoformat(), 'mode': 'Close-only', 'target_time': pd.Timestamp('2026-01-01 00:01:00+00:00').isoformat(), 'current_close': 1.0, 'predicted_close': 1.0, 'predicted_direction': 'up', 'actual_close': np.nan, 'actual_direction': None, 'correct': None}
-        json.dumps(row)
-
-    @staticmethod
-    def _ohlcv(n: int=60, seed: int=3) -> pd.DataFrame:
-        rng = np.random.default_rng(seed)
-        close = 100 + np.cumsum(rng.normal(0, 0.5, n))
-        idx = pd.date_range('2026-01-01', periods=n, freq='15min', tz='UTC')
-        return pd.DataFrame({'Open': close, 'High': close + 1, 'Low': close - 1, 'Close': close, 'Volume': 1000.0}, index=idx)
-
-class _ConstantModel(BaseForecastModel):
-
-    def predict(self, history, horizon=1, features=None):
-        return np.array([float(history.iloc[-1])] * horizon)
-    name = 'ConstantModel'
-if __name__ == '__main__':
-    unittest.main()

tests/test_data_layer.py

@@ -1,191 +0,0 @@
-import math
-import unittest
-from datetime import timedelta
-from unittest import mock
-import numpy as np
-import pandas as pd
-from config import YF_NATIVE_INTERVALS
-from data.historical import OHLCV_COLUMNS, DataFetchError, get_historical, get_historical_with_features, resample_ohlc
-from features.feature_pipeline import FEATURE_COLUMNS
-
-def _window_candles(start, end, freq: str) -> pd.DataFrame:
-    idx = pd.date_range(start=start, end=end, freq=freq, inclusive='left')
-    if len(idx) == 0:
-        return pd.DataFrame()
-    n = len(idx)
-    base = 100.0 + np.arange(n, dtype=float) * 0.1
-    return pd.DataFrame({'Open': base, 'High': base + 0.5, 'Low': base - 0.5, 'Close': base + 0.2, 'Volume': np.arange(n, dtype=float) + 1.0, 'Dividends': np.zeros(n)}, index=idx)
-
-class _RecordingFetcher:
-
-    def __init__(self, freq: str='1h', empty_calls=()):
-        self.freq = freq
-        self.empty_calls = set(empty_calls)
-        self.calls = []
-        self.frames = []
-
-    def __call__(self, symbol, interval, start, end):
-        self.calls.append({'symbol': symbol, 'interval': interval, 'start': start, 'end': end})
-        if len(self.calls) in self.empty_calls:
-            return pd.DataFrame()
-        frame = _window_candles(start, end, self.freq)
-        self.frames.append(frame)
-        return frame
-
-    @property
-    def spans(self):
-        return [c['end'] - c['start'] for c in self.calls]
-
-    @property
-    def total_span(self):
-        return max((c['end'] for c in self.calls)) - min((c['start'] for c in self.calls))
-
-    def raw(self) -> pd.DataFrame:
-        return pd.concat(self.frames).sort_index()
-
-class TestLookbackIsHonored(unittest.TestCase):
-
-    def test_daily_lookback_requests_exactly_that_window(self):
-        fetcher = _RecordingFetcher(freq='1D')
-        with mock.patch('data.historical._fetch_yf', fetcher):
-            df = get_historical('BTC-USD', '1d', lookback_days=30)
-        self.assertEqual(len(fetcher.calls), 1)
-        self.assertEqual(fetcher.calls[0]['interval'], '1d')
-        self.assertEqual(fetcher.spans[0], timedelta(days=30))
-        self.assertLessEqual(len(df), 31)
-        self.assertGreater(len(df), 0)
-
-    def test_returned_frame_is_ordered_and_ohlcv_only(self):
-        fetcher = _RecordingFetcher(freq='1D')
-        with mock.patch('data.historical._fetch_yf', fetcher):
-            df = get_historical('BTC-USD', '1d', lookback_days=10)
-        self.assertEqual(list(df.columns), OHLCV_COLUMNS)
-        self.assertNotIn('Dividends', df.columns)
-        self.assertTrue(df.index.is_monotonic_increasing)
-        self.assertFalse(df.index.duplicated().any())
-
-    def test_no_lookback_falls_back_to_the_interval_limit(self):
-        fetcher = _RecordingFetcher(freq='1h')
-        with mock.patch('data.historical._fetch_yf', fetcher):
-            get_historical('BTC-USD', '60m')
-        self.assertEqual(fetcher.total_span, timedelta(days=YF_NATIVE_INTERVALS['60m']['max_days']))
-
-class TestChunkedFetching(unittest.TestCase):
-
-    def setUp(self):
-        self.limits = YF_NATIVE_INTERVALS['1m']
-
-    def test_window_wider_than_the_request_limit_is_split(self):
-        requested = 30
-        fetcher = _RecordingFetcher(freq='1h')
-        with mock.patch('data.historical._fetch_yf', fetcher):
-            df = get_historical('BTC-USD', '1m', lookback_days=requested)
-        request_days = self.limits['max_request_days']
-        self.assertEqual(len(fetcher.calls), math.ceil(requested / request_days))
-        for span in fetcher.spans:
-            self.assertLessEqual(span, timedelta(days=request_days))
-        self.assertEqual(sum(fetcher.spans, timedelta()), timedelta(days=requested))
-        self.assertEqual(fetcher.total_span, timedelta(days=requested))
-        self.assertGreater(len(df), 0)
-
-    def test_chunks_are_contiguous_with_no_gap_or_overlap(self):
-        fetcher = _RecordingFetcher(freq='1h')
-        with mock.patch('data.historical._fetch_yf', fetcher):
-            get_historical('BTC-USD', '1m', lookback_days=20)
-        for newer, older in zip(fetcher.calls, fetcher.calls[1:]):
-            self.assertEqual(newer['start'], older['end'])
-
-    def test_lookback_beyond_the_source_limit_is_clamped(self):
-        fetcher = _RecordingFetcher(freq='1h')
-        with mock.patch('data.historical._fetch_yf', fetcher):
-            get_historical('BTC-USD', '1m', lookback_days=90)
-        max_days = self.limits['max_days']
-        self.assertEqual(fetcher.total_span, timedelta(days=max_days))
-        self.assertEqual(len(fetcher.calls), math.ceil(max_days / self.limits['max_request_days']))
-
-    def test_one_empty_chunk_does_not_abort_the_fetch(self):
-        fetcher = _RecordingFetcher(freq='1h', empty_calls=(2,))
-        with mock.patch('data.historical._fetch_yf', fetcher):
-            df = get_historical('BTC-USD', '1m', lookback_days=30)
-        self.assertEqual(len(fetcher.calls), 5)
-        self.assertEqual(len(df), len(fetcher.raw()))
-        self.assertGreater(len(df), 0)
-
-    def test_all_chunks_empty_reports_the_source_limit(self):
-        fetcher = _RecordingFetcher(freq='1h', empty_calls=range(1, 6))
-        with mock.patch('data.historical._fetch_yf', fetcher):
-            with self.assertRaises(DataFetchError) as ctx:
-                get_historical('NOPE-USD', '1m', lookback_days=30)
-        message = str(ctx.exception)
-        self.assertIn('NOPE-USD', message)
-        self.assertIn('1m', message)
-        self.assertIn(str(self.limits['max_days']), message)
-
-class TestTimeframeValidation(unittest.TestCase):
-
-    def test_unknown_timeframe_raises_before_any_request(self):
-        fetcher = _RecordingFetcher()
-        with mock.patch('data.historical._fetch_yf', fetcher):
-            with self.assertRaises(DataFetchError):
-                get_historical('BTC-USD', '3y', lookback_days=5)
-        self.assertEqual(fetcher.calls, [])
-
-    def test_blank_symbol_raises_before_any_request(self):
-        fetcher = _RecordingFetcher()
-        with mock.patch('data.historical._fetch_yf', fetcher):
-            with self.assertRaises(DataFetchError):
-                get_historical('   ', '1d', lookback_days=5)
-        self.assertEqual(fetcher.calls, [])
-
-class TestResampling(unittest.TestCase):
-
-    def test_custom_timeframe_resamples_from_its_source_interval(self):
-        fetcher = _RecordingFetcher(freq='1h')
-        with mock.patch('data.historical._fetch_yf', fetcher):
-            df = get_historical('BTC-USD', '4h', lookback_days=5)
-        self.assertEqual([c['interval'] for c in fetcher.calls], ['60m'])
-        spacing = df.index.to_series().diff().dropna().unique()
-        self.assertEqual(list(spacing), [pd.Timedelta(hours=4)])
-        raw = fetcher.raw()
-        bar_time = df.index[len(df) // 2]
-        bucket = raw[(raw.index >= bar_time) & (raw.index < bar_time + pd.Timedelta(hours=4))]
-        self.assertEqual(len(bucket), 4)
-        self.assertAlmostEqual(df.loc[bar_time, 'Open'], float(bucket['Open'].iloc[0]))
-        self.assertAlmostEqual(df.loc[bar_time, 'High'], float(bucket['High'].max()))
-        self.assertAlmostEqual(df.loc[bar_time, 'Low'], float(bucket['Low'].min()))
-        self.assertAlmostEqual(df.loc[bar_time, 'Close'], float(bucket['Close'].iloc[-1]))
-        self.assertAlmostEqual(df.loc[bar_time, 'Volume'], float(bucket['Volume'].sum()))
-
-    def test_resample_ohlc_aggregates_each_field(self):
-        idx = pd.date_range('2024-01-01', periods=4, freq='1h')
-        df = pd.DataFrame({'Open': [10.0, 11.0, 12.0, 13.0], 'High': [15.0, 11.5, 20.0, 13.5], 'Low': [9.0, 8.0, 11.0, 12.0], 'Close': [11.0, 12.0, 13.0, 14.0], 'Volume': [1.0, 2.0, 3.0, 4.0]}, index=idx)
-        out = resample_ohlc(df, '4h')
-        self.assertEqual(len(out), 1)
-        row = out.iloc[0]
-        self.assertEqual(row['Open'], 10.0)
-        self.assertEqual(row['High'], 20.0)
-        self.assertEqual(row['Low'], 8.0)
-        self.assertEqual(row['Close'], 14.0)
-        self.assertEqual(row['Volume'], 10.0)
-
-class TestGetHistoricalWithFeatures(unittest.TestCase):
-
-    def test_features_off_returns_none_and_requests_no_padding(self):
-        fetcher = _RecordingFetcher(freq='1h')
-        with mock.patch('data.historical._fetch_yf', fetcher):
-            df, features = get_historical_with_features('BTC-USD', '1h', lookback_days=3, use_features=False)
-        self.assertIsNone(features)
-        self.assertEqual(fetcher.total_span, timedelta(days=3))
-        self.assertGreater(len(df), 0)
-
-    def test_features_on_pads_history_and_returns_aligned_clean_frames(self):
-        fetcher = _RecordingFetcher(freq='1h')
-        with mock.patch('data.historical._fetch_yf', fetcher):
-            df, features = get_historical_with_features('BTC-USD', '1h', lookback_days=3, use_features=True)
-        self.assertGreater(fetcher.total_span, timedelta(days=3))
-        self.assertEqual(list(features.columns), FEATURE_COLUMNS)
-        self.assertEqual(len(features), len(df))
-        self.assertFalse(features.isna().any().any())
-        self.assertLess(len(df), len(fetcher.raw()))
-if __name__ == '__main__':
-    unittest.main()

tests/test_feature_pipeline.py

@@ -1,167 +0,0 @@
-import unittest
-import numpy as np
-import pandas as pd
-from features.feature_pipeline import FEATURE_COLUMNS, carry_forward_future, compute_feature_frame, compute_feature_frame_for_period, slice_features, validate_features
-
-def _synthetic_ohlcv(n: int, seed: int=0) -> pd.DataFrame:
-    rng = np.random.default_rng(seed)
-    steps = rng.normal(loc=0.0, scale=0.5, size=n)
-    close = 100 + np.cumsum(steps)
-    close = np.abs(close) + 1.0
-    open_ = close + rng.normal(0, 0.1, n)
-    high = np.maximum(open_, close) + np.abs(rng.normal(0, 0.2, n))
-    low = np.minimum(open_, close) - np.abs(rng.normal(0, 0.2, n))
-    volume = rng.integers(100, 10000, n).astype(float)
-    idx = pd.date_range('2024-01-01', periods=n, freq='min')
-    return pd.DataFrame({'Open': open_, 'High': high, 'Low': low, 'Close': close, 'Volume': volume}, index=idx)
-
-class TestNoLookahead(unittest.TestCase):
-
-    def test_truncation_invariance(self):
-        df = _synthetic_ohlcv(300, seed=1)
-        full = compute_feature_frame(df)
-        for cutoff in (50, 100, 150, 250, 299):
-            truncated = compute_feature_frame(df.iloc[:cutoff + 1])
-            overlap = min(len(full), len(truncated))
-            pd.testing.assert_frame_equal(full.iloc[:overlap].reset_index(drop=True), truncated.iloc[:overlap].reset_index(drop=True), check_exact=False, atol=1e-10, obj=f'feature frame truncated at row {cutoff}')
-
-    def test_single_row_extension_does_not_rewrite_history(self):
-        df = _synthetic_ohlcv(120, seed=2)
-        shorter = compute_feature_frame(df.iloc[:100])
-        longer = compute_feature_frame(df.iloc[:101])
-        pd.testing.assert_frame_equal(shorter.reset_index(drop=True), longer.iloc[:100].reset_index(drop=True), check_exact=False, atol=1e-10)
-
-class TestShapeAndColumns(unittest.TestCase):
-
-    def test_columns_are_exactly_the_expected_14(self):
-        df = _synthetic_ohlcv(200, seed=3)
-        feats = compute_feature_frame(df)
-        self.assertEqual(list(feats.columns), FEATURE_COLUMNS)
-        self.assertEqual(len(FEATURE_COLUMNS), 14)
-
-    def test_close_is_not_a_feature_column(self):
-        self.assertNotIn('Close', FEATURE_COLUMNS)
-
-    def test_bb_mid_not_duplicated_as_sma20(self):
-        self.assertIn('SMA_20', FEATURE_COLUMNS)
-        self.assertNotIn('BB_Mid', FEATURE_COLUMNS)
-
-class TestNoNaN(unittest.TestCase):
-
-    def test_no_nan_once_past_warmup(self):
-        df = _synthetic_ohlcv(200, seed=4)
-        feats = compute_feature_frame(df)
-        self.assertFalse(feats.iloc[60:].isna().any().any())
-
-    def test_first_19_rows_ARE_nan_without_padding(self):
-        df = _synthetic_ohlcv(500, seed=99)
-        feats = compute_feature_frame(df)
-        self.assertTrue(feats.iloc[:19].isna().any().any())
-        self.assertFalse(feats.iloc[19:].isna().any().any())
-
-    def test_missing_ohlcv_column_raises(self):
-        bad = pd.DataFrame({'Open': [1, 2], 'High': [1, 2], 'Low': [1, 2]})
-        with self.assertRaises(ValueError):
-            compute_feature_frame(bad)
-
-class TestComputeFeatureFrameForPeriod(unittest.TestCase):
-
-    def test_no_nan_anywhere_in_the_trimmed_result(self):
-        df_padded = _synthetic_ohlcv(60 * 24 * 3, seed=21)
-        df_trimmed, feats_trimmed = compute_feature_frame_for_period(df_padded, keep_days=2)
-        self.assertFalse(feats_trimmed.isna().any().any(), 'compute_feature_frame_for_period must never leave leading NaN in the period actually requested')
-
-    def test_trimmed_period_is_the_requested_length_not_the_padded_one(self):
-        df_padded = _synthetic_ohlcv(60 * 24 * 3, seed=22)
-        keep_days = 1
-        df_trimmed, feats_trimmed = compute_feature_frame_for_period(df_padded, keep_days=keep_days)
-        expected_span = df_padded.index[-1] - df_trimmed.index[0]
-        self.assertLessEqual(expected_span, pd.Timedelta(days=keep_days) + pd.Timedelta(minutes=1))
-        self.assertEqual(len(df_trimmed), len(feats_trimmed))
-
-    def test_trimmed_values_match_computing_on_the_full_padded_series(self):
-        df_padded = _synthetic_ohlcv(60 * 24 * 2, seed=23)
-        full_features = compute_feature_frame(df_padded)
-        df_trimmed, feats_trimmed = compute_feature_frame_for_period(df_padded, keep_days=1)
-        keep_mask = df_padded.index >= df_padded.index[-1] - pd.Timedelta(days=1)
-        expected = full_features.iloc[keep_mask].reset_index(drop=True)
-        pd.testing.assert_frame_equal(feats_trimmed, expected, atol=1e-10)
-
-    def test_reproduces_and_fixes_the_reported_btc_1m_window60_case(self):
-        from utils.helpers import feature_warmup_days
-        keep_days = 1
-        padding_days = feature_warmup_days('1m', minimum_days=0)
-        df_padded = _synthetic_ohlcv(60 * 24 * (keep_days + padding_days) + 100, seed=24)
-        df_trimmed, feats_trimmed = compute_feature_frame_for_period(df_padded, keep_days=keep_days)
-        window = 60
-        first_window = slice_features(feats_trimmed, 0, window)
-        self.assertFalse(first_window.isna().any().any(), 'the FIRST walk-forward window must be NaN-free after padding')
-
-class TestSliceFeatures(unittest.TestCase):
-
-    def test_slice_matches_close_slice_positionally(self):
-        df = _synthetic_ohlcv(200, seed=5)
-        feats = compute_feature_frame(df)
-        close = df['Close'].reset_index(drop=True)
-        window, i = (60, 130)
-        close_window = close.iloc[i - window:i]
-        feat_window = slice_features(feats, i - window, i)
-        self.assertEqual(len(close_window), len(feat_window))
-        self.assertAlmostEqual(df['Close'].iloc[i - 1], close_window.iloc[-1], places=8)
-
-class TestValidateFeatures(unittest.TestCase):
-
-    def test_length_mismatch_raises(self):
-        feats = pd.DataFrame({c: [1.0, 2.0] for c in FEATURE_COLUMNS})
-        with self.assertRaises(ValueError):
-            validate_features(feats, expected_len=3, model_name='Test')
-
-    def test_nan_raises(self):
-        feats = pd.DataFrame({c: [1.0, np.nan] for c in FEATURE_COLUMNS})
-        with self.assertRaises(ValueError):
-            validate_features(feats, expected_len=2, model_name='Test')
-
-    def test_check_nan_false_skips_nan_but_still_checks_length(self):
-        feats_with_nan = pd.DataFrame({c: [np.nan, 1.0, 2.0] for c in FEATURE_COLUMNS})
-        validate_features(feats_with_nan, expected_len=3, model_name='Test', check_nan=False)
-        with self.assertRaises(ValueError):
-            validate_features(feats_with_nan, expected_len=2, model_name='Test', check_nan=False)
-
-    def test_check_nan_false_then_true_on_truncated_tail_mirrors_model_usage(self):
-        feats = pd.DataFrame({c: [np.nan, 1.0, 2.0] for c in FEATURE_COLUMNS})
-        validate_features(feats, expected_len=3, model_name='Test', check_nan=False)
-        clean_tail = feats.iloc[-2:].reset_index(drop=True)
-        validate_features(clean_tail, expected_len=2, model_name='Test')
-        dirty_tail = feats.iloc[-3:].reset_index(drop=True)
-        with self.assertRaises(ValueError):
-            validate_features(dirty_tail, expected_len=3, model_name='Test')
-
-    def test_clean_window_passes(self):
-        feats = pd.DataFrame({c: [1.0, 2.0, 3.0] for c in FEATURE_COLUMNS})
-        validate_features(feats, expected_len=3, model_name='Test')
-
-class TestCarryForwardFuture(unittest.TestCase):
-
-    def test_repeats_last_row(self):
-        feats = pd.DataFrame({'a': [1.0, 2.0, 3.0], 'b': [10.0, 20.0, 30.0]})
-        future = carry_forward_future(feats, horizon=4)
-        self.assertEqual(len(future), 4)
-        self.assertTrue((future['a'] == 3.0).all())
-        self.assertTrue((future['b'] == 30.0).all())
-
-    def test_uses_zero_future_information(self):
-        df = _synthetic_ohlcv(150, seed=6)
-        feats_short = compute_feature_frame(df.iloc[:80])
-        feats_long = compute_feature_frame(df)
-        future_from_short = carry_forward_future(feats_short.iloc[:80], horizon=5)
-        future_from_long = carry_forward_future(feats_long.iloc[:80], horizon=5)
-        pd.testing.assert_frame_equal(future_from_short, future_from_long, atol=1e-10)
-
-    def test_rejects_bad_input(self):
-        feats = pd.DataFrame({'a': [1.0]})
-        with self.assertRaises(ValueError):
-            carry_forward_future(feats, horizon=0)
-        with self.assertRaises(ValueError):
-            carry_forward_future(pd.DataFrame({'a': []}), horizon=1)
-if __name__ == '__main__':
-    unittest.main()

tests/test_helpers.py

@@ -1,113 +0,0 @@
-import unittest
-import pandas as pd
-from config import CUSTOM_TIMEFRAMES, YF_NATIVE_INTERVALS
-from utils.helpers import INDICATOR_WARMUP_CANDLES, MINUTES_PER_CANDLE, PREDICTION_HISTORY_CANDLES, drop_forming_candle, feature_warmup_days, future_index, history_days_for_candles, infer_step
-
-def _frame(index) -> pd.DataFrame:
-    return pd.DataFrame({'Close': range(len(index))}, index=index)
-
-class TestHistoryDaysForCandles(unittest.TestCase):
-
-    def test_window_covers_the_requested_candle_count(self):
-        for timeframe, minutes in MINUTES_PER_CANDLE.items():
-            days = history_days_for_candles(timeframe, 200)
-            self.assertGreaterEqual(days * 24 * 60, 200 * minutes, timeframe)
-
-    def test_known_sizes(self):
-        self.assertEqual(history_days_for_candles('1d', 200), 200)
-        self.assertEqual(history_days_for_candles('4h', 200), 34)
-        self.assertEqual(history_days_for_candles('5m', 200), 1)
-
-    def test_minimum_days_acts_as_a_floor_only(self):
-        self.assertEqual(history_days_for_candles('1m', 10, minimum_days=2), 2)
-        self.assertEqual(history_days_for_candles('1d', 10, minimum_days=2), 10)
-
-    def test_non_positive_candle_counts_still_request_a_real_window(self):
-        self.assertEqual(history_days_for_candles('1h', 0), 1)
-        self.assertEqual(history_days_for_candles('1h', -5), 1)
-
-    def test_unknown_timeframe_uses_the_hourly_fallback(self):
-        self.assertEqual(history_days_for_candles('7m', 200), history_days_for_candles('1h', 200))
-
-class TestFeatureWarmupDays(unittest.TestCase):
-
-    def test_padding_covers_the_indicator_warmup(self):
-        for timeframe, minutes in MINUTES_PER_CANDLE.items():
-            days = feature_warmup_days(timeframe, minimum_days=0)
-            self.assertGreaterEqual(days * 24 * 60, INDICATOR_WARMUP_CANDLES * minutes, timeframe)
-
-    def test_default_floor_is_two_days(self):
-        self.assertEqual(feature_warmup_days('1m'), 2)
-
-    def test_floor_can_be_dropped_for_padding_math(self):
-        self.assertEqual(feature_warmup_days('1m', minimum_days=0), 1)
-        self.assertEqual(feature_warmup_days('1d', minimum_days=0), 30)
-
-class TestLiveSizingFitsSourceLimits(unittest.TestCase):
-
-    def test_prediction_history_is_servable_for_every_timeframe(self):
-        for timeframe in MINUTES_PER_CANDLE:
-            source = CUSTOM_TIMEFRAMES.get(timeframe, {}).get('source', timeframe)
-            limit = YF_NATIVE_INTERVALS.get(source, {}).get('max_days')
-            if limit is None:
-                continue
-            wanted = history_days_for_candles(timeframe, PREDICTION_HISTORY_CANDLES)
-            self.assertLessEqual(wanted, limit, f"{timeframe} wants {wanted}d but '{source}' serves {limit}d")
-
-class TestInferStep(unittest.TestCase):
-
-    def test_uses_the_median_spacing(self):
-        idx = pd.date_range('2024-01-01', periods=5, freq='15min')
-        self.assertEqual(infer_step(idx), pd.Timedelta(minutes=15))
-
-    def test_market_closure_gap_does_not_dominate(self):
-        idx = pd.DatetimeIndex(['2024-01-05 20:00', '2024-01-05 21:00', '2024-01-05 22:00', '2024-01-08 20:00', '2024-01-08 21:00'])
-        self.assertEqual(infer_step(idx), pd.Timedelta(hours=1))
-
-    def test_single_candle_falls_back_to_one_minute(self):
-        idx = pd.date_range('2024-01-01', periods=1, freq='5min')
-        self.assertEqual(infer_step(idx), pd.Timedelta(minutes=1))
-
-class TestFutureIndex(unittest.TestCase):
-
-    def test_projects_timestamps_after_the_last_candle(self):
-        last = pd.Timestamp('2024-01-01 00:00')
-        self.assertEqual(future_index(last, pd.Timedelta(minutes=5), 3), [pd.Timestamp('2024-01-01 00:05'), pd.Timestamp('2024-01-01 00:10'), pd.Timestamp('2024-01-01 00:15')])
-
-    def test_zero_horizon_projects_nothing(self):
-        self.assertEqual(future_index(pd.Timestamp('2024-01-01'), pd.Timedelta(minutes=1), 0), [])
-
-class TestDropFormingCandle(unittest.TestCase):
-
-    def test_drops_the_still_forming_candle_and_its_feature_row(self):
-        now = pd.Timestamp.now(tz='UTC').floor('min')
-        idx = pd.DatetimeIndex([now - pd.Timedelta(minutes=10), now - pd.Timedelta(minutes=5), now])
-        features = pd.DataFrame({'f': [1.0, 2.0, 3.0]})
-        df, trimmed_features = drop_forming_candle(_frame(idx), features)
-        self.assertEqual(len(df), 2)
-        self.assertEqual(df.index[-1], idx[-2])
-        self.assertEqual(len(trimmed_features), 2)
-        self.assertEqual(list(trimmed_features.index), [0, 1])
-
-    def test_keeps_a_closed_final_candle(self):
-        now = pd.Timestamp.now(tz='UTC').floor('min')
-        idx = pd.DatetimeIndex([now - pd.Timedelta(minutes=20), now - pd.Timedelta(minutes=15), now - pd.Timedelta(minutes=10)])
-        features = pd.DataFrame({'f': [1.0, 2.0, 3.0]})
-        df, kept_features = drop_forming_candle(_frame(idx), features)
-        self.assertEqual(len(df), 3)
-        self.assertEqual(len(kept_features), 3)
-
-    def test_handles_a_tz_naive_index(self):
-        now = pd.Timestamp.now(tz='UTC').tz_localize(None).floor('min')
-        idx = pd.DatetimeIndex([now - pd.Timedelta(minutes=10), now - pd.Timedelta(minutes=5), now])
-        df, features = drop_forming_candle(_frame(idx), None)
-        self.assertEqual(len(df), 2)
-        self.assertIsNone(features)
-
-    def test_empty_frame_passes_through(self):
-        empty = pd.DataFrame({'Close': []}, index=pd.DatetimeIndex([]))
-        df, features = drop_forming_candle(empty, None)
-        self.assertEqual(len(df), 0)
-        self.assertIsNone(features)
-if __name__ == '__main__':
-    unittest.main()

tests/test_indicators.py

@@ -1,144 +0,0 @@
-import unittest
-import numpy as np
-import pandas as pd
-from indicators.indicators import _wilder_rma, add_all_indicators, bollinger_bands, ema, latest_signals, macd, rsi, sma, stochastic_oscillator
-
-def _ohlcv(n: int, seed: int=5) -> pd.DataFrame:
-    rng = np.random.default_rng(seed)
-    close = 100 + np.cumsum(rng.normal(0, 0.5, n))
-    open_ = close + rng.normal(0, 0.1, n)
-    high = np.maximum(open_, close) + np.abs(rng.normal(0, 0.3, n))
-    low = np.minimum(open_, close) - np.abs(rng.normal(0, 0.3, n))
-    volume = rng.integers(100, 5000, n).astype(float)
-    idx = pd.date_range('2024-01-01', periods=n, freq='5min')
-    return pd.DataFrame({'Open': open_, 'High': high, 'Low': low, 'Close': close, 'Volume': volume}, index=idx)
-
-class TestWilderRma(unittest.TestCase):
-
-    def test_seeds_from_a_window_length_average_then_recurses(self):
-        values = pd.Series([1.0, 2.0, 3.0, 4.0, 5.0])
-        out = _wilder_rma(values, 3)
-        self.assertTrue(out.iloc[:2].isna().all())
-        self.assertAlmostEqual(out.iloc[2], 2.0)
-        self.assertAlmostEqual(out.iloc[3], (2.0 * 2 + 4.0) / 3)
-        self.assertAlmostEqual(out.iloc[4], (out.iloc[3] * 2 + 5.0) / 3)
-
-    def test_skips_a_leading_nan_before_seeding(self):
-        values = pd.Series([np.nan, 2.0, 4.0, 6.0])
-        out = _wilder_rma(values, 3)
-        self.assertTrue(out.iloc[:3].isna().all())
-        self.assertAlmostEqual(out.iloc[3], 4.0)
-
-    def test_series_shorter_than_the_window_is_all_nan(self):
-        out = _wilder_rma(pd.Series([1.0, 2.0]), 14)
-        self.assertTrue(out.isna().all())
-
-class TestRsi(unittest.TestCase):
-
-    def test_warmup_rows_are_nan_not_fifty(self):
-        out = rsi(_ohlcv(60)['Close'], 14)
-        self.assertTrue(out.iloc[:14].isna().all())
-        self.assertTrue(out.iloc[14:].notna().all())
-        self.assertEqual(int((out.iloc[:14] == 50.0).sum()), 0)
-
-    def test_only_gains_reads_one_hundred(self):
-        out = rsi(pd.Series(np.arange(40, dtype=float) + 100), 14)
-        self.assertTrue(out.iloc[:14].isna().all())
-        self.assertTrue((out.iloc[14:] == 100.0).all())
-
-    def test_flat_market_is_neutral_only_after_warmup(self):
-        out = rsi(pd.Series([100.0] * 40), 14)
-        self.assertTrue(out.iloc[:14].isna().all())
-        self.assertTrue((out.iloc[14:] == 50.0).all())
-
-    def test_stays_within_bounds(self):
-        out = rsi(_ohlcv(200, seed=9)['Close'], 14).dropna()
-        self.assertGreaterEqual(out.min(), 0.0)
-        self.assertLessEqual(out.max(), 100.0)
-
-class TestMacdAndBollinger(unittest.TestCase):
-
-    def setUp(self):
-        self.close = _ohlcv(80, seed=3)['Close']
-
-    def test_macd_is_the_fast_minus_slow_ema_with_its_own_signal_ema(self):
-        line, signal, hist = macd(self.close)
-        expected_line = ema(self.close, 12) - ema(self.close, 26)
-        pd.testing.assert_series_equal(line, expected_line, check_names=False)
-        pd.testing.assert_series_equal(signal, ema(expected_line, 9), check_names=False)
-        pd.testing.assert_series_equal(hist, expected_line - signal, check_names=False)
-
-    def test_bollinger_uses_population_std_around_the_sma(self):
-        upper, mid, lower = bollinger_bands(self.close, window=20, num_std=2.0)
-        pd.testing.assert_series_equal(mid, sma(self.close, 20), check_names=False)
-        self.assertTrue(upper.iloc[:19].isna().all())
-        window = self.close.iloc[-20:].to_numpy()
-        expected_std = float(np.std(window))
-        self.assertAlmostEqual(float(upper.iloc[-1]), float(window.mean()) + 2 * expected_std, places=9)
-        self.assertAlmostEqual(float(lower.iloc[-1]), float(window.mean()) - 2 * expected_std, places=9)
-
-class TestStochastic(unittest.TestCase):
-
-    def test_warmup_rows_are_nan_not_fifty(self):
-        df = _ohlcv(60, seed=4)
-        k, d = stochastic_oscillator(df['High'], df['Low'], df['Close'])
-        self.assertTrue(k.iloc[:13].isna().all())
-        self.assertTrue(k.iloc[13:].notna().all())
-        self.assertTrue(d.iloc[:15].isna().all())
-        self.assertEqual(int((k.iloc[:13] == 50.0).sum()), 0)
-
-    def test_percent_k_matches_the_definition(self):
-        df = _ohlcv(40, seed=6)
-        k, _ = stochastic_oscillator(df['High'], df['Low'], df['Close'])
-        lowest = float(df['Low'].iloc[-14:].min())
-        highest = float(df['High'].iloc[-14:].max())
-        expected = 100 * (float(df['Close'].iloc[-1]) - lowest) / (highest - lowest)
-        self.assertAlmostEqual(float(k.iloc[-1]), expected, places=9)
-
-    def test_zero_range_is_neutral_only_after_warmup(self):
-        flat = pd.Series([100.0] * 30)
-        k, d = stochastic_oscillator(flat, flat, flat)
-        self.assertTrue(k.iloc[:13].isna().all())
-        self.assertTrue((k.iloc[13:] == 50.0).all())
-        self.assertTrue((d.iloc[15:] == 50.0).all())
-
-class TestAddAllIndicators(unittest.TestCase):
-
-    def setUp(self):
-        self.df = _ohlcv(60, seed=8)
-        self.out = add_all_indicators(self.df)
-
-    def test_adds_every_indicator_column_without_mutating_the_input(self):
-        expected = ['SMA_20', 'EMA_20', 'RSI_14', 'MACD', 'MACD_Signal', 'MACD_Hist', 'BB_Upper', 'BB_Mid', 'BB_Lower', 'Stoch_%K', 'Stoch_%D']
-        for column in expected:
-            self.assertIn(column, self.out.columns)
-            self.assertNotIn(column, self.df.columns)
-
-    def test_warmup_nan_counts_are_the_real_indicator_periods(self):
-        self.assertEqual(int(self.out['RSI_14'].isna().sum()), 14)
-        self.assertEqual(int(self.out['Stoch_%K'].isna().sum()), 13)
-        self.assertEqual(int(self.out['Stoch_%D'].isna().sum()), 15)
-        self.assertEqual(int(self.out['SMA_20'].isna().sum()), 19)
-        self.assertEqual(int(self.out['BB_Upper'].isna().sum()), 19)
-
-class TestLatestSignals(unittest.TestCase):
-
-    def test_reports_insufficient_data_instead_of_a_fabricated_reading(self):
-        out = add_all_indicators(_ohlcv(3, seed=2))
-        signals = latest_signals(out)
-        self.assertEqual(signals['RSI (14)']['value'], 'n/a')
-        self.assertEqual(signals['RSI (14)']['signal'], 'Insufficient data')
-        self.assertEqual(signals['Stochastic (14,3)']['value'], 'n/a')
-        self.assertEqual(signals['Stochastic (14,3)']['signal'], 'Insufficient data')
-        self.assertEqual(signals['Bollinger Bands']['signal'], 'Insufficient data')
-        self.assertEqual(signals['Moving Averages']['signal'], 'Insufficient data for SMA')
-        self.assertIn('SMA20=n/a', signals['Moving Averages']['value'])
-
-    def test_reports_real_readings_once_warmed_up(self):
-        signals = latest_signals(add_all_indicators(_ohlcv(80, seed=1)))
-        for name, entry in signals.items():
-            self.assertNotIn('Insufficient', entry['signal'], name)
-        self.assertIsInstance(signals['RSI (14)']['value'], float)
-        self.assertIsInstance(signals['Stochastic (14,3)']['value'], float)
-if __name__ == '__main__':
-    unittest.main()

tests/test_maythos_engine.py

@@ -1,71 +0,0 @@
-"""Self-tests for the ported MAYTHOS streaming engine.
-
-The original standalone engine shipped a ``__main__`` smoke test. That was removed
-during the merge (no experimental / dead code) and its oracle is preserved here as
-a real unit test.
-"""
-
-import unittest
-
-from models.maythos.engine import MAYTHOS, Candle
-
-
-def _ramp_candles(n: int = 150):
-    base_ts = 1_700_000_000.0
-    candles = []
-    for i in range(n):
-        close = 1.0000 + i * 0.0005
-        candles.append(
-            Candle(
-                timestamp=base_ts + i * 60,
-                open=close,
-                high=close + 0.0002,
-                low=close - 0.0002,
-                close=close,
-                volume=100.0,
-            )
-        )
-    return candles
-
-
-class TestMaythosEngine(unittest.TestCase):
-    def test_ramp_stream_produces_valid_output(self):
-        engine = MAYTHOS()
-        output = None
-        for candle in _ramp_candles(150):
-            output = engine.tick(candle)
-        self.assertIsNotNone(output)
-        self.assertEqual(engine.validate(output), [])
-        self.assertIn(output["direction"], ("BUY", "SELL"))
-        self.assertGreaterEqual(output["confidence"], 0.0)
-        self.assertLessEqual(output["confidence"], 1.0)
-        self.assertTrue(engine.is_warm)
-        self.assertEqual(engine.tick_count, 150)
-
-    def test_reset_clears_state(self):
-        engine = MAYTHOS()
-        for candle in _ramp_candles(60):
-            engine.tick(candle)
-        self.assertGreater(engine.tick_count, 0)
-        engine.reset()
-        self.assertEqual(engine.tick_count, 0)
-        self.assertFalse(engine.is_warm)
-
-    def test_non_finite_candle_is_sanitized_not_crashing(self):
-        engine = MAYTHOS()
-        for candle in _ramp_candles(40):
-            engine.tick(candle)
-        bad = Candle(
-            timestamp=1_700_000_000.0 + 40 * 60,
-            open=float("nan"),
-            high=float("inf"),
-            low=float("-inf"),
-            close=float("nan"),
-            volume=0.0,
-        )
-        output = engine.tick(bad)
-        self.assertEqual(engine.validate(output), [])
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_maythos_model.py

@@ -1,79 +0,0 @@
-"""Tests for MaythosModel and its integration into the unified model layer."""
-
-import math
-import unittest
-
-import numpy as np
-import pandas as pd
-
-from backtest.backtester import backtest_model, summarize_backtest
-from models.base_model import BaseModel, Signal
-from models.maythos.model import MaythosModel
-from models.registry import fresh_model, get_model
-
-
-def _synthetic_ohlcv(n: int, seed: int = 5) -> pd.DataFrame:
-    rng = np.random.default_rng(seed)
-    steps = rng.normal(loc=0.02, scale=0.4, size=n)
-    close = 100 + np.cumsum(steps)
-    close = np.abs(close) + 5.0
-    open_ = close + rng.normal(0, 0.1, n)
-    high = np.maximum(open_, close) + np.abs(rng.normal(0, 0.2, n))
-    low = np.minimum(open_, close) - np.abs(rng.normal(0, 0.2, n))
-    volume = rng.integers(100, 10000, n).astype(float)
-    idx = pd.date_range("2024-01-01", periods=n, freq="min", tz="UTC")
-    return pd.DataFrame(
-        {"Open": open_, "High": high, "Low": low, "Close": close, "Volume": volume},
-        index=idx,
-    )
-
-
-class TestMaythosModel(unittest.TestCase):
-    def setUp(self):
-        self.df = _synthetic_ohlcv(120)
-
-    def test_predict_signal_shape(self):
-        model = MaythosModel()
-        signal = model.predict_signal(self.df, horizon=1)
-        self.assertIsInstance(signal, Signal)
-        self.assertIn(signal.direction, ("up", "down"))
-        self.assertGreaterEqual(signal.confidence, 0.0)
-        self.assertLessEqual(signal.confidence, 1.0)
-        self.assertIsNone(signal.predicted_close)
-        self.assertIn(signal.meta["raw_direction"], ("BUY", "SELL"))
-        self.assertIn("market_state", signal.meta)
-
-    def test_requires_ohlc_columns(self):
-        model = MaythosModel()
-        with self.assertRaises(ValueError):
-            model.predict_signal(self.df[["Close"]], horizon=1)
-
-    def test_rejects_bare_series(self):
-        model = MaythosModel()
-        with self.assertRaises(ValueError):
-            model.predict_signal(self.df["Close"], horizon=1)
-
-    def test_registry_returns_maythos(self):
-        self.assertIsInstance(fresh_model("MAYTHOS"), MaythosModel)
-        self.assertIsInstance(get_model("MAYTHOS"), BaseModel)
-
-    def test_backtest_runs_with_direction_only(self):
-        model = fresh_model("MAYTHOS")
-        results = backtest_model(self.df, model, window=60, horizon=1, step=5)
-        self.assertGreater(len(results), 0)
-        # No prediction should fail: MAYTHOS always emits a decision.
-        self.assertEqual(int(results["error"].notna().sum()), 0)
-        # It reports direction, not a price level, so predicted_close is NaN
-        # and price-error metrics are undefined (never faked).
-        self.assertTrue(results["predicted_close"].isna().all())
-        self.assertIn("confidence", results.columns)
-        self.assertTrue((results["confidence"] >= 0).all())
-        summary = summarize_backtest(results, "MAYTHOS")
-        self.assertEqual(summary["failed_predictions"], 0)
-        self.assertIsNone(summary["mae"])
-        self.assertIsNone(summary["rmse"])
-        self.assertGreaterEqual(summary["accuracy_pct"], 0.0)
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_models_with_features.py

@@ -1,177 +0,0 @@
-import importlib.util
-import unittest
-import numpy as np
-import pandas as pd
-from features.feature_pipeline import compute_feature_frame
-
-def _have(module_name: str) -> bool:
-    return importlib.util.find_spec(module_name) is not None
-_HAVE_STATSMODELS = _have('statsmodels')
-_HAVE_ARCH = _have('arch')
-_HAVE_MOIRAI = _have('uni2ts') and _have('gluonts')
-_HAVE_TIMESFM = _have('timesfm') and _have('torch')
-
-def _synthetic_ohlcv(n: int, seed: int=42) -> pd.DataFrame:
-    rng = np.random.default_rng(seed)
-    steps = rng.normal(loc=0.0, scale=0.4, size=n)
-    close = 100 + np.cumsum(steps)
-    close = np.abs(close) + 5.0
-    open_ = close + rng.normal(0, 0.1, n)
-    high = np.maximum(open_, close) + np.abs(rng.normal(0, 0.2, n))
-    low = np.minimum(open_, close) - np.abs(rng.normal(0, 0.2, n))
-    volume = rng.integers(100, 10000, n).astype(float)
-    idx = pd.date_range('2024-01-01', periods=n, freq='min')
-    return pd.DataFrame({'Open': open_, 'High': high, 'Low': low, 'Close': close, 'Volume': volume}, index=idx)
-
-def _warm_close_and_features(df: pd.DataFrame, feats: pd.DataFrame):
-    complete = ~feats.isna().any(axis=1).to_numpy()
-    start = int(np.argmax(complete)) if complete.any() else len(df)
-    return (df['Close'].reset_index(drop=True).iloc[start:], feats.iloc[start:].reset_index(drop=True))
-
-class TestArimaFamilyAlignment(unittest.TestCase):
-
-    def test_returns_alignment_has_no_off_by_one(self):
-        n = 10
-        prices = pd.Series(100 + np.arange(n, dtype=float))
-        features = pd.Series([float(i) for i in range(n)])
-        log_returns = np.log(prices / prices.shift(1)).dropna().reset_index(drop=True)
-        exog = features.iloc[1:].reset_index(drop=True)
-        self.assertEqual(len(exog), len(log_returns))
-        for k in range(len(log_returns)):
-            self.assertEqual(exog[k], float(k + 1))
-
-@unittest.skipUnless(_HAVE_STATSMODELS, 'statsmodels not installed in this environment')
-class TestArimaWithFeatures(unittest.TestCase):
-
-    def setUp(self):
-        self.df = _synthetic_ohlcv(120)
-        self.feats = compute_feature_frame(self.df)
-        self.close, self.warm_feats = _warm_close_and_features(self.df, self.feats)
-
-    def test_baseline_unchanged_shape(self):
-        from models.arima_model import ArimaModel
-        m = ArimaModel(max_p=2, max_d=1, max_q=2)
-        out = m.predict(self.close, horizon=3)
-        self.assertEqual(len(out), 3)
-        self.assertTrue(all(np.isfinite(out)))
-
-    def test_with_features_runs_and_is_finite(self):
-        from models.arima_model import ArimaModel
-        m = ArimaModel(max_p=2, max_d=1, max_q=2)
-        out = m.predict(self.close, horizon=3, features=self.warm_feats)
-        self.assertEqual(len(out), 3)
-        self.assertTrue(all(np.isfinite(out)))
-
-    def test_mismatched_features_length_raises(self):
-        from models.arima_model import ArimaModel
-        m = ArimaModel(max_p=2, max_d=1, max_q=2)
-        short_window = self.warm_feats.iloc[:-5].reset_index(drop=True)
-        with self.assertRaises(ValueError):
-            m.predict(self.close, horizon=3, features=short_window)
-
-@unittest.skipUnless(_HAVE_STATSMODELS, 'statsmodels not installed in this environment')
-class TestAutoArimaWithFeatures(unittest.TestCase):
-
-    def setUp(self):
-        self.df = _synthetic_ohlcv(120)
-        self.feats = compute_feature_frame(self.df)
-        self.close, self.warm_feats = _warm_close_and_features(self.df, self.feats)
-
-    def test_with_features_runs_and_is_finite(self):
-        from models.auto_arima_model import AutoArimaModel
-        m = AutoArimaModel(max_p=3, max_q=3, max_d=1)
-        out = m.predict(self.close, horizon=2, features=self.warm_feats)
-        self.assertEqual(len(out), 2)
-        self.assertTrue(all(np.isfinite(out)))
-
-@unittest.skipUnless(_HAVE_STATSMODELS and _HAVE_ARCH, 'statsmodels+arch not installed in this environment')
-class TestArimaGarchWithFeatures(unittest.TestCase):
-
-    def setUp(self):
-        self.df = _synthetic_ohlcv(150)
-        self.feats = compute_feature_frame(self.df)
-        self.close, self.warm_feats = _warm_close_and_features(self.df, self.feats)
-
-    def test_with_features_runs_and_is_finite(self):
-        from models.arima_garch_model import ArimaGarchModel
-        m = ArimaGarchModel(max_p=2, max_q=2)
-        out = m.predict(self.close, horizon=2, features=self.warm_feats)
-        self.assertEqual(len(out), 2)
-        self.assertTrue(all(np.isfinite(out)))
-        self.assertIsNotNone(m.last_volatility_forecast)
-
-@unittest.skipUnless(_HAVE_MOIRAI, 'uni2ts/gluonts not installed in this environment')
-class TestMoiraiWithFeatures(unittest.TestCase):
-
-    def test_with_features_runs_and_is_finite(self):
-        from models.moirai_model import MoiraiModel
-        df = _synthetic_ohlcv(60)
-        feats = compute_feature_frame(df)
-        close, warm_feats = _warm_close_and_features(df, feats)
-        m = MoiraiModel(context_length=60, num_samples=10)
-        out = m.predict(close, horizon=2, features=warm_feats)
-        self.assertEqual(len(out), 2)
-        self.assertTrue(all(np.isfinite(out)))
-
-@unittest.skipUnless(_HAVE_TIMESFM, 'timesfm/torch not installed in this environment')
-class TestTimesFMWithFeatures(unittest.TestCase):
-
-    def test_with_features_runs_and_is_finite(self):
-        from models.timesfm_model import TimesFMModel
-        df = _synthetic_ohlcv(64)
-        feats = compute_feature_frame(df)
-        close, warm_feats = _warm_close_and_features(df, feats)
-        m = TimesFMModel(max_context=64)
-        out = m.predict(close, horizon=2, features=warm_feats)
-        self.assertEqual(len(out), 2)
-        self.assertTrue(all(np.isfinite(out)))
-
-    def test_short_input_below_compiled_context_is_finite(self):
-        from models.timesfm_model import TimesFMModel
-        rng = np.random.default_rng(99)
-        df = _synthetic_ohlcv(60, seed=99)
-        close = 40000 + df['Close'].reset_index(drop=True)
-        m = TimesFMModel(max_context=512)
-        out = m.predict(close, horizon=2)
-        self.assertEqual(len(out), 2)
-        self.assertTrue(all(np.isfinite(out)), f'TimesFM NaN on short window: {out}')
-
-    def test_repeated_window_lengths_stay_finite(self):
-        from models.timesfm_model import TimesFMModel
-        df = _synthetic_ohlcv(120, seed=7)
-        close = 40000 + df['Close'].reset_index(drop=True)
-        m = TimesFMModel(max_context=512)
-        for w in (40, 100, 40):
-            out = m.predict(close.iloc[-w:], horizon=1)
-            self.assertEqual(len(out), 1)
-            self.assertTrue(np.isfinite(out[0]), f'TimesFM NaN at w={w}: {out[0]}')
-
-class TestInputContractGuards(unittest.TestCase):
-
-    def test_nan_history_raises_for_all_models(self):
-        from models.registry import fresh_model
-        rng = np.random.default_rng(3)
-        good = pd.Series(100 + np.cumsum(rng.normal(0, 0.5, 200)))
-        for name in ('ARIMA', 'Auto-ARIMA', 'ARIMA-GARCH', 'Moirai'):
-            m = fresh_model(name)
-            h = good.copy()
-            h.iloc[50] = np.nan
-            with self.assertRaises(ValueError, msg=name):
-                m.predict(h, horizon=1)
-        m = fresh_model('TimesFM')
-        h = good.copy()
-        h.iloc[50] = np.nan
-        with self.assertRaises(ValueError):
-            m.predict(h, horizon=1)
-
-    def test_horizon_below_one_raises_for_all_models(self):
-        from models.registry import fresh_model
-        rng = np.random.default_rng(3)
-        good = pd.Series(100 + np.cumsum(rng.normal(0, 0.5, 200)))
-        for name in ('ARIMA', 'Auto-ARIMA', 'ARIMA-GARCH', 'Moirai', 'TimesFM'):
-            m = fresh_model(name)
-            for bad in (0, -1):
-                with self.assertRaises(ValueError, msg=f'{name} horizon={bad}'):
-                    m.predict(good, horizon=bad)
-if __name__ == '__main__':
-    unittest.main()

tests/test_signal_contract.py

@@ -1,96 +0,0 @@
-"""Tests that the unified Signal contract behaves consistently across model types.
-
-These exercise the shared contract without any heavy optional dependencies: a
-minimal in-test forecaster stands in for the ARIMA family (whose libraries are
-not always installed), while MAYTHOS is real.
-"""
-
-import unittest
-
-import numpy as np
-import pandas as pd
-
-from models.base_model import (
-    BaseForecastModel,
-    Signal,
-    _confidence_from_forecast,
-)
-from models.maythos.model import MaythosModel
-
-
-def _synthetic_ohlcv(n: int, seed: int = 9) -> pd.DataFrame:
-    rng = np.random.default_rng(seed)
-    close = 100 + np.cumsum(rng.normal(0, 0.4, n))
-    close = np.abs(close) + 5.0
-    open_ = close + rng.normal(0, 0.1, n)
-    high = np.maximum(open_, close) + 0.2
-    low = np.minimum(open_, close) - 0.2
-    idx = pd.date_range("2024-01-01", periods=n, freq="min", tz="UTC")
-    return pd.DataFrame(
-        {"Open": open_, "High": high, "Low": low, "Close": close, "Volume": 1000.0},
-        index=idx,
-    )
-
-
-class _UpForecaster(BaseForecastModel):
-    name = "UpForecaster"
-
-    def predict(self, history, horizon=1, features=None):
-        last = float(pd.Series(history).iloc[-1])
-        return [last + 1.0 * (k + 1) for k in range(horizon)]
-
-
-class _DownForecaster(BaseForecastModel):
-    name = "DownForecaster"
-
-    def predict(self, history, horizon=1, features=None):
-        last = float(pd.Series(history).iloc[-1])
-        return [last - 1.0 * (k + 1) for k in range(horizon)]
-
-
-class TestForecastSignalContract(unittest.TestCase):
-    def setUp(self):
-        self.df = _synthetic_ohlcv(80)
-
-    def test_forecaster_signal_matches_predict(self):
-        model = _UpForecaster()
-        signal = model.predict_signal(self.df, horizon=3)
-        forecast = model.predict(self.df["Close"], horizon=3)
-        self.assertIsInstance(signal, Signal)
-        self.assertEqual(signal.predicted_close, float(forecast[-1]))
-        self.assertEqual(signal.direction, "up")
-        self.assertEqual(signal.horizon, 3)
-        self.assertGreaterEqual(signal.confidence, 0.0)
-        self.assertLessEqual(signal.confidence, 1.0)
-
-    def test_down_direction(self):
-        signal = _DownForecaster().predict_signal(self.df, horizon=1)
-        self.assertEqual(signal.direction, "down")
-
-    def test_accepts_bare_close_series(self):
-        signal = _UpForecaster().predict_signal(self.df["Close"], horizon=1)
-        self.assertEqual(signal.direction, "up")
-
-    def test_confidence_saturates_at_two_sigma(self):
-        history = np.array([1.0, 2.0, 1.0, 2.0, 1.0, 2.0], dtype=float)
-        # A huge move relative to volatility saturates confidence at 1.0.
-        self.assertEqual(_confidence_from_forecast(history, 100.0), 1.0)
-        # A flat history with no move yields zero confidence.
-        flat = np.array([5.0, 5.0, 5.0], dtype=float)
-        self.assertEqual(_confidence_from_forecast(flat, 5.0), 0.0)
-
-    def test_every_model_type_speaks_signal(self):
-        forecaster_signal = _UpForecaster().predict_signal(self.df, horizon=1)
-        maythos_signal = MaythosModel().predict_signal(self.df, horizon=1)
-        for signal in (forecaster_signal, maythos_signal):
-            self.assertIsInstance(signal, Signal)
-            self.assertIn(signal.direction, ("up", "down"))
-            self.assertGreaterEqual(signal.confidence, 0.0)
-            self.assertLessEqual(signal.confidence, 1.0)
-        # The forecaster reports a price; MAYTHOS reports a decision only.
-        self.assertIsNotNone(forecaster_signal.predicted_close)
-        self.assertIsNone(maythos_signal.predicted_close)
-
-
-if __name__ == "__main__":
-    unittest.main()

utils/__init__.py

@@ -1 +0,0 @@
-pass

utils/helpers.py

@@ -1,37 +0,0 @@
-import math
-import pandas as pd
-MINUTES_PER_CANDLE = {'1m': 1, '5m': 5, '10m': 10, '15m': 15, '30m': 30, '1h': 60, '4h': 240, '1d': 1440}
-INDICATOR_WARMUP_CANDLES = 30
-PREDICTION_HISTORY_CANDLES = 200
-
-def infer_step(index: pd.DatetimeIndex):
-    if len(index) < 2:
-        return pd.Timedelta(minutes=1)
-    diffs = index.to_series().diff().dropna()
-    if diffs.empty:
-        return pd.Timedelta(minutes=1)
-    return diffs.median()
-
-def future_index(last_timestamp, step, n):
-    return [last_timestamp + step * (i + 1) for i in range(n)]
-
-def history_days_for_candles(timeframe: str, candles: int, minimum_days: int=1) -> int:
-    minutes = MINUTES_PER_CANDLE.get(timeframe, 60) * max(int(candles), 0)
-    return max(minimum_days, math.ceil(minutes / (24 * 60)))
-
-def feature_warmup_days(timeframe: str, minimum_days: int=2) -> int:
-    return history_days_for_candles(timeframe, INDICATOR_WARMUP_CANDLES, minimum_days=minimum_days)
-
-def drop_forming_candle(df: pd.DataFrame, features_df: pd.DataFrame=None):
-    if df is None or len(df) == 0:
-        return (df, features_df)
-    last = df.index[-1]
-    now = pd.Timestamp.now(tz='UTC')
-    if last.tzinfo is None:
-        now = now.tz_localize(None)
-    if now - last >= infer_step(df.index):
-        return (df, features_df)
-    df = df.iloc[:-1]
-    if features_df is not None:
-        features_df = features_df.iloc[:-1].reset_index(drop=True)
-    return (df, features_df)