@drico2008/fincli 0.1.0

package/fincli/app/providers/ai/http_provider.py

@@ -0,0 +1,145 @@
+"""HTTP-based AI providers."""
+
+from __future__ import annotations
+
+import httpx
+
+from fincli.app.providers.ai.base import AIRequest, AIResponse, BaseAIProvider
+from fincli.app.utils.errors import ProviderError, RateLimitError
+
+
+class OpenAICompatibleProvider(BaseAIProvider):
+    """Provider for OpenAI-compatible chat completion APIs."""
+
+    def __init__(
+        self,
+        name: str,
+        base_url: str,
+        api_key: str | None,
+        client: httpx.AsyncClient | None = None,
+    ) -> None:
+        self.name = name
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key or ""
+        self._client = client
+
+    async def complete(self, request: AIRequest) -> AIResponse:
+        if not self.api_key:
+            raise ProviderError(
+                f"API key untuk provider {self.name} belum diatur.",
+                "Isi API key di .env lalu jalankan ulang FinCLI.",
+            )
+
+        payload = {
+            "model": request.model,
+            "messages": [{"role": "user", "content": request.prompt}],
+            "temperature": request.temperature,
+        }
+        headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
+
+        close_client = self._client is None
+        client = self._client or httpx.AsyncClient(timeout=request.timeout_seconds)
+        try:
+            response = await client.post(f"{self.base_url}/chat/completions", json=payload, headers=headers)
+            if response.status_code == 429:
+                raise RateLimitError(f"Provider {self.name} terkena rate limit.")
+            response.raise_for_status()
+            data = response.json()
+            content = _extract_openai_content(data)
+            return AIResponse(provider=self.name, model=request.model, content=content)
+        except httpx.TimeoutException as exc:
+            raise ProviderError(f"AI provider {self.name} timeout.") from exc
+        except httpx.HTTPStatusError as exc:
+            raise ProviderError(f"AI provider {self.name} gagal: HTTP {exc.response.status_code}.") from exc
+        except (KeyError, IndexError, TypeError, ValueError) as exc:
+            raise ProviderError(f"Response AI provider {self.name} tidak valid.") from exc
+        finally:
+            if close_client:
+                await client.aclose()
+
+
+class GeminiProviderHTTP(BaseAIProvider):
+    """Minimal Gemini generateContent provider."""
+
+    name = "gemini"
+
+    def __init__(self, api_key: str | None, base_url: str = "https://generativelanguage.googleapis.com/v1beta") -> None:
+        self.api_key = api_key or ""
+        self.base_url = base_url.rstrip("/")
+
+    async def complete(self, request: AIRequest) -> AIResponse:
+        if not self.api_key:
+            raise ProviderError("API key untuk provider gemini belum diatur.")
+        url = f"{self.base_url}/models/{request.model}:generateContent?key={self.api_key}"
+        payload = {"contents": [{"parts": [{"text": request.prompt}]}]}
+        try:
+            async with httpx.AsyncClient(timeout=request.timeout_seconds) as client:
+                response = await client.post(url, json=payload)
+                if response.status_code == 429:
+                    raise RateLimitError("Provider gemini terkena rate limit.")
+                response.raise_for_status()
+                data = response.json()
+            content = data["candidates"][0]["content"]["parts"][0]["text"]
+            return AIResponse(provider=self.name, model=request.model, content=str(content))
+        except httpx.TimeoutException as exc:
+            raise ProviderError("AI provider gemini timeout.") from exc
+        except httpx.HTTPStatusError as exc:
+            raise ProviderError(f"AI provider gemini gagal: HTTP {exc.response.status_code}.") from exc
+        except (KeyError, IndexError, TypeError, ValueError) as exc:
+            raise ProviderError("Response AI provider gemini tidak valid.") from exc
+
+
+class AnthropicProviderHTTP(BaseAIProvider):
+    """Minimal Anthropic Messages API provider."""
+
+    name = "anthropic"
+
+    def __init__(self, api_key: str | None, base_url: str = "https://api.anthropic.com/v1") -> None:
+        self.api_key = api_key or ""
+        self.base_url = base_url.rstrip("/")
+
+    async def complete(self, request: AIRequest) -> AIResponse:
+        if not self.api_key:
+            raise ProviderError("API key untuk provider anthropic belum diatur.")
+        payload = {
+            "model": request.model,
+            "max_tokens": 1200,
+            "temperature": request.temperature,
+            "messages": [{"role": "user", "content": request.prompt}],
+        }
+        headers = {
+            "x-api-key": self.api_key,
+            "anthropic-version": "2023-06-01",
+            "Content-Type": "application/json",
+        }
+        try:
+            async with httpx.AsyncClient(timeout=request.timeout_seconds) as client:
+                response = await client.post(f"{self.base_url}/messages", json=payload, headers=headers)
+                if response.status_code == 429:
+                    raise RateLimitError("Provider anthropic terkena rate limit.")
+                response.raise_for_status()
+                data = response.json()
+            content = data["content"][0]["text"]
+            return AIResponse(provider=self.name, model=request.model, content=str(content))
+        except httpx.TimeoutException as exc:
+            raise ProviderError("AI provider anthropic timeout.") from exc
+        except httpx.HTTPStatusError as exc:
+            raise ProviderError(f"AI provider anthropic gagal: HTTP {exc.response.status_code}.") from exc
+        except (KeyError, IndexError, TypeError, ValueError) as exc:
+            raise ProviderError("Response AI provider anthropic tidak valid.") from exc
+
+
+def _extract_openai_content(data: dict[str, object]) -> str:
+    choices = data["choices"]
+    if not isinstance(choices, list) or not choices:
+        raise ValueError("choices kosong")
+    first = choices[0]
+    if not isinstance(first, dict):
+        raise ValueError("choice tidak valid")
+    message = first.get("message")
+    if isinstance(message, dict) and message.get("content"):
+        return str(message["content"])
+    text = first.get("text")
+    if text:
+        return str(text)
+    raise ValueError("content kosong")

