finrix 1.0.0__py3-none-any.whl

finrix-1.0.0.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: finrix
+Version: 1.0.0
+Summary: FINRIX Quantitative Trading Terminal — XAUUSD macro forecast engine with Rich CLI
+Requires-Python: <3.13,>=3.11
+License-File: LICENSE
+Requires-Dist: modal==0.73.0
+Requires-Dist: neuralforecast==1.7.5
+Requires-Dist: pyfredapi==0.10.2
+Requires-Dist: transformers==4.46.3
+Requires-Dist: torch==2.5.1
+Requires-Dist: pandas==2.2.3
+Requires-Dist: numpy==2.1.3
+Requires-Dist: scikit-learn==1.5.2
+Requires-Dist: yfinance==0.2.48
+Requires-Dist: requests==2.32.3
+Requires-Dist: python-dotenv==1.0.1
+Requires-Dist: rich==13.9.4
+Requires-Dist: questionary==2.0.1
+Requires-Dist: InquirerPy==0.3.4
+Dynamic: license-file

finrix-1.0.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+finrix-1.0.0.dist-info/licenses/LICENSE,sha256=PkWpx3QYKjoCyajUqZ4EKlh_FsSnt1zjueGdh-gx5iM,1085
+macro_forecast_engine/__init__.py,sha256=2peZxcAiMEZzRcF5Ejp1RNgL3KviaTz9M9yP7MK1CcY,49
+macro_forecast_engine/config.py,sha256=2CgbnZ71fMDQQNxbhf3mumXKaa0qKqhziuTb5ZDizkM,878
+macro_forecast_engine/data_fetcher.py,sha256=sCid1C6kdsBuX6bnM_P4y4znRNCQz31lw8lO8BOxjkY,254
+macro_forecast_engine/data_loader.py,sha256=5xDK-p7ARwb1Ny22kF8Os3Pv-wV-yWytWKp4_J3AXs4,14121
+macro_forecast_engine/data_processor.py,sha256=3Nx-nflg_fqtWDEYI1agxtZNAPRZdBOXbjUdHChficM,1684
+macro_forecast_engine/finrix_config.py,sha256=XFxfTeItVlV05SJzPVO0jo6w7VHNipSxfTqLXsAixpU,1493
+macro_forecast_engine/indicator_params.py,sha256=Bwa7koq71SAs2NwMJX0cAQ6nnqhJi43OcGPDAx0h66w,3047
+macro_forecast_engine/json_utils.py,sha256=5b1lloZliIwKTXYIvXbM3lYcw2fOYlOANEr28XseHQI,855
+macro_forecast_engine/modal_engine.py,sha256=E8l1K6WSW-G7Xc4X6dsHjiB6eeUkcNfdun-R5WeuICY,29895
+macro_forecast_engine/run_engine.py,sha256=dK_4dCctHY3mhW7pcmQyzFjvRP8kitC7sZHbav6b0t8,2412
+macro_forecast_engine/trader_execution.py,sha256=FUtXuNUuRrPxcvnkLoWszWdFijFyabKgCrMFel5H3-E,3433
+macro_forecast_engine/trader_risk.py,sha256=Vk28Uo3EvDU2AXKhuNZ1AFxW-3u8vfSrmcVBJH0llt4,4040
+macro_forecast_engine/trader_timemachine.py,sha256=gT7yBMl7r1ilqzIjstM0vB6acbjQzmwxq0m-bn59-pQ,21630
+finrix-1.0.0.dist-info/METADATA,sha256=-YoF4abg8iT_TEWUCkal89gmknVSvI0FFJnJbukGOjQ,688
+finrix-1.0.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+finrix-1.0.0.dist-info/entry_points.txt,sha256=l3tMR6voJdR6q35MSksaiRVUD_upmt2alyfu6SHMlY0,36
+finrix-1.0.0.dist-info/top_level.txt,sha256=L_MI7Zo4vb_ZOfz6YbyFfpsr_IIaVD5yFtoIHtP5XiA,22
+finrix-1.0.0.dist-info/RECORD,,

