@drico2008/fincli 0.1.0

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

@@ -0,0 +1,187 @@
+"""Finnhub market provider.
+
+Finnhub supports real-time REST/WebSocket APIs for stocks, forex, and crypto,
+plus company fundamentals/news depending on endpoint and plan. This provider
+implements the endpoints FinCLI needs for stock-style symbols first:
+- /quote
+- /stock/candle
+- /company-news
+- /stock/profile2
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta
+from typing import Any
+
+import httpx
+
+from fincli.app.providers.market.base import Candle, FundamentalSnapshot, NewsItem, ProviderStatus, Quote
+from fincli.app.providers.market.symbols import resolve_finnhub_symbol
+from fincli.app.utils.errors import ProviderError, RateLimitError
+
+
+class FinnhubProvider:
+    name = "finnhub"
+
+    def __init__(
+        self,
+        api_key: str | None,
+        base_url: str = "https://finnhub.io/api/v1",
+        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:
+        resolved = resolve_finnhub_symbol(symbol)
+        if resolved.asset_class in {"forex", "crypto"}:
+            candles = await self.history(symbol, period="5d", interval="1d")
+            if not candles:
+                raise ProviderError(f"Finnhub tidak mengembalikan harga valid untuk {symbol}.")
+            latest = candles[-1]
+            return Quote(
+                symbol=resolved.symbol,
+                price=latest.close,
+                currency="USD",
+                provider=self.name,
+                timestamp=latest.timestamp,
+                status="delayed",
+            )
+        data = await self._get("/quote", {"symbol": symbol.upper()})
+        price = _safe_float(data.get("c"))
+        if price is None or price == 0:
+            raise ProviderError(f"Finnhub tidak mengembalikan harga valid untuk {symbol}.")
+        return Quote(
+            symbol=symbol.upper(),
+            price=price,
+            currency="USD",
+            provider=self.name,
+            timestamp=datetime.fromtimestamp(int(data.get("t") or datetime.now().timestamp())),
+            status="realtime",
+        )
+
+    async def history(self, symbol: str, period: str = "6mo", interval: str = "1d") -> list[Candle]:
+        resolved = resolve_finnhub_symbol(symbol)
+        now = datetime.now()
+        start = now - _period_to_delta(period)
+        path = {
+            "forex": "/forex/candle",
+            "crypto": "/crypto/candle",
+        }.get(resolved.asset_class, "/stock/candle")
+        data = await self._get(
+            path,
+            {
+                "symbol": resolved.symbol,
+                "resolution": _interval_to_resolution(interval),
+                "from": int(start.timestamp()),
+                "to": int(now.timestamp()),
+            },
+        )
+        if data.get("s") != "ok":
+            raise ProviderError(f"Finnhub candle data kosong untuk {symbol} ({resolved.symbol}).")
+        timestamps = data.get("t") or []
+        candles = [
+            Candle(
+                timestamp=datetime.fromtimestamp(int(ts)),
+                open=float(data["o"][index]),
+                high=float(data["h"][index]),
+                low=float(data["l"][index]),
+                close=float(data["c"][index]),
+                volume=float(data["v"][index]),
+            )
+            for index, ts in enumerate(timestamps)
+        ]
+        if not candles:
+            raise ProviderError(f"Finnhub candle data kosong untuk {symbol} ({resolved.symbol}).")
+        return candles
+
+    async def news(self, symbol: str, limit: int = 5) -> list[NewsItem]:
+        today = datetime.now().date()
+        start = today - timedelta(days=14)
+        data = await self._get(
+            "/company-news",
+            {"symbol": symbol.upper(), "from": start.isoformat(), "to": today.isoformat()},
+        )
+        if not isinstance(data, list):
+            raise ProviderError("Response Finnhub news tidak valid.")
+        items: list[NewsItem] = []
+        for item in data[:limit]:
+            if not isinstance(item, dict):
+                continue
+            timestamp = item.get("datetime")
+            published_at = datetime.fromtimestamp(timestamp) if isinstance(timestamp, int) else None
+            items.append(
+                NewsItem(
+                    title=str(item.get("headline") or item.get("title") or "Untitled"),
+                    source=str(item.get("source") or self.name),
+                    url=item.get("url"),
+                    published_at=published_at,
+                    summary=str(item.get("summary") or ""),
+                )
+            )
+        return items
+
+    async def fundamentals(self, symbol: str) -> FundamentalSnapshot:
+        data = await self._get("/stock/profile2", {"symbol": symbol.upper()})
+        return FundamentalSnapshot(
+            symbol=str(data.get("ticker") or symbol).upper(),
+            provider=self.name,
+            currency=str(data.get("currency") or "USD"),
+            market_cap=_safe_float(data.get("marketCapitalization")),
+            sector=data.get("finnhubIndustry"),
+            industry=data.get("finnhubIndustry"),
+        )
+
+    async def status(self) -> ProviderStatus:
+        status = "configured" if self.api_key else "unavailable"
+        message = "Finnhub provider configured." if self.api_key else "Requires FINNHUB_API_KEY."
+        return ProviderStatus(name=self.name, realtime=True, status=status, message=message)
+
+    async def _get(self, path: str, params: dict[str, object]) -> Any:
+        if not self.api_key:
+            raise ProviderError("API key Finnhub belum diatur.", "Isi FINNHUB_API_KEY di .env.")
+        close_client = self._client is None
+        client = self._client or httpx.AsyncClient(timeout=30)
+        query = {**params, "token": self.api_key}
+        try:
+            response = await client.get(f"{self.base_url}{path}", params=query)
+            if response.status_code == 429:
+                raise RateLimitError("Finnhub terkena rate limit.")
+            response.raise_for_status()
+            return response.json()
+        except httpx.TimeoutException as exc:
+            raise ProviderError("Finnhub timeout.") from exc
+        except httpx.HTTPStatusError as exc:
+            raise ProviderError(f"Finnhub gagal: HTTP {exc.response.status_code}.") from exc
+        except ValueError as exc:
+            raise ProviderError("Response Finnhub 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 _period_to_delta(period: str) -> timedelta:
+    normalized = period.lower()
+    if normalized.endswith("mo"):
+        return timedelta(days=30 * int(normalized[:-2] or 6))
+    if normalized.endswith("y"):
+        return timedelta(days=365 * int(normalized[:-1] or 1))
+    if normalized.endswith("d"):
+        return timedelta(days=int(normalized[:-1] or 30))
+    return timedelta(days=180)
+
+
+def _interval_to_resolution(interval: str) -> str:
+    mapping = {"1d": "D", "d": "D", "1w": "W", "w": "W", "1m": "M"}
+    return mapping.get(interval.lower(), interval)

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

@@ -0,0 +1,123 @@
+"""Market/news provider catalog."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import os
+
+from fincli.app.providers.market.base import BaseMarketProvider
+from fincli.app.providers.market.custom_provider import CustomMarketProvider
+from fincli.app.providers.market.finnhub_provider import FinnhubProvider
+from fincli.app.providers.market.twelvedata_provider import TwelveDataProvider
+from fincli.app.providers.market.yfinance_provider import YFinanceProvider
+
+
+@dataclass(frozen=True, slots=True)
+class MarketProviderInfo:
+    name: str
+    realtime: bool
+    status: str
+    notes: str
+
+
+MARKET_PROVIDERS: dict[str, MarketProviderInfo] = {
+    "yfinance": MarketProviderInfo(
+        name="yfinance",
+        realtime=False,
+        status="fallback",
+        notes="Fallback delayed data. No API key required.",
+    ),
+    "custom": MarketProviderInfo(
+        name="custom",
+        realtime=True,
+        status="configured",
+        notes="Custom API provider scaffold. Requires MARKET_DATA_API_KEY.",
+    ),
+    "finnhub": MarketProviderInfo(
+        name="finnhub",
+        realtime=True,
+        status="configured",
+        notes="Finnhub REST provider. Requires FINNHUB_API_KEY.",
+    ),
+    "twelvedata": MarketProviderInfo(
+        name="twelvedata",
+        realtime=True,
+        status="configured",
+        notes="Multi-asset provider for stocks, forex, ETFs, indices, commodities, and crypto. Requires TWELVE_DATA_API_KEY.",
+    ),
+}
+
+
+class MarketProviderManager:
+    """Market provider catalog and factory."""
+
+    def list_providers(self) -> list[MarketProviderInfo]:
+        return list(MARKET_PROVIDERS.values())
+
+    def get(self, name: str) -> MarketProviderInfo | None:
+        return MARKET_PROVIDERS.get(name.lower())
+
+    def create(self, name: str) -> BaseMarketProvider:
+        provider_name = name.lower()
+        if provider_name == "yfinance":
+            return YFinanceProvider()
+        if provider_name == "custom":
+            return CustomMarketProvider(
+                api_key=os.getenv("MARKET_DATA_API_KEY"),
+                base_url=os.getenv("MARKET_DATA_BASE_URL", ""),
+            )
+        if provider_name == "finnhub":
+            return FinnhubProvider(api_key=os.getenv("FINNHUB_API_KEY"))
+        if provider_name == "twelvedata":
+            return TwelveDataProvider(api_key=os.getenv("TWELVE_DATA_API_KEY"))
+        raise ValueError(f"Market provider tidak dikenal: {name}")
+
+    def create_many(self, names: list[str]) -> list[BaseMarketProvider]:
+        providers: list[BaseMarketProvider] = []
+        seen: set[str] = set()
+        for name in names:
+            normalized = name.lower().strip()
+            if not normalized or normalized in seen:
+                continue
+            providers.append(self.create(normalized))
+            seen.add(normalized)
+        if not providers:
+            providers.append(self.create("yfinance"))
+        return providers
+
+    def key_status(self) -> list[dict[str, str]]:
+        return [
+            {"provider": "yfinance", "key": "-", "status": "not required", "source": "-"},
+            {
+                "provider": "custom",
+                "key": "MARKET_DATA_API_KEY",
+                "status": _mask_status(os.getenv("MARKET_DATA_API_KEY")),
+                "source": ".env" if os.getenv("MARKET_DATA_API_KEY") else "-",
+            },
+            {
+                "provider": "custom",
+                "key": "MARKET_DATA_BASE_URL",
+                "status": _mask_status(os.getenv("MARKET_DATA_BASE_URL")),
+                "source": ".env" if os.getenv("MARKET_DATA_BASE_URL") else "-",
+            },
+            {
+                "provider": "finnhub",
+                "key": "FINNHUB_API_KEY",
+                "status": _mask_status(os.getenv("FINNHUB_API_KEY")),
+                "source": ".env" if os.getenv("FINNHUB_API_KEY") else "-",
+            },
+            {
+                "provider": "twelvedata",
+                "key": "TWELVE_DATA_API_KEY",
+                "status": _mask_status(os.getenv("TWELVE_DATA_API_KEY")),
+                "source": ".env" if os.getenv("TWELVE_DATA_API_KEY") else "-",
+            },
+        ]
+
+
+def _mask_status(value: str | None) -> str:
+    if not value:
+        return "not set"
+    if len(value) <= 8:
+        return "set"
+    return f"{value[:4]}...{value[-4:]}"

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

