bitsentry 0.1.0__py3-none-any.whl

bitsentry/reporter.py

@@ -0,0 +1,227 @@
+from __future__ import annotations
+
+import os
+from datetime import datetime, timedelta, timezone
+from typing import TYPE_CHECKING
+
+try:
+    import requests as _requests
+    _HAS_REQUESTS = True
+except ImportError:
+    _HAS_REQUESTS = False
+
+if TYPE_CHECKING:
+    from bitsentry.audit_engine import AuditEngine
+    from bitsentry.position_monitor import PositionMonitor
+    from bitsentry.strategy_evaluator import StrategyEvaluator
+
+_VERSION = "0.1.0"
+
+
+def _now_utc() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def _date_str(dt: datetime) -> str:
+    return dt.strftime("%Y-%m-%d")
+
+
+class ReportGenerator:
+    """
+    Generates daily/weekly/monthly plain-text reports and optionally
+    sends them to a Telegram chat.
+    """
+
+    def __init__(
+        self,
+        audit_engine: "AuditEngine",
+        strategy_evaluator: "StrategyEvaluator",
+        position_monitor: "PositionMonitor | None" = None,
+        telegram_token: str | None = None,
+        telegram_chat_id: str | None = None,
+    ):
+        self._audit     = audit_engine
+        self._evaluator = strategy_evaluator
+        self._monitor   = position_monitor
+
+        self._token   = telegram_token   or os.environ.get("TELEGRAM_BOT_TOKEN", "")
+        self._chat_id = telegram_chat_id or os.environ.get("TELEGRAM_CHAT_ID", "")
+
+    # ── Internal data helpers ─────────────────────────────────────────────────
+
+    def _audit_data(self) -> dict:
+        return self._audit.generate_audit_report()
+
+    def _position_data(self) -> dict:
+        if not self._monitor:
+            return {
+                "total_positions": 0,
+                "green_count": 0,
+                "yellow_count": 0,
+                "red_count": 0,
+                "overall_safety": "UNKNOWN",
+                "total_unrealized_pnl": 0.0,
+            }
+        return self._monitor.get_account_summary()
+
+    def _strategy_data(self) -> list[dict]:
+        return self._evaluator.get_leaderboard()
+
+    # ── Section builders ──────────────────────────────────────────────────────
+
+    def _section_risk(self, report: dict) -> str:
+        total    = report["total_trade_intents"]
+        approved = round(total * report["approval_rate"] / 100) if total else 0
+        blocked  = total - approved
+
+        lines = [
+            "📋 *RISK ACTIVITY*",
+            f"  Total trade intents : {total}",
+            f"  Approved            : {approved}",
+            f"  Blocked             : {blocked}",
+        ]
+        if blocked and total:
+            lines.append(f"  Approval rate       : {report['approval_rate']}%")
+        return "\n".join(lines)
+
+    def _section_positions(self, pos: dict) -> str:
+        pnl = pos["total_unrealized_pnl"]
+        pnl_str = ("+$" if pnl >= 0 else "-$") + f"{abs(pnl):.2f}"
+        safety_icon = {"GREEN": "🟢", "YELLOW": "🟡", "RED": "🔴"}.get(
+            pos["overall_safety"], "⚪"
+        )
+
+        return "\n".join([
+            "📍 *POSITION SAFETY*",
+            f"  Overall safety : {safety_icon} {pos['overall_safety']}",
+            f"  Positions      : 🟢 {pos['green_count']}  🟡 {pos['yellow_count']}  🔴 {pos['red_count']}",
+            f"  Unrealized PnL : {pnl_str} USDT",
+        ])
+
+    def _section_strategies(self, strategies: list[dict]) -> str:
+        if not strategies:
+            return "📈 *STRATEGY PERFORMANCE*\n  No strategies recorded yet."
+
+        verdict_icon = {
+            "PERFORMING":        "✅",
+            "DEGRADING":         "⚠️",
+            "DEAD":              "💀",
+            "INSUFFICIENT_DATA": "❓",
+        }
+
+        lines = ["📈 *STRATEGY PERFORMANCE*"]
+        best = strategies[0]
+        dead_or_degrading = [s for s in strategies if s["verdict"] in ("DEAD", "DEGRADING")]
+
+        for s in strategies:
+            icon = verdict_icon.get(s["verdict"], "❓")
+            lines.append(
+                f"  {icon} `{s['strategy_tag']}`  "
+                f"WR30d {s['win_rate_30d']:.0%}  "
+                f"PF {s['profit_factor']:.2f}  "
+                f"PnL ${s['total_pnl_usdt']:.2f}"
+            )
+
+        lines.append(f"  🏆 Best: `{best['strategy_tag']}` (PF {best['profit_factor']:.2f})")
+
+        for s in dead_or_degrading:
+            icon = verdict_icon[s["verdict"]]
+            lines.append(f"  {icon} WARNING: `{s['strategy_tag']}` is {s['verdict']}")
+
+        return "\n".join(lines)
+
+    def _section_audit(self, report: dict) -> str:
+        h = report["integrity_hash"]
+        short_hash = h[:16] + "..." if h else "—"
+        verified = self._audit.verify_integrity(h) if h else False
+        integrity_str = "✅ Verified" if verified else "❌ Tampered"
+
+        return "\n".join([
+            "🔒 *AUDIT INTEGRITY*",
+            f"  SHA-256 : `{short_hash}`",
+            f"  Status  : {integrity_str}",
+            f"  Checks  : {report['total_risk_checks']} risk checks logged",
+        ])
+
+    def _build_report(self, period_label: str, date_range: str) -> str:
+        # strategies first — evaluate() writes checkpoints to the DB
+        # audit hash must be taken AFTER those writes to stay consistent
+        strategies = self._strategy_data()
+        pos        = self._position_data()
+        report     = self._audit_data()
+
+        divider = "─" * 36
+
+        return "\n".join([
+            f"📊 *BitSentry {period_label} Report — {date_range}*",
+            divider,
+            self._section_risk(report),
+            divider,
+            self._section_positions(pos),
+            divider,
+            self._section_strategies(strategies),
+            divider,
+            self._section_audit(report),
+            divider,
+            f"_Generated by BitSentry v{_VERSION}_",
+        ])
+
+    # ── Public report methods ─────────────────────────────────────────────────
+
+    def generate_daily_report(self) -> str:
+        today = _date_str(_now_utc())
+        return self._build_report("Daily", today)
+
+    def generate_weekly_report(self) -> str:
+        end   = _now_utc()
+        start = end - timedelta(days=7)
+        span  = f"{_date_str(start)} → {_date_str(end)}"
+        return self._build_report("Weekly", span)
+
+    def generate_monthly_report(self) -> str:
+        end   = _now_utc()
+        start = end - timedelta(days=30)
+        span  = f"{_date_str(start)} → {_date_str(end)}"
+        return self._build_report("Monthly", span)
+
+    # ── Telegram ──────────────────────────────────────────────────────────────
+
+    def send_telegram(self, message: str) -> bool:
+        if not self._token or not self._chat_id:
+            print("[bitsentry] No Telegram token configured — printing report to console:\n")
+            print(message)
+            return False
+
+        if not _HAS_REQUESTS:
+            print("[bitsentry] 'requests' not installed — cannot send Telegram message.")
+            return False
+
+        url = f"https://api.telegram.org/bot{self._token}/sendMessage"
+        try:
+            resp = _requests.post(
+                url,
+                json={
+                    "chat_id":    self._chat_id,
+                    "text":       message,
+                    "parse_mode": "Markdown",
+                },
+                timeout=10,
+            )
+            if resp.status_code == 200:
+                print(f"[bitsentry] Telegram report sent (chat_id={self._chat_id})")
+                return True
+            else:
+                print(f"[bitsentry] Telegram send failed: {resp.status_code} {resp.text[:200]}")
+                return False
+        except Exception as exc:
+            print(f"[bitsentry] Telegram send error: {exc}")
+            return False
+
+    def send_daily_report(self) -> bool:
+        return self.send_telegram(self.generate_daily_report())
+
+    def send_weekly_report(self) -> bool:
+        return self.send_telegram(self.generate_weekly_report())
+
+    def send_monthly_report(self) -> bool:
+        return self.send_telegram(self.generate_monthly_report())

