@drico2008/fincli 0.1.9 → 0.3.0

package/fincli/app/modules/transactions.py

@@ -1,84 +1,84 @@
-"""Portfolio transaction ledger."""
-
-from __future__ import annotations
-
-from fincli.app.modules.portfolio import PortfolioService
-from fincli.app.storage.database import FinCLIDatabase
-from fincli.app.utils.errors import CommandError
-from fincli.app.utils.formatting import normalize_symbol
-
-
-class TransactionService:
-    def __init__(self, db: FinCLIDatabase, portfolio: PortfolioService) -> None:
-        self.db = db
-        self.portfolio = portfolio
-
-    def add(self, action: str, symbol: str, quantity: float, price: float, currency: str = "USD") -> dict[str, object]:
-        normalized_action = action.lower()
-        normalized_symbol = normalize_symbol(symbol)
-        if normalized_action not in {"buy", "sell"}:
-            raise CommandError("Action transaksi harus buy atau sell.")
-        if quantity <= 0 or price <= 0:
-            raise CommandError("Quantity dan price harus lebih besar dari 0.")
-
-        current = self._position(normalized_symbol)
-        realized_pnl = 0.0
-
-        if normalized_action == "buy":
-            old_qty = float(current["quantity"]) if current else 0.0
-            old_avg = float(current["average_price"]) if current else 0.0
-            new_qty = old_qty + quantity
-            new_avg = ((old_qty * old_avg) + (quantity * price)) / new_qty
-            self.portfolio.add(normalized_symbol, new_qty, new_avg, currency)
-        else:
-            if current is None:
-                raise CommandError(f"Tidak ada posisi {normalized_symbol} untuk dijual.")
-            old_qty = float(current["quantity"])
-            old_avg = float(current["average_price"])
-            if quantity > old_qty:
-                raise CommandError(f"Quantity sell melebihi posisi {normalized_symbol}.")
-            realized_pnl = (price - old_avg) * quantity
-            remaining = old_qty - quantity
-            if remaining == 0:
-                self.portfolio.remove(normalized_symbol)
-            else:
-                self.portfolio.add(normalized_symbol, remaining, old_avg, currency)
-
-        self.db.execute(
-            """
-            INSERT INTO portfolio_transactions(action, symbol, quantity, price, currency, realized_pnl)
-            VALUES (?, ?, ?, ?, ?, ?)
-            """,
-            (normalized_action, normalized_symbol, quantity, price, currency.upper(), realized_pnl),
-        )
-        return {
-            "action": normalized_action,
-            "symbol": normalized_symbol,
-            "quantity": quantity,
-            "price": price,
-            "currency": currency.upper(),
-            "realized_pnl": realized_pnl,
-        }
-
-    def list(self, limit: int = 50) -> list[dict[str, object]]:
-        rows = self.db.query(
-            """
-            SELECT id, action, symbol, quantity, price, currency, realized_pnl, created_at
-            FROM portfolio_transactions
-            ORDER BY id DESC
-            LIMIT ?
-            """,
-            (limit,),
-        )
-        return [dict(row) for row in rows]
-
-    def realized_pnl_total(self) -> float:
-        rows = self.db.query("SELECT COALESCE(SUM(realized_pnl), 0) AS total FROM portfolio_transactions")
-        return float(rows[0]["total"]) if rows else 0.0
-
-    def _position(self, symbol: str) -> dict[str, object] | None:
-        rows = self.db.query(
-            "SELECT symbol, quantity, average_price, currency FROM portfolio_positions WHERE symbol = ?",
-            (symbol,),
-        )
-        return dict(rows[0]) if rows else None
+"""Portfolio transaction ledger."""
+
+from __future__ import annotations
+
+from fincli.app.modules.portfolio import PortfolioService
+from fincli.app.storage.database import FinCLIDatabase
+from fincli.app.utils.errors import CommandError
+from fincli.app.utils.formatting import normalize_symbol
+
+
+class TransactionService:
+    def __init__(self, db: FinCLIDatabase, portfolio: PortfolioService) -> None:
+        self.db = db
+        self.portfolio = portfolio
+
+    def add(self, action: str, symbol: str, quantity: float, price: float, currency: str = "USD") -> dict[str, object]:
+        normalized_action = action.lower()
+        normalized_symbol = normalize_symbol(symbol)
+        if normalized_action not in {"buy", "sell"}:
+            raise CommandError("Action transaksi harus buy atau sell.")
+        if quantity <= 0 or price <= 0:
+            raise CommandError("Quantity dan price harus lebih besar dari 0.")
+
+        current = self._position(normalized_symbol)
+        realized_pnl = 0.0
+
+        if normalized_action == "buy":
+            old_qty = float(current["quantity"]) if current else 0.0
+            old_avg = float(current["average_price"]) if current else 0.0
+            new_qty = old_qty + quantity
+            new_avg = ((old_qty * old_avg) + (quantity * price)) / new_qty
+            self.portfolio.add(normalized_symbol, new_qty, new_avg, currency)
+        else:
+            if current is None:
+                raise CommandError(f"Tidak ada posisi {normalized_symbol} untuk dijual.")
+            old_qty = float(current["quantity"])
+            old_avg = float(current["average_price"])
+            if quantity > old_qty:
+                raise CommandError(f"Quantity sell melebihi posisi {normalized_symbol}.")
+            realized_pnl = (price - old_avg) * quantity
+            remaining = old_qty - quantity
+            if remaining == 0:
+                self.portfolio.remove(normalized_symbol)
+            else:
+                self.portfolio.add(normalized_symbol, remaining, old_avg, currency)
+
+        self.db.execute(
+            """
+            INSERT INTO portfolio_transactions(action, symbol, quantity, price, currency, realized_pnl)
+            VALUES (?, ?, ?, ?, ?, ?)
+            """,
+            (normalized_action, normalized_symbol, quantity, price, currency.upper(), realized_pnl),
+        )
+        return {
+            "action": normalized_action,
+            "symbol": normalized_symbol,
+            "quantity": quantity,
+            "price": price,
+            "currency": currency.upper(),
+            "realized_pnl": realized_pnl,
+        }
+
+    def list(self, limit: int = 50) -> list[dict[str, object]]:
+        rows = self.db.query(
+            """
+            SELECT id, action, symbol, quantity, price, currency, realized_pnl, created_at
+            FROM portfolio_transactions
+            ORDER BY id DESC
+            LIMIT ?
+            """,
+            (limit,),
+        )
+        return [dict(row) for row in rows]
+
+    def realized_pnl_total(self) -> float:
+        rows = self.db.query("SELECT COALESCE(SUM(realized_pnl), 0) AS total FROM portfolio_transactions")
+        return float(rows[0]["total"]) if rows else 0.0
+
+    def _position(self, symbol: str) -> dict[str, object] | None:
+        rows = self.db.query(
+            "SELECT symbol, quantity, average_price, currency FROM portfolio_positions WHERE symbol = ?",
+            (symbol,),
+        )
+        return dict(rows[0]) if rows else None