@@ -0,0 +1,28 @@
+"""News provider placeholder for Phase 2."""
+
+from fincli.app.providers.market.base import BaseMarketProvider, Candle, FundamentalSnapshot, NewsItem, ProviderStatus, Quote
+from fincli.app.utils.errors import ProviderError
+
+
+class NewsProvider(BaseMarketProvider):
+    name = "news"
+
+    async def quote(self, symbol: str) -> Quote:
+        raise ProviderError("News provider tidak menyediakan quote.")
+
+    async def history(self, symbol: str, period: str = "6mo", interval: str = "1d") -> list[Candle]:
+        raise ProviderError("News provider tidak menyediakan OHLCV.")
+
+    async def news(self, symbol: str, limit: int = 5) -> list[NewsItem]:
+        raise ProviderError("News fetching belum diimplementasi di Phase 2.")
+
+    async def fundamentals(self, symbol: str) -> FundamentalSnapshot:
+        raise ProviderError("News provider tidak menyediakan fundamental.")
+
+    async def status(self) -> ProviderStatus:
+        return ProviderStatus(
+            name=self.name,
+            realtime=False,
+            status="configured",
+            message="News fetching pending in Phase 2.",
+        )

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

@@ -0,0 +1,182 @@
+"""Provider-specific symbol normalization for multi-asset market data."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+FOREX_CURRENCIES = {
+    "AUD",
+    "CAD",
+    "CHF",
+    "CNH",
+    "CNY",
+    "EUR",
+    "GBP",
+    "HKD",
+    "JPY",
+    "MXN",
+    "NOK",
+    "NZD",
+    "SEK",
+    "SGD",
+    "USD",
+    "ZAR",
+}
+
+YFINANCE_ALIASES = {
+    "SPX": "^GSPC",
+    "SP500": "^GSPC",
+    "S&P500": "^GSPC",
+    "NASDAQ": "^IXIC",
+    "IXIC": "^IXIC",
+    "NDX": "^NDX",
+    "DOW": "^DJI",
+    "DJI": "^DJI",
+    "RUSSELL2000": "^RUT",
+    "VIX": "^VIX",
+    "DAX": "^GDAXI",
+    "FTSE": "^FTSE",
+    "CAC40": "^FCHI",
+    "NIKKEI": "^N225",
+    "N225": "^N225",
+    "HSI": "^HSI",
+    "HANGSENG": "^HSI",
+    "STI": "^STI",
+    "KOSPI": "^KS11",
+    "ASX200": "^AXJO",
+    "STOXX50": "^STOXX50E",
+    "GOLD": "GC=F",
+    "SILVER": "SI=F",
+    "WTI": "CL=F",
+    "BRENT": "BZ=F",
+    "NATGAS": "NG=F",
+    "COPPER": "HG=F",
+    "CORN": "ZC=F",
+    "SOYBEAN": "ZS=F",
+}
+
+IDX_ALIASES = {
+    "ACES",
+    "ADRO",
+    "AKRA",
+    "AMMN",
+    "ANTM",
+    "ARTO",
+    "ASII",
+    "BBCA",
+    "BBNI",
+    "BBRI",
+    "BBTN",
+    "BMRI",
+    "BRIS",
+    "BRPT",
+    "BUKA",
+    "CPIN",
+    "EMTK",
+    "ESSA",
+    "EXCL",
+    "GGRM",
+    "GOTO",
+    "HRUM",
+    "ICBP",
+    "INCO",
+    "INDF",
+    "INKP",
+    "INTP",
+    "ITMG",
+    "JPFA",
+    "JSMR",
+    "KLBF",
+    "MDKA",
+    "MEDC",
+    "PGAS",
+    "PTBA",
+    "SIDO",
+    "SMGR",
+    "TINS",
+    "TLKM",
+    "TOWR",
+    "UNTR",
+    "UNVR",
+}
+
+TWELVEDATA_ALIASES = {
+    "SPX": "SPX",
+    "SP500": "SPX",
+    "S&P500": "SPX",
+    "NASDAQ": "IXIC",
+    "IXIC": "IXIC",
+    "NDX": "NDX",
+    "DOW": "DJI",
+    "DJI": "DJI",
+    "DAX": "DAX",
+    "FTSE": "FTSE",
+    "CAC40": "CAC",
+    "NIKKEI": "N225",
+    "HSI": "HSI",
+    "GOLD": "XAU/USD",
+    "SILVER": "XAG/USD",
+    "WTI": "WTI/USD",
+    "BRENT": "BRENT/USD",
+}
+
+
+@dataclass(frozen=True, slots=True)
+class ResolvedSymbol:
+    original: str
+    symbol: str
+    asset_class: str
+
+
+def resolve_yfinance_symbol(symbol: str) -> ResolvedSymbol:
+    normalized = _normalize(symbol)
+    if normalized in YFINANCE_ALIASES:
+        return ResolvedSymbol(symbol, YFINANCE_ALIASES[normalized], _alias_class(normalized))
+    if normalized in IDX_ALIASES:
+        return ResolvedSymbol(symbol, f"{normalized}.JK", "stock")
+    if _is_metal_pair(normalized) or _is_forex_pair(normalized):
+        return ResolvedSymbol(symbol, f"{normalized}=X", "forex")
+    return ResolvedSymbol(symbol, symbol.upper(), "stock")
+
+
+def resolve_twelvedata_symbol(symbol: str) -> ResolvedSymbol:
+    normalized = _normalize(symbol)
+    if normalized in TWELVEDATA_ALIASES:
+        return ResolvedSymbol(symbol, TWELVEDATA_ALIASES[normalized], _alias_class(normalized))
+    if _is_metal_pair(normalized) or _is_forex_pair(normalized):
+        return ResolvedSymbol(symbol, f"{normalized[:3]}/{normalized[3:]}", "forex")
+    if "/" in symbol or ":" in symbol:
+        return ResolvedSymbol(symbol, symbol.upper(), "custom")
+    return ResolvedSymbol(symbol, symbol.upper(), "stock")
+
+
+def resolve_finnhub_symbol(symbol: str) -> ResolvedSymbol:
+    normalized = _normalize(symbol)
+    if _is_forex_pair(normalized):
+        return ResolvedSymbol(symbol, f"OANDA:{normalized[:3]}_{normalized[3:]}", "forex")
+    if normalized.startswith("BINANCE:"):
+        return ResolvedSymbol(symbol, normalized, "crypto")
+    if normalized.endswith("USDT") and len(normalized) > 6:
+        return ResolvedSymbol(symbol, f"BINANCE:{normalized}", "crypto")
+    return ResolvedSymbol(symbol, symbol.upper(), "stock")
+
+
+def _normalize(symbol: str) -> str:
+    return symbol.strip().upper().replace(" ", "").replace("-", "").replace("_", "").replace("/", "")
+
+
+def _is_forex_pair(symbol: str) -> bool:
+    return len(symbol) == 6 and symbol[:3] in FOREX_CURRENCIES and symbol[3:] in FOREX_CURRENCIES
+
+
+def _is_metal_pair(symbol: str) -> bool:
+    return len(symbol) == 6 and symbol[:3] in {"XAU", "XAG", "XPT", "XPD"} and symbol[3:] in FOREX_CURRENCIES
+
+
+def _alias_class(symbol: str) -> str:
+    if symbol in {"GOLD", "SILVER", "WTI", "BRENT", "NATGAS", "COPPER", "CORN", "SOYBEAN"}:
+        return "commodity"
+    if symbol.startswith("XAU") or symbol.startswith("XAG"):
+        return "commodity"
+    return "index"

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

@@ -0,0 +1,167 @@
+"""Twelve Data provider for multi-asset market data."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+import httpx
+
+from fincli.app.providers.market.base import Candle, FundamentalSnapshot, NewsItem, ProviderStatus, Quote
+from fincli.app.providers.market.symbols import resolve_twelvedata_symbol
+from fincli.app.utils.errors import ProviderError, RateLimitError
+
+
+class TwelveDataProvider:
+    name = "twelvedata"
+
+    def __init__(
+        self,
+        api_key: str | None,
+        base_url: str = "https://api.twelvedata.com",
+        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:
+        resolved = resolve_twelvedata_symbol(symbol)
+        data = await self._get("/quote", {"symbol": resolved.symbol})
+        price = _safe_float(data.get("close") or data.get("price"))
+        if price is None:
+            raise ProviderError(f"Twelve Data tidak mengembalikan quote valid untuk {symbol}.")
+        return Quote(
+            symbol=str(data.get("symbol") or resolved.symbol).upper(),
+            price=price,
+            currency=str(data.get("currency") or "USD"),
+            provider=self.name,
+            timestamp=_parse_datetime(data.get("datetime")) or datetime.now(),
+            status="realtime",
+        )
+
+    async def history(self, symbol: str, period: str = "6mo", interval: str = "1d") -> list[Candle]:
+        resolved = resolve_twelvedata_symbol(symbol)
+        data = await self._get(
+            "/time_series",
+            {
+                "symbol": resolved.symbol,
+                "interval": _interval_to_twelvedata(interval),
+                "outputsize": _period_to_outputsize(period, interval),
+                "timezone": "UTC",
+            },
+        )
+        values = data.get("values") if isinstance(data, dict) else None
+        if not isinstance(values, list) or not values:
+            message = data.get("message") if isinstance(data, dict) else None
+            raise ProviderError(f"Twelve Data OHLCV kosong untuk {symbol}.", str(message) if message else None)
+
+        candles = [_parse_candle(item) for item in values if isinstance(item, dict)]
+        candles.sort(key=lambda candle: candle.timestamp)
+        if not candles:
+            raise ProviderError(f"Twelve Data OHLCV kosong untuk {symbol}.")
+        return candles
+
+    async def news(self, symbol: str, limit: int = 5) -> list[NewsItem]:
+        return []
+
+    async def fundamentals(self, symbol: str) -> FundamentalSnapshot:
+        resolved = resolve_twelvedata_symbol(symbol)
+        return FundamentalSnapshot(symbol=resolved.symbol.upper(), provider=self.name, currency="USD")
+
+    async def status(self) -> ProviderStatus:
+        status = "configured" if self.api_key else "unavailable"
+        message = "Twelve Data provider configured." if self.api_key else "Requires TWELVE_DATA_API_KEY."
+        return ProviderStatus(name=self.name, realtime=True, status=status, message=message)
+
+    async def _get(self, path: str, params: dict[str, object]) -> Any:
+        if not self.api_key:
+            raise ProviderError("API key Twelve Data belum diatur.", "Isi TWELVE_DATA_API_KEY di .env.")
+        close_client = self._client is None
+        client = self._client or httpx.AsyncClient(timeout=30)
+        try:
+            response = await client.get(f"{self.base_url}{path}", params={**params, "apikey": self.api_key})
+            if response.status_code == 429:
+                raise RateLimitError("Twelve Data terkena rate limit.")
+            response.raise_for_status()
+            data = response.json()
+            if isinstance(data, dict) and data.get("status") == "error":
+                raise ProviderError(f"Twelve Data gagal: {data.get('message') or 'unknown error'}")
+            return data
+        except httpx.TimeoutException as exc:
+            raise ProviderError("Twelve Data timeout.") from exc
+        except httpx.HTTPStatusError as exc:
+            raise ProviderError(f"Twelve Data gagal: HTTP {exc.response.status_code}.") from exc
+        except ValueError as exc:
+            raise ProviderError("Response Twelve Data bukan JSON valid.") from exc
+        finally:
+            if close_client:
+                await client.aclose()
+
+
+def _parse_candle(item: dict[str, Any]) -> Candle:
+    return Candle(
+        timestamp=_parse_datetime(item.get("datetime")) or datetime.now(),
+        open=float(item["open"]),
+        high=float(item["high"]),
+        low=float(item["low"]),
+        close=float(item["close"]),
+        volume=float(item.get("volume") or 0),
+    )
+
+
+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: object) -> datetime | None:
+    if not value:
+        return None
+    text = str(value).replace("Z", "+00:00")
+    for fmt in ("%Y-%m-%d %H:%M:%S", "%Y-%m-%d"):
+        try:
+            return datetime.strptime(text, fmt)
+        except ValueError:
+            continue
+    try:
+        return datetime.fromisoformat(text)
+    except ValueError:
+        return None
+
+
+def _interval_to_twelvedata(interval: str) -> str:
+    mapping = {
+        "1m": "1min",
+        "5m": "5min",
+        "15m": "15min",
+        "30m": "30min",
+        "1h": "1h",
+        "4h": "4h",
+        "1d": "1day",
+        "d": "1day",
+        "1w": "1week",
+        "w": "1week",
+        "1mo": "1month",
+    }
+    return mapping.get(interval.lower(), interval)
+
+
+def _period_to_outputsize(period: str, interval: str) -> int:
+    normalized = period.lower()
+    interval_normalized = interval.lower()
+    if normalized.endswith("mo"):
+        days = 30 * int(normalized[:-2] or 6)
+    elif normalized.endswith("y"):
+        days = 365 * int(normalized[:-1] or 1)
+    elif normalized.endswith("d"):
+        days = int(normalized[:-1] or 180)
+    else:
+        days = 180
+    if interval_normalized in {"1m", "5m", "15m", "30m", "1h", "4h"}:
+        return min(5000, max(120, days * 24))
+    return min(5000, max(30, days))