finrix-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

finrix-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+finrix = app:main

finrix-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 carnoba
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

finrix-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+macro_forecast_engine

macro_forecast_engine/__init__.py

@@ -0,0 +1,2 @@
+"""Macro-quant XAUUSD forecasting package."""
+

macro_forecast_engine/config.py

@@ -0,0 +1,28 @@
+"""Environment-backed configuration for the Modal forecast engine."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+try:
+    from dotenv import load_dotenv
+except ImportError:  # pragma: no cover
+    load_dotenv = None
+
+BASE_DIR = Path(__file__).resolve().parent
+PROJECT_ROOT = BASE_DIR.parent
+DATA_DIR = PROJECT_ROOT / "data"
+
+if load_dotenv is not None:
+    load_dotenv(PROJECT_ROOT / ".env")
+
+FRED_API_KEY = os.getenv("FRED_API_KEY", "").strip()
+FORECAST_MODE = os.getenv("FORECAST_MODE", os.getenv("FORECAST_HORIZON", "monthly")).lower()
+FINBERT_MODEL = os.getenv("FINBERT_MODEL", "ProsusAI/finbert")
+FRED_SERIES_TIPS = "DFII10"
+FRED_SERIES_2Y = "DGS2"
+
+HORIZONS = {"daily": 30, "monthly": 22, "yearly": 252}
+if FORECAST_MODE not in HORIZONS:
+    raise ValueError(f"FORECAST_MODE must be one of {', '.join(HORIZONS)}")

macro_forecast_engine/data_fetcher.py

@@ -0,0 +1,9 @@
+"""Compatibility exports for timeframe-aware market data ingestion."""
+
+from .data_loader import (
+    GOLD_TICKERS,
+    INTRADAY_PERIOD_LIMITS,
+    fetch_market_data,
+)
+
+__all__ = ["GOLD_TICKERS", "INTRADAY_PERIOD_LIMITS", "fetch_market_data"]

macro_forecast_engine/data_loader.py

@@ -0,0 +1,300 @@
+"""Institutional cross-asset and macro data ingestion helpers."""
+
+from __future__ import annotations
+
+import os
+import re
+import warnings
+from pathlib import Path
+from io import StringIO
+import xml.etree.ElementTree as ET
+from typing import Any, Iterable, Mapping, Optional
+
+import numpy as np
+import pandas as pd
+import requests
+from sklearn.preprocessing import RobustScaler
+
+try:
+    from .data_processor import add_sentiment_and_flow
+except ImportError:  # Modal may load this file as a top-level script.
+    from macro_forecast_engine.data_processor import add_sentiment_and_flow
+
+try:
+    import yfinance as yf
+except ImportError:  # pragma: no cover
+    yf = None
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+GOLD_TICKERS = ("GC=F", "XAUUSD=X")
+INTRADAY_PERIOD_LIMITS = {
+    "15m": ("60d", "15m"),
+    "1h": ("60d", "1h"),
+    "4h": ("60d", "1h"),
+    "1d": ("730d", "1d"),
+}
+
+
+def _download(ticker: str, period: str = "10y", interval: str = "1d") -> pd.DataFrame:
+    if yf is None:
+        raise RuntimeError("yfinance is required for market data ingestion")
+    frame = yf.download(ticker, period=period, interval=interval, auto_adjust=False,
+                        progress=False, threads=False)
+    if isinstance(frame.columns, pd.MultiIndex):
+        frame.columns = frame.columns.get_level_values(0)
+    if frame.empty:
+        raise ValueError(f"No data returned for {ticker}")
+    frame.index = pd.to_datetime(frame.index, utc=True).tz_localize(None)
+    frame.columns = [str(column).lower() for column in frame.columns]
+    return frame
+
+
+def _normalized_request(period: str, interval: str) -> tuple[str, str]:
+    configured = INTRADAY_PERIOD_LIMITS.get(interval.lower())
+    return configured if configured else (period, interval)
+
+
+def _cache_path(interval: str) -> Path:
+    normalized = interval.lower()
+    suffix = "1d" if normalized in {"1d", "d"} else normalized
+    safe_suffix = re.sub(r"[^a-z0-9_-]", "", suffix) or "1d"
+    return PROJECT_ROOT / "cache" / f"gold_cache_{safe_suffix}.csv"
+
+
+def _load_cached_gold(interval: str) -> pd.DataFrame:
+    cache_path = _cache_path(interval)
+    if not cache_path.exists():
+        return pd.DataFrame()
+    try:
+        cached = pd.read_csv(cache_path, index_col=0, parse_dates=True)
+        cached.index = pd.to_datetime(cached.index, utc=True).tz_localize(None)
+        if "gold_close" not in cached.columns:
+            return pd.DataFrame()
+        return cached.sort_index().dropna(subset=["gold_close"])
+    except (OSError, ValueError, TypeError):
+        return pd.DataFrame()
+
+
+def _fetch_gold(period: str, interval: str, cache_key: str | None = None) -> pd.DataFrame:
+    request_period, request_interval = _normalized_request(period, interval)
+    for ticker in GOLD_TICKERS:
+        try:
+            data = _download(ticker, request_period, request_interval)
+            if "close" not in data.columns or data["close"].dropna().empty:
+                continue
+            result = data.rename(columns={
+                "open": "gold_open", "high": "gold_high", "low": "gold_low",
+                "close": "gold_close", "volume": "gold_volume",
+            })
+            cache_path = _cache_path(cache_key or request_interval)
+            cache_path.parent.mkdir(parents=True, exist_ok=True)
+            result.to_csv(cache_path)
+            return result
+        except (RuntimeError, ValueError, requests.RequestException, OSError):
+            continue
+    cached = _load_cached_gold(cache_key or request_interval)
+    if not cached.empty:
+        return cached
+    raise ValueError("Gold market data is unavailable from GC=F, XAUUSD=X, and local cache")
+
+
+def fetch_market_data(period: str = "10y", interval: str = "1d") -> pd.DataFrame:
+    """Fetch gold, DXY, GVZ, ETF holdings/volume, and align daily factors."""
+    gold = _fetch_gold(period, interval, cache_key=interval)
+    frames: list[pd.DataFrame] = [gold]
+    request_period, request_interval = _normalized_request(period, interval)
+    for ticker, prefix in (("DX-Y.NYB", "dxy"),
+                           ("^GVZ", "gvz"), ("GLD", "gld"), ("IAU", "iau")):
+        try:
+            data = _download(ticker, request_period, request_interval)
+        except (RuntimeError, ValueError, requests.RequestException, OSError):
+            continue
+        columns = {
+            "open": f"{prefix}_open", "high": f"{prefix}_high",
+            "low": f"{prefix}_low", "close": f"{prefix}_close",
+            "volume": f"{prefix}_volume",
+        }
+        available = {source: target for source, target in columns.items() if source in data.columns}
+        frames.append(data.rename(columns=available)[list(available.values())])
+    frame = frames[0]
+    for other in frames[1:]:
+        frame = frame.join(other, how="left")
+    return frame.sort_index().ffill().dropna(subset=["gold_close"])
+
+
+def _fred_series(series_id: str, start_date: Optional[str], end_date: Optional[str],
+                 api_key: Optional[str] = None) -> pd.Series:
+    params = {"id": series_id, "cosd": start_date or "", "coed": end_date or ""}
+    url = "https://fred.stlouisfed.org/graph/fredgraph.csv"
+    api_key = (api_key or os.getenv("FRED_API_KEY", "")).strip()
+    if api_key:
+        url = "https://api.stlouisfed.org/fred/series/observations"
+        params = {"series_id": series_id, "api_key": api_key, "file_type": "json",
+                  "observation_start": start_date or "", "observation_end": end_date or ""}
+        response = requests.get(url, params=params, timeout=30)
+        response.raise_for_status()
+        data = pd.DataFrame(response.json().get("observations", []))
+        series = data.set_index("date")["value"]
+    else:
+        response = requests.get(url, params=params, timeout=30)
+        response.raise_for_status()
+        data = pd.read_csv(StringIO(response.text))
+        date_column = "DATE" if "DATE" in data.columns else "observation_date"
+        series = data.set_index(date_column)[series_id].replace(".", np.nan)
+    series.index = pd.to_datetime(series.index, utc=True).tz_localize(None)
+    return pd.to_numeric(series, errors="coerce").rename(series_id).dropna()
+
+
+def fetch_macro_data(start_date: str, end_date: str,
+                     fred_api_key: Optional[str] = None) -> pd.DataFrame:
+    """Fetch TIPS real yields and the 10Y-2Y Treasury curve spread."""
+    result = pd.DataFrame(index=pd.date_range(start_date, end_date, freq="D"))
+    for series_id, name in (("DFII10", "tips10y"), ("DGS10", "ust10y"), ("DGS2", "ust2y")):
+        try:
+            result = result.join(
+                _fred_series(series_id, start_date, end_date, api_key=fred_api_key),
+                how="left",
+            )
+        except (requests.RequestException, ValueError, KeyError):
+            result[name] = np.nan
+    if "DGS10" in result and "DGS2" in result:
+        result["curve_spread_10y2y"] = result["DGS10"] - result["DGS2"]
+    else:
+        result["curve_spread_10y2y"] = np.nan
+    return result.rename(columns={"DFII10": "tips10y"}).drop(columns=["DGS10", "DGS2"], errors="ignore")
+
+
+def fetch_cot_data() -> pd.DataFrame:
+    """Fetch current CFTC disaggregated gold positioning when available."""
+    url = "https://publicreporting.cftc.gov/resource/jun7-fc8e.json"
+    try:
+        response = requests.get(url, params={"$limit": 2000, "$q": "GOLD"}, timeout=30)
+        response.raise_for_status()
+        rows = response.json()
+        data = pd.DataFrame(rows)
+        date_col = next((c for c in ("report_date_as_yyyy_mm_dd", "report_date") if c in data), None)
+        if date_col is None:
+            return pd.DataFrame()
+        data.index = pd.to_datetime(data[date_col], errors="coerce")
+        result = pd.DataFrame(index=data.index)
+        for prefix, target in (("comm_positions", "commercial_positions"),
+                               ("noncomm_positions", "noncommercial_positions")):
+            long = next((c for c in data.columns if c.startswith(f"{prefix}_long")), None)
+            short = next((c for c in data.columns if c.startswith(f"{prefix}_short")), None)
+            if long and short:
+                result[target] = (
+                    pd.to_numeric(data[long], errors="coerce")
+                    - pd.to_numeric(data[short], errors="coerce")
+                )
+        return result.groupby(level=0).last().sort_index()
+    except (requests.RequestException, ValueError, KeyError):
+        return pd.DataFrame()
+
+
+GOLD_NEWS_FEEDS: tuple[tuple[str, str], ...] = (
+    ("forexlive_gold", "https://www.forexlive.com/feed/news"),
+    ("investing_commodities", "https://www.investing.com/rss/commodities.rss"),
+    ("marketwatch_macro", "https://feeds.marketwatch.com/marketwatch/marketpulse/"),
+)
+GOLD_MACRO_KEYWORDS = re.compile(
+    r"\b("
+    r"gold|xauusd|fomc rate|cpi|inflation|non[- ]farm payrolls?|"
+    r"dxy|yields?"
+    r")\b",
+    re.IGNORECASE,
+)
+
+
+def filter_gold_macro_headlines(headlines: Iterable[Any]) -> list[str]:
+    """Keep only headlines tied to gold macro drivers."""
+    return [text for item in headlines if (text := str(item).strip())
+            and GOLD_MACRO_KEYWORDS.search(text)]
+
+
+def fetch_live_news() -> pd.DataFrame:
+    rows: list[dict[str, Any]] = []
+    for source, feed_url in GOLD_NEWS_FEEDS:
+        try:
+            response = requests.get(feed_url, headers={"User-Agent": "macro-forecast-engine/1.0"}, timeout=30)
+            response.raise_for_status()
+            root = ET.fromstring(response.content)
+        except (requests.RequestException, ET.ParseError):
+            continue
+        for item in root.findall(".//item"):
+            title = (item.findtext("title") or "").strip()
+            date = pd.to_datetime(item.findtext("pubDate"), errors="coerce", utc=True)
+            if title and not pd.isna(date) and GOLD_MACRO_KEYWORDS.search(title):
+                rows.append({"date": date.tz_localize(None), "headline": title, "source": source})
+    result = pd.DataFrame(rows, columns=["date", "headline", "source"])
+    if result.empty:
+        return result
+    return result.drop_duplicates(subset=["headline"]).sort_values("date", ascending=False).reset_index(drop=True)
+
+
+def score_headlines(headlines: Iterable[Any], model_name: str = "ProsusAI/finbert") -> float:
+    texts = filter_gold_macro_headlines(headlines)
+    if not texts:
+        return float("nan")
+    try:
+        from transformers import pipeline
+        try:
+            classifier = pipeline("text-classification", model=model_name, top_k=None, device=0)
+        except (RuntimeError, OSError, ValueError):
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore", UserWarning)
+                classifier = pipeline("text-classification", model=model_name, top_k=None, device=-1)
+        values = []
+        for output in classifier(texts, truncation=True, max_length=256):
+            labels = output if isinstance(output, list) else [output]
+            scores = {str(item["label"]).lower(): float(item["score"]) for item in labels}
+            positive = scores.get("positive", scores.get("bullish", 0.0))
+            negative = scores.get("negative", scores.get("bearish", 0.0))
+            neutral = scores.get("neutral", 0.0)
+            values.append((positive - negative) * (1.0 - 0.25 * neutral))
+        return float(np.mean(values)) if values else float("nan")
+    except (ImportError, OSError, RuntimeError, ValueError):
+        bullish = re.compile(
+            r"\b(weak dollar|dollar falls?|dxy falls?|lower yield|rate cut|"
+            r"dovish|recession|uncertainty|gold rises?)\b", re.I,
+        )
+        bearish = re.compile(
+            r"\b(strong dollar|dollar rises?|dxy rises?|higher yield|yields? rise|"
+            r"rate hike|hawkish|hot inflation|cpi rises|ppi rises|payrolls beat)\b", re.I,
+        )
+        values = []
+        for text in texts:
+            positive = len(bullish.findall(text))
+            negative = len(bearish.findall(text))
+            values.append((positive - negative) / max(1, positive + negative))
+        return float(np.mean(values)) if values else float("nan")
+
+
+def build_feature_frame(daily: pd.DataFrame, macro: Optional[pd.DataFrame] = None,
+                        cot: Optional[pd.DataFrame] = None,
+                        news: Optional[pd.DataFrame] = None) -> pd.DataFrame:
+    """Align market, macro, positioning, ETF, volatility, and NLP velocity features."""
+    frame = daily.copy().sort_index()
+    if macro is not None:
+        frame = frame.join(macro.reindex(frame.index, method="ffill"), how="left")
+    if cot is not None and not cot.empty:
+        frame = frame.join(cot.reindex(frame.index, method="ffill"), how="left")
+    sentiment = 0.0
+    if news is not None and not news.empty:
+        scored_sentiment = score_headlines(news["headline"].tolist())
+        sentiment = 0.0 if pd.isna(scored_sentiment) else float(scored_sentiment)
+    frame = add_sentiment_and_flow(frame, sentiment, cot)
+    frame["sentiment"] = sentiment
+    frame["sentiment_velocity"] = frame["sentiment"].diff().fillna(0.0)
+    for column in ("tips10y", "curve_spread_10y2y", "commercial_positions",
+                   "noncommercial_positions", "gvz_close", "gld_volume", "iau_volume"):
+        if column not in frame:
+            frame[column] = 0.0
+        frame[column] = pd.to_numeric(frame[column], errors="coerce").ffill().bfill().fillna(0.0)
+    scaled_columns = [
+        "gvz_close", "gld_volume", "iau_volume",
+        "commercial_positions", "noncommercial_positions",
+    ]
+    frame[scaled_columns] = RobustScaler().fit_transform(frame[scaled_columns])
+    frame["gold_return"] = frame["gold_close"].pct_change()
+    frame["dxy_return"] = frame["dxy_close"].pct_change()
+    return frame.replace([np.inf, -np.inf], np.nan).dropna(subset=["gold_close"])

macro_forecast_engine/data_processor.py

@@ -0,0 +1,40 @@
+"""Macro sentiment and institutional flow feature aggregation."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import pandas as pd
+
+
+def add_sentiment_and_flow(
+    frame: pd.DataFrame,
+    sentiment: float,
+    cot: Optional[pd.DataFrame],
+) -> pd.DataFrame:
+    """Add central-bank sentiment and CFTC-derived institutional flow features."""
+    result = frame.copy()
+    result["central_bank_sentiment"] = float(sentiment)
+    result["institutional_flow"] = 0.0
+    if cot is not None and not cot.empty:
+        columns = [name for name in ("commercial_positions", "noncommercial_positions")
+                   if name in result]
+        if columns:
+            result["institutional_flow"] = result[columns].diff().sum(axis=1).fillna(0.0)
+    return result
+
+
+def analyze_news_sentiment(news: pd.DataFrame, model_name: str = "ProsusAI/finbert") -> dict[str, float]:
+    """Score live news and expose a simple sentiment velocity metric."""
+    from .data_loader import score_headlines
+
+    if news.empty or "headline" not in news:
+        return {"score": 0.0, "velocity": 0.0}
+    score = score_headlines(news["headline"].tolist(), model_name=model_name)
+    if pd.isna(score):
+        return {"score": float("nan"), "velocity": float("nan")}
+    midpoint = max(1, len(news) // 2)
+    recent = score_headlines(news["headline"].head(midpoint).tolist(), model_name=model_name)
+    prior = score_headlines(news["headline"].tail(len(news) - midpoint).tolist(), model_name=model_name)
+    velocity = float(recent - prior) if not pd.isna(prior) else float(score)
+    return {"score": float(score), "velocity": float(velocity)}

macro_forecast_engine/finrix_config.py

@@ -0,0 +1,46 @@
+"""Persistent FINRIX terminal settings."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+DEFAULT_CONFIG: dict[str, Any] = {
+    "execution_environment": "modal",
+    "account_equity": 1000.0,
+    "risk_per_trade_pct": 1.0,
+    "micro_lot_floor": 0.01,
+    "theme": "dark_green",
+}
+VALID_ENVIRONMENTS = {"modal", "local"}
+
+
+def load_config(path: Path) -> dict[str, Any]:
+    config = dict(DEFAULT_CONFIG)
+    if path.exists():
+        try:
+            loaded = json.loads(path.read_text(encoding="utf-8-sig"))
+            if isinstance(loaded, dict):
+                config.update(loaded)
+        except (OSError, json.JSONDecodeError):
+            pass
+    config["execution_environment"] = (
+        config["execution_environment"]
+        if config["execution_environment"] in VALID_ENVIRONMENTS
+        else DEFAULT_CONFIG["execution_environment"]
+    )
+    for key in ("account_equity", "risk_per_trade_pct", "micro_lot_floor"):
+        try:
+            config[key] = max(0.0, float(config[key]))
+        except (TypeError, ValueError):
+            config[key] = DEFAULT_CONFIG[key]
+    return config
+
+
+def save_config(path: Path, config: dict[str, Any]) -> dict[str, Any]:
+    normalized = load_config(path)
+    normalized.update(config)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(normalized, indent=2) + "\n", encoding="utf-8")
+    return normalized

macro_forecast_engine/indicator_params.py

@@ -0,0 +1,77 @@
+"""Persistent FINRIX MT5/TradingView indicator parameters."""
+
+from __future__ import annotations
+
+import json
+import math
+from pathlib import Path
+from typing import Any
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+INDICATOR_PARAMS_PATH = PROJECT_ROOT / "data" / "finrix_indicator_params.json"
+
+DEFAULT_INDICATOR_PARAMS: dict[str, dict[str, float | int]] = {
+    "rsi": {"period": 14, "overbought": 70, "oversold": 30},
+    "ema": {"fast_period": 9, "slow_period": 21, "trend_period": 200},
+    "macd": {"fast": 12, "slow": 26, "signal": 9},
+    "bollinger": {"period": 20, "std_dev": 2.0},
+    "supertrend": {"atr_period": 10, "factor": 3.0},
+    "stochastic": {"k_period": 14, "d_period": 3, "slowing": 3},
+    "adx": {"period": 14, "threshold": 25},
+    "atr": {"period": 14},
+    "ichimoku": {"tenkan": 9, "kijun": 26, "senkou_b": 52},
+    "smc": {"fvg_min_pip_gap": 1.5, "order_block_lookback": 20},
+}
+
+_LIMITS: dict[str, dict[str, tuple[float, float]]] = {
+    "rsi": {"period": (2, 100), "overbought": (50, 99), "oversold": (1, 50)},
+}
+
+
+def _coerce(value: Any, default: float | int) -> float | int:
+    try:
+        converted = float(value)
+    except (TypeError, ValueError):
+        return default
+    # Guard against infinity and NaN - clamp to safe defaults
+    if not math.isfinite(converted):
+        return default
+    if isinstance(default, int):
+        return int(round(converted))
+    return converted
+
+
+def validate_indicator_params(params: dict[str, Any] | None) -> dict[str, dict[str, float | int]]:
+    source = params or {}
+    result: dict[str, dict[str, float | int]] = {}
+    for group, defaults in DEFAULT_INDICATOR_PARAMS.items():
+        result[group] = {}
+        for key, default in defaults.items():
+            value = _coerce(source.get(group, {}).get(key), default)
+            low, high = _LIMITS.get(group, {}).get(key, (0.1, 1000.0))
+            result[group][key] = min(high, max(low, value))
+    result["rsi"]["oversold"] = min(result["rsi"]["oversold"], result["rsi"]["overbought"] - 1)
+    result["rsi"]["overbought"] = max(result["rsi"]["overbought"], result["rsi"]["oversold"] + 1)
+    return result
+
+
+def load_indicator_params(path: Path = INDICATOR_PARAMS_PATH) -> dict[str, dict[str, float | int]]:
+    try:
+        params = json.loads(path.read_text(encoding="utf-8-sig"))
+    except (OSError, json.JSONDecodeError):
+        params = {}
+    validated = validate_indicator_params(params)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if not path.exists() or validated != params:
+        path.write_text(json.dumps(validated, indent=2), encoding="utf-8")
+    return validated
+
+
+def save_indicator_params(
+    params: dict[str, Any],
+    path: Path = INDICATOR_PARAMS_PATH,
+) -> dict[str, dict[str, float | int]]:
+    validated = validate_indicator_params(params)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(validated, indent=2), encoding="utf-8")
+    return validated

macro_forecast_engine/json_utils.py

@@ -0,0 +1,27 @@
+"""JSON-safe conversion helpers shared by local and Modal execution paths."""
+
+from __future__ import annotations
+
+from datetime import date, datetime
+from typing import Any
+
+import numpy as np
+import pandas as pd
+
+
+def _json_safe(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {str(key): _json_safe(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_json_safe(item) for item in value]
+    if value is pd.NaT or isinstance(value, type(pd.NaT)):
+        return None
+    if isinstance(value, (datetime, date)):
+        return value.isoformat()
+    if value is None:
+        return None
+    if isinstance(value, (np.integer, np.floating)):
+        value = value.item()
+    if isinstance(value, float) and not np.isfinite(value):
+        return None
+    return value