marketmyna 0.2.0__py3-none-any.whl

marketmyna/bot/models.py

@@ -0,0 +1,27 @@
+"""Platform-agnostic message shapes."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Optional
+
+
+@dataclass
+class IncomingMessage:
+    """One message from any platform, normalized to the same shape
+    before it reaches CommandDispatcher."""
+
+    platform: str
+    chat_id: str
+    text: str
+    user_id: Optional[str] = None
+    raw: Any = None
+
+
+@dataclass
+class CommandResult:
+    """A command's response - plain text, no platform-specific
+    formatting (markdown/embeds/etc are each listener's own concern)."""
+
+    text: str
+    success: bool = True

marketmyna/bot/registry.py

@@ -0,0 +1,50 @@
+"""Builds a CommandDispatcher with every command registered - the one
+place that ordering (HelpCommand last, see commands/help.py) is handled,
+so callers (marketmyna/api/app.py's lifespan, tests, a future CLI) don't each have
+to get it right themselves."""
+
+from __future__ import annotations
+
+from typing import Callable, Optional
+
+from .commands.analyze import AnalyzeCommand
+from .commands.ask import AskCommand
+from .commands.batch import BatchCommand
+from .commands.help import HelpCommand
+from .commands.markets import CalendarCommand, MarketCommand, ScreenCommand, SectorsCommand
+from .commands.portfolio import PortfolioCommand, ReviewCommand, WatchlistCommand
+from .commands.research import (
+    CompareCommand,
+    DividendsCommand,
+    EstimatesCommand,
+    FinancialsCommand,
+    OverviewCommand,
+    PeersCommand,
+    QuoteCommand,
+    ShariahCommand,
+    ValuationCommand,
+)
+from .commands.status import StatusCommand
+from .commands.trade import AlertCommand, AlertsCommand, RiskCommand, ScanCommand
+from .dispatcher import CommandDispatcher
+
+
+def build_default_dispatcher(config, scheduler_running: Optional[Callable[[], bool]] = None) -> CommandDispatcher:
+    dispatcher = CommandDispatcher()
+    for research in (QuoteCommand, OverviewCommand, ValuationCommand, FinancialsCommand, EstimatesCommand,
+                     DividendsCommand, PeersCommand, ShariahCommand, CompareCommand):
+        dispatcher.register(research(config))
+    for market in (MarketCommand, SectorsCommand, ScreenCommand, CalendarCommand):
+        dispatcher.register(market(config))
+    for own in (PortfolioCommand, ReviewCommand, WatchlistCommand):
+        dispatcher.register(own(config))
+    dispatcher.register(AnalyzeCommand(config))
+    dispatcher.register(BatchCommand(config))
+    dispatcher.register(AskCommand(config))
+    dispatcher.register(StatusCommand(config, scheduler_running=scheduler_running))
+    dispatcher.register(AlertCommand(config))
+    dispatcher.register(AlertsCommand(config))
+    dispatcher.register(RiskCommand(config))
+    dispatcher.register(ScanCommand(config))
+    dispatcher.register(HelpCommand(dispatcher))
+    return dispatcher

marketmyna/bot/telegram_listener.py

@@ -0,0 +1,227 @@
+"""Real (not stubbed) inbound Telegram listener: long-polls getUpdates,
+routes each message through a CommandDispatcher, replies via Telegram's
+sendMessage - the one platform with genuine two-way bot support in this
+phase. The 13 other notifier channels in marketmyna/notifiers/ remain outbound
+(alert-push) only; each would need its own listener (webhook or poll,
+depending on the platform) as separate follow-up work.
+
+Reuses config.telegram_bot_token (the same credential marketmyna/notifiers/
+telegram.py's outbound TelegramSender uses) rather than a new field.
+Does NOT reuse TelegramSender itself for replies: that sender's chat_id
+is fixed at construction (one configured alert destination), but a bot
+must reply to whichever chat_id sent the incoming message, which can
+differ - so this calls Telegram's sendMessage directly with the
+per-message chat_id instead of force-fitting the wrong abstraction.
+
+Same start()/stop()/is_running() shape as RuntimeSchedulerService
+(marketmyna/services/runtime_scheduler.py) for consistency across the app's
+background services.
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+from typing import Optional
+
+import requests
+
+from .dispatcher import CommandDispatcher
+from .models import IncomingMessage
+
+logger = logging.getLogger(__name__)
+
+API_ROOT = "https://api.telegram.org"
+POLL_TIMEOUT_SECONDS = 30
+REQUEST_TIMEOUT_SECONDS = 35  # a bit more than the long-poll timeout itself
+ERROR_BACKOFF_SECONDS = 5.0
+
+
+IDLE_CHECK_SECONDS = 10.0  # how often to look for a newly saved token
+
+SETUP_REPLY = (
+    "👋 This is the MarketMyna bot.\n\n"
+    "Your chat ID is {chat_id} - paste it into Settings → Notifications → Telegram → Chat ID."
+)
+
+
+def allowed_chats(config) -> set[str]:
+    """Chats the bot obeys: Settings → Telegram → Chat ID (comma-separated for
+    several, e.g. you and a group)."""
+    raw = str(getattr(config, "telegram_chat_id", None) or "")
+    return {c.strip() for c in raw.split(",") if c.strip()}
+
+
+class TelegramListener:
+    """Long-polls getUpdates and answers commands - only from the chats in
+    Settings' Chat ID. Anyone else (and you, before a Chat ID is saved)
+    just gets told their chat ID, so the bot can't be used by strangers
+    who find its username.
+
+    Reads the token from the shared Config on every poll, so saving a
+    token in Settings takes effect without restarting the server."""
+
+    def __init__(self, config, dispatcher: CommandDispatcher):
+        self._config = config
+        self._dispatcher = dispatcher
+        self._last_update_id: Optional[int] = None
+        self._token_in_use: Optional[str] = None
+        self._stop_event = threading.Event()
+        self._thread: Optional[threading.Thread] = None
+
+    @property
+    def _bot_token(self) -> Optional[str]:
+        return getattr(self._config, "telegram_bot_token", None)
+
+    def is_configured(self) -> bool:
+        return bool(self._bot_token)
+
+    # ---- lifecycle ----
+
+    def start(self) -> None:
+        if self._thread is not None and self._thread.is_alive():
+            return
+        if not self.is_configured():
+            logger.info("TelegramListener waiting: no telegram_bot_token yet (picked up once saved in Settings)")
+        self._stop_event.clear()
+        self._thread = threading.Thread(target=self._loop, name="marketmyna-telegram-listener", daemon=True)
+        self._thread.start()
+
+    def stop(self, timeout: float = 5.0) -> None:
+        self._stop_event.set()
+        if self._thread is not None:
+            self._thread.join(timeout=timeout)
+
+    def is_running(self) -> bool:
+        return self._thread is not None and self._thread.is_alive()
+
+    # ---- polling loop ----
+
+    def _loop(self) -> None:
+        while not self._stop_event.is_set():
+            if not self._bot_token:
+                self._stop_event.wait(IDLE_CHECK_SECONDS)
+                continue
+            if self._bot_token != self._token_in_use:  # new or changed bot: start from its latest update
+                self._token_in_use = self._bot_token
+                self._last_update_id = None
+                self._publish_commands()
+            try:
+                self._poll_once()
+            except Exception:
+                logger.exception("Telegram poll failed, backing off")
+                self._stop_event.wait(ERROR_BACKOFF_SECONDS)
+
+    def _poll_once(self) -> None:
+        params = {"timeout": POLL_TIMEOUT_SECONDS}
+        if self._last_update_id is not None:
+            params["offset"] = self._last_update_id + 1
+
+        resp = requests.get(
+            f"{API_ROOT}/bot{self._bot_token}/getUpdates",
+            params=params,
+            timeout=REQUEST_TIMEOUT_SECONDS,
+        )
+        resp.raise_for_status()
+        payload = resp.json()
+        if not payload.get("ok"):
+            logger.warning("Telegram getUpdates returned ok=false: %s", payload)
+            return
+
+        for update in payload.get("result", []):
+            update_id = update.get("update_id")
+            if update_id is not None:
+                self._last_update_id = update_id
+
+            message = update.get("message")
+            if not message or "text" not in message:
+                continue  # edited_message/channel_post/non-text - skip, not an error
+
+            self._handle_message(message)
+
+    def _handle_message(self, message: dict) -> None:
+        from marketmyna.core import tenant
+
+        with tenant.system_scope():
+            self._handle_message_scoped(message)
+
+    def _command_scope(self, chat_id: str, is_owner: bool):
+        """Commands run as the owner (only the owner's chats get this far)."""
+        import contextlib
+
+        from marketmyna.core import tenant
+        from marketmyna.services.accounts import owner_scope
+
+        if not tenant.enabled():
+            return contextlib.nullcontext()
+        return owner_scope(self._config)
+
+    def _handle_message_scoped(self, message: dict) -> None:
+        chat_id = str(message["chat"]["id"])
+        text = message.get("text", "")
+        word = text.strip().split(" ")[0].split("@")[0]
+
+        is_owner = chat_id in allowed_chats(self._config)
+        if not is_owner:
+            # Not the owner's chat: never run commands, just explain how to connect.
+            if word in ("/start", "/id", "/help") or not allowed_chats(self._config):
+                self._reply(chat_id, SETUP_REPLY.format(chat_id=chat_id))
+            else:
+                logger.info("Ignored Telegram message from unauthorised chat %s", chat_id)
+            return
+
+        user = message.get("from") or {}
+        incoming = IncomingMessage(
+            platform="telegram",
+            chat_id=chat_id,
+            text=text,
+            user_id=str(user["id"]) if "id" in user else None,
+            raw=message,
+        )
+        if word in ("/start", "/id"):
+            self._reply(chat_id, f"✅ Connected to MarketMyna. Chat ID {chat_id}.\nSend /help for commands.")
+            return
+
+        with self._command_scope(chat_id, is_owner):
+            result = self._dispatcher.dispatch(incoming)
+        if result.text:
+            self._reply(chat_id, result.text)
+
+    def _publish_commands(self) -> None:
+        """Telegram's own "/" menu: the registered commands with their one-line descriptions."""
+        commands = [{"command": c.name, "description": (c.description or c.help_line())[:256]}
+                    for c in self._dispatcher.list_commands()][:100]
+        try:
+            requests.post(f"{API_ROOT}/bot{self._bot_token}/setMyCommands", json={"commands": commands},
+                          timeout=REQUEST_TIMEOUT_SECONDS)
+        except requests.RequestException:
+            logger.warning("Could not publish the Telegram command menu")
+
+    def _reply(self, chat_id: str, text: str) -> None:
+        for part in split_message(text):
+            try:
+                requests.post(
+                    f"{API_ROOT}/bot{self._bot_token}/sendMessage",
+                    json={"chat_id": chat_id, "text": part},
+                    timeout=REQUEST_TIMEOUT_SECONDS,
+                )
+            except requests.RequestException:
+                logger.exception("Failed to send Telegram reply to chat %s", chat_id)
+                return
+
+
+def split_message(text: str, limit: int = 4000) -> list[str]:
+    """Telegram caps a message at 4096 characters: split on line breaks."""
+    parts, current = [], ""
+    for line in text.split("\n"):
+        while len(line) > limit:
+            parts.append(line[:limit])
+            line = line[limit:]
+        if current and len(current) + 1 + len(line) > limit:
+            parts.append(current)
+            current = line
+        else:
+            current = f"{current}\n{line}" if current else line
+    if current:
+        parts.append(current)
+    return parts

marketmyna/cli/__init__.py

@@ -0,0 +1 @@
+"""Command-line entry points (headless runs, e.g. from cron)."""

marketmyna/cli/scheduled_run.py

@@ -0,0 +1,292 @@
+"""Headless scheduled analysis: analyze a stock list, then push the report
+to every configured notification channel.
+
+Runs anywhere - cron, a server, your laptop:
+
+    python -m marketmyna.cli.scheduled_run --symbols "RELIANCE,TCS,us:AAPL" --market india
+    python -m marketmyna.cli.scheduled_run --watchlist "My watchlist" --dry-run
+
+Everything can also come from environment variables, which is how the
+workflow passes GitHub Secrets/Variables in:
+
+    STOCK_LIST       symbols, comma-separated; "market:SYMBOL" overrides the market
+    MARKET           default market for unprefixed symbols (default: india)
+    ANALYSIS_MODE    quick | standard | full | specialist (default: standard)
+    REPORT_TIMEZONE  timestamp timezone in the report (default: Asia/Kolkata)
+    TRADING_DAY_CHECK_ENABLED  "false" to also run on weekends
+    REPORT_LANGUAGE  default report language code, e.g. en, hi, ta, zh (default: en)
+    REPORT_SECTIONS  comma-separated section ids (see marketmyna/services/report.py SECTIONS)
+    STOCK_SECTIONS   per-stock sections: "RELIANCE=news+fundamentals,TCS=technical"
+    CHANNEL_LANGUAGES  per-channel language: "telegram:ta,email:en"
+    SMART_MESSAGING  "true": short top-N message + full report (HTML email/file)
+    SMART_TOP_N      stocks in the short message (default 5)
+    SMART_AI_TOP     stocks that get the AI pipeline (default 10; 0 = none)
+    SMART_EMAIL_FULL "false": email gets only the short message
+    REPORT_BASE_URL  public MarketMyna address for full-report links
+    MF_LIST          AMFI scheme codes for the mutual-fund section: "122639,120503"
+    + LLM_* and every notification channel field (TELEGRAM_BOT_TOKEN, ...),
+      read by Config.apply_env().
+
+Exit codes: 0 = report produced (and delivered, if any channel is set),
+1 = nothing to analyze or every symbol failed outright,
+2 = channels are configured but none accepted the message.
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+from zoneinfo import ZoneInfo
+
+from ..core.config import Config
+from ..notifiers.dispatcher import NotificationDispatcher
+from ..services.analysis_run import (
+    MARKET_LABELS,
+    analyze_symbol,
+    deliver_report,
+    is_trading_day,
+    notify_failure,
+    parse_targets,
+)
+from ..services.report import ReportPrefs, clean_sections
+from ..services.report_i18n import normalize_language
+
+logger = logging.getLogger("marketmyna.scheduled_run")
+
+MODES = ("quick", "standard", "full", "specialist")
+
+
+def _env_flag(name: str, default: bool) -> bool:
+    value = os.environ.get(name, "").strip().lower()
+    if not value:
+        return default
+    return value in ("1", "true", "yes", "on")
+
+
+def _watchlist_symbols(config: Config, name: str) -> str:
+    """Symbols from a saved in-app watchlist, as a STOCK_LIST-style spec."""
+    from ..storage import DatabaseManager, WatchlistRecord, get_db_url
+
+    db = DatabaseManager.instance(get_db_url(config=config))
+    with db.get_session() as session:
+        record = session.query(WatchlistRecord).filter(WatchlistRecord.name == name).first()
+        if record is None:
+            raise SystemExit(f"No watchlist named {name!r}")
+        # Funds have no price-chart analysis; skip them.
+        return ",".join(f"{i.market}:{i.symbol}" for i in record.items if i.type != "mf")
+
+
+def _saved_prefs(config: Config) -> ReportPrefs | None:
+    """Report preferences saved on the Scheduler page, if this machine has
+    the app database (a server run); a fresh GitHub runner has none."""
+    try:
+        from ..services.schedule_config import ScheduleConfigStore
+        from ..storage import has_app_db
+
+        if not has_app_db(config):
+            return None
+        return ScheduleConfigStore(config=config).load().report_prefs()
+    except Exception as exc:
+        logger.warning("Saved report preferences unreadable: %s", exc)
+        return None
+
+
+def parse_pairs(raw: str, sep: str) -> dict[str, str]:
+    """"telegram:ta,email:en" -> {"telegram": "ta", "email": "en"}."""
+    out = {}
+    for part in raw.split(","):
+        if sep in part:
+            key, value = part.split(sep, 1)
+            if key.strip() and value.strip():
+                out[key.strip()] = value.strip()
+    return out
+
+
+def parse_list(raw: str) -> list[str]:
+    return [part.strip() for part in raw.split(",") if part.strip()]
+
+
+def build_prefs(
+    config: Config, mode: str, timezone: str, language: str | None = None
+) -> ReportPrefs:
+    """Saved Scheduler preferences, overridden by env vars / flags."""
+    prefs = _saved_prefs(config)
+    if prefs is None:
+        prefs = ReportPrefs()
+    prefs.mode, prefs.timezone = mode, timezone
+    if language or os.environ.get("REPORT_LANGUAGE", "").strip():
+        prefs.language = normalize_language(language or os.environ["REPORT_LANGUAGE"])
+    if os.environ.get("REPORT_SECTIONS", "").strip():
+        prefs.sections = clean_sections(os.environ["REPORT_SECTIONS"].split(","))
+    if os.environ.get("STOCK_SECTIONS", "").strip():
+        prefs.stock_sections = {
+            sym.upper(): clean_sections(secs.replace("|", "+").split("+"))
+            for sym, secs in parse_pairs(os.environ["STOCK_SECTIONS"], "=").items()
+        }
+    if os.environ.get("MF_LIST", "").strip():
+        prefs.funds = [c for c in parse_list(os.environ["MF_LIST"]) if c.isdigit()]
+    if os.environ.get("SMART_MESSAGING", "").strip():
+        prefs.smart = os.environ["SMART_MESSAGING"].strip().lower() in ("1", "true", "yes", "on")
+    if os.environ.get("SMART_TOP_N", "").strip():
+        prefs.smart_top_n = max(1, min(20, int(os.environ["SMART_TOP_N"])))
+    if os.environ.get("SMART_AI_TOP", "").strip():
+        prefs.smart_ai_top = max(0, int(os.environ["SMART_AI_TOP"]))
+    if os.environ.get("SMART_EMAIL_FULL", "").strip():
+        prefs.smart_email_full = os.environ["SMART_EMAIL_FULL"].strip().lower() not in ("0", "false", "no", "off")
+    if os.environ.get("REPORT_BASE_URL", "").strip():
+        prefs.report_base_url = os.environ["REPORT_BASE_URL"].strip()
+    if os.environ.get("CHANNEL_LANGUAGES", "").strip():
+        prefs.channel_languages = {
+            ch.lower(): normalize_language(lang) for ch, lang in parse_pairs(os.environ["CHANNEL_LANGUAGES"], ":").items()
+        }
+    return prefs
+
+
+def _run_smart(targets, prefs, config, args) -> int:
+    """Smart messaging: top-N message + full report (HTML file here, since
+    a GitHub runner has no server to host the link)."""
+    from ..services.smart_report import run_smart
+
+    logger.info("Smart messaging: %d stocks, AI for the top %d, message shows top %d",
+                len(targets), prefs.smart_ai_top, prefs.smart_top_n)
+    dispatcher = NotificationDispatcher(config)
+    reports, delivery, rows, token, full_html = run_smart(targets, prefs, config, dispatcher=dispatcher,
+                                                          dry_run=args.dry_run)
+    out_dir = Path(args.output_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    stamp = datetime.now(ZoneInfo(args.timezone)).strftime("%Y%m%d-%H%M")
+    from ..services.smart_report import html_report
+
+    (out_dir / f"marketmyna-{stamp}-full.html").write_text(
+        full_html or html_report(rows, f"MarketMyna · {len(rows)} stocks", datetime.now(ZoneInfo(args.timezone)), None),
+        encoding="utf-8")
+    for lang, (title, body) in reports.items():
+        print(f"===== {title} [{lang}] =====\n{body}\n")
+        (out_dir / f"marketmyna-{stamp}-{lang}.txt").write_text(f"{title}\n\n{body}\n", encoding="utf-8")
+    good = [r for r in rows if "error" not in r]
+    if not good:
+        logger.error("Every symbol failed - check the symbols, market and data sources above.")
+        if not args.dry_run:
+            notify_failure(config, "No stock could be analyzed.", dispatcher=dispatcher)
+        return 1
+    for name, ok in delivery.items():
+        logger.info("Notification %-12s %s", name, "sent" if ok else "FAILED")
+    if delivery and not any(delivery.values()):
+        return 2
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="python -m marketmyna.cli.scheduled_run", description=__doc__.split("\n\n")[0])
+    parser.add_argument("--symbols", default=os.environ.get("STOCK_LIST", ""), help="comma-separated; env STOCK_LIST")
+    parser.add_argument("--watchlist", help="use a saved in-app watchlist instead of --symbols")
+    parser.add_argument(
+        "--market", default=os.environ.get("MARKET", "india").strip().lower() or "india", choices=sorted(MARKET_LABELS)
+    )
+    parser.add_argument(
+        "--mode", default=os.environ.get("ANALYSIS_MODE", "standard").strip().lower() or "standard", choices=MODES
+    )
+    parser.add_argument("--timezone", default=os.environ.get("REPORT_TIMEZONE", "Asia/Kolkata") or "Asia/Kolkata")
+    parser.add_argument("--language", help="report language code (env REPORT_LANGUAGE)")
+    parser.add_argument("--force-run", action="store_true", help="run even on weekends")
+    parser.add_argument("--dry-run", action="store_true", help="print the report, don't send it")
+    parser.add_argument("--output-dir", default="reports", help="where to save the report file")
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    logging.basicConfig(level=os.environ.get("LOG_LEVEL", "INFO"), format="%(asctime)s %(levelname)s %(message)s")
+    args = build_parser().parse_args(argv)
+    config = Config.load()
+    if config.accounts_enabled:
+        # Accounts mode: report on the platform owner's lists, like the in-app scheduler.
+        from ..core import tenant
+        from ..services.accounts import owner_scope
+
+        tenant.enable()
+        with owner_scope(config):
+            return _main(args, config)
+    return _main(args, config)
+
+
+def _main(args, config) -> int:
+
+    spec = _watchlist_symbols(config, args.watchlist) if args.watchlist else args.symbols
+    targets = parse_targets(spec, args.market)
+    if not targets:
+        logger.error("No symbols to analyze. Set STOCK_LIST (e.g. RELIANCE,TCS,INFY) or pass --symbols.")
+        return 1
+
+    check_days = _env_flag("TRADING_DAY_CHECK_ENABLED", True) and not args.force_run
+    if check_days:
+        open_targets = [t for t in targets if is_trading_day(t.market)]
+        skipped = len(targets) - len(open_targets)
+        if skipped:
+            logger.info("Skipping %d symbol(s): market closed today (use --force-run to override)", skipped)
+        targets = open_targets
+        if not targets:
+            logger.info("All markets closed today - nothing to do.")
+            return 0
+
+    from ..llm.channels import build_routes
+
+    routes = build_routes(config)
+    if routes:
+        logger.info("AI routes (in order): %s", ", ".join(r.label() for r in routes))
+    else:
+        logger.warning("No AI model configured (LLM_MODEL / LLM_CHANNELS): reports carry technical/risk signals but no AI decision.")
+
+    prefs = build_prefs(config, args.mode, args.timezone, args.language)
+    logger.info("Report: language=%s sections=%s", prefs.language, ",".join(prefs.sections))
+    if prefs.smart:
+        return _run_smart(targets, prefs, config, args)
+
+    results = []
+    for i, target in enumerate(targets, 1):
+        logger.info("[%d/%d] Analyzing %s (%s, %s)", i, len(targets), target.symbol, target.market, args.mode)
+        result = analyze_symbol(
+            target.symbol, target.market, args.mode, config, sections=prefs.sections_for(target.symbol)
+        )
+        if not result["ok"]:
+            logger.warning("%s: %s", target.symbol, result.get("error"))
+        results.append(result)
+
+    produced_anything = any(r.get("dashboard") for r in results)
+    if not produced_anything:
+        logger.error("Every symbol failed - check the symbols, market and data sources above.")
+
+    dispatcher = NotificationDispatcher(config)
+    reports, delivery = deliver_report(results, prefs, config, dispatcher=dispatcher, dry_run=args.dry_run)
+
+    out_dir = Path(args.output_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    stamp = datetime.now(ZoneInfo(args.timezone)).strftime("%Y%m%d-%H%M")
+    for lang, (title, body) in reports.items():
+        print(f"===== {title} [{lang}] =====\n{body}\n")
+        (out_dir / f"marketmyna-{stamp}-{lang}.txt").write_text(f"{title}\n\n{body}\n", encoding="utf-8")
+
+    if args.dry_run:
+        logger.info("Dry run: not sending.")
+        return 0 if produced_anything else 1
+    if not produced_anything and not args.dry_run:
+        errors = "\n".join(f"{r['symbol']}: {r.get('error', 'no data')}" for r in results)
+        notify_failure(config, f"No stock could be analyzed.\n{errors}", dispatcher=dispatcher)
+
+    if not dispatcher.configured_channels("report"):
+        logger.warning("No notification channel configured (e.g. TELEGRAM_BOT_TOKEN + TELEGRAM_CHAT_ID); report only printed.")
+        return 0 if produced_anything else 1
+
+    for name, ok in delivery.items():
+        lang = normalize_language(prefs.channel_languages.get(name) or prefs.language)
+        logger.info("Notification %-12s [%s] %s", name, lang, "sent" if ok else "FAILED")
+    if not any(delivery.values()):
+        return 2
+    return 0 if produced_anything else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

marketmyna/core/__init__.py

@@ -0,0 +1,6 @@
+"""Core module - Configuration and constants."""
+
+from .config import Config
+from .constants import Markets, TimeFrame
+
+__all__ = ["Config", "Markets", "TimeFrame"]

marketmyna/core/compliance.py

@@ -0,0 +1,53 @@
+"""What the app may say about a single stock: facts, explanations and
+comparisons, never a call.
+
+MarketMyna never gives a buy / hold / sell call, price target, entry, exit
+or stop loss. Where a direction helps, it is shown as an outlook: bullish,
+neutral or bearish (outlook() below). The frontend reads mode() ("analytics")
+to pick its wording.
+"""
+
+from __future__ import annotations
+
+MODE = "analytics"
+
+
+def mode() -> str:
+    return MODE
+
+
+def mode_for(user_id) -> str:
+    """mode() for the /me endpoint (the frontend reads it to pick the wording)."""
+    return MODE
+
+
+# A buy / hold / sell style rating (an analyst consensus, an AI reply) as a direction.
+OUTLOOKS = {"strong_buy": "bullish", "buy": "bullish", "hold": "neutral", "sell": "bearish", "strong_sell": "bearish"}
+
+
+def outlook(rating) -> "str | None":
+    """bullish / neutral / bearish for a rating (or an outlook already),
+    None when there is none."""
+    value = str(rating or "").lower()
+    return value if value in ("bullish", "neutral", "bearish") else OUTLOOKS.get(value)
+
+
+# Appended to every AI prompt that writes about a single security, so no
+# agent slips a call into its prose.
+NO_CALLS_RULE = (
+    "This is an analytics tool that is not registered with SEBI as an investment adviser or research "
+    "analyst. Describe what the data shows as observations. Never recommend buying, holding, selling, "
+    "accumulating, booking profit or exiting, and never give a price target, entry, exit or stop loss. A "
+    "direction may be described only as a bullish, neutral or bearish outlook, never as an instruction. Do "
+    "not use words like attractive, cheap, expensive, undervalued or overvalued as a verdict."
+)
+
+
+def guard_prompt(system_prompt: str) -> str:
+    """The system prompt, plus NO_CALLS_RULE."""
+    return f"{system_prompt}\n\n{NO_CALLS_RULE}"
+
+
+# Response fields that carry a call, target or stop; always stripped.
+CALL_FIELDS = ("decision_type", "target_price", "stop_loss", "buy_point", "sell_point", "action",
+               "ai_target", "ai_stop", "technical_signal")