marketmyna 0.2.0__py3-none-any.whl

marketmyna/llm/providers.py

@@ -0,0 +1,128 @@
+"""Provider catalogue for the Settings page: which AI providers the app
+knows, where to get a key, and a live "which models can this key use"
+lookup - so model names come from the provider, not from a list in this
+code that goes stale.
+
+Returned model ids are already in litellm form ("groq/openai/gpt-oss-120b"),
+and the one model_catalog.recommend() would pick is marked "recommended".
+"""
+
+from __future__ import annotations
+
+from typing import Iterable, Optional
+
+import requests
+
+_TIMEOUT = 15
+
+# id, label, config key field, where to get a key, free-tier note
+PROVIDERS = [
+    {"id": "gemini", "label": "Google Gemini", "key_field": "gemini_api_key",
+     "key_url": "https://aistudio.google.com/app/apikey",
+     "note": "Free tier with per-model rate limits - a good default."},
+    {"id": "groq", "label": "Groq", "key_field": "groq_api_key",
+     "key_url": "https://console.groq.com/keys",
+     "note": "Free tier, very fast - good as the fast model or a fallback."},
+    {"id": "openrouter", "label": "OpenRouter", "key_field": "openrouter_api_key",
+     "key_url": "https://openrouter.ai/keys",
+     "note": "One key for many models; free models are marked but rate-limited."},
+    {"id": "openai", "label": "OpenAI", "key_field": "openai_api_key",
+     "key_url": "https://platform.openai.com/api-keys", "note": "Paid."},
+    {"id": "anthropic", "label": "Anthropic", "key_field": "anthropic_api_key",
+     "key_url": "https://console.anthropic.com/settings/keys", "note": "Paid."},
+    {"id": "deepseek", "label": "DeepSeek", "key_field": "deepseek_api_key",
+     "key_url": "https://platform.deepseek.com/api_keys", "note": "Paid, low cost."},
+    {"id": "mistral", "label": "Mistral", "key_field": "mistral_api_key",
+     "key_url": "https://console.mistral.ai/api-keys", "note": "Free experiment tier available."},
+    {"id": "cerebras", "label": "Cerebras", "key_field": "cerebras_api_key",
+     "key_url": "https://cloud.cerebras.ai/platform", "note": "Free tier with a large daily token allowance - a strong fallback."},
+    {"id": "nvidia_nim", "label": "NVIDIA NIM", "key_field": "nvidia_api_key",
+     "key_url": "https://build.nvidia.com/settings/api-keys", "note": "Free developer credits for hosted open models."},
+    {"id": "ollama", "label": "Ollama (local)", "key_field": None,
+     "key_url": "https://ollama.com/download", "note": "Runs on your machine: free and private."},
+]
+PROVIDER_IDS = {p["id"] for p in PROVIDERS}
+
+
+def list_models(provider: str, api_key: Optional[str] = None, base_url: Optional[str] = None,
+                include_old: bool = True, hide: Iterable[str] = ()) -> list[dict]:
+    """[{id, label, free, recommended}] for models this key can use to
+    generate text; the recommended one first.
+
+    include_old=False leaves out models a newer stable release of the same
+    line replaces (model_catalog.superseded), models the provider marks
+    inactive, and `hide` (litellm ids found retired by model_health)."""
+    from .model_catalog import bare, is_text_model, recommend, superseded
+
+    models = [m for m in _list_models(provider, api_key, base_url) if is_text_model(bare(m["id"]))]
+    if not include_old:
+        gone = superseded(bare(m["id"]) for m in models)
+        hidden = set(hide)
+        models = [m for m in models if m.get("active", True) and bare(m["id"]) not in gone and m["id"] not in hidden]
+    for m in models:
+        m.pop("active", None)
+    best = recommend(provider, [bare(m["id"]) for m in models])
+    for m in models:
+        m["recommended"] = best is not None and bare(m["id"]) == best
+    return sorted(models, key=lambda m: not m["recommended"])
+
+
+def _list_models(provider: str, api_key: Optional[str] = None, base_url: Optional[str] = None) -> list[dict]:
+    if provider == "gemini":
+        resp = requests.get("https://generativelanguage.googleapis.com/v1beta/models",
+                            params={"key": api_key, "pageSize": 200}, timeout=_TIMEOUT)
+        resp.raise_for_status()
+        out = []
+        for m in resp.json().get("models", []):
+            if "generateContent" not in (m.get("supportedGenerationMethods") or []):
+                continue
+            name = m["name"].split("/", 1)[-1]
+            out.append({"id": f"gemini/{name}", "label": m.get("displayName") or name, "free": None})
+        return out
+
+    if provider == "openrouter":
+        # Public list; pricing tells which models are free.
+        resp = requests.get("https://openrouter.ai/api/v1/models", timeout=_TIMEOUT)
+        resp.raise_for_status()
+        out = []
+        for m in resp.json().get("data", []):
+            pricing = m.get("pricing") or {}
+            free = str(pricing.get("prompt")) in ("0", "0.0") and str(pricing.get("completion")) in ("0", "0.0")
+            out.append({"id": f"openrouter/{m['id']}", "label": m.get("name") or m["id"], "free": free})
+        return sorted(out, key=lambda m: (not m["free"], m["label"].lower()))
+
+    if provider == "ollama":
+        base = (base_url or "http://localhost:11434").rstrip("/")
+        resp = requests.get(f"{base}/api/tags", timeout=_TIMEOUT)
+        resp.raise_for_status()
+        return [{"id": f"ollama/{m['name']}", "label": m["name"], "free": True} for m in resp.json().get("models", [])]
+
+    if provider == "anthropic":
+        resp = requests.get("https://api.anthropic.com/v1/models", timeout=_TIMEOUT,
+                            headers={"x-api-key": api_key or "", "anthropic-version": "2023-06-01"})
+        resp.raise_for_status()
+        return [{"id": f"anthropic/{m['id']}", "label": m.get("display_name") or m["id"], "free": False}
+                for m in resp.json().get("data", [])]
+
+    # OpenAI-style /models lists.
+    urls = {
+        "groq": "https://api.groq.com/openai/v1/models",
+        "openai": "https://api.openai.com/v1/models",
+        "deepseek": "https://api.deepseek.com/models",
+        "mistral": "https://api.mistral.ai/v1/models",
+        "cerebras": "https://api.cerebras.ai/v1/models",
+        "nvidia_nim": "https://integrate.api.nvidia.com/v1/models",
+    }
+    if provider not in urls:
+        raise ValueError(f"Unknown provider '{provider}'")
+    resp = requests.get(urls[provider], headers={"Authorization": f"Bearer {api_key or ''}"}, timeout=_TIMEOUT)
+    resp.raise_for_status()
+    skip = ("whisper", "tts", "embedding", "embed", "moderation", "dall-e", "image", "audio", "transcribe", "guard")
+    out = []
+    for m in resp.json().get("data", []):
+        mid = m.get("id", "")
+        if not mid or any(word in mid.lower() for word in skip):
+            continue
+        out.append({"id": f"{provider}/{mid}", "label": mid, "free": True if provider in ("groq", "cerebras") else None,
+                    "active": m.get("active") is not False})
+    return sorted(out, key=lambda m: m["label"].lower())

