@drico2008/fincli 0.3.1 → 0.4.0

package/fincli/app/services/market_data.py

@@ -6,37 +6,53 @@ import asyncio
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import asdict
 from datetime import datetime
-from time import perf_counter
+from time import monotonic, perf_counter
 from typing import Any, Awaitable
 
 from fincli.app.providers.market.base import BaseMarketProvider, Candle, FundamentalSnapshot, NewsItem, ProviderStatus, Quote
-from fincli.app.providers.reliability import ProviderResult, classify_payload, classify_provider_error
-from fincli.app.storage.market_cache import MarketCache
-from fincli.app.utils.errors import ProviderError
-
-
-class MarketDataService:
+from fincli.app.providers.market.symbols import SymbolResolver
+from fincli.app.providers.reliability import (
+    STATUS_CIRCUIT_OPEN,
+    STATUS_NETWORK_ERROR,
+    STATUS_OK,
+    ProviderResult,
+    classify_payload,
+    classify_provider_error,
+)
+from fincli.app.storage.market_cache import MarketCache
+from fincli.app.utils.errors import ProviderError
+
+
+class MarketDataService:
     """Fetch market data through a prioritized provider chain."""
 
     def __init__(
         self,
-        providers: list[BaseMarketProvider],
+        providers: list[BaseMarketProvider],
         cache: MarketCache | None = None,
         cache_ttl_seconds: int = 300,
+        provider_timeout_seconds: float = 12.0,
         metrics_store: Any | None = None,
+        symbol_resolver: SymbolResolver | None = None,
+        circuit_breaker_failure_threshold: int = 3,
+        circuit_breaker_cooldown_seconds: float = 60.0,
     ) -> None:
         if not providers:
             raise ProviderError("MarketDataService membutuhkan minimal satu provider.")
         self.providers = providers
         self.cache = cache
         self.cache_ttl_seconds = cache_ttl_seconds
+        self.provider_timeout_seconds = max(0.05, float(provider_timeout_seconds))
         self.metrics_store = metrics_store
-        self.last_errors: list[str] = []
-        self.provider_results: list[ProviderResult] = []
-        self.provider_metrics: dict[str, ProviderRuntimeMetrics] = {
-            getattr(provider, "name", "unknown"): ProviderRuntimeMetrics(getattr(provider, "name", "unknown"))
-            for provider in providers
-        }
+        self.symbol_resolver = symbol_resolver or SymbolResolver()
+        self.circuit_breaker_failure_threshold = max(1, int(circuit_breaker_failure_threshold))
+        self.circuit_breaker_cooldown_seconds = max(0.0, float(circuit_breaker_cooldown_seconds))
+        self.last_errors: list[str] = []
+        self.provider_results: list[ProviderResult] = []
+        self.provider_metrics: dict[str, ProviderRuntimeMetrics] = {
+            getattr(provider, "name", "unknown"): ProviderRuntimeMetrics(getattr(provider, "name", "unknown"))
+            for provider in providers
+        }
 
     @property
     def primary_provider(self) -> BaseMarketProvider:
@@ -91,72 +107,145 @@ class MarketDataService:
                 message=str(exc),
             )
 
-    async def _with_fallback(self, method_name: str, *args: object) -> Any:
-        errors: list[str] = []
+    async def _with_fallback(self, method_name: str, *args: object) -> Any:
+        errors: list[str] = []
         for provider in self.providers:
             provider_name = getattr(provider, "name", "unknown")
+            if self._is_circuit_open(provider_name):
+                message = (
+                    f"{provider_name}: circuit open; skipped {method_name} for "
+                    f"{self.circuit_breaker_cooldown_seconds:.0f}s cooldown"
+                )
+                errors.append(message)
+                self._record_provider_result(
+                    provider=provider_name,
+                    operation=method_name,
+                    status=STATUS_CIRCUIT_OPEN,
+                    realtime_label=_provider_realtime_label(provider),
+                    message=message,
+                )
+                continue
             started = perf_counter()
             try:
                 method = getattr(provider, method_name)
-                payload = await method(*args)
-                latency_ms = (perf_counter() - started) * 1000
+                provider_args = self._normalize_provider_args(provider_name, method_name, args)
+                payload = await asyncio.wait_for(method(*provider_args), timeout=self.provider_timeout_seconds)
+                latency_ms = (perf_counter() - started) * 1000
                 status, missing = classify_payload(method_name, payload)
