marketmyna 0.2.0__py3-none-any.whl

marketmyna/data/stocks.py

@@ -0,0 +1,197 @@
+"""Stock data fetcher using Yahoo Finance."""
+
+from datetime import datetime
+from typing import Optional
+
+import pandas as pd
+import yfinance as yf
+
+from ..analysis.fundamental import yfinance_fundamentals
+from ..core.constants import TimeFrame
+from .base import DataFetcher
+from .extra_sources import (
+    alphavantage_history,
+    alphavantage_key,
+    alphavantage_quote,
+    finnhub_key,
+    finnhub_quote,
+    nasdaq_history,
+    nasdaq_quote,
+    polygon_history,
+    polygon_key,
+    polygon_quote,
+    tiingo_history,
+    tiingo_key,
+    tiingo_quote,
+    twelvedata_history,
+    twelvedata_key,
+    twelvedata_quote,
+)
+from .resilience import FallbackChain
+
+
+def _plain_us(symbol: str) -> bool:
+    return symbol.replace(".", "").replace("-", "").isalpha()
+
+
+class StockDataFetcher(DataFetcher):
+    """Fetches stock data from Yahoo Finance (US & Global markets).
+
+    Yahoo first; plain US tickers then fall back to the keyed sources
+    configured (Finnhub, Twelve Data, Tiingo, Alpha Vantage, Polygon) and
+    Nasdaq, which needs no key. Index and foreign symbols (^GSPC,
+    RELIANCE.NS) have only Yahoo.
+    """
+
+    def __init__(self):
+        self._cache = {}
+
+    def _fetch_quote_yfinance(self, symbol: str) -> dict:
+        ticker = yf.Ticker(symbol)
+        info = ticker.fast_info
+        try:
+            price = info.last_price
+        except KeyError:
+            return {}  # unknown symbol: empty, not a source failure (see india.py)
+
+        return {
+            "symbol": symbol,
+            "price": price,
+            "previous_close": info.previous_close,
+            "open": info.open,
+            "day_high": info.day_high,
+            "day_low": info.day_low,
+            "volume": info.last_volume,
+            "market_cap": info.market_cap,
+            "change": info.last_price - info.previous_close,
+            "change_percent": ((info.last_price - info.previous_close) / info.previous_close) * 100
+            if info.previous_close
+            else 0,
+        }
+
+    def get_quote(self, symbol: str) -> dict:
+        """Get current quote for a stock."""
+        chain = FallbackChain("stocks.get_quote").add("yfinance", self._fetch_quote_yfinance)
+        # Keyed backups for US tickers (index/foreign symbols like ^GSPC or
+        # RELIANCE.NS aren't covered by these APIs' free tiers).
+        if _plain_us(symbol):
+            if finnhub_key():
+                chain.add("finnhub", finnhub_quote)
+            if twelvedata_key():
+                chain.add("twelvedata", twelvedata_quote)
+            if tiingo_key():
+                chain.add("tiingo", tiingo_quote)
+            chain.add("nasdaq", nasdaq_quote)
+            if alphavantage_key():
+                chain.add("alphavantage", alphavantage_quote)
+            if polygon_key():
+                chain.add("polygon", polygon_quote)
+        return chain.call(symbol, is_empty=lambda d: not d or d.get("price") is None)
+
+    def _fetch_history_yfinance(
+        self,
+        symbol: str,
+        period: str = "1y",
+        interval: TimeFrame = TimeFrame.DAY_1,
+        start: Optional[datetime] = None,
+        end: Optional[datetime] = None,
+    ) -> pd.DataFrame:
+        ticker = yf.Ticker(symbol)
+
+        if start and end:
+            df = ticker.history(start=start, end=end, interval=interval.value)
+        else:
+            df = ticker.history(period=period, interval=interval.value)
+
+        if df.empty:
+            return pd.DataFrame()
+
+        # Standardize column names
+        df.columns = [col.lower().replace(" ", "_") for col in df.columns]
+        return df
+
+    def get_history(
+        self,
+        symbol: str,
+        period: str = "1y",
+        interval: TimeFrame = TimeFrame.DAY_1,
+        start: Optional[datetime] = None,
+        end: Optional[datetime] = None,
+    ) -> pd.DataFrame:
+        """Get historical price data for a stock."""
+        chain = FallbackChain("stocks.get_history").add("yfinance", self._fetch_history_yfinance)
+        # Daily bars only: an intraday request skips these (they raise).
+        if _plain_us(symbol):
+            if twelvedata_key():
+                chain.add("twelvedata", twelvedata_history)
+            if tiingo_key():
+                chain.add("tiingo", tiingo_history)
+            if polygon_key():
+                chain.add("polygon", polygon_history)
+            chain.add("nasdaq", nasdaq_history)
+            if alphavantage_key():
+                chain.add("alphavantage", alphavantage_history)
+        return chain.call(symbol, period=period, interval=interval, start=start, end=end, is_empty=lambda df: df.empty)
+
+    def search(self, query: str) -> list[dict]:
+        """Search for stocks matching query."""
+        try:
+            ticker = yf.Ticker(query)
+            info = ticker.info
+            if info and "symbol" in info:
+                return [
+                    {
+                        "symbol": info.get("symbol", query),
+                        "name": info.get("longName", info.get("shortName", "")),
+                        "exchange": info.get("exchange", ""),
+                        "type": info.get("quoteType", ""),
+                    }
+                ]
+        except Exception:
+            pass
+        return []
+
+    def get_info(self, symbol: str) -> dict:
+        """Get detailed information about a stock."""
+        ticker = yf.Ticker(symbol)
+        info = ticker.info
+
+        return {
+            "symbol": info.get("symbol", symbol),
+            "name": info.get("longName", ""),
+            "sector": info.get("sector", ""),
+            "industry": info.get("industry", ""),
+            "description": info.get("longBusinessSummary", ""),
+            "website": info.get("website", ""),
+            "employees": info.get("fullTimeEmployees", 0),
+            "country": info.get("country", ""),
+            "currency": info.get("currency", "USD"),
+            # Valuation metrics
+            "market_cap": info.get("marketCap", 0),
+            "pe_ratio": info.get("trailingPE", 0),
+            "forward_pe": info.get("forwardPE", 0),
+            "peg_ratio": info.get("pegRatio", 0),
+            "price_to_book": info.get("priceToBook", 0),
+            "price_to_sales": info.get("priceToSalesTrailing12Months", 0),
+            # Financial metrics
+            "revenue": info.get("totalRevenue", 0),
+            "gross_profit": info.get("grossProfits", 0),
+            "ebitda": info.get("ebitda", 0),
+            "net_income": info.get("netIncomeToCommon", 0),
+            "eps": info.get("trailingEps", 0),
+            # Dividend info
+            "dividend_yield": info.get("dividendYield", 0),
+            "dividend_rate": info.get("dividendRate", 0),
+            "payout_ratio": info.get("payoutRatio", 0),
+            # Trading info
+            "52_week_high": info.get("fiftyTwoWeekHigh", 0),
+            "52_week_low": info.get("fiftyTwoWeekLow", 0),
+            "50_day_avg": info.get("fiftyDayAverage", 0),
+            "200_day_avg": info.get("twoHundredDayAverage", 0),
+            "avg_volume": info.get("averageVolume", 0),
+            "beta": info.get("beta", 0),
+            # Normalized ratios for FundamentalAnalyzer (overrides the raw
+            # yfinance-unit fields above, e.g. dividend_yield)
+            **yfinance_fundamentals(info),
+        }
+