bitsentry/risk_guardian.py

@@ -0,0 +1,256 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import yaml
+
+if TYPE_CHECKING:
+    from bitsentry.audit_engine import AuditEngine
+
+
+@dataclass
+class RiskCheckResult:
+    approved: bool
+    blocking_layer: str | None
+    reason: str
+    warnings: list[str] = field(default_factory=list)
+    risk_score: int = 0
+
+
+class RiskGuardian:
+    """
+    5-layer pre-trade risk middleware.
+
+    Layers run in order and stop at the first blocking failure.
+    A non-blocking warning is added for consecutive loss throttle.
+    """
+
+    def __init__(
+        self,
+        config_path: str = "config/risk_rules.yaml",
+        audit_engine: "AuditEngine | None" = None,
+    ):
+        self._rules = self._load_rules(config_path)
+        self._audit = audit_engine
+        self._config_path = config_path
+        print(
+            f"[bitsentry] RiskGuardian loaded rules from {config_path}: "
+            f"leverage_cap={self._rules['leverage_cap']}, "
+            f"max_position_size_pct={self._rules['max_position_size_pct']}%, "
+            f"daily_loss_limit_pct={self._rules['daily_loss_limit_pct']}%, "
+            f"consecutive_loss_limit={self._rules['consecutive_loss_limit']}, "
+            f"allowed_symbols={self._rules['allowed_symbols']}"
+        )
+
+    # ── Config loading ───────────────────────────────────────────────────────
+
+    @staticmethod
+    def _load_rules(config_path: str) -> dict[str, Any]:
+        path = Path(config_path)
+        if not path.exists():
+            raise FileNotFoundError(
+                f"Risk rules config not found: {config_path}. "
+                "Expected YAML with a top-level 'risk_rules' key."
+            )
+        with path.open() as fh:
+            raw = yaml.safe_load(fh)
+        rules = raw.get("risk_rules", {})
+        required = {
+            "leverage_cap", "max_position_size_pct",
+            "daily_loss_limit_pct", "consecutive_loss_limit",
+            "allowed_symbols",
+        }
+        missing = required - rules.keys()
+        if missing:
+            raise ValueError(f"risk_rules.yaml is missing keys: {missing}")
+        rules.setdefault("blocked_symbols", [])
+        return rules
+
+    # ── Risk score ───────────────────────────────────────────────────────────
+
+    @staticmethod
+    def _compute_risk_score(
+        leverage: float,
+        size_usdt: float,
+        account_balance_usdt: float,
+        daily_pnl_usdt: float,
+        consecutive_losses: int,
+    ) -> int:
+        score = 0
+        if leverage > 5:
+            score += 20
+        if leverage > 10:
+            score += 20
+        if account_balance_usdt > 0 and (size_usdt / account_balance_usdt) > 0.03:
+            score += 20
+        if daily_pnl_usdt < 0:
+            score += 20
+        if consecutive_losses >= 2:
+            score += 20
+        return min(score, 100)
+
+    # ── 5 Layers ─────────────────────────────────────────────────────────────
+
+    def _layer1_symbol_check(self, symbol: str) -> str | None:
+        """Returns a block reason string, or None if the symbol passes."""
+        if symbol in self._rules["blocked_symbols"]:
+            return f"{symbol} is on the blocked symbols list"
+        if symbol not in self._rules["allowed_symbols"]:
+            return (
+                f"{symbol} is not in the allowed symbols list "
+                f"({self._rules['allowed_symbols']})"
+            )
+        return None
+
+    def _layer2_leverage_cap(self, leverage: float) -> str | None:
+        cap = self._rules["leverage_cap"]
+        if leverage > cap:
+            return f"Leverage {leverage}x exceeds cap of {cap}x"
+        return None
+
+    def _layer3_position_size(
+        self, size_usdt: float, account_balance_usdt: float
+    ) -> str | None:
+        pct = self._rules["max_position_size_pct"]
+        max_size = account_balance_usdt * pct / 100
+        if size_usdt > max_size:
+            return (
+                f"Position size ${size_usdt:.2f} exceeds "
+                f"{pct}% of account (${max_size:.2f})"
+            )
+        return None
+
+    def _layer4_daily_loss_circuit(
+        self, daily_pnl_usdt: float, account_balance_usdt: float
+    ) -> str | None:
+        pct = self._rules["daily_loss_limit_pct"]
+        limit = -(account_balance_usdt * pct / 100)
+        if daily_pnl_usdt < limit:
+            return (
+                f"Daily PnL ${daily_pnl_usdt:.2f} breaches "
+                f"{pct}% daily loss limit (${limit:.2f})"
+            )
+        return None
+
+    def _layer5_consecutive_loss_throttle(
+        self, consecutive_losses: int
+    ) -> str | None:
+        """Returns a warning string if throttle applies, else None."""
+        limit = self._rules["consecutive_loss_limit"]
+        if consecutive_losses >= limit:
+            return (
+                f"{consecutive_losses} consecutive losses (≥ limit of {limit}): "
+                "recommended size reduced 50%"
+            )
+        return None
+
+    # ── Public API ───────────────────────────────────────────────────────────
+
+    def check(
+        self,
+        symbol: str,
+        side: str,
+        size_usdt: float,
+        leverage: float,
+        account_balance_usdt: float,
+        daily_pnl_usdt: float,
+        consecutive_losses: int,
+    ) -> RiskCheckResult:
+        """
+        Run all 5 layers in order.  Returns a RiskCheckResult.
+        Layers 1-4 are hard blocks; layer 5 is a warning only.
+        """
+        risk_score = self._compute_risk_score(
+            leverage, size_usdt, account_balance_usdt,
+            daily_pnl_usdt, consecutive_losses,
+        )
+        warnings: list[str] = []
+
+        layers = [
+            ("symbol_check",          lambda: self._layer1_symbol_check(symbol)),
+            ("leverage_cap",          lambda: self._layer2_leverage_cap(leverage)),
+            ("position_size",         lambda: self._layer3_position_size(size_usdt, account_balance_usdt)),
+            ("daily_loss_circuit",    lambda: self._layer4_daily_loss_circuit(daily_pnl_usdt, account_balance_usdt)),
+        ]
+
+        for layer_name, check_fn in layers:
+            block_reason = check_fn()
+            passed = block_reason is None
+
+            if self._audit:
+                self._audit.log_risk_check(
+                    symbol=symbol,
+                    layer_name=layer_name,
+                    passed=passed,
+                    reason=block_reason or "passed",
+                    value_checked=self._layer_value(
+                        layer_name, leverage, size_usdt,
+                        account_balance_usdt, daily_pnl_usdt,
+                    ),
+                    threshold=self._layer_threshold(layer_name, account_balance_usdt),
+                )
+
+            if not passed:
+                return RiskCheckResult(
+                    approved=False,
+                    blocking_layer=layer_name,
+                    reason=block_reason,
+                    warnings=warnings,
+                    risk_score=risk_score,
+                )
+
+        # Layer 5 — non-blocking throttle warning
+        throttle_warn = self._layer5_consecutive_loss_throttle(consecutive_losses)
+        if throttle_warn:
+            warnings.append(throttle_warn)
+            if self._audit:
+                self._audit.log_risk_check(
+                    symbol=symbol,
+                    layer_name="consecutive_loss_throttle",
+                    passed=True,
+                    reason=throttle_warn,
+                    value_checked=float(consecutive_losses),
+                    threshold=float(self._rules["consecutive_loss_limit"]),
+                )
+
+        return RiskCheckResult(
+            approved=True,
+            blocking_layer=None,
+            reason="All risk layers passed",
+            warnings=warnings,
+            risk_score=risk_score,
+        )
+
+    def get_summary(self) -> dict:
+        return {
+            "config_path": self._config_path,
+            "rules": dict(self._rules),
+        }
+
+    # ── Helpers for audit logging ────────────────────────────────────────────
+
+    def _layer_value(
+        self,
+        layer_name: str,
+        leverage: float,
+        size_usdt: float,
+        account_balance_usdt: float,
+        daily_pnl_usdt: float,
+    ) -> float | None:
+        return {
+            "leverage_cap":       leverage,
+            "position_size":      size_usdt,
+            "daily_loss_circuit": daily_pnl_usdt,
+        }.get(layer_name)
+
+    def _layer_threshold(
+        self, layer_name: str, account_balance_usdt: float
+    ) -> float | None:
+        r = self._rules
+        return {
+            "leverage_cap":    float(r["leverage_cap"]),
+            "position_size":   account_balance_usdt * r["max_position_size_pct"] / 100,
+            "daily_loss_circuit": -(account_balance_usdt * r["daily_loss_limit_pct"] / 100),
+        }.get(layer_name)