-                self._record_provider_metric(provider_name, success=status != "partial_data", latency_ms=latency_ms)
+                self._record_provider_metric(provider_name, success=status == STATUS_OK, latency_ms=latency_ms)
+                self._record_circuit_success(provider_name)
                 self._record_provider_result(
                     provider=provider_name,
                     operation=method_name,
                     status=status,
+                    realtime_label=_provider_realtime_label(provider),
                     missing_fields=missing,
                     message="ok" if not missing else f"partial payload: {', '.join(missing)}",
                 )
-                return payload
-            except Exception as exc:  # noqa: BLE001
+                return payload
+            except TimeoutError as exc:
                 latency_ms = (perf_counter() - started) * 1000
+                message = f"{provider_name}: {method_name} timeout after {self.provider_timeout_seconds:.1f}s"
+                errors.append(message)
+                self._record_provider_metric(provider_name, success=False, latency_ms=latency_ms, fallback=True)
+                self._record_circuit_failure(provider_name)
+                self._record_provider_result(
+                    provider=provider_name,
+                    operation=method_name,
+                    status=STATUS_NETWORK_ERROR,
+                    realtime_label=_provider_realtime_label(provider),
+                    message=message,
+                )
+            except Exception as exc:  # noqa: BLE001
+                latency_ms = (perf_counter() - started) * 1000
                 errors.append(f"{provider_name}: {exc}")
                 self._record_provider_metric(provider_name, success=False, latency_ms=latency_ms, fallback=True)
+                self._record_circuit_failure(provider_name)
                 self._record_provider_result(
                     provider=provider_name,
                     operation=method_name,
                     status=classify_provider_error(exc),
+                    realtime_label=_provider_realtime_label(provider),
                     message=str(exc),
                 )
-        self.last_errors = errors
+        self.last_errors = errors
         raise ProviderError(
             f"Semua provider gagal untuk {method_name}.",
             "\n".join(errors),
         )
 
