marketmyna 0.2.0__py3-none-any.whl

marketmyna/analysis/sip_optimizer.py

@@ -0,0 +1,81 @@
+"""SIP (Systematic Investment Plan) Optimization Module."""
+
+from dataclasses import dataclass
+from typing import Optional
+
+from marketmyna.data.mutual_funds import MutualFundDataFetcher
+
+
+@dataclass
+class StepUpSIPProjection:
+    """Step-up SIP projection."""
+    base_amount: float
+    annual_increase_pct: float
+    duration_years: int
+    expected_return_pct: float
+    total_invested: float
+    projected_corpus: float
+    projected_gain: float
+    yearly_breakdown: list[dict]
+
+
+
+class SIPOptimizer:
+    """SIP optimization and analysis tools."""
+
+    def __init__(self, data_fetcher: Optional[MutualFundDataFetcher] = None):
+        self.data_fetcher = data_fetcher or MutualFundDataFetcher()
+
+
+
+
+    def calculate_step_up_sip(
+        self,
+        base_amount: float,
+        annual_increase_pct: float,
+        duration_years: int,
+        expected_return_pct: float,
+    ) -> StepUpSIPProjection:
+        """
+        Calculate step-up SIP projection where SIP amount increases annually.
+        """
+        monthly_rate = expected_return_pct / 100 / 12
+
+        total_invested = 0
+        corpus = 0
+        yearly_breakdown = []
+        current_amount = base_amount
+
+        for year in range(1, duration_years + 1):
+            year_invested = 0
+            year_start_corpus = corpus
+
+            for month in range(12):
+                # Add this month's investment
+                corpus = corpus * (1 + monthly_rate) + current_amount
+                year_invested += current_amount
+                total_invested += current_amount
+
+            yearly_breakdown.append({
+                'year': year,
+                'monthly_sip': current_amount,
+                'year_invested': year_invested,
+                'year_end_corpus': corpus,
+                'year_growth': corpus - year_start_corpus - year_invested,
+            })
+
+            # Increase for next year
+            current_amount = current_amount * (1 + annual_increase_pct / 100)
+
+        projected_gain = corpus - total_invested
+
+        return StepUpSIPProjection(
+            base_amount=base_amount,
+            annual_increase_pct=annual_increase_pct,
+            duration_years=duration_years,
+            expected_return_pct=expected_return_pct,
+            total_invested=total_invested,
+            projected_corpus=corpus,
+            projected_gain=projected_gain,
+            yearly_breakdown=yearly_breakdown,
+        )

marketmyna/analysis/technical.py