marketmyna/llm/store.py

@@ -0,0 +1,128 @@
+"""Response cache and usage counters for LLM calls (sqlite, shared by the
+API process and the scheduler's child processes).
+
+The cache key covers everything that shapes the answer - model tier,
+system prompt, prompt, and generation limits - so a cached reply is only
+reused for a byte-identical request. Prompts embed the current price and
+indicator values, so a new trading day naturally misses the cache.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import logging
+from datetime import date, datetime, timedelta
+from typing import Optional
+
+from ..utils.log_redact import SECRETS as _SECRETS
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_CACHE_HOURS = 6.0
+
+# GenerationErrorCode value -> the reason shown in Settings -> AI usage.
+ERROR_KINDS = {
+    "model_unavailable": "retired",
+    "rate_limited": "quota",
+    "auth_failed": "key",
+    "timeout": "timeout",
+    "invalid_response": "bad answer",
+    "unknown": "outage",
+}
+
+
+def clean_error(exc, limit: int = 300) -> str:
+    """One line of an error's text, with anything that looks like an API key
+    masked (provider errors can echo the request URL, ?key=... included)."""
+    return _SECRETS.sub("***", " ".join(str(exc).split()))[:limit]
+
+
+def error_kind(exc) -> str:
+    code = getattr(getattr(exc, "error_code", None), "value", "")
+    return ERROR_KINDS.get(code, "other")
+
+
+class LLMStore:
+    def __init__(self, config):
+        from ..storage import DatabaseManager, get_db_url
+
+        self._db = DatabaseManager.instance(get_db_url(config=config))
+        hours = getattr(config, "llm_cache_hours", None)
+        self.cache_hours = DEFAULT_CACHE_HOURS if hours is None else float(hours)
+
+    @staticmethod
+    def key(tier: str, system_prompt: Optional[str], prompt: str, max_tokens, temperature) -> str:
+        raw = "\x1f".join([tier, system_prompt or "", prompt, str(max_tokens), str(temperature)])
+        return hashlib.sha256(raw.encode("utf-8")).hexdigest()
+
+    # ---- cache
+    def get(self, key: str) -> Optional[tuple[str, str]]:
+        if self.cache_hours <= 0:
+            return None
+        from ..storage import LLMCacheRecord
+
+        try:
+            with self._db.get_session() as session:
+                record = session.get(LLMCacheRecord, key)
+                if record and record.created_at >= datetime.now() - timedelta(hours=self.cache_hours):
+                    return record.text, record.model or ""
+        except Exception as exc:
+            logger.debug("LLM cache read failed: %s", exc)
+        return None
+
+    def put(self, key: str, text: str, model: str) -> None:
+        if self.cache_hours <= 0 or not text:
+            return
+        from ..storage import LLMCacheRecord
+
+        try:
+            with self._db.get_session() as session:
+                session.merge(LLMCacheRecord(key=key, text=text, model=model, created_at=datetime.now()))
+                # Keep the table small: drop answers as soon as they are past the TTL.
+                cutoff = datetime.now() - timedelta(hours=self.cache_hours)
+                session.query(LLMCacheRecord).filter(LLMCacheRecord.created_at < cutoff).delete(
+                    synchronize_session=False)
+        except Exception as exc:
+            logger.debug("LLM cache write failed: %s", exc)
+
+    # ---- usage
+    def record(self, route: str, *, ok: bool = True, cached: bool = False, usage: Optional[dict] = None,
+               error: Optional[Exception] = None) -> None:
+        from ..storage import LLMUsageRecord
+
+        usage = usage or {}
+        try:
+            with self._db.get_session() as session:
+                today = date.today().isoformat()
+                row = session.query(LLMUsageRecord).filter_by(day=today, route=route).first()
+                if row is None:
+                    row = LLMUsageRecord(day=today, route=route, calls=0, failures=0, cache_hits=0,
+                                         prompt_tokens=0, completion_tokens=0)
+                    session.add(row)
+                if cached:
+                    row.cache_hits = (row.cache_hits or 0) + 1
+                elif ok:
+                    row.calls = (row.calls or 0) + 1
+                    row.prompt_tokens = (row.prompt_tokens or 0) + int(usage.get("prompt_tokens") or 0)
+                    row.completion_tokens = (row.completion_tokens or 0) + int(usage.get("completion_tokens") or 0)
+                else:
+                    row.failures = (row.failures or 0) + 1
+                    if error is not None:
+                        row.last_error_kind = error_kind(error)
+                        row.last_error = clean_error(error)
+        except Exception as exc:
+            logger.debug("LLM usage write failed: %s", exc)
+
+    def usage(self, days: int = 7) -> list[dict]:
+        from ..storage import LLMUsageRecord
+
+        since = (date.today() - timedelta(days=days - 1)).isoformat()
+        with self._db.get_session() as session:
+            rows = session.query(LLMUsageRecord).filter(LLMUsageRecord.day >= since).all()
+            return [
+                {"day": r.day, "route": r.route, "calls": r.calls or 0, "failures": r.failures or 0,
+                 "cache_hits": r.cache_hits or 0, "prompt_tokens": r.prompt_tokens or 0,
+                 "completion_tokens": r.completion_tokens or 0, "last_error_kind": r.last_error_kind,
+                 "last_error": r.last_error}
+                for r in sorted(rows, key=lambda r: (r.day, r.route), reverse=True)
+            ]

marketmyna/notifiers/__init__.py

@@ -0,0 +1,35 @@
+"""Notification channel senders and dispatcher."""
+
+from .astrbot import AstrbotSender
+from .dingtalk import DingtalkSender
+from .discord import DiscordSender
+from .dispatcher import NotificationDispatcher
+from .email import EmailSender
+from .feishu import FeishuSender
+from .gotify import GotifySender
+from .ntfy import NtfySender
+from .pushover import PushoverSender
+from .pushplus import PushplusSender
+from .serverchan3 import Serverchan3Sender
+from .slack import SlackSender
+from .telegram import TelegramSender
+from .webhook import WebhookSender
+from .wechat import WechatSender
+
+__all__ = [
+    "AstrbotSender",
+    "DingtalkSender",
+    "DiscordSender",
+    "EmailSender",
+    "FeishuSender",
+    "GotifySender",
+    "NotificationDispatcher",
+    "NtfySender",
+    "PushoverSender",
+    "PushplusSender",
+    "Serverchan3Sender",
+    "SlackSender",
+    "TelegramSender",
+    "WebhookSender",
+    "WechatSender",
+]

marketmyna/notifiers/apprise_sender.py

@@ -0,0 +1,43 @@
+"""Apprise sender: one field that reaches 100+ services (LINE, Viber,
+Mastodon, Zulip, Home Assistant, Rocket.Chat, SMS gateways, ...) through
+Apprise URLs - see https://github.com/caronc/apprise/wiki.
+
+Optional dependency: `pip install apprise`. Without it the channel is
+reported as not configured (and logged) rather than failing.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from .base import DEFAULT_TIMEOUT, DEFAULT_TITLE, logger
+
+
+class AppriseSender:
+    def __init__(self, config):
+        self._urls = [u for u in (getattr(config, "apprise_urls", None) or []) if u]
+
+    def is_configured(self) -> bool:
+        if not self._urls:
+            return False
+        try:
+            import apprise  # noqa: F401
+        except ImportError:
+            logger.warning("apprise_urls is set but the apprise package isn't installed (pip install apprise)")
+            return False
+        return True
+
+    def send(self, message: str, title: Optional[str] = None, *, timeout: float = DEFAULT_TIMEOUT) -> bool:
+        if not self.is_configured():
+            return False
+        import apprise
+
+        client = apprise.Apprise()
+        for url in self._urls:
+            if not client.add(url):
+                logger.error("Apprise rejected URL (check its format): %s", url.split("://")[0] + "://…")
+        try:
+            return bool(client.notify(body=message, title=title or DEFAULT_TITLE))
+        except Exception as exc:
+            logger.error("Apprise send failed: %s", exc)
+            return False