-    def _record_provider_result(
-        self,
-        provider: str,
-        operation: str,
+    def _normalize_provider_args(self, provider: str, method_name: str, args: tuple[object, ...]) -> tuple[object, ...]:
+        if method_name not in {"quote", "history", "news", "fundamentals"}:
+            return args
+        if not args or not isinstance(args[0], str):
+            return args
+        try:
+            symbol = self.symbol_resolver.provider_symbol(provider, args[0])
+        except Exception:  # noqa: BLE001
+            return args
+        return (symbol, *args[1:])
+
+    def _is_circuit_open(self, provider: str) -> bool:
+        metric = self.provider_metrics.setdefault(provider, ProviderRuntimeMetrics(provider))
+        if not metric.circuit_open:
+            return False
+        if self.circuit_breaker_cooldown_seconds <= 0:
+            return False
+        if metric.circuit_opened_at is None:
+            return False
+        if monotonic() - metric.circuit_opened_at >= self.circuit_breaker_cooldown_seconds:
+            metric.circuit_open = False
+            metric.circuit_opened_at = None
+            metric.last_status = "half_open"
+            return False
+        return True
+
+    def _record_circuit_failure(self, provider: str) -> None:
+        metric = self.provider_metrics.setdefault(provider, ProviderRuntimeMetrics(provider))
+        metric.consecutive_failures += 1
+        if metric.consecutive_failures >= self.circuit_breaker_failure_threshold:
+            metric.circuit_open = True
+            metric.circuit_opened_at = monotonic()
+            metric.last_status = STATUS_CIRCUIT_OPEN
+
+    def _record_circuit_success(self, provider: str) -> None:
+        metric = self.provider_metrics.setdefault(provider, ProviderRuntimeMetrics(provider))
+        metric.consecutive_failures = 0
+        metric.circuit_open = False
+        metric.circuit_opened_at = None
+
+    def _record_provider_result(
+        self,
+        provider: str,
+        operation: str,
         status: str,
+        realtime_label: str = "unknown",
         missing_fields: tuple[str, ...] = (),
         message: str = "",
     ) -> None:
-        self.provider_results.append(
-            ProviderResult(
+        self.provider_results.append(
+            ProviderResult(
                 provider=provider,
                 operation=operation,
                 status=status,
-                realtime_label="unknown",
+                realtime_label=realtime_label,
                 source=provider,
                 data_quality=status,
                 missing_fields=missing_fields,
-                message=message,
-            )
-        )
-        if len(self.provider_results) > 50:
-            self.provider_results = self.provider_results[-50:]
-
-    def _record_provider_metric(self, provider: str, success: bool, latency_ms: float, fallback: bool = False) -> None:
-        metric = self.provider_metrics.setdefault(provider, ProviderRuntimeMetrics(provider))
-        metric.record(success=success, latency_ms=latency_ms, fallback=fallback)
-        if self.metrics_store is not None:
-            self.metrics_store.record(provider, success=success, latency_ms=latency_ms, fallback=fallback)
-
-    def provider_metrics_snapshot(self) -> dict[str, "ProviderRuntimeMetrics"]:
-        return {provider: metric.copy() for provider, metric in self.provider_metrics.items()}
+                message=message,
+            )
+        )
+        if len(self.provider_results) > 50:
+            self.provider_results = self.provider_results[-50:]
+
+    def _record_provider_metric(self, provider: str, success: bool, latency_ms: float, fallback: bool = False) -> None:
+        metric = self.provider_metrics.setdefault(provider, ProviderRuntimeMetrics(provider))
+        metric.record(success=success, latency_ms=latency_ms, fallback=fallback)
+        if self.metrics_store is not None:
+            self.metrics_store.record(provider, success=success, latency_ms=latency_ms, fallback=fallback)
+
+    def provider_metrics_snapshot(self) -> dict[str, "ProviderRuntimeMetrics"]:
+        return {provider: metric.copy() for provider, metric in self.provider_metrics.items()}
 
     def _cache_key(self, symbol: str, *parts: object) -> str:
         provider_chain = ",".join(provider.name for provider in self.providers)
@@ -260,49 +349,64 @@ def _parse_datetime(value: object) -> datetime:
 
 
 def _optional_float(value: object) -> float | None:
-    if value is None:
-        return None
+    if value is None:
+        return None
     return float(value)
 
 
-class ProviderRuntimeMetrics:
-    """Runtime metrics for one market provider."""
-
-    def __init__(self, provider: str) -> None:
-        self.provider = provider
-        self.calls = 0
-        self.successes = 0
-        self.errors = 0
+def _provider_realtime_label(provider: BaseMarketProvider) -> str:
+    realtime = getattr(provider, "realtime", None)
+    if realtime is True:
+        return "realtime_or_plan_dependent"
+    if realtime is False:
+        return "delayed_or_fallback"
+    return "unknown"
+
+
+class ProviderRuntimeMetrics:
+    """Runtime metrics for one market provider."""
+
+    def __init__(self, provider: str) -> None:
+        self.provider = provider
+        self.calls = 0
+        self.successes = 0
+        self.errors = 0
         self.fallbacks = 0
         self.total_latency_ms = 0.0
         self.last_status = "not_called"
-
-    @property
-    def success_rate(self) -> float:
-        return (self.successes / self.calls * 100) if self.calls else 0.0
-
-    @property
-    def avg_latency_ms(self) -> float:
-        return (self.total_latency_ms / self.calls) if self.calls else 0.0
-
-    def record(self, success: bool, latency_ms: float, fallback: bool = False) -> None:
-        self.calls += 1
-        self.total_latency_ms += max(latency_ms, 0.0)
-        if success:
-            self.successes += 1
-            self.last_status = "success"
-        else:
-            self.errors += 1
-            self.last_status = "error"
-        if fallback:
-            self.fallbacks += 1
-
-    def copy(self) -> "ProviderRuntimeMetrics":
-        duplicate = ProviderRuntimeMetrics(self.provider)
-        duplicate.calls = self.calls
-        duplicate.successes = self.successes
-        duplicate.errors = self.errors
+        self.consecutive_failures = 0
+        self.circuit_open = False
+        self.circuit_opened_at: float | None = None
+
+    @property
+    def success_rate(self) -> float:
+        return (self.successes / self.calls * 100) if self.calls else 0.0
+
+    @property
+    def avg_latency_ms(self) -> float:
+        return (self.total_latency_ms / self.calls) if self.calls else 0.0
+
+    def record(self, success: bool, latency_ms: float, fallback: bool = False) -> None:
+        self.calls += 1
+        self.total_latency_ms += max(latency_ms, 0.0)
+        if success:
+            self.successes += 1
+            self.last_status = "success"
+        else:
+            self.errors += 1
+            self.last_status = "error"
+        if fallback:
+            self.fallbacks += 1
+
+    def copy(self) -> "ProviderRuntimeMetrics":
+        duplicate = ProviderRuntimeMetrics(self.provider)
+        duplicate.calls = self.calls
+        duplicate.successes = self.successes
+        duplicate.errors = self.errors
         duplicate.fallbacks = self.fallbacks
         duplicate.total_latency_ms = self.total_latency_ms
         duplicate.last_status = self.last_status
+        duplicate.consecutive_failures = self.consecutive_failures
+        duplicate.circuit_open = self.circuit_open
+        duplicate.circuit_opened_at = self.circuit_opened_at
         return duplicate

package/fincli/app/services/market_overview.py

@@ -1,152 +1,141 @@
-"""Market overview orchestration."""
-
-from __future__ import annotations
-
+"""Market overview orchestration."""
+
+from __future__ import annotations
+
 from dataclasses import dataclass
 
 from fincli.app.analysis.indicators import TechnicalSummary, summarize_technical_indicators
 from fincli.app.analysis.market_structure import MarketStructureSummary, analyze_market_structure
 from fincli.app.providers.market.base import Candle, FundamentalSnapshot, NewsItem, Quote
 from fincli.app.providers.reliability import STATUS_OK, STATUS_PARTIAL_DATA, STATUS_UNAVAILABLE
+from fincli.app.services.data_quality import DataQualityReport
 from fincli.app.services.market_data import MarketDataService
 from fincli.app.utils.errors import FinCLIError
 
 
-@dataclass(frozen=True, slots=True)
-class DataQuality:
-    score: int
-    quote: str
-    ohlcv: str
-    news: str
-    fundamentals: str
-    provider: str
-    tier: str
-    freshness: str
-    reliability_status: str
-    missing_fields: tuple[str, ...]
-    label: str
-
-
-@dataclass(frozen=True, slots=True)
-class MarketOverview:
-    symbol: str
-    timeframe: str
-    quote: Quote
-    candles: list[Candle]
-    technical: TechnicalSummary
-    structure: MarketStructureSummary
-    news: list[NewsItem]
-    fundamentals: FundamentalSnapshot | None
-    data_quality: DataQuality
-
-
-async def build_market_overview(symbol: str, market_service: MarketDataService, timeframe: str = "1d") -> MarketOverview:
-    """Build a compact market overview from available provider data."""
-    normalized = symbol.upper()
-    quote = await market_service.quote(normalized)
-    candles = await market_service.history(normalized, period="6mo", interval=timeframe)
-    technical = summarize_technical_indicators(candles)
-    structure = analyze_market_structure(candles)
-
-    try:
-        news = await market_service.news(normalized, limit=3)
-    except FinCLIError:
-        news = []
-
-    try:
-        fundamentals = await market_service.fundamentals(normalized)
-    except FinCLIError:
-        fundamentals = None
-
-    quality = _score_data_quality(quote, candles, news, fundamentals)
-    return MarketOverview(
-        symbol=normalized,
-        timeframe=timeframe,
-        quote=quote,
-        candles=candles,
-        technical=technical,
-        structure=structure,
-        news=news,
-        fundamentals=fundamentals,
-        data_quality=quality,
-    )
-
-
-def _score_data_quality(
-    quote: Quote,
-    candles: list[Candle],
-    news: list[NewsItem],
-    fundamentals: FundamentalSnapshot | None,
-) -> DataQuality:
-    score = 0
-    missing: list[str] = []
-    quote_status = "ok" if quote.price is not None else "missing"
-    if quote.price is not None:
-        score += 25
-    else:
-        missing.append("quote")
-
-    candle_count = len(candles)
-    if candle_count >= 120:
-        ohlcv_status = f"strong ({candle_count} candles)"
-        score += 35
-    elif candle_count >= 20:
-        ohlcv_status = f"usable ({candle_count} candles)"
-        score += 25
-    elif candle_count:
-        ohlcv_status = f"weak ({candle_count} candles)"
-        score += 10
-    else:
-        ohlcv_status = "missing"
-        missing.append("ohlcv")
-
-    news_status = f"{len(news)} item(s)" if news else "missing"
-    if news:
-        score += 15
-    else:
-        missing.append("news")
-
-    fundamentals_status = "ok" if fundamentals is not None else "missing"
-    if fundamentals is not None:
-        score += 20
-    else:
-        missing.append("fundamentals")
-
-    if quote.status == "realtime":
-        score += 5
-
-    normalized_score = min(score, 100)
-    tier = _quality_tier(normalized_score)
-    freshness = quote.status or "unknown"
-    reliability_status = _reliability_status(missing, normalized_score)
-    return DataQuality(
-        score=normalized_score,
-        quote=quote_status,
-        ohlcv=ohlcv_status,
-        news=news_status,
-        fundamentals=fundamentals_status,
-        provider=f"{quote.provider} ({quote.status})",
-        tier=tier,
-        freshness=freshness,
-        reliability_status=reliability_status,
-        missing_fields=tuple(missing),
-        label=f"{tier} | {reliability_status} | freshness={freshness}",
-    )
-
-
-def _quality_tier(score: int) -> str:
-    if score >= 85:
-        return "strong"
-    if score >= 65:
-        return "usable"
-    if score >= 40:
-        return "partial"
-    return "weak"
-
-
-def _reliability_status(missing: list[str], score: int) -> str:
-    if "quote" in missing or "ohlcv" in missing or score < 25:
-        return STATUS_UNAVAILABLE
-    if missing:
-        return STATUS_PARTIAL_DATA
-    return STATUS_OK
+DataQuality = DataQualityReport
+
+
+@dataclass(frozen=True, slots=True)
+class MarketOverview:
+    symbol: str
+    timeframe: str
+    quote: Quote
+    candles: list[Candle]
+    technical: TechnicalSummary
+    structure: MarketStructureSummary
+    news: list[NewsItem]
+    fundamentals: FundamentalSnapshot | None
+    data_quality: DataQuality
+
+
+async def build_market_overview(symbol: str, market_service: MarketDataService, timeframe: str = "1d") -> MarketOverview:
+    """Build a compact market overview from available provider data."""
+    normalized = symbol.upper()
+    quote = await market_service.quote(normalized)
+    candles = await market_service.history(normalized, period="6mo", interval=timeframe)
+    technical = summarize_technical_indicators(candles)
+    structure = analyze_market_structure(candles)
+
+    try:
+        news = await market_service.news(normalized, limit=3)
+    except FinCLIError:
+        news = []
+
+    try:
+        fundamentals = await market_service.fundamentals(normalized)
+    except FinCLIError:
+        fundamentals = None
+
+    quality = _score_data_quality(quote, candles, news, fundamentals)
+    return MarketOverview(
+        symbol=normalized,
+        timeframe=timeframe,
+        quote=quote,
+        candles=candles,
+        technical=technical,
+        structure=structure,
+        news=news,
+        fundamentals=fundamentals,
+        data_quality=quality,
+    )
+
+
+def _score_data_quality(
+    quote: Quote,
+    candles: list[Candle],
+    news: list[NewsItem],
+    fundamentals: FundamentalSnapshot | None,
+) -> DataQuality:
+    score = 0
+    missing: list[str] = []
+    quote_status = "ok" if quote.price is not None else "missing"
+    if quote.price is not None:
+        score += 25
+    else:
+        missing.append("quote")
+
+    candle_count = len(candles)
+    if candle_count >= 120:
+        ohlcv_status = f"strong ({candle_count} candles)"
+        score += 35
+    elif candle_count >= 20:
+        ohlcv_status = f"usable ({candle_count} candles)"
+        score += 25
+    elif candle_count:
+        ohlcv_status = f"weak ({candle_count} candles)"
+        score += 10
+    else:
+        ohlcv_status = "missing"
+        missing.append("ohlcv")
+
+    news_status = f"{len(news)} item(s)" if news else "missing"
+    if news:
+        score += 15
+    else:
+        missing.append("news")
+
+    fundamentals_status = "ok" if fundamentals is not None else "missing"
+    if fundamentals is not None:
+        score += 20
+    else:
+        missing.append("fundamentals")
+
+    if quote.status == "realtime":
+        score += 5
+
+    normalized_score = min(score, 100)
+    tier = _quality_tier(normalized_score)
+    freshness = quote.status or "unknown"
+    reliability_status = _reliability_status(missing, normalized_score)
+    return DataQuality(
+        score=normalized_score,
+        quote=quote_status,
+        ohlcv=ohlcv_status,
+        news=news_status,
+        fundamentals=fundamentals_status,
+        provider=f"{quote.provider} ({quote.status})",
+        tier=tier,
+        freshness=freshness,
+        reliability_status=reliability_status,
+        missing_fields=tuple(missing),
+        label=f"{tier} | {reliability_status} | freshness={freshness}",
+    )
+
+
+def _quality_tier(score: int) -> str:
+    if score >= 85:
+        return "strong"
+    if score >= 65:
+        return "usable"
+    if score >= 40:
+        return "partial"
+    return "weak"
+
+
+def _reliability_status(missing: list[str], score: int) -> str:
+    if "quote" in missing or "ohlcv" in missing or score < 25:
+        return STATUS_UNAVAILABLE
+    if missing:
+        return STATUS_PARTIAL_DATA
+    return STATUS_OK