marketmyna 0.2.0__py3-none-any.whl

marketmyna/api/v1/endpoints/calendar.py

@@ -0,0 +1,269 @@
+"""Event calendar: upcoming earnings / dividend dates for followed symbols,
+economic releases, market holidays and sessions, and the daily reminder
+settings (marketmyna/services/calendar.py)."""
+
+from __future__ import annotations
+
+import time
+from datetime import datetime
+from typing import Optional
+from zoneinfo import ZoneInfo
+
+from fastapi import APIRouter, Depends, HTTPException, Query, Request
+from pydantic import BaseModel, Field
+
+from marketmyna.api.deps import get_config_dep
+
+router = APIRouter()
+
+
+class SymbolIn(BaseModel):
+    symbol: str = Field(min_length=1, max_length=40)
+    market: str = Field(default="us", max_length=32)
+
+
+class CalendarSettingsIn(BaseModel):
+    notify: Optional[bool] = None
+    days_before: Optional[int] = Field(default=None, ge=0, le=14)
+    notify_hour: Optional[int] = Field(default=None, ge=0, le=23)
+    timezone: Optional[str] = None
+    hidden_events: Optional[list[str]] = None
+    # "My events list": the lists that count ("w:<id>" / "p:<id>"); all_lists=True goes back to every list
+    sources: Optional[list[str]] = Field(default=None, max_length=200)
+    all_lists: Optional[bool] = None
+    extra_symbols: Optional[list[SymbolIn]] = Field(default=None, max_length=200)
+
+
+class AlertIn(BaseModel):
+    name: Optional[str] = Field(default=None, min_length=1, max_length=80)
+    enabled: Optional[bool] = None
+    sources: Optional[list[str]] = Field(default=None, max_length=200)
+    all_lists: Optional[bool] = None  # back to every list (sources = null)
+    symbols: Optional[list[SymbolIn]] = Field(default=None, max_length=200)
+    event_types: Optional[list[str]] = None
+    all_types: Optional[bool] = None
+    days_before: Optional[int] = Field(default=None, ge=0, le=14)
+    notify_hour: Optional[int] = Field(default=None, ge=0, le=23)
+
+
+class CustomIn(BaseModel):
+    title: Optional[str] = Field(default=None, min_length=1, max_length=120)
+    date: Optional[str] = Field(default=None, pattern=r"^\d{4}-\d{2}-\d{2}$")
+    repeat: Optional[str] = None
+    note: Optional[str] = Field(default=None, max_length=500)
+
+
+MAX_ALERTS = 20
+MAX_CUSTOM = 200
+_last_send: dict[str, float] = {}
+
+
+def _throttle(request: Request, what: str) -> None:
+    """One manual send a minute per user (they go to real channels)."""
+    from marketmyna.core import tenant
+
+    key = f"{tenant.current_user_id() or request.client.host if request.client else ''}:{what}"
+    now = time.time()
+    if now - _last_send.get(key, 0) < 60:
+        raise HTTPException(status_code=429, detail="Sent a moment ago - try again in a minute.")
+    _last_send[key] = now
+
+
+def _check_types(keys: list[str]) -> None:
+    from marketmyna.services.calendar import EVENT_KEYS
+
+    unknown = set(keys) - EVENT_KEYS
+    if unknown:
+        raise HTTPException(status_code=400, detail=f"Unknown event types: {', '.join(sorted(unknown))}")
+
+
+def _public(settings: dict) -> dict:
+    from marketmyna.services.calendar import hidden
+
+    out = {k: settings[k] for k in ("notify", "days_before", "notify_hour", "timezone")}
+    return {**out, "hidden_events": sorted(hidden(settings)), "sources": settings.get("sources"),
+            "extra_symbols": settings.get("extra_symbols") or []}
+
+
+@router.get("/calendar")
+def upcoming_events(days: int = Query(default=30, ge=1, le=120), config=Depends(get_config_dep)) -> dict:
+    from marketmyna.services import econ_calendar, market_calendar
+    from marketmyna.services.calendar import (
+        EVENT_TYPES,
+        _fresh_points,
+        collect,
+        custom_events,
+        hidden,
+        list_alerts,
+        list_custom,
+        list_sources,
+        load_settings,
+        my_symbols,
+        visible,
+    )
+    from marketmyna.services.schedule_config import source_catalog
+
+    settings = load_settings(config)
+    catalog = source_catalog(config)
+    symbols = my_symbols(config, settings, catalog)
+    tz = settings.get("timezone") or "Asia/Kolkata"
+    today = datetime.now(ZoneInfo(tz)).date()
+    econ = econ_calendar.collect(today, days)
+    markets = market_calendar.collect(today, days)
+    econ["events"] = sorted(econ["events"] + markets["events"], key=lambda e: (e["date"], e["time"] or "", e["title"]))
+    econ["warnings"] += markets["warnings"]
+    for e in econ["events"]:
+        e["local_time"] = econ_calendar.local_time(e, tz)
+    econ_calendar.enrich(econ["events"], symbols)
+    now = datetime.now(ZoneInfo(tz))
+    for done in econ_calendar.results([e for e in econ["events"] if e["days_away"] == 0], now, _fresh_points):
+        for e in econ["events"]:
+            if e["date"] == done["date"] and e["key"] == done["key"]:
+                e["result"], e["verdict"] = done["result"], done["verdict"]
+    off = hidden(settings)
+    custom = list_custom(config)
+    return {"from": today.isoformat(), "days": days, "symbols": len(symbols),
+            "events": visible(collect(symbols, today, days), off, "kind"),
+            "economic": visible(econ["events"], off, "key"),
+            "custom": custom_events(custom, today, days) if "custom" not in off else [],
+            "custom_all": custom,
+            "economic_warnings": econ["warnings"], "settings": _public(settings),
+            "lists": list_sources(config, catalog), "alerts": list_alerts(config),
+            "event_types": [{"key": k, "group": g, "name": n, "about": a} for k, g, n, a in EVENT_TYPES]}
+
+
+@router.put("/calendar/settings")
+def update_settings(body: CalendarSettingsIn, config=Depends(get_config_dep)) -> dict:
+    from marketmyna.services.calendar import clean_symbols, save_settings
+
+    changes = body.model_dump(exclude_none=True)
+    if "hidden_events" in changes:
+        _check_types(changes["hidden_events"])
+        changes["hidden_events"] = ",".join(sorted(set(changes["hidden_events"]))) or None
+    if "timezone" in changes:
+        try:
+            ZoneInfo(changes["timezone"])
+        except Exception:
+            raise HTTPException(status_code=400, detail=f"Unknown timezone '{changes['timezone']}'")
+    if changes.pop("all_lists", False):
+        changes["sources"] = None
+    if "extra_symbols" in changes:
+        changes["extra_symbols"] = clean_symbols(changes["extra_symbols"])
+    return _public(save_settings(config, **changes))
+
+
+@router.post("/calendar/remind-now")
+def remind_now(request: Request, config=Depends(get_config_dep)) -> dict:
+    """Send today's digest right away (does not count as the daily one)."""
+    from marketmyna.services.calendar import check_reminders
+
+    _throttle(request, "digest")
+    result = check_reminders(config, force=True) or {"events": [], "delivery": {}}
+    count = len(result["events"]) + len(result.get("economic", [])) + len(result.get("custom", []))
+    return {"sent": bool(count), "count": count, "delivery": result["delivery"]}
+
+
+# ------------------------------------------------------------------ named event alerts
+
+
+def _alert_changes(body: AlertIn) -> dict:
+    changes = body.model_dump(exclude_none=True)
+    if "event_types" in changes:
+        _check_types(changes["event_types"])
+    if changes.pop("all_types", False):
+        changes["event_types"] = None
+    if changes.pop("all_lists", False):
+        changes["sources"] = None
+    return changes
+
+
+@router.post("/calendar/alerts", status_code=201)
+def create_alert(body: AlertIn, config=Depends(get_config_dep)) -> dict:
+    from marketmyna.services.calendar import list_alerts, save_alert
+
+    if len(list_alerts(config)) >= MAX_ALERTS:
+        raise HTTPException(status_code=400, detail=f"Up to {MAX_ALERTS} event alerts.")
+    return save_alert(config, None, **_alert_changes(body))
+
+
+@router.put("/calendar/alerts/{alert_id}")
+def update_alert(alert_id: int, body: AlertIn, config=Depends(get_config_dep)) -> dict:
+    from marketmyna.services.calendar import save_alert
+
+    out = save_alert(config, alert_id, **_alert_changes(body))
+    if out is None:
+        raise HTTPException(status_code=404, detail="Alert not found")
+    return out
+
+
+@router.delete("/calendar/alerts/{alert_id}", status_code=204)
+def remove_alert(alert_id: int, config=Depends(get_config_dep)) -> None:
+    from marketmyna.services.calendar import delete_alert
+
+    if not delete_alert(config, alert_id):
+        raise HTTPException(status_code=404, detail="Alert not found")
+
+
+@router.post("/calendar/alerts/{alert_id}/send-now")
+def send_alert_now(alert_id: int, request: Request, config=Depends(get_config_dep)) -> dict:
+    """Run one alert right away (does not count as its daily run)."""
+    from marketmyna.services.calendar import _local, _tz, list_alerts, load_settings, run_alert
+
+    alert = next((a for a in list_alerts(config) if a["id"] == alert_id), None)
+    if alert is None:
+        raise HTTPException(status_code=404, detail="Alert not found")
+    _throttle(request, f"alert{alert_id}")
+    result = run_alert(config, alert, _local(None, _tz(load_settings(config))))
+    count = len(result["events"]) + len(result["economic"]) + len(result["custom"])
+    return {"sent": bool(count), "count": count, "delivery": result["delivery"]}
+
+
+# ------------------------------------------------------------------ custom events
+
+
+def _custom_fields(body: CustomIn) -> dict:
+    from datetime import date as _date
+
+    from marketmyna.services.calendar import REPEATS
+
+    fields = body.model_dump(exclude_none=True)
+    if "date" in fields:
+        try:
+            _date.fromisoformat(fields["date"])
+        except ValueError:
+            raise HTTPException(status_code=400, detail="Not a real date")
+    if "repeat" in fields and fields["repeat"] not in REPEATS:
+        raise HTTPException(status_code=400, detail="Repeat must be none, monthly or yearly")
+    if "title" in fields:
+        fields["title"] = fields["title"].strip()
+    return fields
+
+
+@router.post("/calendar/custom-events", status_code=201)
+def create_custom(body: CustomIn, config=Depends(get_config_dep)) -> dict:
+    from marketmyna.services.calendar import list_custom, save_custom
+
+    fields = _custom_fields(body)
+    if not fields.get("title") or not fields.get("date"):
+        raise HTTPException(status_code=400, detail="A title and a date are needed")
+    if len(list_custom(config)) >= MAX_CUSTOM:
+        raise HTTPException(status_code=400, detail=f"Up to {MAX_CUSTOM} of your own events.")
+    return save_custom(config, None, **fields)
+
+
+@router.put("/calendar/custom-events/{event_id}")
+def update_custom(event_id: int, body: CustomIn, config=Depends(get_config_dep)) -> dict:
+    from marketmyna.services.calendar import save_custom
+
+    out = save_custom(config, event_id, **_custom_fields(body))
+    if out is None:
+        raise HTTPException(status_code=404, detail="Event not found")
+    return out
+
+
+@router.delete("/calendar/custom-events/{event_id}", status_code=204)
+def remove_custom(event_id: int, config=Depends(get_config_dep)) -> None:
+    from marketmyna.services.calendar import delete_custom
+
+    if not delete_custom(config, event_id):
+        raise HTTPException(status_code=404, detail="Event not found")

