@drico2008/fincli 0.3.1 → 0.4.0

package/fincli/app/services/news_aggregator.py

@@ -1,95 +1,95 @@
-"""News aggregation helpers."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from datetime import datetime, timedelta, timezone
-
-from fincli.app.connectors.news_connectors import NewsConnectorManager
-from fincli.app.providers.market.base import NewsItem
-from fincli.app.providers.reliability import STATUS_OK, STATUS_PARTIAL_DATA, STATUS_UNAVAILABLE, classify_provider_error
-from fincli.app.services.market_data import MarketDataService
-
-
-@dataclass(frozen=True, slots=True)
-class NewsDesk:
-    symbol: str
-    provider_chain: tuple[str, ...]
-    items: list[NewsItem]
-    note: str
-    errors: tuple[str, ...] = ()
-    lookback_days: int | None = None
-    reliability_status: str = STATUS_UNAVAILABLE
-
-
-class NewsAggregator:
-    def __init__(
-        self,
-        market_service: MarketDataService,
-        news_connectors: NewsConnectorManager | None = None,
-        priority: list[str] | None = None,
-    ) -> None:
-        self.market_service = market_service
-        self.news_connectors = news_connectors or NewsConnectorManager()
-        self.priority = priority or ["yfinance", "google_news_rss", "yahoo_finance_rss"]
-
-    async def latest(self, symbol: str, limit: int = 12, lookback_days: int | None = None) -> NewsDesk:
-        normalized = symbol.upper()
-        items: list[NewsItem] = []
-        errors: list[str] = []
-        seen: set[str] = set()
-        provider_chain = tuple(_dedupe(self.priority))
-
-        for provider in provider_chain:
-            try:
-                fetched = await self._fetch_provider(provider, normalized, max(limit - len(items), 1))
-            except Exception as exc:  # noqa: BLE001 - fallback chain should continue
-                errors.append(f"{provider}: {classify_provider_error(exc)} ({exc})")
-                continue
-            for item in fetched:
-                if lookback_days is not None and not _within_lookback(item, lookback_days):
-                    continue
-                key = (item.url or item.title).strip().lower()
-                if key and key not in seen:
-                    seen.add(key)
-                    items.append(item)
-                if len(items) >= limit:
-                    break
-            if len(items) >= limit:
-                break
-
-        note = "Provider-backed news. Realtime/delayed status depends on provider entitlement."
-        reliability_status = STATUS_OK
-        if not items:
-            note = "No news returned by active providers. Try /research <symbol> --deep or configure /news_model priority."
-            reliability_status = STATUS_UNAVAILABLE if errors else STATUS_PARTIAL_DATA
-        elif errors:
-            note = f"{note} Fallback used after {len(errors)} provider error(s)."
-            reliability_status = STATUS_PARTIAL_DATA
-        return NewsDesk(normalized, provider_chain, items, note, tuple(errors), lookback_days, reliability_status)
-
-    async def _fetch_provider(self, provider: str, symbol: str, limit: int) -> list[NewsItem]:
-        if provider == "yfinance" or any(item.name == provider for item in self.market_service.providers):
-            return await self.market_service.news(symbol, limit=limit)
-        return await self.news_connectors.fetch(provider, symbol, limit=limit)
-
-
-def _dedupe(values: list[str]) -> list[str]:
-    seen: set[str] = set()
-    result: list[str] = []
-    for value in values:
-        normalized = value.strip().lower()
-        if normalized and normalized not in seen:
-            seen.add(normalized)
-            result.append(normalized)
-    return result
-
-
-def _within_lookback(item: NewsItem, lookback_days: int) -> bool:
-    if item.published_at is None:
-        return True
-    published = item.published_at
-    if published.tzinfo is None:
-        published = published.replace(tzinfo=timezone.utc)
-    cutoff = datetime.now(timezone.utc) - timedelta(days=lookback_days)
-    return published >= cutoff
+"""News aggregation helpers."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+
+from fincli.app.connectors.news_connectors import NewsConnectorManager
+from fincli.app.providers.market.base import NewsItem
+from fincli.app.providers.reliability import STATUS_OK, STATUS_PARTIAL_DATA, STATUS_UNAVAILABLE, classify_provider_error
+from fincli.app.services.market_data import MarketDataService
+
+
+@dataclass(frozen=True, slots=True)
+class NewsDesk:
+    symbol: str
+    provider_chain: tuple[str, ...]
+    items: list[NewsItem]
+    note: str
+    errors: tuple[str, ...] = ()
+    lookback_days: int | None = None
+    reliability_status: str = STATUS_UNAVAILABLE
+
+
+class NewsAggregator:
+    def __init__(
+        self,
+        market_service: MarketDataService,
+        news_connectors: NewsConnectorManager | None = None,
+        priority: list[str] | None = None,
+    ) -> None:
+        self.market_service = market_service
+        self.news_connectors = news_connectors or NewsConnectorManager()
+        self.priority = priority or ["yfinance", "google_news_rss", "yahoo_finance_rss"]
+
+    async def latest(self, symbol: str, limit: int = 12, lookback_days: int | None = None) -> NewsDesk:
+        normalized = symbol.upper()
+        items: list[NewsItem] = []
+        errors: list[str] = []
+        seen: set[str] = set()
+        provider_chain = tuple(_dedupe(self.priority))
+
+        for provider in provider_chain:
+            try:
+                fetched = await self._fetch_provider(provider, normalized, max(limit - len(items), 1))
+            except Exception as exc:  # noqa: BLE001 - fallback chain should continue
+                errors.append(f"{provider}: {classify_provider_error(exc)} ({exc})")
+                continue
+            for item in fetched:
+                if lookback_days is not None and not _within_lookback(item, lookback_days):
+                    continue
+                key = (item.url or item.title).strip().lower()
+                if key and key not in seen:
+                    seen.add(key)
+                    items.append(item)
+                if len(items) >= limit:
+                    break
+            if len(items) >= limit:
+                break
+
+        note = "Provider-backed news. Realtime/delayed status depends on provider entitlement."
+        reliability_status = STATUS_OK
+        if not items:
+            note = "No news returned by active providers. Try /research <symbol> --deep or configure /news_model priority."
+            reliability_status = STATUS_UNAVAILABLE if errors else STATUS_PARTIAL_DATA
+        elif errors:
+            note = f"{note} Fallback used after {len(errors)} provider error(s)."
+            reliability_status = STATUS_PARTIAL_DATA
+        return NewsDesk(normalized, provider_chain, items, note, tuple(errors), lookback_days, reliability_status)
+
+    async def _fetch_provider(self, provider: str, symbol: str, limit: int) -> list[NewsItem]:
+        if provider == "yfinance" or any(item.name == provider for item in self.market_service.providers):
+            return await self.market_service.news(symbol, limit=limit)
+        return await self.news_connectors.fetch(provider, symbol, limit=limit)
+
+
+def _dedupe(values: list[str]) -> list[str]:
+    seen: set[str] = set()
+    result: list[str] = []
+    for value in values:
+        normalized = value.strip().lower()
+        if normalized and normalized not in seen:
+            seen.add(normalized)
+            result.append(normalized)
+    return result
+
+
+def _within_lookback(item: NewsItem, lookback_days: int) -> bool:
+    if item.published_at is None:
+        return True
+    published = item.published_at
+    if published.tzinfo is None:
+        published = published.replace(tzinfo=timezone.utc)
+    cutoff = datetime.now(timezone.utc) - timedelta(days=lookback_days)
+    return published >= cutoff

