kadeconsole 0.1.0__py3-none-any.whl

kadeconsole/__init__.py

@@ -0,0 +1,10 @@
+"""
+kadeConsole — Bloomberg-terminal-style equity research console.
+
+Usage:
+    pip install kadeconsole
+    kadeconsole
+"""
+
+__version__ = "0.1.0"
+__author__ = "kadeConsole Contributors"

kadeconsole/cache/store.py

@@ -0,0 +1,155 @@
+"""
+cache/store.py — SQLite-backed response and Jev-verdict cache.
+
+Two tables:
+  provider_cache  — raw market data, keyed by (symbol, endpoint), TTL 15 min
+  jev_cache       — Jev responses, keyed by sha256 of (ticker+timeframe+data_hash), TTL 24h
+
+The cache lives at ~/.kadeconsole/cache.db and is created automatically.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import sqlite3
+import time
+from pathlib import Path
+from typing import Any, Optional
+
+CACHE_DB = Path.home() / ".kadeconsole" / "cache.db"
+
+_CREATE_PROVIDER = """
+CREATE TABLE IF NOT EXISTS provider_cache (
+    key        TEXT PRIMARY KEY,
+    data_json  TEXT NOT NULL,
+    expires_at REAL NOT NULL
+);
+"""
+
+_CREATE_JEV = """
+CREATE TABLE IF NOT EXISTS jev_cache (
+    key          TEXT PRIMARY KEY,
+    response_json TEXT NOT NULL,
+    created_at   REAL NOT NULL,
+    expires_at   REAL NOT NULL
+);
+"""
+
+
+class CacheStore:
+    """Thread-safe SQLite cache store."""
+
+    def __init__(
+        self,
+        db_path: Path = CACHE_DB,
+        provider_ttl_minutes: int = 15,
+        jev_ttl_hours: int = 24,
+    ) -> None:
+        self.db_path = db_path
+        self.provider_ttl = provider_ttl_minutes * 60
+        self.jev_ttl = jev_ttl_hours * 3600
+        self._ensure_db()
+
+    # ── Public API ─────────────────────────────────────────────────────────────
+
+    def get_provider(self, symbol: str, endpoint: str) -> Optional[Any]:
+        """Return cached provider data or None if missing/expired."""
+        key = self._provider_key(symbol, endpoint)
+        row = self._fetch("provider_cache", key)
+        return json.loads(row) if row else None
+
+    def set_provider(self, symbol: str, endpoint: str, data: Any) -> None:
+        """Cache provider data with TTL."""
+        key = self._provider_key(symbol, endpoint)
+        self._upsert("provider_cache", key, json.dumps(data, default=str), self.provider_ttl)
+
+    def get_jev(self, ticker: str, timeframe: str, data_fingerprint: str) -> Optional[Any]:
+        """Return cached Jev response or None if missing/expired."""
+        key = self._jev_key(ticker, timeframe, data_fingerprint)
+        row = self._fetch_jev(key)
+        return json.loads(row) if row else None
+
+    def set_jev(self, ticker: str, timeframe: str, data_fingerprint: str, response: Any) -> None:
+        """Cache a Jev response with TTL."""
+        key = self._jev_key(ticker, timeframe, data_fingerprint)
+        self._upsert("jev_cache", key, json.dumps(response, default=str), self.jev_ttl)
+
+    def clear_expired(self) -> None:
+        """Purge all expired rows from both tables."""
+        now = time.time()
+        with self._connect() as conn:
+            conn.execute("DELETE FROM provider_cache WHERE expires_at < ?", (now,))
+            conn.execute("DELETE FROM jev_cache WHERE expires_at < ?", (now,))
+
+    def clear_all(self) -> None:
+        """Nuke entire cache (useful for debugging)."""
+        with self._connect() as conn:
+            conn.execute("DELETE FROM provider_cache")
+            conn.execute("DELETE FROM jev_cache")
+
+    # ── Helpers ────────────────────────────────────────────────────────────────
+
+    @staticmethod
+    def make_data_fingerprint(data: Any) -> str:
+        """Return a short sha256 fingerprint of any JSON-serialisable data."""
+        raw = json.dumps(data, sort_keys=True, default=str).encode()
+        return hashlib.sha256(raw).hexdigest()[:16]
+
+    # ── Internal ───────────────────────────────────────────────────────────────
+
+    def _ensure_db(self) -> None:
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        with self._connect() as conn:
+            conn.execute(_CREATE_PROVIDER)
+            conn.execute(_CREATE_JEV)
+
+    def _connect(self) -> sqlite3.Connection:
+        return sqlite3.connect(str(self.db_path))
+
+    def _fetch(self, table: str, key: str) -> Optional[str]:
+        """Fetch from provider_cache (data_json column)."""
+        now = time.time()
+        with self._connect() as conn:
+            row = conn.execute(
+                f"SELECT data_json FROM {table} WHERE key=? AND expires_at>?",
+                (key, now),
+            ).fetchone()
+        return row[0] if row else None
+
+    def _fetch_jev(self, key: str) -> Optional[str]:
+        """Fetch from jev_cache (response_json column)."""
+        now = time.time()
+        with self._connect() as conn:
+            row = conn.execute(
+                "SELECT response_json FROM jev_cache WHERE key=? AND expires_at>?",
+                (key, now),
+            ).fetchone()
+        return row[0] if row else None
+
+    def _upsert(self, table: str, key: str, data_json: str, ttl: float) -> None:
+        now = time.time()
+        expires = now + ttl
+        if table == "provider_cache":
+            sql = (
+                "INSERT OR REPLACE INTO provider_cache (key, data_json, expires_at) "
+                "VALUES (?, ?, ?)"
+            )
+            with self._connect() as conn:
+                conn.execute(sql, (key, data_json, expires))
+        else:
+            sql = (
+                "INSERT OR REPLACE INTO jev_cache (key, response_json, created_at, expires_at) "
+                "VALUES (?, ?, ?, ?)"
+            )
+            with self._connect() as conn:
+                conn.execute(sql, (key, data_json, now, expires))
+
+    @staticmethod
+    def _provider_key(symbol: str, endpoint: str) -> str:
+        return f"{symbol.upper()}:{endpoint}"
+
+    @staticmethod
+    def _jev_key(ticker: str, timeframe: str, fingerprint: str) -> str:
+        raw = f"{ticker.upper()}:{timeframe}:{fingerprint}"
+        return hashlib.sha256(raw.encode()).hexdigest()

kadeconsole/cli.py

@@ -0,0 +1,193 @@
+"""
+cli.py — kadeConsole REPL entrypoint.
+
+Entry point: `kadeconsole` (via pyproject.toml console_scripts)
+
+Startup sequence:
+  1. Load config from ~/.kadeconsole/config.yaml
+  2. Initialise provider registry + Jev client + SQLite cache
+  3. Print startup banner
+  4. Drop into prompt_toolkit REPL loop
+  5. Parse each input line → Router.dispatch() → continue or exit
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import Optional
+
+from rich.console import Console
+
+from kadeconsole.render.theme import RICH_THEME, t
+from kadeconsole import __version__
+
+console = Console(theme=RICH_THEME)
+
+# ── Banner ─────────────────────────────────────────────────────────────────────
+_BANNER = r"""
+  ██╗  ██╗ █████╗ ██████╗ ███████╗
+  ██║ ██╔╝██╔══██╗██╔══██╗██╔════╝
+  █████╔╝ ███████║██║  ██║█████╗
+  ██╔═██╗ ██╔══██║██║  ██║██╔══╝
+  ██║  ██╗██║  ██║██████╔╝███████╗
+  ╚═╝  ╚═╝╚═╝  ╚═╝╚═════╝ ╚══════╝
+"""
+
+
+def _print_banner() -> None:
+    console.print(f"[accent]{_BANNER}[/accent]", highlight=False)
+    console.print(
+        f"  [bold {t.accent}]CONSOLE[/bold {t.accent}]  "
+        f"[{t.muted}]v{__version__}[/]  "
+        f"[{t.dim_text}]·  Bloomberg-style equity research terminal[/]\n"
+    )
+    console.print(
+        f"  [{t.muted}]Type [accent]HELP[/accent] or [accent]?[/accent] for the command reference.  "
+        f"[accent]EXIT[/accent] or [accent]Q[/accent] to quit.[/]\n"
+    )
+
+
+# ── Autocomplete word list ─────────────────────────────────────────────────────
+_AUTOCOMPLETE_WORDS = [
+    "EQUITY", "DES", "FA", "FA Q", "GP", "HP", "VERDICT", "RATE",
+    "TA", "NI", "RV", "COMPARE", "MACRO", "SCREEN", "WATCH", "EXPORT",
+    "SOURCE", "HELP", "EXIT", "QUIT",
+    "1D", "5D", "1M", "3M", "6M", "1Y", "2Y", "5Y",
+]
+
+
+def _build_completer():
+    """Build a prompt_toolkit WordCompleter for the REPL."""
+    try:
+        from prompt_toolkit.completion import WordCompleter
+        return WordCompleter(_AUTOCOMPLETE_WORDS, ignore_case=True, sentence=True)
+    except ImportError:
+        return None
+
+
+def _build_prompt_session():
+    """Build a prompt_toolkit PromptSession (with history)."""
+    try:
+        from prompt_toolkit import PromptSession
+        from prompt_toolkit.history import FileHistory
+        from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
+        from pathlib import Path
+
+        hist_file = Path.home() / ".kadeconsole" / "history"
+        hist_file.parent.mkdir(parents=True, exist_ok=True)
+
+        return PromptSession(
+            history=AutoSuggestFromHistory() and FileHistory(str(hist_file)),
+            auto_suggest=AutoSuggestFromHistory(),
+            completer=_build_completer(),
+            complete_while_typing=False,
+        )
+    except ImportError:
+        return None
+
+
+def _simple_input(prompt: str) -> str:
+    """Fallback to built-in input() when prompt_toolkit is unavailable."""
+    try:
+        return input(prompt)
+    except EOFError:
+        return "EXIT"
+
+
+def main() -> None:
+    """Main entrypoint — called by the `kadeconsole` console script."""
+
+    # ── 1. Load config ─────────────────────────────────────────────────────────
+    from kadeconsole.config.loader import load_config
+    config = load_config()
+
+    # ── 2. Initialise cache ────────────────────────────────────────────────────
+    from kadeconsole.cache.store import CacheStore
+    cache = CacheStore(
+        provider_ttl_minutes = config.get("cache_ttl_provider_minutes", 15),
+        jev_ttl_hours        = config.get("cache_ttl_jev_hours", 24),
+    )
+    cache.clear_expired()  # housekeeping on startup
+
+    # ── 3. Initialise providers ────────────────────────────────────────────────
+    from kadeconsole.providers.registry import ProviderRegistry
+    registry = ProviderRegistry(config)
+    provider = registry.get_primary()
+
+    # ── 4. Initialise Jev client ───────────────────────────────────────────────
+    from kadeconsole.jev.client import JevClient
+    jev = JevClient(
+        api_key = config.get("typesafe_api_key", ""),
+        cache   = cache,
+    )
+
+    # ── 5. Session + Router ───────────────────────────────────────────────────
+    from kadeconsole.core.session import Session
+    from kadeconsole.core.router import Router
+    session = Session(timeframe=config.get("default_timeframe", "1Y"))
+    router  = Router(session=session, provider=provider, jev=jev)
+
+    # ── 6. Banner ──────────────────────────────────────────────────────────────
+    _print_banner()
+
+    # Provider status line
+    provider_line = f"[{t.muted}]  Data: [accent]{provider.name}[/accent]"
+    if registry.provider_names:
+        provider_line += f"  [{t.muted}]({', '.join(registry.provider_names)})[/]"
+    jev_status = (
+        f"[positive]◆ Jev active[/positive]"
+        if jev.available
+        else f"[{t.muted}]◆ Jev inactive — set TYPESAFE_API_KEY to enable AI analysis[/]"
+    )
+    console.print(f"{provider_line}   {jev_status}\n")
+
+    # ── 7. REPL loop ───────────────────────────────────────────────────────────
+    prompt_session = _build_prompt_session()
+
+    # Prompt style — amber "kadeConsole >" prefix
+    prompt_str = f"kadeConsole > "
+
+    while True:
+        try:
+            if prompt_session is not None:
+                try:
+                    from prompt_toolkit.styles import Style as PTStyle
+                    pt_style = PTStyle.from_dict({
+                        "": f"#{t.text[1:]}",
+                        "prompt": f"bold #{t.accent[1:]}",
+                    })
+                    raw = prompt_session.prompt(
+                        [("class:prompt", prompt_str)],
+                        style=pt_style,
+                    )
+                except Exception:
+                    raw = prompt_session.prompt(prompt_str)
+            else:
+                raw = _simple_input(prompt_str)
+
+        except KeyboardInterrupt:
+            console.print(f"\n[{t.muted}]  Use EXIT or Q to quit.[/]\n")
+            continue
+        except EOFError:
+            break
+
+        raw = raw.strip()
+        if not raw:
+            continue
+
+        # Parse and dispatch
+        from kadeconsole.core.parser import parse, ParseError
+        try:
+            parsed = parse(raw)
+        except ParseError as exc:
+            console.print(f"[negative]  Parse error: {exc}[/negative]")
+            continue
+
+        keep_going = router.dispatch(parsed)
+        if not keep_going:
+            console.print(f"\n[{t.muted}]  Goodbye.[/]\n")
+            break
+
+
+if __name__ == "__main__":
+    main()