bitsentry/scheduler.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import threading
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from bitsentry.reporter import ReportGenerator
+
+
+class Scheduler:
+    """
+    Background thread that fires report sends at fixed UTC times.
+
+    Schedule:
+      Daily   — 23:00 UTC every day
+      Weekly  — 23:30 UTC every Sunday
+      Monthly — 23:45 UTC on the 1st of each month
+    """
+
+    def __init__(self, reporter: "ReportGenerator", tick_seconds: int = 60):
+        self._reporter = reporter
+        self._tick     = tick_seconds
+        self._stop_evt = threading.Event()
+        self._thread: threading.Thread | None = None
+        self._last_fired: dict[str, str] = {}
+
+    def _utc_key(self) -> tuple[int, int, int, int]:
+        now = datetime.now(timezone.utc)
+        return now.year, now.month, now.day, now.hour, now.minute  # type: ignore[return-value]
+
+    def _should_fire(self, key: str, dt: datetime) -> bool:
+        tag = f"{key}-{dt.year}-{dt.month}-{dt.day}-{dt.hour}-{dt.minute}"
+        if self._last_fired.get(key) == tag:
+            return False
+        self._last_fired[key] = tag
+        return True
+
+    def _tick_loop(self) -> None:
+        while not self._stop_evt.wait(self._tick):
+            now = datetime.now(timezone.utc)
+            h, m, wd, dom = now.hour, now.minute, now.weekday(), now.day
+
+            # Daily at 23:00
+            if h == 23 and m == 0 and self._should_fire("daily", now):
+                print("[bitsentry-scheduler] Sending daily report…")
+                try:
+                    self._reporter.send_daily_report()
+                except Exception as exc:
+                    print(f"[bitsentry-scheduler] Daily report error: {exc}")
+
+            # Weekly Sunday (weekday=6) at 23:30
+            if h == 23 and m == 30 and wd == 6 and self._should_fire("weekly", now):
+                print("[bitsentry-scheduler] Sending weekly report…")
+                try:
+                    self._reporter.send_weekly_report()
+                except Exception as exc:
+                    print(f"[bitsentry-scheduler] Weekly report error: {exc}")
+
+            # Monthly on 1st at 23:45
+            if h == 23 and m == 45 and dom == 1 and self._should_fire("monthly", now):
+                print("[bitsentry-scheduler] Sending monthly report…")
+                try:
+                    self._reporter.send_monthly_report()
+                except Exception as exc:
+                    print(f"[bitsentry-scheduler] Monthly report error: {exc}")
+
+    def start(self) -> None:
+        if self._thread and self._thread.is_alive():
+            return
+        self._stop_evt.clear()
+        self._thread = threading.Thread(target=self._tick_loop, daemon=True, name="bitsentry-scheduler")
+        self._thread.start()
+        print(f"[bitsentry-scheduler] Started (tick={self._tick}s). "
+              "Daily@23:00 Weekly@Sun23:30 Monthly@1st23:45 UTC")
+
+    def stop(self) -> None:
+        self._stop_evt.set()
+        if self._thread:
+            self._thread.join(timeout=5)
+        print("[bitsentry-scheduler] Stopped.")