158 lines
5.3 KiB
Python
158 lines
5.3 KiB
Python
"""Alert evaluation and history persistence."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from dataclasses import dataclass
|
|
from decimal import Decimal
|
|
from typing import Mapping
|
|
|
|
from app.domain.portfolio_math import build_alert_context
|
|
from app.domain.units import decimal_from_float
|
|
from app.models.alerts import AlertEvent, AlertHistoryRepository, AlertStatus
|
|
from app.models.portfolio import PortfolioConfig
|
|
|
|
|
|
@dataclass(frozen=True, slots=True)
|
|
class AlertEvaluationInput:
|
|
ltv_ratio: Decimal
|
|
spot_price: Decimal
|
|
updated_at: str
|
|
warning_threshold: Decimal
|
|
critical_threshold: Decimal
|
|
email_alerts_enabled: bool
|
|
|
|
|
|
def _decimal_from_boundary_value(value: object, *, field_name: str, default: float = 0.0) -> Decimal:
|
|
if value is None:
|
|
return decimal_from_float(float(default))
|
|
if isinstance(value, bool):
|
|
raise TypeError(f"{field_name} must be numeric, got bool")
|
|
if isinstance(value, int):
|
|
parsed = float(value)
|
|
elif isinstance(value, float):
|
|
parsed = value
|
|
elif isinstance(value, str):
|
|
stripped = value.strip()
|
|
if not stripped:
|
|
parsed = float(default)
|
|
else:
|
|
try:
|
|
parsed = float(stripped)
|
|
except ValueError as exc:
|
|
raise ValueError(f"{field_name} must be numeric, got {value!r}") from exc
|
|
else:
|
|
raise TypeError(f"{field_name} must be numeric, got {type(value)!r}")
|
|
return decimal_from_float(float(parsed))
|
|
|
|
|
|
def _normalize_alert_evaluation_input(
|
|
config: PortfolioConfig,
|
|
portfolio: Mapping[str, object],
|
|
) -> AlertEvaluationInput:
|
|
return AlertEvaluationInput(
|
|
ltv_ratio=_decimal_from_boundary_value(
|
|
portfolio.get("ltv_ratio", 0.0),
|
|
field_name="portfolio.ltv_ratio",
|
|
),
|
|
spot_price=_decimal_from_boundary_value(
|
|
portfolio.get("spot_price", 0.0),
|
|
field_name="portfolio.spot_price",
|
|
),
|
|
updated_at=str(portfolio.get("quote_updated_at", "")),
|
|
warning_threshold=_decimal_from_boundary_value(
|
|
config.ltv_warning,
|
|
field_name="config.ltv_warning",
|
|
),
|
|
critical_threshold=_decimal_from_boundary_value(
|
|
config.margin_threshold,
|
|
field_name="config.margin_threshold",
|
|
),
|
|
email_alerts_enabled=bool(config.email_alerts),
|
|
)
|
|
|
|
|
|
def _ratio_text(value: Decimal) -> str:
|
|
return f"{float(value):.1%}"
|
|
|
|
|
|
def build_portfolio_alert_context(
|
|
config: PortfolioConfig,
|
|
*,
|
|
spot_price: float,
|
|
source: str,
|
|
updated_at: str,
|
|
) -> dict[str, float | str]:
|
|
return build_alert_context(
|
|
config,
|
|
spot_price=spot_price,
|
|
source=source,
|
|
updated_at=updated_at,
|
|
)
|
|
|
|
|
|
class AlertService:
|
|
def __init__(self, history_path=None) -> None:
|
|
self.repository = AlertHistoryRepository(history_path=history_path)
|
|
|
|
def evaluate(
|
|
self, config: PortfolioConfig, portfolio: Mapping[str, object], *, persist: bool = True
|
|
) -> AlertStatus:
|
|
history = self.repository.load() if persist else []
|
|
evaluation = _normalize_alert_evaluation_input(config, portfolio)
|
|
|
|
if evaluation.ltv_ratio >= evaluation.critical_threshold:
|
|
severity = "critical"
|
|
message = (
|
|
f"Current LTV {_ratio_text(evaluation.ltv_ratio)} is above the critical threshold of "
|
|
f"{_ratio_text(evaluation.critical_threshold)}."
|
|
)
|
|
elif evaluation.ltv_ratio >= evaluation.warning_threshold:
|
|
severity = "warning"
|
|
message = (
|
|
f"Current LTV {_ratio_text(evaluation.ltv_ratio)} is above the warning threshold of "
|
|
f"{_ratio_text(evaluation.warning_threshold)}."
|
|
)
|
|
else:
|
|
severity = "ok"
|
|
message = "LTV is within configured thresholds."
|
|
|
|
preview_history: list[AlertEvent] = []
|
|
if severity != "ok":
|
|
event = AlertEvent(
|
|
severity=severity,
|
|
message=message,
|
|
ltv_ratio=float(evaluation.ltv_ratio),
|
|
warning_threshold=float(evaluation.warning_threshold),
|
|
critical_threshold=float(evaluation.critical_threshold),
|
|
spot_price=float(evaluation.spot_price),
|
|
updated_at=evaluation.updated_at,
|
|
email_alerts_enabled=evaluation.email_alerts_enabled,
|
|
)
|
|
if persist:
|
|
if self._should_record(history, event):
|
|
history.append(event)
|
|
self.repository.save(history)
|
|
else:
|
|
preview_history = [event]
|
|
|
|
return AlertStatus(
|
|
severity=severity,
|
|
message=message,
|
|
ltv_ratio=float(evaluation.ltv_ratio),
|
|
warning_threshold=float(evaluation.warning_threshold),
|
|
critical_threshold=float(evaluation.critical_threshold),
|
|
email_alerts_enabled=evaluation.email_alerts_enabled,
|
|
history=(
|
|
preview_history
|
|
if not persist
|
|
else list(reversed(self.repository.load() if severity != "ok" else history))
|
|
),
|
|
)
|
|
|
|
@staticmethod
|
|
def _should_record(history: list[AlertEvent], event: AlertEvent) -> bool:
|
|
if not history:
|
|
return True
|
|
latest = history[-1]
|
|
return latest.severity != event.severity
|