marketmyna/data/yahoo_price.py

@@ -0,0 +1,48 @@
+"""A price from a Yahoo `info` dict that is safe to use.
+
+Yahoo's quote fields go stale for some listings while their daily bars stay
+current: Indian REITs and InvITs report a `regularMarketPrice` frozen in
+2024 with no `currentPrice` at all. A price older than MAX_AGE is treated as
+missing (or replaced by the latest daily close when a ticker is given), so
+a yield or upside is never worked out from it.
+"""
+
+from __future__ import annotations
+
+import math
+import time
+from typing import Any, Optional
+
+MAX_AGE = 10 * 24 * 3600  # a week of holidays plus a weekend
+
+
+def _num(value: Any) -> Optional[float]:
+    try:
+        v = float(value)
+    except (TypeError, ValueError):
+        return None
+    return v if math.isfinite(v) and v > 0 else None
+
+
+def info_price(info: dict, now: Optional[float] = None) -> Optional[float]:
+    """currentPrice, else a regularMarketPrice that is still fresh."""
+    price = _num(info.get("currentPrice"))
+    if price:
+        return price
+    price = _num(info.get("regularMarketPrice"))
+    stamp = _num(info.get("regularMarketTime"))
+    if price and stamp and (now or time.time()) - stamp > MAX_AGE:
+        return None
+    return price
+
+
+def fresh_price(info: dict, ticker=None) -> Optional[float]:
+    """info_price(), falling back to the ticker's latest daily close."""
+    price = info_price(info)
+    if price or ticker is None:
+        return price
+    try:
+        bars = ticker.history(period="5d", interval="1d")
+        return _num(bars["Close"].iloc[-1]) if not bars.empty else None
+    except Exception:
+        return None