@@ -0,0 +1,321 @@
+"""Technical analysis indicators and signals."""
+
+from dataclasses import dataclass
+from enum import Enum
+
+import numpy as np
+import pandas as pd
+
+
+class Signal(Enum):
+    """Trading signal types."""
+    STRONG_BUY = "strong_buy"
+    BUY = "buy"
+    NEUTRAL = "neutral"
+    SELL = "sell"
+    STRONG_SELL = "strong_sell"
+
+
+@dataclass
+class IndicatorResult:
+    """Result of a technical indicator calculation."""
+    name: str
+    value: float
+    signal: Signal
+    description: str = ""
+
+
+class TechnicalAnalyzer:
+    """Technical analysis calculator."""
+
+    def __init__(self, df: pd.DataFrame):
+        """
+        Initialize with OHLCV dataframe.
+
+        Args:
+            df: DataFrame with columns: open, high, low, close, volume
+        """
+        self.df = df.copy()
+        self._ensure_columns()
+
+    def _ensure_columns(self):
+        """Ensure required columns exist with proper names."""
+        col_map = {
+            "Open": "open",
+            "High": "high",
+            "Low": "low",
+            "Close": "close",
+            "Volume": "volume",
+        }
+        for old, new in col_map.items():
+            if old in self.df.columns and new not in self.df.columns:
+                self.df[new] = self.df[old]
+
+    # Moving Averages
+    def sma(self, period: int = 20, column: str = "close") -> pd.Series:
+        """Simple Moving Average."""
+        return self.df[column].rolling(window=period).mean()
+
+    def ema(self, period: int = 20, column: str = "close") -> pd.Series:
+        """Exponential Moving Average."""
+        return self.df[column].ewm(span=period, adjust=False).mean()
+
+
+    # Momentum Indicators
+    def rsi(self, period: int = 14) -> pd.Series:
+        """Relative Strength Index, Wilder smoothing - the same formula as
+        broker charts and the rest of the app (marketmyna/trading/indicators.py)."""
+        from ..trading.indicators import rsi
+
+        return rsi(self.df["close"].astype(float), period)
+
+    def macd(
+        self, fast: int = 12, slow: int = 26, signal: int = 9
+    ) -> tuple[pd.Series, pd.Series, pd.Series]:
+        """
+        MACD - Moving Average Convergence Divergence.
+
+        Returns: (macd_line, signal_line, histogram)
+        """
+        ema_fast = self.ema(fast)
+        ema_slow = self.ema(slow)
+        macd_line = ema_fast - ema_slow
+        signal_line = macd_line.ewm(span=signal, adjust=False).mean()
+        histogram = macd_line - signal_line
+
+        return macd_line, signal_line, histogram
+
+    def stochastic(
+        self, k_period: int = 14, d_period: int = 3
+    ) -> tuple[pd.Series, pd.Series]:
+        """
+        Stochastic Oscillator.
+
+        Returns: (k_line, d_line)
+        """
+        low_min = self.df["low"].rolling(window=k_period).min()
+        high_max = self.df["high"].rolling(window=k_period).max()
+
+        k = 100 * (self.df["close"] - low_min) / (high_max - low_min)
+        d = k.rolling(window=d_period).mean()
+
+        return k, d
+
+    def williams_r(self, period: int = 14) -> pd.Series:
+        """Williams %R."""
+        high_max = self.df["high"].rolling(window=period).max()
+        low_min = self.df["low"].rolling(window=period).min()
+
+        return -100 * (high_max - self.df["close"]) / (high_max - low_min)
+
+    def cci(self, period: int = 20) -> pd.Series:
+        """Commodity Channel Index."""
+        typical_price = (self.df["high"] + self.df["low"] + self.df["close"]) / 3
+        sma_tp = typical_price.rolling(window=period).mean()
+        mean_dev = typical_price.rolling(window=period).apply(
+            lambda x: np.abs(x - x.mean()).mean()
+        )
+
+        return (typical_price - sma_tp) / (0.015 * mean_dev)
+
+
+    # Volatility Indicators
+    def bollinger_bands(
+        self, period: int = 20, std_dev: float = 2.0
+    ) -> tuple[pd.Series, pd.Series, pd.Series]:
+        """
+        Bollinger Bands.
+
+        Returns: (upper_band, middle_band, lower_band)
+        """
+        middle = self.sma(period)
+        std = self.df["close"].rolling(window=period).std()
+        upper = middle + (std * std_dev)
+        lower = middle - (std * std_dev)
+
+        return upper, middle, lower
+
+    def atr(self, period: int = 14) -> pd.Series:
+        """Average True Range."""
+        high = self.df["high"]
+        low = self.df["low"]
+        close = self.df["close"]
+
+        tr1 = high - low
+        tr2 = abs(high - close.shift())
+        tr3 = abs(low - close.shift())
+
+        tr = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)
+        return tr.rolling(window=period).mean()
+
+
+    # Volume Indicators
+    def obv(self) -> pd.Series:
+        """On-Balance Volume."""
+        obv = [0]
+        for i in range(1, len(self.df)):
+            if self.df["close"].iloc[i] > self.df["close"].iloc[i - 1]:
+                obv.append(obv[-1] + self.df["volume"].iloc[i])
+            elif self.df["close"].iloc[i] < self.df["close"].iloc[i - 1]:
+                obv.append(obv[-1] - self.df["volume"].iloc[i])
+            else:
+                obv.append(obv[-1])
+        return pd.Series(obv, index=self.df.index)
+
+    def vwap(self) -> pd.Series:
+        """Volume Weighted Average Price."""
+        typical_price = (self.df["high"] + self.df["low"] + self.df["close"]) / 3
+        return (typical_price * self.df["volume"]).cumsum() / self.df["volume"].cumsum()
+
+    def mfi(self, period: int = 14) -> pd.Series:
+        """Money Flow Index."""
+        typical_price = (self.df["high"] + self.df["low"] + self.df["close"]) / 3
+        money_flow = typical_price * self.df["volume"]
+
+        positive_flow = money_flow.where(typical_price > typical_price.shift(), 0)
+        negative_flow = money_flow.where(typical_price < typical_price.shift(), 0)
+
+        positive_mf = positive_flow.rolling(window=period).sum()
+        negative_mf = negative_flow.rolling(window=period).sum()
+
+        mfi = 100 - (100 / (1 + positive_mf / negative_mf))
+        return mfi
+
+    # Trend Indicators
+    def adx(self, period: int = 14) -> pd.Series:
+        """Average Directional Index."""
+        high = self.df["high"]
+        low = self.df["low"]
+
+        plus_dm = high.diff()
+        minus_dm = low.diff().abs()
+
+        plus_dm = plus_dm.where((plus_dm > minus_dm) & (plus_dm > 0), 0)
+        minus_dm = minus_dm.where((minus_dm > plus_dm) & (minus_dm > 0), 0)
+
+        atr_val = self.atr(period)
+
+        plus_di = 100 * (plus_dm.rolling(window=period).mean() / atr_val)
+        minus_di = 100 * (minus_dm.rolling(window=period).mean() / atr_val)
+
+        dx = 100 * abs(plus_di - minus_di) / (plus_di + minus_di)
+        adx = dx.rolling(window=period).mean()
+
+        return adx
+
+    def supertrend(
+        self, period: int = 10, multiplier: float = 3.0
+    ) -> tuple[pd.Series, pd.Series]:
+        """
+        Supertrend indicator.
+
+        Returns: (supertrend, direction)  direction: 1=uptrend, -1=downtrend
+        """
+        atr_val = self.atr(period)
+        hl2 = (self.df["high"] + self.df["low"]) / 2
+
+        upper_band = hl2 + (multiplier * atr_val)
+        lower_band = hl2 - (multiplier * atr_val)
+
+        supertrend = pd.Series(index=self.df.index, dtype=float)
+        direction = pd.Series(index=self.df.index, dtype=float)
+
+        for i in range(period, len(self.df)):
+            if self.df["close"].iloc[i] > upper_band.iloc[i - 1]:
+                direction.iloc[i] = 1
+            elif self.df["close"].iloc[i] < lower_band.iloc[i - 1]:
+                direction.iloc[i] = -1
+            else:
+                direction.iloc[i] = direction.iloc[i - 1]
+
+            if direction.iloc[i] == 1:
+                supertrend.iloc[i] = lower_band.iloc[i]
+            else:
+                supertrend.iloc[i] = upper_band.iloc[i]
+
+        return supertrend, direction
+
+    # Analysis Summary
+    def get_signals(self) -> dict[str, IndicatorResult]:
+        """Get trading signals from multiple indicators."""
+        signals = {}
+        close = self.df["close"].iloc[-1]
+
+        # RSI Signal
+        rsi_val = self.rsi().iloc[-1]
+        if rsi_val < 30:
+            rsi_signal = Signal.BUY
+        elif rsi_val > 70:
+            rsi_signal = Signal.SELL
+        else:
+            rsi_signal = Signal.NEUTRAL
+        signals["rsi"] = IndicatorResult("RSI", rsi_val, rsi_signal)
+
+        # MACD Signal
+        macd_line, signal_line, _ = self.macd()
+        macd_val = macd_line.iloc[-1]
+        if macd_line.iloc[-1] > signal_line.iloc[-1] and macd_line.iloc[-2] <= signal_line.iloc[-2]:
+            macd_signal = Signal.BUY
+        elif macd_line.iloc[-1] < signal_line.iloc[-1] and macd_line.iloc[-2] >= signal_line.iloc[-2]:
+            macd_signal = Signal.SELL
+        else:
+            macd_signal = Signal.NEUTRAL
+        signals["macd"] = IndicatorResult("MACD", macd_val, macd_signal)
+
+        # Moving Average Signal
+        sma20 = self.sma(20).iloc[-1]
+        sma50 = self.sma(50).iloc[-1]
+        if close > sma20 > sma50:
+            ma_signal = Signal.BUY
+        elif close < sma20 < sma50:
+            ma_signal = Signal.SELL
+        else:
+            ma_signal = Signal.NEUTRAL
+        signals["ma"] = IndicatorResult("Moving Averages", sma20, ma_signal)
+
+        # Bollinger Bands Signal
+        upper, middle, lower = self.bollinger_bands()
+        bb_position = (close - lower.iloc[-1]) / (upper.iloc[-1] - lower.iloc[-1])
+        if bb_position < 0.2:
+            bb_signal = Signal.BUY
+        elif bb_position > 0.8:
+            bb_signal = Signal.SELL
+        else:
+            bb_signal = Signal.NEUTRAL
+        signals["bollinger"] = IndicatorResult("Bollinger Bands", bb_position * 100, bb_signal)
+
+        # Stochastic Signal
+        k, d = self.stochastic()
+        stoch_val = k.iloc[-1]
+        if stoch_val < 20:
+            stoch_signal = Signal.BUY
+        elif stoch_val > 80:
+            stoch_signal = Signal.SELL
+        else:
+            stoch_signal = Signal.NEUTRAL
+        signals["stochastic"] = IndicatorResult("Stochastic", stoch_val, stoch_signal)
+
+        return signals
+
+    def get_summary(self) -> dict:
+        """Get overall analysis summary."""
+        signals = self.get_signals()
+
+        buy_count = sum(1 for s in signals.values() if s.signal in [Signal.BUY, Signal.STRONG_BUY])
+        sell_count = sum(1 for s in signals.values() if s.signal in [Signal.SELL, Signal.STRONG_SELL])
+        neutral_count = sum(1 for s in signals.values() if s.signal == Signal.NEUTRAL)
+
+        if buy_count > sell_count + neutral_count:
+            overall = Signal.BUY
+        elif sell_count > buy_count + neutral_count:
+            overall = Signal.SELL
+        else:
+            overall = Signal.NEUTRAL
+
+        return {
+            "overall_signal": overall,
+            "buy_signals": buy_count,
+            "sell_signals": sell_count,
+            "neutral_signals": neutral_count,
+            "indicators": {name: {"value": r.value, "signal": r.signal.value} for name, r in signals.items()},
+        }

