marketmyna 0.2.0__py3-none-any.whl

marketmyna/services/accounts.py

@@ -0,0 +1,278 @@
+"""The local owner account and helpers around it. Single-user build: no
+sign-up or login; every request runs as the owner (marketmyna/api/middlewares/auth.py),
+an admin account made on first use. Saved secrets (channel webhooks, AI keys)
+are encrypted with AES-GCM using SECRET_KEY or a generated key file.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import logging
+import os
+import re
+import secrets
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.orm import Session
+
+from marketmyna.core.home import app_home
+
+from ..core import tenant
+from ..storage import UserApiKeyRecord, UserRecord
+
+logger = logging.getLogger(__name__)
+
+
+class AccountError(Exception):
+    def __init__(self, message: str, status: int = 400):
+        super().__init__(message)
+        self.message = message
+        self.status = status
+
+
+BYOK_PROVIDERS = ("gemini", "groq", "openrouter", "openai", "anthropic", "deepseek", "mistral")
+
+
+LOCAL_OWNER_EMAIL = "owner@localhost"
+
+
+def ensure_local_owner(session: Session) -> UserRecord:
+    """Single-user build: the one account every request runs as. The first
+    active admin if there is one, otherwise a fresh admin with no password
+    (nobody logs in; the app is reachable only by whoever runs it)."""
+    user = (session.query(UserRecord).filter_by(role="admin", status="active")
+            .order_by(UserRecord.id).first())
+    if user is not None:
+        return user
+    user = UserRecord(email=LOCAL_OWNER_EMAIL, display_name="Owner", role="admin", status="active",
+                      email_verified_at=datetime.now())
+    session.add(user)
+    session.flush()
+    adopt_unowned(session, user.id)
+    logger.info("Created the local owner account")
+    return user
+
+
+def adopt_unowned(session: Session, user_id: int) -> int:
+    """Gives rows saved before accounts existed (user_id NULL: portfolios,
+    watchlists, alerts, ...) to the first admin, so switching a local
+    install to log-in keeps its data. Returns the number of rows moved."""
+    moved = 0
+    with tenant.system_scope():
+        for model in tenant.owned_models():
+            moved += session.query(model).filter(model.user_id.is_(None)).update(
+                {model.user_id: user_id}, synchronize_session=False)
+    return moved
+
+
+# ---------- email ----------
+
+
+def report_sender(config, purpose: Optional[str]) -> Optional[str]:
+    """From address for `purpose`: the reports address for scheduled reports
+    and alerts, else None (the main sender)."""
+    return (getattr(config, "email_reports_sender", None) or None) if purpose in ("report", "alert") else None
+
+
+# ---------- saved secrets ----------
+
+
+def _aes_key(config) -> bytes:
+    secret = getattr(config, "secret_key", None)
+    if not secret:
+        path = Path(getattr(config, "app_dir", app_home())) / "secret.key"
+        if not path.exists():
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(secrets.token_urlsafe(48), encoding="utf-8")
+            path.chmod(0o600)
+        secret = path.read_text(encoding="utf-8").strip()
+    return hashlib.sha256(b"marketmyna-byok-v1:" + secret.encode()).digest()
+
+
+def encrypt_secret(config, plaintext: str) -> bytes:
+    nonce = os.urandom(12)
+    return nonce + AESGCM(_aes_key(config)).encrypt(nonce, plaintext.encode(), b"byok")
+
+
+def decrypt_secret(config, blob: bytes) -> str:
+    return AESGCM(_aes_key(config)).decrypt(blob[:12], blob[12:], b"byok").decode()
+
+
+# ---------- AI keys ----------
+
+
+MAX_API_KEYS = 10
+
+
+def set_api_key(session: Session, config, user: UserRecord, provider: Optional[str], key: str) -> UserApiKeyRecord:
+    """Saves a key. With no provider, works out the provider and model from the
+    key itself (byok_detect), checking the provider accepts it. The same key
+    saved again only refreshes what was detected."""
+    provider = (provider or "").strip().lower()
+    key = (key or "").strip()
+    if len(key) < 8 or len(key) > 512 or any(c.isspace() for c in key):
+        raise AccountError("That doesn't look like an API key.")
+    if provider and provider not in BYOK_PROVIDERS:
+        raise AccountError(f"Unsupported provider. Choose one of: {', '.join(BYOK_PROVIDERS)}.")
+    rows = session.query(UserApiKeyRecord).filter_by(user_id=user.id).all()
+    row = next((r for r in rows if r.key_last4 == key[-4:] and _same_secret(config, r, key)), None)
+    if row is None and len(rows) >= MAX_API_KEYS:
+        raise AccountError(f"You can keep up to {MAX_API_KEYS} keys. Remove one first.")
+    detected = None
+    if not provider:
+        from .byok_detect import KeyDetectError, detect
+
+        try:
+            detected = detect(key)
+        except KeyDetectError as exc:
+            raise AccountError(str(exc)) from None
+        provider = detected.provider
+    if row is None:
+        row = UserApiKeyRecord(user_id=user.id, key_ciphertext=encrypt_secret(config, key), key_last4=key[-4:],
+                               created_at=datetime.now())
+    row.provider = provider
+    row.model = detected.model if detected else None
+    row.free = detected.free if detected else None
+    row.note = detected.note if detected else None
+    try:
+        with session.begin_nested():
+            session.add(row)
+    except IntegrityError:
+        raise AccountError(f"This database keeps one {provider} key. Remove the old one first.", status=409) from None
+    return row
+
+
+def _same_secret(config, row: UserApiKeyRecord, key: str) -> bool:
+    try:
+        return decrypt_secret(config, row.key_ciphertext) == key
+    except Exception:
+        return False
+
+
+def split_keys(raw: str) -> list[str]:
+    """Several keys pasted at once: one per line, or separated by spaces or commas."""
+    seen: list[str] = []
+    for part in re.split(r"[\s,;]+", raw or ""):
+        if part and part not in seen:
+            seen.append(part)
+    return seen
+
+
+def set_api_keys(session: Session, config, user: UserRecord, provider: Optional[str], raw: str) -> list[str]:
+    """Saves every key in `raw` (split_keys). Returns one message per key that
+    failed; raises when none could be saved."""
+    keys = split_keys(raw)
+    if not keys:
+        raise AccountError("Paste an API key.")
+    errors = []
+    for key in keys:
+        try:
+            set_api_key(session, config, user, provider, key)
+        except AccountError as exc:
+            if len(keys) == 1:
+                raise
+            errors.append(f"Key ending {key[-4:]}: {exc.message}")
+    if len(errors) == len(keys):
+        raise AccountError(" ".join(errors))
+    return errors
+
+
+def delete_api_key(session: Session, user: UserRecord, key_id: str) -> bool:
+    """key_id: the key's id, or a provider name to remove all of its keys."""
+    query = session.query(UserApiKeyRecord).filter_by(user_id=user.id)
+    ref = (key_id or "").strip().lower()
+    rows = query.filter_by(id=int(ref)).all() if ref.isdigit() else query.filter_by(provider=ref).all()
+    for row in rows:
+        session.delete(row)
+    session.flush()
+    return bool(rows)
+
+
+def api_keys(session: Session, user: UserRecord) -> list[dict]:
+    """In the order AI tries them (oldest first)."""
+    return [
+        {
+            "id": r.id,
+            "provider": r.provider,
+            "last4": r.key_last4,
+            "model": r.model,
+            "free": r.free,
+            "note": r.note,
+            "added_at": r.created_at.isoformat() if r.created_at else None,
+        }
+        for r in session.query(UserApiKeyRecord).filter_by(user_id=user.id).order_by(UserApiKeyRecord.id)
+    ]
+
+
+# ---------- background work in accounts mode ----------
+
+_owner_cache: dict[str, tuple[float, Optional[int]]] = {}
+OWNER_CACHE_SECONDS = 60
+
+
+def owner_user_id(config) -> Optional[int]:
+    """The platform owner: the first admin account. Its scope gets the
+    owner's channels (config.json) and the platform's scheduled report."""
+    import time
+
+    from ..storage import DatabaseManager, get_db_url
+
+    url = get_db_url(config=config)
+    hit = _owner_cache.get(url)
+    if hit and time.time() - hit[0] < OWNER_CACHE_SECONDS:
+        return hit[1]
+    with DatabaseManager.instance(url).get_session() as session:
+        row = (session.query(UserRecord.id).filter_by(role="admin", status="active")
+               .order_by(UserRecord.id).first())
+    owner = row[0] if row else None
+    _owner_cache[url] = (time.time(), owner)
+    return owner
+
+
+def is_owner_scope(config) -> bool:
+    """Whether the current data scope may use the owner's channels: always
+    outside accounts mode; the system scope (errors) or the owner otherwise."""
+    if not tenant.enabled():
+        return True
+    scope = tenant.current()
+    if scope is tenant.SYSTEM:
+        return True
+    return scope is not None and scope == owner_user_id(config)
+
+
+def owner_scope(config):
+    """Runs the block as the platform owner in accounts mode (fails closed
+    when there is no admin yet); a no-op otherwise."""
+    import contextlib
+
+    if not tenant.enabled():
+        return contextlib.nullcontext()
+    return tenant.user_scope(owner_user_id(config))
+
+
+def active_user_ids(config) -> list[int]:
+    from ..storage import DatabaseManager, get_db_url
+
+    with DatabaseManager.instance(get_db_url(config=config)).get_session() as session:
+        rows = (session.query(UserRecord.id)
+                .filter(UserRecord.status == "active", UserRecord.email_verified_at.isnot(None))
+                .order_by(UserRecord.id).all())
+    return [r[0] for r in rows]
+
+
+def for_each_user(config, fn, label: str) -> None:
+    """Runs fn() once per active user in that user's scope (accounts mode),
+    or once unscoped otherwise. One user's failure doesn't stop the rest."""
+    if not tenant.enabled():
+        fn()
+        return
+    for user_id in active_user_ids(config):
+        try:
+            with tenant.user_scope(user_id):
+                fn()
+        except Exception:
+            logger.exception("%s failed for user %s", label, user_id)