kadeconsole/config/loader.py

@@ -0,0 +1,111 @@
+"""
+config/loader.py — ~/.kadeconsole/config.yaml reader.
+
+Creates a default config file on first run. Returns a validated config dict.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any
+
+try:
+    import yaml
+    _YAML_AVAILABLE = True
+except ImportError:
+    _YAML_AVAILABLE = False
+
+CONFIG_DIR = Path.home() / ".kadeconsole"
+CONFIG_FILE = CONFIG_DIR / "config.yaml"
+
+DEFAULT_CONFIG: dict[str, Any] = {
+    "provider_priority": ["yfinance"],
+    "typesafe_api_key": "",
+    "alpaca_api_key": "",
+    "alphavantage_api_key": "",
+    "polygon_api_key": "",
+    "default_timeframe": "1Y",
+    "theme": "default",
+    "cache_ttl_provider_minutes": 15,
+    "cache_ttl_jev_hours": 24,
+}
+
+
+def load_config() -> dict[str, Any]:
+    """
+    Load configuration from ~/.kadeconsole/config.yaml.
+
+    Creates the directory and a default config file if they don't exist.
+    Merges loaded values over the defaults (new keys in defaults are preserved
+    across upgrades without blowing away user customisations).
+    """
+    _ensure_dir()
+
+    if not CONFIG_FILE.exists():
+        _write_default()
+
+    if not _YAML_AVAILABLE:
+        # Fallback: return defaults, don't crash if PyYAML not installed yet
+        return DEFAULT_CONFIG.copy()
+
+    try:
+        with open(CONFIG_FILE, "r") as f:
+            user_config: dict[str, Any] = yaml.safe_load(f) or {}
+    except Exception:  # noqa: BLE001
+        user_config = {}
+
+    # Merge: defaults first, user values override
+    merged = {**DEFAULT_CONFIG, **user_config}
+
+    # Also honour environment variable overrides (CI-friendly)
+    _apply_env_overrides(merged)
+
+    return merged
+
+
+def _ensure_dir() -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def _write_default() -> None:
+    if not _YAML_AVAILABLE:
+        return
+    comment_block = """\
+# kadeConsole configuration
+# ─────────────────────────────────────────────────────────────
+# Set your API keys below to unlock all data providers.
+# kadeConsole works without any keys using yfinance (free).
+#
+# Get a TypeSafe AI key at: https://typesafe.ai
+# ─────────────────────────────────────────────────────────────
+
+"""
+    with open(CONFIG_FILE, "w") as f:
+        f.write(comment_block)
+        yaml.dump(DEFAULT_CONFIG, f, default_flow_style=False, allow_unicode=True)
+
+
+def _apply_env_overrides(config: dict[str, Any]) -> None:
+    """Override config values from environment variables."""
+    env_map = {
+        "TYPESAFE_API_KEY": "typesafe_api_key",
+        "ALPACA_API_KEY": "alpaca_api_key",
+        "ALPHAVANTAGE_API_KEY": "alphavantage_api_key",
+        "POLYGON_API_KEY": "polygon_api_key",
+    }
+    for env_key, config_key in env_map.items():
+        val = os.environ.get(env_key)
+        if val:
+            config[config_key] = val
+
+
+def get_api_key(config: dict[str, Any], provider: str) -> str:
+    """Convenience helper to retrieve a provider's API key from config."""
+    key_map = {
+        "typesafe": "typesafe_api_key",
+        "alpaca": "alpaca_api_key",
+        "alphavantage": "alphavantage_api_key",
+        "polygon": "polygon_api_key",
+    }
+    return config.get(key_map.get(provider, ""), "") or ""