marketmyna/api/v1/endpoints/data_sources.py

@@ -0,0 +1,174 @@
+"""Optional data-source keys (Settings -> Data sources): live US prices,
+backup price sources and Reddit. Secrets are never sent back, only whether
+they are set (and the last 4). A value from an environment variable can't be
+changed here."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends, HTTPException
+
+from marketmyna.api.deps import get_config_dep
+from marketmyna.api.middlewares.auth import accounts_db, require_admin
+
+router = APIRouter(prefix="/system-config/data-sources", dependencies=[Depends(require_admin)])
+
+
+def _db(config):
+    return accounts_db(config)
+
+
+INTEGRATIONS = [
+    {
+        "id": "finnhub",
+        "title": "Finnhub live prices (US)",
+        "help": "Real-time US stock prices for the Markets and Watchlist tables (trade by trade). "
+                "Free key at finnhub.io -> Dashboard. The free plan streams about 50 symbols at once; "
+                "without a key, US prices come from the default source.",
+        "fields": [("finnhub_api_key", "API key", "secret")],
+    },
+    {
+        "id": "market_data",
+        "title": "Backup price sources",
+        "help": "Used only when the default price source fails or rate-limits, tried in this order. All have free keys: "
+                "twelvedata.com (800 calls/day, also NSE / BSE), tiingo.com, alphavantage.co (25 calls/day), "
+                "polygon.io (5 calls/min, daily bars). US stocks also fall back to Nasdaq and crypto to CoinGecko, "
+                "which need no key (a free CoinGecko demo key raises its rate limit).",
+        "fields": [
+            ("twelvedata_api_key", "Twelve Data API key", "secret"),
+            ("tiingo_api_key", "Tiingo API token", "secret"),
+            ("alpha_vantage_key", "Alpha Vantage API key", "secret"),
+            ("polygon_key", "Polygon API key", "secret"),
+            ("coingecko_api_key", "CoinGecko demo key (optional, crypto)", "secret"),
+        ],
+    },
+    {
+        "id": "social",
+        "title": "Social sentiment (Reddit, StockTwits)",
+        "help": "Reddit is read with a headless browser (Playwright) unless API keys are set - Reddit blocks "
+                "scrapers quickly, especially from cloud servers. For the API: reddit.com/prefs/apps -> create a "
+                "'script' app; mode 'auto' then uses the API first. StockTwits always needs the browser. "
+                "Install it with: pip install playwright && python -m playwright install --with-deps chromium",
+        "fields": [
+            ("reddit_client_id", "Reddit client ID", "text"),
+            ("reddit_client_secret", "Reddit client secret", "secret"),
+            ("reddit_user_agent", "Reddit user agent (e.g. MarketMyna/1.0 by u/you)", "text"),
+            ("social_reddit_mode", "Reddit mode: auto | api | playwright", "text"),
+            ("social_playwright", "Allow headless-browser scraping", "bool"),
+        ],
+    },
+]
+_FIELD_KINDS = {name: kind for group in INTEGRATIONS for name, _label, kind in group["fields"]}
+
+
+def _integrations(config) -> dict:
+    env = getattr(config, "_env_fields", set())
+    groups = []
+    for group in INTEGRATIONS:
+        fields = []
+        for name, label, kind in group["fields"]:
+            value = getattr(config, name, None)
+            item = {"name": name, "label": label, "kind": kind, "from_env": name in env}
+            if kind == "secret":
+                item["is_set"] = bool(value)
+                item["last4"] = value[-4:] if value and len(value) > 8 else ""
+            else:
+                item["value"] = value
+            fields.append(item)
+        groups.append({"id": group["id"], "title": group["title"], "help": group["help"], "fields": fields})
+    return {"groups": groups}
+
+
+@router.get("")
+def get_data_sources(config=Depends(get_config_dep)) -> dict:
+    _db(config)
+    return _integrations(config)
+
+
+@router.put("")
+def update_data_sources(body: dict, config=Depends(get_config_dep)) -> dict:
+    """Partial update: only the fields present change; null or "" clears one."""
+    _db(config)
+    env = getattr(config, "_env_fields", set())
+    changes = {}
+    for name, value in body.items():
+        kind = _FIELD_KINDS.get(name)
+        if kind is None:
+            raise HTTPException(status_code=400, detail=f"Unknown setting '{name}'.")
+        if name in env:
+            raise HTTPException(status_code=400, detail=f"{name.upper()} is set by an environment variable on the server.")
+        if value in (None, ""):
+            changes[name] = None
+        elif kind == "bool":
+            changes[name] = bool(value)
+        else:
+            value = str(value).strip()
+            if len(value) > 500:
+                raise HTTPException(status_code=400, detail="Value is too long.")
+            changes[name] = value
+    for name, value in changes.items():
+        setattr(config, name, value)
+    config.save()
+    return _integrations(config)
+
+
+def _test_market_data() -> dict:
+    """One quote per configured source, straight from that source."""
+    from marketmyna.data import extra_sources as xs
+
+    xs._key_cache.clear()  # a key saved a moment ago counts
+    checks = [
+        ("Twelve Data", xs.twelvedata_key, lambda: xs.twelvedata_quote("RELIANCE", "india"), "₹"),
+        ("Tiingo", xs.tiingo_key, lambda: xs.tiingo_quote("AAPL"), "$"),
+        ("Alpha Vantage", xs.alphavantage_key, lambda: xs.alphavantage_quote("AAPL"), "$"),
+        ("Polygon", xs.polygon_key, lambda: xs.polygon_quote("AAPL"), "$"),
+        ("Nasdaq", lambda: True, lambda: xs.nasdaq_quote("AAPL"), "$"),
+        ("CoinGecko", lambda: True, lambda: xs.coingecko_quote("BTC"), "$"),
+    ]
+    parts, failed = [], []
+    for name, has_key, fetch, cur in checks:
+        if not has_key():
+            continue
+        try:
+            q = fetch()
+            parts.append(f"{name} OK ({q['symbol']} {cur}{q['price']:,.2f})")
+        except Exception as exc:  # noqa: BLE001 - report every source, not just the first failure
+            failed.append(f"{name}: {str(exc)[:120]}")
+    if failed:
+        raise HTTPException(status_code=400, detail="; ".join(failed + parts))
+    return {"ok": True, "message": ". ".join(parts) + "."}
+
+
+@router.post("/{group_id}/test")
+def test_data_source(group_id: str, config=Depends(get_config_dep)) -> dict:
+    if group_id == "finnhub":
+        import requests
+
+        key = getattr(config, "finnhub_api_key", None)
+        if not key:
+            raise HTTPException(status_code=400, detail="Enter the Finnhub API key first.")
+        try:
+            q = requests.get("https://finnhub.io/api/v1/quote", params={"symbol": "AAPL", "token": key}, timeout=10)
+        except requests.RequestException as exc:
+            raise HTTPException(status_code=400, detail=f"Finnhub unreachable: {exc}")
+        if q.status_code in (401, 403):
+            raise HTTPException(status_code=400, detail="Finnhub rejected the API key.")
+        price = (q.json() if q.ok else {}).get("c")
+        return {"ok": True, "message": f"Finnhub connected. AAPL ${price:,.2f}." if price else "Finnhub connected."}
+    if group_id == "market_data":
+        return _test_market_data()
+    if group_id == "social":
+        from marketmyna.data.social import browser, reddit
+
+        parts = ["Headless browser: " + ("installed." if browser.available() else "not installed - scraping is off.")]
+        client_id, secret = getattr(config, "reddit_client_id", None), getattr(config, "reddit_client_secret", None)
+        if client_id and secret:
+            try:
+                reddit._token.update(value=None, expires=0.0)
+                reddit._api_token(client_id, secret, getattr(config, "reddit_user_agent", None) or "MarketMyna/1.0")
+            except Exception as exc:
+                raise HTTPException(status_code=400, detail=f"Reddit API: {exc}")
+            parts.append("Reddit API keys work.")
+        else:
+            parts.append("No Reddit API keys - Reddit will be scraped.")
+        return {"ok": True, "message": " ".join(parts)}
+    raise HTTPException(status_code=404, detail="Nothing to test here.")

marketmyna/api/v1/endpoints/health.py

@@ -0,0 +1,10 @@
+"""Health check endpoint."""
+
+from fastapi import APIRouter
+
+router = APIRouter()
+
+
+@router.get("/health")
+def health() -> dict:
+    return {"status": "ok"}