package/fincli/app/providers/ai/huggingface_provider.py

@@ -0,0 +1,11 @@
+"""HuggingFace provider placeholder for Phase 2."""
+
+from fincli.app.providers.ai.base import AIRequest, AIResponse, BaseAIProvider
+from fincli.app.utils.errors import ProviderError
+
+
+class HuggingFaceProvider(BaseAIProvider):
+    name = "huggingface"
+
+    async def complete(self, request: AIRequest) -> AIResponse:
+        raise ProviderError("HuggingFace client belum diimplementasi di Phase 1.")

package/fincli/app/providers/ai/manager.py

@@ -0,0 +1,60 @@
+"""AI provider catalog and selection state."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import os
+
+from fincli.app.providers.ai.base import BaseAIProvider
+from fincli.app.providers.ai.http_provider import AnthropicProviderHTTP, GeminiProviderHTTP, OpenAICompatibleProvider
+
+
+@dataclass(frozen=True, slots=True)
+class AIProviderInfo:
+    name: str
+    env_key: str
+    default_model: str
+    status: str = "configured"
+
+
+AI_PROVIDERS: dict[str, AIProviderInfo] = {
+    "openrouter": AIProviderInfo("openrouter", "OPENROUTER_API_KEY", "openai/gpt-4o-mini"),
+    "gemini": AIProviderInfo("gemini", "GEMINI_API_KEY", "gemini-1.5-flash"),
+    "anthropic": AIProviderInfo("anthropic", "ANTHROPIC_API_KEY", "claude-3-5-sonnet-latest"),
+    "openai": AIProviderInfo("openai", "OPENAI_API_KEY", "gpt-4o-mini"),
+    "together": AIProviderInfo("together", "TOGETHER_API_KEY", "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo"),
+    "huggingface": AIProviderInfo("huggingface", "HUGGINGFACE_API_KEY", "meta-llama/Llama-3.1-8B-Instruct"),
+    "groq": AIProviderInfo("groq", "GROQ_API_KEY", "llama-3.1-70b-versatile"),
+}
+
+
+class AIProviderManager:
+    """AI provider catalog and factory."""
+
+    def list_providers(self) -> list[AIProviderInfo]:
+        return list(AI_PROVIDERS.values())
+
+    def get(self, name: str) -> AIProviderInfo | None:
+        return AI_PROVIDERS.get(name.lower())
+
+    def create(self, name: str) -> BaseAIProvider:
+        provider = self.get(name)
+        if provider is None:
+            raise ValueError(f"AI provider tidak dikenal: {name}")
+
+        api_key = os.getenv(provider.env_key)
+        if provider.name == "openrouter":
+            return OpenAICompatibleProvider(provider.name, "https://openrouter.ai/api/v1", api_key)
+        if provider.name == "openai":
+            return OpenAICompatibleProvider(provider.name, "https://api.openai.com/v1", api_key)
+        if provider.name == "together":
+            return OpenAICompatibleProvider(provider.name, "https://api.together.xyz/v1", api_key)
+        if provider.name == "groq":
+            return OpenAICompatibleProvider(provider.name, "https://api.groq.com/openai/v1", api_key)
+        if provider.name == "huggingface":
+            return OpenAICompatibleProvider(provider.name, "https://router.huggingface.co/v1", api_key)
+        if provider.name == "gemini":
+            return GeminiProviderHTTP(api_key)
+        if provider.name == "anthropic":
+            return AnthropicProviderHTTP(api_key)
+        raise ValueError(f"AI provider tidak didukung: {name}")

package/fincli/app/providers/ai/openai_provider.py

@@ -0,0 +1,11 @@
+"""OpenAI provider placeholder for Phase 2."""
+
+from fincli.app.providers.ai.base import AIRequest, AIResponse, BaseAIProvider
+from fincli.app.utils.errors import ProviderError
+
+
+class OpenAIProvider(BaseAIProvider):
+    name = "openai"
+
+    async def complete(self, request: AIRequest) -> AIResponse:
+        raise ProviderError("OpenAI client belum diimplementasi di Phase 1.")

package/fincli/app/providers/ai/openrouter_provider.py

@@ -0,0 +1,11 @@
+"""OpenRouter provider placeholder for Phase 2."""
+
+from fincli.app.providers.ai.base import AIRequest, AIResponse, BaseAIProvider
+from fincli.app.utils.errors import ProviderError
+
+
+class OpenRouterProvider(BaseAIProvider):
+    name = "openrouter"
+
+    async def complete(self, request: AIRequest) -> AIResponse:
+        raise ProviderError("OpenRouter client belum diimplementasi di Phase 1.")

package/fincli/app/providers/ai/together_provider.py

@@ -0,0 +1,11 @@
+"""Together AI provider placeholder for Phase 2."""
+
+from fincli.app.providers.ai.base import AIRequest, AIResponse, BaseAIProvider
+from fincli.app.utils.errors import ProviderError
+
+
+class TogetherProvider(BaseAIProvider):
+    name = "together"
+
+    async def complete(self, request: AIRequest) -> AIResponse:
+        raise ProviderError("Together AI client belum diimplementasi di Phase 1.")

package/fincli/app/providers/market/__init__.py

@@ -0,0 +1 @@
+"""Market data provider modules."""

package/fincli/app/providers/market/base.py

@@ -0,0 +1,77 @@
+"""Base market provider contract for future provider implementations."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Protocol
+
+
+@dataclass(frozen=True, slots=True)
+class Quote:
+    symbol: str
+    price: float | None
+    currency: str
+    provider: str
+    timestamp: datetime
+    status: str
+
+
+@dataclass(frozen=True, slots=True)
+class Candle:
+    timestamp: datetime
+    open: float
+    high: float
+    low: float
+    close: float
+    volume: float
+
+
+@dataclass(frozen=True, slots=True)
+class NewsItem:
+    title: str
+    source: str
+    url: str | None
+    published_at: datetime | None
+    summary: str = ""
+
+
+@dataclass(frozen=True, slots=True)
+class FundamentalSnapshot:
+    symbol: str
+    provider: str
+    currency: str
+    market_cap: float | None = None
+    pe_ratio: float | None = None
+    eps: float | None = None
+    revenue: float | None = None
+    beta: float | None = None
+    sector: str | None = None
+    industry: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class ProviderStatus:
+    name: str
+    realtime: bool
+    status: str
+    message: str
+
+
+class BaseMarketProvider(Protocol):
+    name: str
+
+    async def quote(self, symbol: str) -> Quote:
+        """Fetch a single quote."""
+
+    async def history(self, symbol: str, period: str = "6mo", interval: str = "1d") -> list[Candle]:
+        """Fetch historical candles."""
+
+    async def status(self) -> ProviderStatus:
+        """Return provider health and realtime/delayed status."""
+
+    async def news(self, symbol: str, limit: int = 5) -> list[NewsItem]:
+        """Fetch latest news items."""
+
+    async def fundamentals(self, symbol: str) -> FundamentalSnapshot:
+        """Fetch a compact fundamental snapshot."""