marketmyna/notifiers/astrbot.py

@@ -0,0 +1,47 @@
+"""Self-hosted AstrBot webhook notification sender."""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+import time
+from typing import Optional
+
+import requests
+
+from .base import DEFAULT_TIMEOUT, logger
+
+
+class AstrbotSender:
+    def __init__(self, config):
+        self._url = getattr(config, "astrbot_url", None)
+        self._token = getattr(config, "astrbot_token", None)
+
+    def is_configured(self) -> bool:
+        return bool(self._url)
+
+    def send(self, message: str, title: Optional[str] = None, *, timeout: float = DEFAULT_TIMEOUT) -> bool:
+        if not self.is_configured():
+            return False
+
+        payload = {"content": f"{title}\n\n{message}" if title else message}
+        headers = {"Content-Type": "application/json"}
+
+        if self._token:
+            timestamp = str(int(time.time()))
+            payload_json = json.dumps(payload, sort_keys=True)
+            sign_data = f"{timestamp}.{payload_json}".encode("utf-8")
+            signature = hmac.new(self._token.encode("utf-8"), sign_data, hashlib.sha256).hexdigest()
+            headers["X-Signature"] = signature
+            headers["X-Timestamp"] = timestamp
+
+        try:
+            resp = requests.post(self._url, json=payload, headers=headers, timeout=timeout)
+            if resp.status_code == 200:
+                return True
+            logger.error("AstrBot send failed: HTTP %s %s", resp.status_code, resp.text[:200])
+            return False
+        except requests.RequestException as exc:
+            logger.error("AstrBot send failed: %s", exc)
+            return False