package/fincli/app/storage/config.py

@@ -35,9 +35,12 @@ class FinCLISettings:
         default_factory=lambda: ["yfinance", "google_news_rss", "yahoo_finance_rss", "marketaux", "newsapi", "gnews"]
     )
     timezone: str = "Asia/Jakarta"
-    default_currency: str = "USD"
-    cache_ttl_seconds: int = 300
-    theme: str = "fincli-dark"
+    default_currency: str = "USD"
+    cache_ttl_seconds: int = 300
+    provider_timeout_seconds: float = 12.0
+    provider_circuit_breaker_failure_threshold: int = 3
+    provider_circuit_breaker_cooldown_seconds: float = 60.0
+    theme: str = "fincli-dark"
 
     def safe_dict(self) -> dict[str, Any]:
         """Return display-safe config, including masked secret status."""

package/fincli/app/storage/database.py

@@ -98,43 +98,56 @@ class FinCLIDatabase:
                             FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
                         );
 
-                        CREATE TABLE IF NOT EXISTS alerts (
-                            id INTEGER PRIMARY KEY AUTOINCREMENT,
-                            symbol TEXT NOT NULL,
-                            condition TEXT NOT NULL,
-                            target REAL NOT NULL,
+                        CREATE TABLE IF NOT EXISTS alerts (
+                            id INTEGER PRIMARY KEY AUTOINCREMENT,
+                            symbol TEXT NOT NULL,
+                            condition TEXT NOT NULL,
+                            target REAL NOT NULL,
                             note TEXT DEFAULT '',
                             active INTEGER DEFAULT 1,
-                            triggered_at TEXT DEFAULT '',
-                            created_at TEXT DEFAULT CURRENT_TIMESTAMP
-                        );
-
-                        CREATE TABLE IF NOT EXISTS user_profile (
-                            id INTEGER PRIMARY KEY CHECK (id = 1),
-                            name TEXT NOT NULL,
-                            equity REAL NOT NULL,
-                            currency TEXT NOT NULL,
-                            leverage TEXT NOT NULL,
-                            years_in_investment REAL NOT NULL,
-                            gameplay TEXT NOT NULL,
-                            updated_at TEXT DEFAULT CURRENT_TIMESTAMP
-                        );
-
-                        CREATE TABLE IF NOT EXISTS provider_metrics (
-                            provider TEXT PRIMARY KEY,
-                            calls INTEGER DEFAULT 0,
-                            successes INTEGER DEFAULT 0,
-                            errors INTEGER DEFAULT 0,
-                            fallbacks INTEGER DEFAULT 0,
-                            total_latency_ms REAL DEFAULT 0,
-                            last_status TEXT DEFAULT 'not_called',
-                            updated_at TEXT DEFAULT CURRENT_TIMESTAMP
-                        );
-                        """
-                    )
-                    _migrate_user_profile_schema(db)
-        except sqlite3.Error as exc:
-            raise StorageError("Database lokal gagal diinisialisasi.") from exc
+                            triggered_at TEXT DEFAULT '',
+                            created_at TEXT DEFAULT CURRENT_TIMESTAMP
+                        );
+
+                        CREATE TABLE IF NOT EXISTS user_profile (
+                            id INTEGER PRIMARY KEY CHECK (id = 1),
+                            name TEXT NOT NULL,
+                            equity REAL NOT NULL,
+                            currency TEXT NOT NULL,
+                            leverage TEXT NOT NULL,
+                            years_in_investment REAL NOT NULL,
+                            gameplay TEXT NOT NULL,
+                            updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+                        );
+
+                        CREATE TABLE IF NOT EXISTS provider_metrics (
+                            provider TEXT PRIMARY KEY,
+                            calls INTEGER DEFAULT 0,
+                            successes INTEGER DEFAULT 0,
+                            errors INTEGER DEFAULT 0,
+                            fallbacks INTEGER DEFAULT 0,
+                            total_latency_ms REAL DEFAULT 0,
+                            last_status TEXT DEFAULT 'not_called',
+                            updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+                        );
+
+                        CREATE TABLE IF NOT EXISTS paper_orders (
+                            id INTEGER PRIMARY KEY AUTOINCREMENT,
+                            side TEXT NOT NULL,
+                            symbol TEXT NOT NULL,
+                            quantity REAL NOT NULL,
+                            order_type TEXT NOT NULL,
+                            price REAL,
+                            notional REAL DEFAULT 0,
+                            status TEXT NOT NULL,
+                            strategy TEXT DEFAULT 'manual',
+                            created_at TEXT DEFAULT CURRENT_TIMESTAMP
+                        );
+                        """
+                    )
+                    _migrate_user_profile_schema(db)
+        except sqlite3.Error as exc:
+            raise StorageError("Database lokal gagal diinisialisasi.") from exc
 
     def execute(self, sql: str, params: Iterable[object] = ()) -> None:
         try:
@@ -144,85 +157,85 @@ class FinCLIDatabase:
         except sqlite3.Error as exc:
             raise StorageError("Operasi database gagal.") from exc
 
-    def query(self, sql: str, params: Iterable[object] = ()) -> list[sqlite3.Row]:
-        try:
-            with closing(self.connect()) as db:
-                return list(db.execute(sql, tuple(params)).fetchall())
-        except sqlite3.Error as exc:
-            raise StorageError("Query database gagal.") from exc
-
-
-def _migrate_user_profile_schema(db: sqlite3.Connection) -> None:
-    """Normalize older user_profile schemas to the v0.3.1 canonical shape."""
-
-    columns = {str(row["name"]) for row in db.execute("PRAGMA table_info(user_profile)").fetchall()}
-    canonical = {"id", "name", "equity", "currency", "leverage", "years_in_investment", "gameplay", "updated_at"}
-    if canonical.issubset(columns):
-        return
-
-    rows = list(db.execute("SELECT * FROM user_profile").fetchall())
-    legacy_profile = _legacy_profile_payload(rows[0]) if rows else None
-    db.execute("DROP TABLE user_profile")
-    db.execute(
-        """
-        CREATE TABLE user_profile (
-            id INTEGER PRIMARY KEY CHECK (id = 1),
-            name TEXT NOT NULL,
-            equity REAL NOT NULL,
-            currency TEXT NOT NULL,
-            leverage TEXT NOT NULL,
-            years_in_investment REAL NOT NULL,
-            gameplay TEXT NOT NULL,
-            updated_at TEXT DEFAULT CURRENT_TIMESTAMP
-        )
-        """
-    )
-    if legacy_profile is None:
-        return
-    db.execute(
-        """
-        INSERT INTO user_profile (id, name, equity, currency, leverage, years_in_investment, gameplay, updated_at)
-        VALUES (1, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
-        """,
-        legacy_profile,
-    )
-
-
-def _legacy_profile_payload(row: sqlite3.Row) -> tuple[object, ...]:
-    keys = set(row.keys())
-    name = row["name"] if "name" in keys else "User"
-    equity = row["equity"] if "equity" in keys else row["equity_amount"] if "equity_amount" in keys else 0
-    currency = row["currency"] if "currency" in keys else row["equity_currency"] if "equity_currency" in keys else "USD"
-    leverage = row["leverage"] if "leverage" in keys else "1:1"
-    years = (
-        row["years_in_investment"]
-        if "years_in_investment" in keys
-        else row["experience_years"]
-        if "experience_years" in keys
-        else 0
-    )
-    gameplay = _normalize_legacy_gameplay(str(row["gameplay"])) if "gameplay" in keys else _classify_legacy_gameplay(float(equity))
-    return (name, equity, currency, leverage, years, gameplay)
-
-
-def _normalize_legacy_gameplay(value: str) -> str:
-    normalized = value.strip().lower().replace("-", "_").replace(" ", "_")
-    return {
-        "scalper": "Scalper",
-        "intra_day": "Intra day",
-        "intraday": "Intra day",
-        "day_trade": "Day trade",
-        "day_trader": "Day trade",
-        "swing": "Swing/Investor",
-        "investor": "Swing/Investor",
-    }.get(normalized, value.strip() or "Scalper")
-
-
-def _classify_legacy_gameplay(equity: float) -> str:
-    if equity <= 400:
-        return "Scalper"
-    if equity <= 1000:
-        return "Intra day"
-    if equity <= 5000:
-        return "Day trade"
-    return "Swing/Investor"
+    def query(self, sql: str, params: Iterable[object] = ()) -> list[sqlite3.Row]:
+        try:
+            with closing(self.connect()) as db:
+                return list(db.execute(sql, tuple(params)).fetchall())
+        except sqlite3.Error as exc:
+            raise StorageError("Query database gagal.") from exc
+
+
+def _migrate_user_profile_schema(db: sqlite3.Connection) -> None:
+    """Normalize older user_profile schemas to the v0.4.0 canonical shape."""
+
+    columns = {str(row["name"]) for row in db.execute("PRAGMA table_info(user_profile)").fetchall()}
+    canonical = {"id", "name", "equity", "currency", "leverage", "years_in_investment", "gameplay", "updated_at"}
+    if canonical.issubset(columns):
+        return
+
+    rows = list(db.execute("SELECT * FROM user_profile").fetchall())
+    legacy_profile = _legacy_profile_payload(rows[0]) if rows else None
+    db.execute("DROP TABLE user_profile")
+    db.execute(
+        """
+        CREATE TABLE user_profile (
+            id INTEGER PRIMARY KEY CHECK (id = 1),
+            name TEXT NOT NULL,
+            equity REAL NOT NULL,
+            currency TEXT NOT NULL,
+            leverage TEXT NOT NULL,
+            years_in_investment REAL NOT NULL,
+            gameplay TEXT NOT NULL,
+            updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+        )
+        """
+    )
+    if legacy_profile is None:
+        return
+    db.execute(
+        """
+        INSERT INTO user_profile (id, name, equity, currency, leverage, years_in_investment, gameplay, updated_at)
+        VALUES (1, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+        """,
+        legacy_profile,
+    )
+
+
+def _legacy_profile_payload(row: sqlite3.Row) -> tuple[object, ...]:
+    keys = set(row.keys())
+    name = row["name"] if "name" in keys else "User"
+    equity = row["equity"] if "equity" in keys else row["equity_amount"] if "equity_amount" in keys else 0
+    currency = row["currency"] if "currency" in keys else row["equity_currency"] if "equity_currency" in keys else "USD"
+    leverage = row["leverage"] if "leverage" in keys else "1:1"
+    years = (
+        row["years_in_investment"]
+        if "years_in_investment" in keys
+        else row["experience_years"]
+        if "experience_years" in keys
+        else 0
+    )
+    gameplay = _normalize_legacy_gameplay(str(row["gameplay"])) if "gameplay" in keys else _classify_legacy_gameplay(float(equity))
+    return (name, equity, currency, leverage, years, gameplay)
+
+
+def _normalize_legacy_gameplay(value: str) -> str:
+    normalized = value.strip().lower().replace("-", "_").replace(" ", "_")
+    return {
+        "scalper": "Scalper",
+        "intra_day": "Intra day",
+        "intraday": "Intra day",
+        "day_trade": "Day trade",
+        "day_trader": "Day trade",
+        "swing": "Swing/Investor",
+        "investor": "Swing/Investor",
+    }.get(normalized, value.strip() or "Scalper")
+
+
+def _classify_legacy_gameplay(equity: float) -> str:
+    if equity <= 400:
+        return "Scalper"
+    if equity <= 1000:
+        return "Intra day"
+    if equity <= 5000:
+        return "Day trade"
+    return "Swing/Investor"