package/fincli/app/providers/market/custom_provider.py

@@ -0,0 +1,169 @@
+"""Custom HTTP market API provider.
+
+Expected endpoint contract:
+- GET /quote/{symbol}
+- GET /history/{symbol}?period=6mo&interval=1d
+- GET /news/{symbol}?limit=5
+- GET /fundamentals/{symbol}
+
+The provider accepts common JSON key variants so users can adapt simple APIs
+without changing FinCLI core.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+import httpx
+
+from fincli.app.providers.market.base import (
+    BaseMarketProvider,
+    Candle,
+    FundamentalSnapshot,
+    NewsItem,
+    ProviderStatus,
+    Quote,
+)
+from fincli.app.utils.errors import ProviderError, RateLimitError
+
+
+class CustomMarketProvider(BaseMarketProvider):
+    name = "custom"
+
+    def __init__(
+        self,
+        api_key: str | None,
+        base_url: str,
+        client: httpx.AsyncClient | None = None,
+    ) -> None:
+        self.api_key = api_key or ""
+        self.base_url = base_url.rstrip("/")
+        self._client = client
+
+    async def quote(self, symbol: str) -> Quote:
+        data = await self._get(f"/quote/{symbol.upper()}")
+        return Quote(
+            symbol=str(data.get("symbol") or symbol).upper(),
+            price=_safe_float(data.get("price") or data.get("last") or data.get("last_price")),
+            currency=str(data.get("currency") or "USD"),
+            provider=self.name,
+            timestamp=_parse_datetime(data.get("timestamp")) or datetime.now(),
+            status=str(data.get("status") or "custom"),
+        )
+
+    async def history(self, symbol: str, period: str = "6mo", interval: str = "1d") -> list[Candle]:
+        data = await self._get(f"/history/{symbol.upper()}", params={"period": period, "interval": interval})
+        raw_items = data.get("candles") if isinstance(data, dict) else data
+        if not isinstance(raw_items, list):
+            raise ProviderError("Response history custom provider tidak valid.")
+        candles: list[Candle] = []
+        for item in raw_items:
+            if not isinstance(item, dict):
+                continue
+            candles.append(
+                Candle(
+                    timestamp=_parse_datetime(item.get("timestamp") or item.get("date")) or datetime.now(),
+                    open=float(item.get("open") or item.get("o")),
+                    high=float(item.get("high") or item.get("h")),
+                    low=float(item.get("low") or item.get("l")),
+                    close=float(item.get("close") or item.get("c")),
+                    volume=float(item.get("volume") or item.get("v") or 0),
+                )
+            )
+        if not candles:
+            raise ProviderError(f"Data OHLCV kosong untuk {symbol}.")
+        return candles
+
+    async def news(self, symbol: str, limit: int = 5) -> list[NewsItem]:
+        data = await self._get(f"/news/{symbol.upper()}", params={"limit": limit})
+        raw_items = data.get("news") if isinstance(data, dict) else data
+        if not isinstance(raw_items, list):
+            raise ProviderError("Response news custom provider tidak valid.")
+        items: list[NewsItem] = []
+        for item in raw_items[:limit]:
+            if not isinstance(item, dict):
+                continue
+            items.append(
+                NewsItem(
+                    title=str(item.get("title") or "Untitled"),
+                    source=str(item.get("source") or self.name),
+                    url=item.get("url"),
+                    published_at=_parse_datetime(item.get("published_at") or item.get("timestamp")),
+                    summary=str(item.get("summary") or ""),
+                )
+            )
+        return items
+
+    async def fundamentals(self, symbol: str) -> FundamentalSnapshot:
+        data = await self._get(f"/fundamentals/{symbol.upper()}")
+        return FundamentalSnapshot(
+            symbol=str(data.get("symbol") or symbol).upper(),
+            provider=self.name,
+            currency=str(data.get("currency") or "USD"),
+            market_cap=_safe_float(data.get("market_cap") or data.get("marketCap")),
+            pe_ratio=_safe_float(data.get("pe_ratio") or data.get("trailingPE")),
+            eps=_safe_float(data.get("eps") or data.get("trailingEps")),
+            revenue=_safe_float(data.get("revenue") or data.get("totalRevenue")),
+            beta=_safe_float(data.get("beta")),
+            sector=data.get("sector"),
+            industry=data.get("industry"),
+        )
+
+    async def status(self) -> ProviderStatus:
+        status = "configured" if self.api_key else "unavailable"
+        message = "Custom provider configured." if self.api_key else "Requires MARKET_DATA_API_KEY."
+        return ProviderStatus(name=self.name, realtime=True, status=status, message=message)
+
+    async def _get(self, path: str, params: dict[str, object] | None = None) -> Any:
+        if not self.api_key:
+            raise ProviderError(
+                "API key custom market provider belum diatur.",
+                "Isi MARKET_DATA_API_KEY di .env.",
+            )
+        if not self.base_url:
+            raise ProviderError(
+                "Base URL custom market provider belum diatur.",
+                "Isi MARKET_DATA_BASE_URL di .env.",
+            )
+
+        close_client = self._client is None
+        client = self._client or httpx.AsyncClient(timeout=30)
+        headers = {"X-API-Key": self.api_key, "Authorization": f"Bearer {self.api_key}"}
+        try:
+            response = await client.get(f"{self.base_url}{path}", params=params, headers=headers)
+            if response.status_code == 429:
+                raise RateLimitError("Custom market provider terkena rate limit.")
+            response.raise_for_status()
+            return response.json()
+        except httpx.TimeoutException as exc:
+            raise ProviderError("Custom market provider timeout.") from exc
+        except httpx.HTTPStatusError as exc:
+            raise ProviderError(f"Custom market provider gagal: HTTP {exc.response.status_code}.") from exc
+        except ValueError as exc:
+            raise ProviderError("Response custom market provider bukan JSON valid.") from exc
+        finally:
+            if close_client:
+                await client.aclose()
+
+
+def _safe_float(value: Any) -> float | None:
+    try:
+        if value is None:
+            return None
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _parse_datetime(value: Any) -> datetime | None:
+    if value is None:
+        return None
+    if isinstance(value, (int, float)):
+        return datetime.fromtimestamp(value)
+    if isinstance(value, str):
+        try:
+            return datetime.fromisoformat(value.replace("Z", "+00:00"))
+        except ValueError:
+            return None
+    return None