marketmyna/services/ai_access.py

@@ -0,0 +1,94 @@
+"""Which AI the app uses.
+
+The owner's own keys come first (Settings -> AI keys: paste a key, the
+provider and model are worked out from it, marketmyna/services/byok_detect.py),
+each tried in turn. With no saved key, the AI setup in config.json and the
+environment (LLM_MODEL, OLLAMA_BASE_URL, ...) is used unchanged; with
+neither, AI features say no model is configured.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+# Model used with a key when none was picked from the provider's list when
+# the key was saved (marketmyna/services/byok_detect.py). Aliases the provider keeps
+# current where they exist; a retired one is replaced at the first failing
+# call (marketmyna/llm/model_health.py). Override with BYOK_MODEL_<PROVIDER>, e.g.
+# BYOK_MODEL_GEMINI=gemini/gemini-pro-latest.
+BYOK_DEFAULT_MODELS = {
+    "gemini": "gemini/gemini-flash-latest",
+    "groq": "groq/openai/gpt-oss-120b",
+    "openrouter": "openrouter/openai/gpt-5-mini",
+    "openai": "openai/gpt-5-mini",
+    "anthropic": "anthropic/claude-haiku-4-5",
+    "deepseek": "deepseek/deepseek-chat",
+    "mistral": "mistral/mistral-small-latest",
+}
+
+
+def byok_model(provider: str, detected: Optional[str] = None) -> str:
+    """Env override, else the model picked when the key was saved, else the default."""
+    return os.environ.get(f"BYOK_MODEL_{provider.upper()}") or detected or BYOK_DEFAULT_MODELS[provider]
+
+
+def _db(config):
+    from ..storage import DatabaseManager, get_db_url
+
+    return DatabaseManager.instance(get_db_url(config=config))
+
+
+def own_keys(config) -> list[tuple[str, str, Optional[str], int]]:
+    """Every usable saved key as (provider, key, model, key row id), oldest first."""
+    from datetime import datetime
+
+    from ..core import tenant
+    from ..storage import UserApiKeyRecord
+    from .accounts import BYOK_PROVIDERS, decrypt_secret, owner_user_id
+
+    owner = owner_user_id(config) if tenant.enabled() else None
+    out = []
+    try:
+        with _db(config).get_session() as session:
+            rows = session.query(UserApiKeyRecord)
+            if owner is not None:
+                rows = rows.filter_by(user_id=owner)
+            for row in rows.order_by(UserApiKeyRecord.id):
+                if row.provider not in BYOK_PROVIDERS:
+                    continue
+                try:
+                    out.append((row.provider, decrypt_secret(config, row.key_ciphertext), row.model, row.id))
+                except Exception:
+                    logger.warning("Could not decrypt the saved %s key %s", row.provider, row.id)
+                    continue
+                row.last_used_at = datetime.now()
+    except Exception:
+        logger.exception("Could not read the saved AI keys")
+    return out
+
+
+def wrap_backend(config, build, tier: str):
+    """The saved keys if there are any, else `build(config, tier)` (config.json / env)."""
+    keys = own_keys(config)
+    if not keys:
+        return build(config, tier)
+    from ..llm.channels import FailoverGenerationBackend, LLMRoute
+
+    routes = [LLMRoute(byok_model(provider, model), [key], None, source="byok", key_id=key_id)
+              for provider, key, model, key_id in keys]
+    return FailoverGenerationBackend(config, routes, store=None, tier=tier)
+
+
+def update_byok_model(config, key_id: int, model: str) -> None:
+    """The model saved with a key was retired: keep the one that answered
+    instead (marketmyna/llm/model_health.py)."""
+    from ..storage import UserApiKeyRecord
+
+    with _db(config).get_session() as session:
+        row = session.get(UserApiKeyRecord, key_id)
+        if row is not None:
+            row.model = model