package/fincli/app/modules/user_profile.py

@@ -0,0 +1,84 @@
+"""Local user profile and gameplay rules."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from fincli.app.storage.database import FinCLIDatabase
+
+
+@dataclass(frozen=True, slots=True)
+class UserProfile:
+    name: str
+    equity: float
+    currency: str
+    leverage: str
+    years_in_investment: float
+    gameplay: str
+
+
+class UserProfileService:
+    """Persist one local profile used to tailor /analyze risk context."""
+
+    def __init__(self, db: FinCLIDatabase) -> None:
+        self.db = db
+
+    def save(self, name: str, equity: float, currency: str, leverage: str, years: float) -> UserProfile:
+        profile = UserProfile(
+            name=name.strip(),
+            equity=float(equity),
+            currency=currency.strip().upper(),
+            leverage=leverage.strip(),
+            years_in_investment=float(years),
+            gameplay=classify_gameplay(float(equity)),
+        )
+        self.db.execute(
+            """
+            INSERT INTO user_profile (id, name, equity, currency, leverage, years_in_investment, gameplay, updated_at)
+            VALUES (1, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+            ON CONFLICT(id) DO UPDATE SET
+                name=excluded.name,
+                equity=excluded.equity,
+                currency=excluded.currency,
+                leverage=excluded.leverage,
+                years_in_investment=excluded.years_in_investment,
+                gameplay=excluded.gameplay,
+                updated_at=CURRENT_TIMESTAMP
+            """,
+            (
+                profile.name,
+                profile.equity,
+                profile.currency,
+                profile.leverage,
+                profile.years_in_investment,
+                profile.gameplay,
+            ),
+        )
+        return profile
+
+    def get(self) -> UserProfile | None:
+        rows = self.db.query("SELECT * FROM user_profile WHERE id = 1")
+        if not rows:
+            return None
+        row = rows[0]
+        return UserProfile(
+            name=str(row["name"]),
+            equity=float(row["equity"]),
+            currency=str(row["currency"]),
+            leverage=str(row["leverage"]),
+            years_in_investment=float(row["years_in_investment"]),
+            gameplay=str(row["gameplay"]),
+        )
+
+    def clear(self) -> None:
+        self.db.execute("DELETE FROM user_profile WHERE id = 1")
+
+
+def classify_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/plugins/loader.py

@@ -0,0 +1,72 @@
+"""Local plugin discovery for FinCLI.
+
+Plugins are intentionally manifest-first in v0.3.0: FinCLI reads metadata and
+exposes status, but does not execute plugin code yet. This keeps the plugin
+surface useful without creating a security footgun.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Iterable
+
+from fincli.app.storage import config_paths
+
+
+@dataclass(frozen=True, slots=True)
+class PluginManifest:
+    name: str
+    version: str
+    description: str
+    commands: tuple[str, ...]
+    capabilities: tuple[str, ...]
+    path: Path
+    status: str = "available"
+
+
+class PluginLoader:
+    """Discover plugin manifests from local plugin directories."""
+
+    def __init__(self, search_paths: Iterable[Path] | None = None) -> None:
+        self.search_paths = tuple(search_paths) if search_paths is not None else (config_paths.APP_DIR / "plugins",)
+
+    def discover(self) -> list[PluginManifest]:
+        plugins: list[PluginManifest] = []
+        for root in self.search_paths:
+            if not root.exists():
+                continue
+            for manifest_path in sorted(root.glob("*/plugin.json")):
+                plugins.append(self._read_manifest(manifest_path))
+        return plugins
+
+    def _read_manifest(self, manifest_path: Path) -> PluginManifest:
+        try:
+            payload = json.loads(manifest_path.read_text(encoding="utf-8"))
+            name = str(payload["name"]).strip()
+            version = str(payload.get("version") or "0.0.0").strip()
+            description = str(payload.get("description") or "").strip()
+            commands = tuple(str(item) for item in payload.get("commands", []) if str(item).strip())
+            capabilities = tuple(str(item) for item in payload.get("capabilities", []) if str(item).strip())
+            if not name:
+                raise ValueError("name is empty")
+            return PluginManifest(
+                name=name,
+                version=version,
+                description=description,
+                commands=commands,
+                capabilities=capabilities,
+                path=manifest_path,
+                status="available",
+            )
+        except Exception as exc:  # noqa: BLE001
+            return PluginManifest(
+                name=manifest_path.parent.name,
+                version="unknown",
+                description=f"Invalid plugin manifest: {exc}",
+                commands=(),
+                capabilities=(),
+                path=manifest_path,
+                status="invalid",
+            )

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

@@ -1,60 +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}")
+"""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/market/alphavantage_provider.py

@@ -0,0 +1,194 @@
+"""Alpha Vantage market provider adapter."""
+
+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_provider_symbol
+from fincli.app.utils.errors import ProviderError, RateLimitError
+
+
+class AlphaVantageProvider:
+    name = "alphavantage"
+
+    def __init__(
+        self,
+        api_key: str | None,
+        base_url: str = "https://www.alphavantage.co/query",
+        client: httpx.AsyncClient | None = None,
+    ) -> None:
+        self.api_key = api_key or ""
+        self.base_url = base_url
+        self._client = client
+
+    async def quote(self, symbol: str) -> Quote:
+        resolved = resolve_provider_symbol(self.name, symbol)
+        if resolved.asset_class == "forex":
+            data = await self._get(
+                {
+                    "function": "CURRENCY_EXCHANGE_RATE",
+                    "from_currency": resolved.symbol[:3],
+                    "to_currency": resolved.symbol[3:],
+                }
+            )
+            rate = data.get("Realtime Currency Exchange Rate", {})
+            price = _safe_float(rate.get("5. Exchange Rate"))
+            if price is None:
+                raise ProviderError(f"Alpha Vantage tidak mengembalikan FX quote valid untuk {symbol}.")
+            return Quote(
+                symbol=resolved.symbol,
+                price=price,
+                currency=resolved.symbol[3:],
+                provider=self.name,
+                timestamp=_parse_datetime(rate.get("6. Last Refreshed")) or datetime.now(),
+                status="plan-dependent",
+            )
+
+        data = await self._get({"function": "GLOBAL_QUOTE", "symbol": resolved.symbol})
+        quote = data.get("Global Quote", {})
+        price = _safe_float(quote.get("05. price"))
+        if price is None:
+            raise ProviderError(f"Alpha Vantage tidak mengembalikan quote valid untuk {symbol}.")
+        return Quote(
+            symbol=str(quote.get("01. symbol") or resolved.symbol).upper(),
+            price=price,
+            currency="USD",
+            provider=self.name,
+            timestamp=_parse_datetime(quote.get("07. latest trading day")) or datetime.now(),
+            status="plan-dependent",
+        )
+
+    async def history(self, symbol: str, period: str = "6mo", interval: str = "1d") -> list[Candle]:
+        resolved = resolve_provider_symbol(self.name, symbol)
+        if resolved.asset_class == "forex":
+            data = await self._get(
+                {
+                    "function": "FX_DAILY",
+                    "from_symbol": resolved.symbol[:3],
+                    "to_symbol": resolved.symbol[3:],
+                    "outputsize": "compact",
+                }
+            )
+            series = data.get("Time Series FX (Daily)", {})
+        else:
+            data = await self._get(
+                {
+                    "function": "TIME_SERIES_DAILY_ADJUSTED",
+                    "symbol": resolved.symbol,
+                    "outputsize": "compact",
+                }
+            )
+            series = data.get("Time Series (Daily)", {})
+
+        if not isinstance(series, dict) or not series:
+            raise ProviderError(f"Alpha Vantage OHLCV kosong untuk {symbol}.")
+        candles = [_parse_daily_candle(day, payload) for day, payload in series.items() if isinstance(payload, dict)]
+        candles.sort(key=lambda candle: candle.timestamp)
+        return candles
+
+    async def news(self, symbol: str, limit: int = 5) -> list[NewsItem]:
+        resolved = resolve_provider_symbol(self.name, symbol)
+        data = await self._get({"function": "NEWS_SENTIMENT", "tickers": resolved.symbol, "limit": limit})
+        feed = data.get("feed", [])
+        if not isinstance(feed, list):
+            return []
+        return [
+            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("time_published")),
+                summary=str(item.get("summary") or ""),
+            )
+            for item in feed[:limit]
+            if isinstance(item, dict)
+        ]
+
+    async def fundamentals(self, symbol: str) -> FundamentalSnapshot:
+        resolved = resolve_provider_symbol(self.name, symbol)
+        data = await self._get({"function": "OVERVIEW", "symbol": resolved.symbol})
+        return FundamentalSnapshot(
+            symbol=str(data.get("Symbol") or resolved.symbol).upper(),
+            provider=self.name,
+            currency=str(data.get("Currency") or "USD"),
+            market_cap=_safe_float(data.get("MarketCapitalization")),
+            pe_ratio=_safe_float(data.get("PERatio")),
+            eps=_safe_float(data.get("EPS")),
+            revenue=_safe_float(data.get("RevenueTTM")),
+            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 = "Alpha Vantage provider configured." if self.api_key else "Requires ALPHA_VANTAGE_API_KEY."
+        return ProviderStatus(name=self.name, realtime=False, status=status, message=message)
+
+    async def _get(self, params: dict[str, object]) -> dict[str, Any]:
+        if not self.api_key:
+            raise ProviderError("API key Alpha Vantage belum diatur.", "Gunakan /news_model key alphavantage <api_key>.")
+        close_client = self._client is None
+        client = self._client or httpx.AsyncClient(timeout=30)
+        try:
+            response = await client.get(self.base_url, params={**params, "apikey": self.api_key})
+            if response.status_code == 429:
+                raise RateLimitError("Alpha Vantage terkena rate limit.")
+            response.raise_for_status()
+            data = response.json()
+            if not isinstance(data, dict):
+                raise ProviderError("Response Alpha Vantage bukan JSON object.")
+            message = data.get("Note") or data.get("Information")
+            if message:
+                raise RateLimitError(f"Alpha Vantage membatasi request: {message}")
+            if "Error Message" in data:
+                raise ProviderError(f"Alpha Vantage gagal: {data['Error Message']}")
+            return data
+        except httpx.TimeoutException as exc:
+            raise ProviderError("Alpha Vantage timeout.") from exc
+        except httpx.HTTPStatusError as exc:
+            raise ProviderError(f"Alpha Vantage gagal: HTTP {exc.response.status_code}.") from exc
+        except ValueError as exc:
+            raise ProviderError("Response Alpha Vantage bukan JSON valid.") from exc
+        finally:
+            if close_client:
+                await client.aclose()
+
+
+def _parse_daily_candle(day: str, payload: dict[str, Any]) -> Candle:
+    return Candle(
+        timestamp=_parse_datetime(day) or datetime.now(),
+        open=float(payload.get("1. open")),
+        high=float(payload.get("2. high")),
+        low=float(payload.get("3. low")),
+        close=float(payload.get("4. close")),
+        volume=float(payload.get("6. volume") or payload.get("5. volume") or 0),
+    )
+
+
+def _safe_float(value: Any) -> float | None:
+    try:
+        if value in {None, "None", "-", ""}:
+            return None
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _parse_datetime(value: Any) -> datetime | None:
+    if not value:
+        return None
+    text = str(value)
+    for fmt in ("%Y%m%dT%H%M%S", "%Y-%m-%d %H:%M:%S", "%Y-%m-%d"):
+        try:
+            return datetime.strptime(text, fmt)
+        except ValueError:
+            continue
+    try:
+        return datetime.fromisoformat(text.replace("Z", "+00:00"))
+    except ValueError:
+        return None