marketmyna/api/__init__.py

@@ -0,0 +1 @@
+"""FastAPI backend for MarketMyna (self-hosted web app)."""

marketmyna/api/app.py

@@ -0,0 +1,209 @@
+"""FastAPI application factory.
+
+Auth: single-user build, every request runs as the local owner
+(marketmyna/api/middlewares/auth.py).
+
+Phase 5 adds a lifespan: RuntimeSchedulerService is started on app
+startup and stopped on shutdown, stashed on app.state.scheduler so
+endpoints can reach the one running instance (marketmyna/api/deps.py's
+get_scheduler_service pulls it from there, matching the same
+"shared services live on app.state" pattern this whole API follows).
+
+Phase 6 adds a second background service to the same lifespan:
+TelegramListener (marketmyna/bot/telegram_listener.py), started only if
+config.telegram_bot_token is set (a no-op, logged, not an error,
+otherwise), stashed on app.state.telegram_listener and app.state.bot_dispatcher.
+
+The lifespan also warms the market listing cache (marketmyna/data/listings.py)
+on a daemon thread so the Markets page and symbol search are instant.
+"""
+
+from __future__ import annotations
+
+import os
+import threading
+import time
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+
+from marketmyna import __version__
+from marketmyna.api.deps import get_config_dep
+from marketmyna.api.middlewares.auth import AuthMiddleware, api_docs_enabled, check_auth_config
+from marketmyna.api.middlewares.auth import router as auth_router
+from marketmyna.api.middlewares.csrf import CSRFMiddleware
+from marketmyna.api.middlewares.error_handler import add_error_handlers
+from marketmyna.api.middlewares.slashes import StripTrailingSlashMiddleware
+from marketmyna.api.v1.endpoints.account import router as account_router
+from marketmyna.api.v1.router import router as api_v1_router
+from marketmyna.bot.registry import build_default_dispatcher
+from marketmyna.bot.telegram_listener import TelegramListener
+from marketmyna.core import tenant
+from marketmyna.data.listings import get_store
+from marketmyna.services.runtime_scheduler import RuntimeSchedulerService
+from marketmyna.trading.alerts import AlertMonitor
+
+# The server keeps times as naive UTC (datetime.now() in the UTC container) and
+# the frontend's serverTime() reads them as UTC; pin the zone so a dev machine
+# in another zone writes the same times as the server.
+os.environ["TZ"] = "UTC"
+if hasattr(time, "tzset"):
+    time.tzset()
+else:  # Windows: no time.tzset(); the C runtime re-reads TZ ("UTC0": UTC, no daylight saving) on _tzset()
+    os.environ["TZ"] = "UTC0"
+    try:
+        import ctypes
+
+        ctypes.CDLL("ucrtbase")._tzset()
+    except (OSError, AttributeError):
+        pass
+
+DEFAULT_CORS_ORIGINS = [
+    "http://localhost:5174",
+    "http://localhost:3000",
+    "http://127.0.0.1:5174",
+    "http://127.0.0.1:3000",
+]
+# Extra allowed origins for a frontend on another domain that calls the API
+# directly (comma-separated). Not needed normally: the API serves the built
+# frontend itself (serve_frontend below), so both share one origin.
+EXTRA_CORS_ORIGINS = [o.strip() for o in os.environ.get("CORS_ORIGINS", "").split(",") if o.strip()]
+
+# The built frontend: frontend/dist in a git checkout (cd frontend && npm run build),
+# or marketmyna/web inside the installed package.
+_PACKAGE = Path(__file__).resolve().parent.parent
+FRONTEND_DIST = next((d for d in (_PACKAGE.parent / "frontend" / "dist", _PACKAGE / "web")
+                      if (d / "index.html").is_file()), _PACKAGE / "web")
+
+
+@asynccontextmanager
+async def app_lifespan(app: FastAPI):
+    config = get_config_dep()
+    if getattr(config, "_plaintext_secrets", False):
+        # One-time upgrade: re-save so older plain-text keys are encrypted on disk.
+        config.save()
+
+    scheduler = RuntimeSchedulerService(config)
+    scheduler.start()
+    app.state.scheduler = scheduler
+
+    dispatcher = build_default_dispatcher(config, scheduler_running=scheduler.is_running)
+    app.state.bot_dispatcher = dispatcher
+
+    telegram_listener = TelegramListener(config, dispatcher)
+    telegram_listener.start()
+    app.state.telegram_listener = telegram_listener
+
+    # Trade section: price alerts, checked every ALERT_POLL_SECONDS while markets are open.
+    alert_monitor = AlertMonitor(config, poll_seconds=int(os.environ.get("ALERT_POLL_SECONDS", "60")))
+    alert_monitor.start()
+    app.state.alert_monitor = alert_monitor
+
+    threading.Thread(target=get_store().rows, args=("all",), name="listings-warmup", daemon=True).start()
+
+    def _warm_funds():
+        import time as _t
+
+        _t.sleep(60)  # after the listings warm-up
+        from marketmyna.services.fund_rotation import warm
+
+        warm()
+
+    threading.Thread(target=_warm_funds, name="fund-rotation-warmup", daemon=True).start()
+
+    from marketmyna.services.fund_holdings import refresh_loop
+
+    threading.Thread(target=refresh_loop, name="fund-portfolios", daemon=True).start()
+
+    from marketmyna.services.sip_days import refresh_loop as sip_days_loop
+
+    threading.Thread(target=sip_days_loop, name="sip-days", daemon=True).start()
+
+    from marketmyna.services.market_valuation import snapshot_loop as valuation_loop
+
+    threading.Thread(target=valuation_loop, name="market-valuation", daemon=True).start()
+
+    from marketmyna.services.india_flows import snapshot_loop as flows_loop
+
+    threading.Thread(target=flows_loop, name="india-flows", daemon=True).start()
+
+    from marketmyna.services.mf_lumpsum import alert_loop as fund_dip_loop
+
+    threading.Thread(target=fund_dip_loop, args=(config,), name="fund-dip-alerts", daemon=True).start()
+
+    from marketmyna.api.v1.endpoints.updates import check_loop as updates_loop
+
+    # Looks for a new MarketMyna release / newer code on GitHub (Settings -> Updates).
+    threading.Thread(target=updates_loop, name="update-check", daemon=True).start()
+
+    try:
+        yield
+    finally:
+        telegram_listener.stop()
+        alert_monitor.stop()
+        scheduler.stop()
+
+
+def create_app() -> FastAPI:
+    check_auth_config()
+    # Every Yahoo Finance request on this server shares one pace and 429 cooldown.
+    from marketmyna.utils import yahoo_gate
+
+    yahoo_gate.install()
+    # Scope every owned-table query to the signed-in user.
+    tenant.enable(bool(get_config_dep().accounts_enabled))
+    docs = api_docs_enabled()
+    app = FastAPI(title="MarketMyna API", version=__version__, lifespan=app_lifespan, redirect_slashes=False,
+                  docs_url="/docs" if docs else None, redoc_url="/redoc" if docs else None,
+                  openapi_url="/openapi.json" if docs else None)
+
+    # Added before CORS so CORS ends up outermost and 401s still carry CORS headers.
+    app.add_middleware(AuthMiddleware)
+    # Cross-site writes are refused before any session lookup (marketmyna/api/middlewares/csrf.py).
+    app.add_middleware(CSRFMiddleware, allowed_origins=DEFAULT_CORS_ORIGINS + EXTRA_CORS_ORIGINS)
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=DEFAULT_CORS_ORIGINS + EXTRA_CORS_ORIGINS,
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+    app.add_middleware(StripTrailingSlashMiddleware)
+
+    add_error_handlers(app)
+
+    app.include_router(auth_router, prefix="/api/auth", tags=["auth"])
+    app.include_router(account_router, prefix="/api/auth/account", tags=["account"])
+    app.include_router(api_v1_router, prefix="/api/v1")
+
+    @app.get("/health")
+    @app.get("/api/health")
+    def health() -> dict:
+        return {"status": "ok"}
+
+    serve_frontend(app)
+    return app
+
+
+def serve_frontend(app: FastAPI, dist: Path = FRONTEND_DIST) -> None:
+    """Serves the built frontend at /, so one uvicorn process is the whole
+    app. Paths that are not files get index.html for the React router;
+    unknown /api/* paths stay 404s. Does nothing before the first build."""
+    dist = dist.resolve()
+    if not (dist / "index.html").is_file():
+        return
+
+    @app.get("/{path:path}", include_in_schema=False)
+    def frontend(path: str):
+        if path == "api" or path.startswith("api/"):
+            raise HTTPException(status_code=404)
+        file = (dist / path).resolve()
+        if path and file.is_file() and file.is_relative_to(dist):
+            return FileResponse(file)
+        return FileResponse(dist / "index.html")
+
+
+app = create_app()