marketmyna/notifiers/bark.py

@@ -0,0 +1,24 @@
+"""Bark iOS push sender (https://github.com/Finb/Bark): the device URL
+shown in the Bark app, e.g. https://api.day.app/yourkey."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from .base import DEFAULT_TIMEOUT, DEFAULT_TITLE, http_ok, truncate
+
+BARK_MAX_LENGTH = 3500
+
+
+class BarkSender:
+    def __init__(self, config):
+        self._url = (getattr(config, "bark_url", None) or "").rstrip("/")
+
+    def is_configured(self) -> bool:
+        return bool(self._url)
+
+    def send(self, message: str, title: Optional[str] = None, *, timeout: float = DEFAULT_TIMEOUT) -> bool:
+        if not self.is_configured():
+            return False
+        payload = {"title": title or DEFAULT_TITLE, "body": truncate(message, BARK_MAX_LENGTH), "group": "MarketMyna"}
+        return http_ok("Bark", "POST", self._url, json=payload, timeout=timeout)

marketmyna/notifiers/base.py

@@ -0,0 +1,80 @@
+"""Shared helpers for notification channel senders.
+
+Each sender follows the same small contract: ``is_configured()`` and
+``send(message, title=None, timeout=10.0) -> bool``. A channel that fails
+must return False rather than raise, so one broken channel never blocks
+the others (see NotificationDispatcher).
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Callable
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_TITLE = "MarketMyna Alert"
+DEFAULT_TIMEOUT = 10.0
+
+
+TRUNCATION_NOTE = "\n…\n(Shortened to fit this channel. Open MarketMyna for the full report.)"
+
+
+def utf8_len(text: str) -> int:
+    return len(text.encode("utf-8"))
+
+
+def truncate(text: str, max_length: int, measure: Callable[[str], int] = len) -> str:
+    """Cap message length for platforms with a hard limit, saying so when it
+    cuts (so a reader knows sections are missing). `measure` = utf8_len for
+    platforms that count bytes."""
+    if measure(text) <= max_length:
+        return text
+    note = TRUNCATION_NOTE if max_length >= 400 else "…"
+    budget = max_length - measure(note)
+    cut = text[:budget]
+    while cut and measure(cut) > budget:  # multi-byte characters
+        cut = cut[: max(1, len(cut) - max(1, (measure(cut) - budget) // 2))]
+    cut = cut.rsplit("\n", 1)[0] if "\n" in cut[-200:] and note != "…" else cut  # end on a whole line
+    return cut.rstrip() + note
+
+
+def split_message(text: str, limit: int, measure: Callable[[str], int] = len) -> list[str]:
+    """Split on line boundaries into chunks of at most `limit` (chars, or
+    bytes with measure=utf8_len); a single over-long line is hard-cut."""
+    chunks: list[str] = []
+    current = ""
+    for line in text.split("\n"):
+        while measure(line) > limit:
+            if current:
+                chunks.append(current)
+                current = ""
+            piece = line[:limit]
+            while measure(piece) > limit:
+                piece = piece[:-1]
+            chunks.append(piece)
+            line = line[len(piece):]
+        candidate = f"{current}\n{line}" if current else line
+        if measure(candidate) > limit:
+            chunks.append(current)
+            current = line
+        else:
+            current = candidate
+    if current:
+        chunks.append(current)
+    return chunks or [""]
+
+
+def http_ok(channel: str, method: str, url: str, *, timeout: float = DEFAULT_TIMEOUT, **kwargs) -> bool:
+    """One HTTP call for a sender: True on 2xx, False (logged) otherwise."""
+    import requests
+
+    try:
+        resp = requests.request(method, url, timeout=timeout, **kwargs)
+    except requests.RequestException as exc:
+        logger.error("%s send failed: %s", channel, exc)
+        return False
+    if 200 <= resp.status_code < 300:
+        return True
+    logger.error("%s send failed: HTTP %s %s", channel, resp.status_code, resp.text[:200])
+    return False

marketmyna/notifiers/dingtalk.py

@@ -0,0 +1,54 @@
+"""DingTalk custom robot webhook notification sender."""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import time
+import urllib.parse
+from typing import Optional
+
+import requests
+
+from .base import DEFAULT_TIMEOUT, DEFAULT_TITLE, logger, truncate, utf8_len
+
+DINGTALK_MAX_LENGTH = 19000
+
+
+class DingtalkSender:
+    def __init__(self, config):
+        self._webhook_url = getattr(config, "dingtalk_webhook_url", None)
+        self._secret = getattr(config, "dingtalk_secret", None)
+
+    def is_configured(self) -> bool:
+        return bool(self._webhook_url)
+
+    def _signed_url(self) -> str:
+        if not self._secret:
+            return self._webhook_url
+
+        timestamp = str(round(time.time() * 1000))
+        string_to_sign = f"{timestamp}\n{self._secret}".encode("utf-8")
+        hmac_code = hmac.new(self._secret.encode("utf-8"), string_to_sign, digestmod=hashlib.sha256).digest()
+        sign = urllib.parse.quote_plus(base64.b64encode(hmac_code))
+        joiner = "&" if "?" in self._webhook_url else "?"
+        return f"{self._webhook_url}{joiner}timestamp={timestamp}&sign={sign}"
+
+    def send(self, message: str, title: Optional[str] = None, *, timeout: float = DEFAULT_TIMEOUT) -> bool:
+        if not self.is_configured():
+            return False
+
+        text = truncate(f"### {title or DEFAULT_TITLE}\n\n{message}", DINGTALK_MAX_LENGTH, measure=utf8_len)  # 20000-byte cap
+        payload = {"msgtype": "markdown", "markdown": {"title": title or DEFAULT_TITLE, "text": text}}
+
+        try:
+            resp = requests.post(self._signed_url(), json=payload, timeout=timeout)
+            result = resp.json()
+            if result.get("errcode") == 0:
+                return True
+            logger.error("DingTalk send failed: %s", result)
+            return False
+        except (requests.RequestException, ValueError) as exc:
+            logger.error("DingTalk send failed: %s", exc)
+            return False

marketmyna/notifiers/discord.py

@@ -0,0 +1,39 @@
+"""Discord Incoming Webhook notification sender."""
+
+from __future__ import annotations
+
+import time
+from typing import Optional
+
+import requests
+
+from .base import DEFAULT_TIMEOUT, DEFAULT_TITLE, logger, split_message
+
+DISCORD_MAX_LENGTH = 2000
+
+
+class DiscordSender:
+    def __init__(self, config):
+        self._webhook_url = getattr(config, "discord_webhook_url", None)
+
+    def is_configured(self) -> bool:
+        return bool(self._webhook_url)
+
+    def send(self, message: str, title: Optional[str] = None, *, timeout: float = DEFAULT_TIMEOUT) -> bool:
+        if not self.is_configured():
+            return False
+
+        text = f"**{title or DEFAULT_TITLE}**\n{message}"
+        # Long reports go out as several messages instead of being cut off.
+        for i, chunk in enumerate(split_message(text, DISCORD_MAX_LENGTH)):
+            if i:
+                time.sleep(0.5)  # webhook rate limit: 5 requests / 2 s
+            try:
+                resp = requests.post(self._webhook_url, json={"content": chunk}, timeout=timeout)
+            except requests.RequestException as exc:
+                logger.error("Discord send failed: %s", exc)
+                return False
+            if not 200 <= resp.status_code < 300:
+                logger.error("Discord send failed: HTTP %s %s", resp.status_code, resp.text[:200])
+                return False
+        return True