marketmyna/launcher.py

@@ -0,0 +1,71 @@
+"""Start MarketMyna: the `marketmyna` command (pip / pipx install) and start.py.
+
+    marketmyna                      # http://127.0.0.1:8001, opens your browser
+    marketmyna --port 9000 --no-browser
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+import threading
+import time
+import urllib.request
+import webbrowser
+
+
+def parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="marketmyna", description="Start MarketMyna.")
+    p.add_argument("--host", default="127.0.0.1",
+                   help="address to listen on (default 127.0.0.1: only this computer can reach it)")
+    p.add_argument("--port", type=int, default=8001)
+    p.add_argument("--no-browser", action="store_true", help="don't open the browser")
+    p.add_argument("--version", action="version", version=f"%(prog)s {_version()}")
+    return p
+
+
+def _version() -> str:
+    from marketmyna import __version__
+    return __version__
+
+
+def open_when_ready(url: str) -> None:
+    for _ in range(120):
+        try:
+            with urllib.request.urlopen(f"{url}/health", timeout=2):
+                webbrowser.open(url)
+                return
+        except OSError:
+            time.sleep(1)
+
+
+def run(args: argparse.Namespace) -> None:
+    try:
+        import uvicorn
+    except ImportError:
+        sys.exit("Install the requirements first: pip install -r requirements-web.txt")
+    url = f"http://{'127.0.0.1' if args.host in ('0.0.0.0', '::') else args.host}:{args.port}"
+    print(f"MarketMyna: {url}  (Ctrl+C to stop)")
+    if not args.no_browser:
+        threading.Thread(target=open_when_ready, args=(url,), daemon=True).start()
+    # One process: the scheduler, price alerts and the Telegram bot run inside it.
+    # Ctrl+C stops within a few seconds even while a slow data download is running.
+    try:
+        uvicorn.run("marketmyna.api.app:app", host=args.host, port=args.port, timeout_graceful_shutdown=5)
+    except KeyboardInterrupt:
+        pass
+    # The app has shut down; don't wait minutes at exit for download threads
+    # (a first China / Hong Kong listing fetch) that nothing will read.
+    if any(t.is_alive() and not t.daemon for t in threading.enumerate() if t is not threading.main_thread()):
+        sys.stdout.flush()
+        sys.stderr.flush()
+        os._exit(0)
+
+
+def main(argv: list[str] | None = None) -> None:
+    run(parser().parse_args(argv))
+
+
+if __name__ == "__main__":
+    main()

marketmyna/llm/__init__.py

@@ -0,0 +1,33 @@
+"""LLM generation backend layer.
+
+A GenerationBackend Protocol (marketmyna/llm/protocol.py) is the swappable
+interface; backend_factory.create_generation_backend(config) builds a
+concrete implementation chosen by backend_registry from Config, the
+same "small pluggable backend" shape daily_stock_analysis uses for its
+own litellm/local-CLI backends.
+"""
+
+from __future__ import annotations
+
+from .backend_factory import create_generation_backend
+from .backend_registry import LITELLM_BACKEND_ID, resolve_generation_backend_id
+from .litellm_backend import LiteLLMGenerationBackend
+from .protocol import (
+    GenerationBackend,
+    GenerationCapabilities,
+    GenerationError,
+    GenerationErrorCode,
+    GenerationResult,
+)
+
+__all__ = [
+    "GenerationBackend",
+    "GenerationCapabilities",
+    "GenerationError",
+    "GenerationErrorCode",
+    "GenerationResult",
+    "LiteLLMGenerationBackend",
+    "LITELLM_BACKEND_ID",
+    "resolve_generation_backend_id",
+    "create_generation_backend",
+]

marketmyna/llm/backend_factory.py

@@ -0,0 +1,51 @@
+"""Builds a concrete GenerationBackend from Config."""
+
+from __future__ import annotations
+
+from .backend_registry import LITELLM_BACKEND_ID, resolve_generation_backend_id
+from .litellm_backend import LiteLLMGenerationBackend
+from .protocol import GenerationBackend, GenerationError, GenerationErrorCode
+
+
+def create_generation_backend(config, tier: str = "deep") -> GenerationBackend:
+    """tier="deep": the main model chain, for decisions and idea picks.
+    tier="fast": the cheaper level-1 model first (commentary, news tone,
+    translation), falling back to the main chain. The deep backend also
+    exposes `.fast`, so agents can pick the right level per job.
+
+    Saved AI keys come first, then the config.json / env setup
+    (marketmyna/services/ai_access.py)."""
+    from ..services.ai_access import wrap_backend
+
+    return wrap_backend(config, _create_platform_backend, tier)
+
+
+def _create_platform_backend(config, tier: str = "deep") -> GenerationBackend:
+    backend_id = resolve_generation_backend_id(config)
+
+    if backend_id == LITELLM_BACKEND_ID:
+        from .channels import FailoverGenerationBackend, build_routes
+        from .store import LLMStore
+
+        routes = build_routes(config, tier=tier)
+        if not routes:
+            # Raises a clear "No llm_model configured" on first use.
+            return LiteLLMGenerationBackend(config)
+        try:
+            store = LLMStore(config)
+        except Exception:  # cache/usage are optional extras
+            store = None
+        backend = FailoverGenerationBackend(config, routes, store=store, tier=tier)
+        if tier == "deep" and getattr(config, "llm_fast_model", None):
+            backend.fast = FailoverGenerationBackend(config, build_routes(config, tier="fast"), store=store,
+                                                     tier="fast")
+        return backend
+
+    raise GenerationError(
+        GenerationErrorCode.BACKEND_NOT_CONFIGURED,
+        f"Unknown or unsupported llm_backend '{backend_id}'",
+        stage="setup",
+        retryable=False,
+        fallbackable=False,
+        backend=backend_id,
+    )

marketmyna/llm/backend_registry.py

@@ -0,0 +1,19 @@
+"""Resolves which LLM backend id a Config selects.
+
+Only "litellm" exists in this phase. daily_stock_analysis also has
+local-CLI backends (codex_cli/claude_code_cli/opencode_cli - subprocess-
+based, with allowlisted env, output caps, redaction) - deliberately not
+built here yet: that's real extra scope (subprocess sandboxing is
+security-sensitive to get right) rather than a small addition, so it's
+cut from Phase 3a rather than half-implemented. backend_factory already
+raises a clear, typed error for any backend id other than "litellm" so
+adding one later doesn't require reshaping this function's callers.
+"""
+
+from __future__ import annotations
+
+LITELLM_BACKEND_ID = "litellm"
+
+
+def resolve_generation_backend_id(config) -> str:
+    return getattr(config, "llm_backend", None) or LITELLM_BACKEND_ID