marketmyna/api/deps.py

@@ -0,0 +1,63 @@
+"""FastAPI dependency-injection functions."""
+
+from __future__ import annotations
+
+from functools import lru_cache
+from typing import Iterator
+
+from fastapi import Depends, Request
+from sqlalchemy.orm import Session
+
+from marketmyna.core.config import Config
+from marketmyna.storage import DatabaseManager, get_db_url
+
+
+@lru_cache(maxsize=1)
+def get_config_dep() -> Config:
+    """Process-wide Config, loaded once per process."""
+    return Config.load()
+
+
+def get_database_manager() -> DatabaseManager:
+    config = get_config_dep()
+    return DatabaseManager.instance(get_db_url(config=config))
+
+
+def get_db_session(config: Config = Depends(get_config_dep)) -> Iterator[Session]:
+    """A request-scoped session: committed on success, rolled back on error."""
+    session = DatabaseManager.instance(get_db_url(config=config)).SessionLocal()
+    try:
+        yield session
+        session.commit()
+    except Exception:
+        session.rollback()
+        raise
+    finally:
+        session.close()
+
+
+def get_scheduler_service(request: Request):
+    """The RuntimeSchedulerService started in marketmyna/api/app.py's lifespan, off
+    app.state - lazily created if somehow missing (e.g. a test app built
+    without going through the real lifespan) rather than 500ing."""
+    scheduler = getattr(request.app.state, "scheduler", None)
+    if scheduler is None:
+        from marketmyna.services.runtime_scheduler import RuntimeSchedulerService
+
+        scheduler = RuntimeSchedulerService(get_config_dep())
+        scheduler.start()
+        request.app.state.scheduler = scheduler
+    return scheduler
+
+
+def get_bot_dispatcher(request: Request):
+    """The CommandDispatcher built in marketmyna/api/app.py's lifespan, off
+    app.state - lazily created if somehow missing, same fallback shape
+    as get_scheduler_service."""
+    dispatcher = getattr(request.app.state, "bot_dispatcher", None)
+    if dispatcher is None:
+        from marketmyna.bot.registry import build_default_dispatcher
+
+        dispatcher = build_default_dispatcher(get_config_dep())
+        request.app.state.bot_dispatcher = dispatcher
+    return dispatcher