package/fincli/app/storage/provider_metrics.py

@@ -1,61 +1,61 @@
-"""Persistent provider metrics storage."""
-
-from __future__ import annotations
-
-from fincli.app.services.market_data import ProviderRuntimeMetrics
-from fincli.app.storage.database import FinCLIDatabase
-
-
-class ProviderMetricsStore:
-    """Persist aggregate provider metrics across FinCLI sessions."""
-
-    def __init__(self, db: FinCLIDatabase) -> None:
-        self.db = db
-
-    def record(self, provider: str, success: bool, latency_ms: float, fallback: bool = False) -> None:
-        current = self.snapshot().get(provider, ProviderRuntimeMetrics(provider))
-        current.record(success=success, latency_ms=latency_ms, fallback=fallback)
-        self.db.execute(
-            """
-            INSERT INTO provider_metrics(provider, calls, successes, errors, fallbacks, total_latency_ms, last_status, updated_at)
-            VALUES (?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
-            ON CONFLICT(provider) DO UPDATE SET
-                calls=excluded.calls,
-                successes=excluded.successes,
-                errors=excluded.errors,
-                fallbacks=excluded.fallbacks,
-                total_latency_ms=excluded.total_latency_ms,
-                last_status=excluded.last_status,
-                updated_at=CURRENT_TIMESTAMP
-            """,
-            (
-                current.provider,
-                current.calls,
-                current.successes,
-                current.errors,
-                current.fallbacks,
-                current.total_latency_ms,
-                current.last_status,
-            ),
-        )
-
-    def snapshot(self) -> dict[str, ProviderRuntimeMetrics]:
-        rows = self.db.query(
-            """
-            SELECT provider, calls, successes, errors, fallbacks, total_latency_ms, last_status
-            FROM provider_metrics
-            ORDER BY provider
-            """
-        )
-        metrics: dict[str, ProviderRuntimeMetrics] = {}
-        for row in rows:
-            metric = ProviderRuntimeMetrics(str(row["provider"]))
-            metric.calls = int(row["calls"])
-            metric.successes = int(row["successes"])
-            metric.errors = int(row["errors"])
-            metric.fallbacks = int(row["fallbacks"])
-            metric.total_latency_ms = float(row["total_latency_ms"])
-            metric.last_status = str(row["last_status"])
-            metrics[metric.provider] = metric
-        return metrics
-
+"""Persistent provider metrics storage."""
+
+from __future__ import annotations
+
+from fincli.app.services.market_data import ProviderRuntimeMetrics
+from fincli.app.storage.database import FinCLIDatabase
+
+
+class ProviderMetricsStore:
+    """Persist aggregate provider metrics across FinCLI sessions."""
+
+    def __init__(self, db: FinCLIDatabase) -> None:
+        self.db = db
+
+    def record(self, provider: str, success: bool, latency_ms: float, fallback: bool = False) -> None:
+        current = self.snapshot().get(provider, ProviderRuntimeMetrics(provider))
+        current.record(success=success, latency_ms=latency_ms, fallback=fallback)
+        self.db.execute(
+            """
+            INSERT INTO provider_metrics(provider, calls, successes, errors, fallbacks, total_latency_ms, last_status, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+            ON CONFLICT(provider) DO UPDATE SET
+                calls=excluded.calls,
+                successes=excluded.successes,
+                errors=excluded.errors,
+                fallbacks=excluded.fallbacks,
+                total_latency_ms=excluded.total_latency_ms,
+                last_status=excluded.last_status,
+                updated_at=CURRENT_TIMESTAMP
+            """,
+            (
+                current.provider,
+                current.calls,
+                current.successes,
+                current.errors,
+                current.fallbacks,
+                current.total_latency_ms,
+                current.last_status,
+            ),
+        )
+
+    def snapshot(self) -> dict[str, ProviderRuntimeMetrics]:
+        rows = self.db.query(
+            """
+            SELECT provider, calls, successes, errors, fallbacks, total_latency_ms, last_status
+            FROM provider_metrics
+            ORDER BY provider
+            """
+        )
+        metrics: dict[str, ProviderRuntimeMetrics] = {}
+        for row in rows:
+            metric = ProviderRuntimeMetrics(str(row["provider"]))
+            metric.calls = int(row["calls"])
+            metric.successes = int(row["successes"])
+            metric.errors = int(row["errors"])
+            metric.fallbacks = int(row["fallbacks"])
+            metric.total_latency_ms = float(row["total_latency_ms"])
+            metric.last_status = str(row["last_status"])
+            metrics[metric.provider] = metric
+        return metrics
+