bitsentry 0.1.0__py3-none-any.whl

bitsentry/strategy_evaluator.py

@@ -0,0 +1,269 @@
+from __future__ import annotations
+
+import sqlite3
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from bitsentry.audit_engine import AuditEngine
+
+
+@dataclass
+class StrategyHealth:
+    strategy_tag: str
+    total_trades: int
+    win_rate_7d: float
+    win_rate_30d: float
+    total_pnl_usdt: float
+    avg_win_usdt: float
+    avg_loss_usdt: float
+    profit_factor: float
+    best_market_condition: str
+    worst_market_condition: str
+    verdict: str
+    recommendation: str
+
+
+_VERDICTS = {
+    "PERFORMING":         "Strategy is performing well. Continue running with current parameters.",
+    "DEGRADING":          "Win rate is declining. Consider reducing position size by 50% and reviewing entry signals.",
+    "DEAD":               "Strategy win rate is critically low. STOP trading this strategy immediately and backtest from scratch.",
+    "INSUFFICIENT_DATA":  "Not enough trades to evaluate. Need at least 3 trades for a meaningful verdict.",
+}
+
+
+class StrategyEvaluator:
+    """
+    Tracks per-strategy trade results and produces health verdicts.
+
+    Data is stored in a `trade_results` table co-located in the
+    AuditEngine's SQLite database so everything stays in one file.
+    """
+
+    def __init__(self, audit_engine: "AuditEngine"):
+        self._audit = audit_engine
+        self._db_path = audit_engine.db_path
+        self._ensure_table()
+
+    # ── Schema ───────────────────────────────────────────────────────────────
+
+    def _ensure_table(self) -> None:
+        with self._conn() as conn:
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS trade_results (
+                    id               INTEGER PRIMARY KEY AUTOINCREMENT,
+                    timestamp        TEXT NOT NULL,
+                    strategy_tag     TEXT NOT NULL,
+                    symbol           TEXT NOT NULL,
+                    side             TEXT NOT NULL,
+                    entry_price      REAL NOT NULL,
+                    exit_price       REAL NOT NULL,
+                    size_usdt        REAL NOT NULL,
+                    pnl_usdt         REAL NOT NULL,
+                    pnl_pct          REAL NOT NULL,
+                    outcome          TEXT NOT NULL,
+                    market_condition TEXT NOT NULL DEFAULT ''
+                )
+            """)
+
+    def _conn(self) -> sqlite3.Connection:
+        conn = sqlite3.connect(self._db_path)
+        conn.row_factory = sqlite3.Row
+        return conn
+
+    @staticmethod
+    def _now() -> str:
+        return datetime.now(timezone.utc).isoformat()
+
+    # ── PnL helpers ──────────────────────────────────────────────────────────
+
+    @staticmethod
+    def _calc_pnl(
+        side: str, entry_price: float, exit_price: float, size_usdt: float
+    ) -> tuple[float, float]:
+        """Return (pnl_usdt, pnl_pct) for a closed trade."""
+        if entry_price <= 0:
+            return 0.0, 0.0
+        if side.lower() in ("buy", "long"):
+            pnl_pct = (exit_price - entry_price) / entry_price
+        else:
+            pnl_pct = (entry_price - exit_price) / entry_price
+        pnl_usdt = pnl_pct * size_usdt
+        return round(pnl_usdt, 6), round(pnl_pct, 8)
+
+    # ── Write ────────────────────────────────────────────────────────────────
+
+    def record_trade_result(
+        self,
+        strategy_tag: str,
+        symbol: str,
+        side: str,
+        entry_price: float,
+        exit_price: float,
+        size_usdt: float,
+        market_condition: str = "",
+    ) -> int:
+        pnl_usdt, pnl_pct = self._calc_pnl(side, entry_price, exit_price, size_usdt)
+        outcome = "WIN" if pnl_usdt > 0 else "LOSS"
+
+        with self._conn() as conn:
+            cur = conn.execute(
+                """
+                INSERT INTO trade_results
+                    (timestamp, strategy_tag, symbol, side, entry_price,
+                     exit_price, size_usdt, pnl_usdt, pnl_pct, outcome, market_condition)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    self._now(), strategy_tag, symbol, side,
+                    entry_price, exit_price, size_usdt,
+                    pnl_usdt, pnl_pct, outcome, market_condition,
+                ),
+            )
+            return cur.lastrowid
+
+    # ── Evaluation helpers ───────────────────────────────────────────────────
+
+    @staticmethod
+    def _win_rate(rows: list[dict]) -> float:
+        if not rows:
+            return 0.0
+        wins = sum(1 for r in rows if r["outcome"] == "WIN")
+        return wins / len(rows)
+
+    @staticmethod
+    def _cutoff(days: int) -> str:
+        dt = datetime.now(timezone.utc) - timedelta(days=days)
+        return dt.isoformat()
+
+    def _rows_for(self, strategy_tag: str) -> list[dict]:
+        with self._conn() as conn:
+            return [
+                dict(r) for r in conn.execute(
+                    "SELECT * FROM trade_results WHERE strategy_tag = ? ORDER BY id",
+                    (strategy_tag,),
+                )
+            ]
+
+    def _rows_since(self, strategy_tag: str, days: int) -> list[dict]:
+        cutoff = self._cutoff(days)
+        with self._conn() as conn:
+            return [
+                dict(r) for r in conn.execute(
+                    """SELECT * FROM trade_results
+                       WHERE strategy_tag = ? AND timestamp >= ?
+                       ORDER BY id""",
+                    (strategy_tag, cutoff),
+                )
+            ]
+
+    @staticmethod
+    def _best_worst_condition(rows: list[dict]) -> tuple[str, str]:
+        """Return (best_condition, worst_condition) by win rate."""
+        conditions: dict[str, list[str]] = {}
+        for r in rows:
+            cond = r.get("market_condition") or "unknown"
+            conditions.setdefault(cond, []).append(r["outcome"])
+
+        if not conditions:
+            return "unknown", "unknown"
+
+        rates = {
+            cond: outcomes.count("WIN") / len(outcomes)
+            for cond, outcomes in conditions.items()
+        }
+        best = max(rates, key=lambda k: rates[k])
+        worst = min(rates, key=lambda k: rates[k])
+        return best, worst
+
+    @staticmethod
+    def _verdict(
+        total_trades: int,
+        win_rate_7d: float,
+        win_rate_30d: float,
+        profit_factor: float,
+    ) -> str:
+        if total_trades < 3:
+            return "INSUFFICIENT_DATA"
+        if win_rate_7d < 0.35:
+            return "DEAD"
+        if win_rate_30d >= 0.55 and profit_factor >= 1.2:
+            return "PERFORMING"
+        return "DEGRADING"
+
+    # ── Public API ───────────────────────────────────────────────────────────
+
+    def evaluate(self, strategy_tag: str) -> StrategyHealth:
+        all_rows = self._rows_for(strategy_tag)
+        rows_7d = self._rows_since(strategy_tag, 7)
+        rows_30d = self._rows_since(strategy_tag, 30)
+
+        total_trades = len(all_rows)
+        win_rate_7d = self._win_rate(rows_7d)
+        win_rate_30d = self._win_rate(rows_30d)
+
+        total_pnl = sum(r["pnl_usdt"] for r in all_rows)
+
+        wins = [r["pnl_usdt"] for r in all_rows if r["outcome"] == "WIN"]
+        losses = [r["pnl_usdt"] for r in all_rows if r["outcome"] == "LOSS"]
+
+        avg_win = (sum(wins) / len(wins)) if wins else 0.0
+        avg_loss = (sum(losses) / len(losses)) if losses else 0.0
+
+        total_wins = sum(wins)
+        total_losses = abs(sum(losses))
+        profit_factor = (total_wins / total_losses) if total_losses > 0 else 0.0
+
+        best_cond, worst_cond = self._best_worst_condition(all_rows)
+
+        v = self._verdict(total_trades, win_rate_7d, win_rate_30d, profit_factor)
+
+        # Log checkpoint to AuditEngine
+        self._audit.log_strategy_checkpoint(
+            strategy_tag=strategy_tag,
+            win_rate_7d=round(win_rate_7d, 4),
+            win_rate_30d=round(win_rate_30d, 4),
+            total_trades=total_trades,
+            verdict=v,
+            market_condition=best_cond,
+        )
+
+        return StrategyHealth(
+            strategy_tag=strategy_tag,
+            total_trades=total_trades,
+            win_rate_7d=round(win_rate_7d, 4),
+            win_rate_30d=round(win_rate_30d, 4),
+            total_pnl_usdt=round(total_pnl, 4),
+            avg_win_usdt=round(avg_win, 4),
+            avg_loss_usdt=round(avg_loss, 4),
+            profit_factor=round(profit_factor, 4),
+            best_market_condition=best_cond,
+            worst_market_condition=worst_cond,
+            verdict=v,
+            recommendation=_VERDICTS[v],
+        )
+
+    def evaluate_all(self) -> list[StrategyHealth]:
+        with self._conn() as conn:
+            tags = [
+                row[0] for row in conn.execute(
+                    "SELECT DISTINCT strategy_tag FROM trade_results ORDER BY strategy_tag"
+                )
+            ]
+        return [self.evaluate(tag) for tag in tags]
+
+    def get_leaderboard(self) -> list[dict]:
+        healths = self.evaluate_all()
+        ranked = sorted(healths, key=lambda h: h.profit_factor, reverse=True)
+        return [
+            {
+                "strategy_tag":    h.strategy_tag,
+                "profit_factor":   h.profit_factor,
+                "win_rate_30d":    h.win_rate_30d,
+                "total_pnl_usdt":  h.total_pnl_usdt,
+                "total_trades":    h.total_trades,
+                "verdict":         h.verdict,
+            }
+            for h in ranked
+        ]

bitsentry-0.1.0.dist-info/METADATA

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: bitsentry
+Version: 0.1.0
+Summary: Safety, audit, and intelligence layer for Bitget trading agents and traders
+Project-URL: Homepage, https://github.com/Benita2001/BitSentry
+Project-URL: Repository, https://github.com/Benita2001/BitSentry
+Author-email: Benita Chidera <0xbeni123@gmail.com>
+License: MIT
+Keywords: agent,audit,bitget,crypto,mcp,risk-management,trading
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.10
+Requires-Dist: fastapi>=0.104.0
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: pyyaml>=6.0.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: uvicorn>=0.24.0
+Description-Content-Type: text/markdown
+
+# BitSentry
+
+Safety, audit, and intelligence layer for Bitget trading agents and traders.
+
+## Structure
+
+- `bitsentry/bgc_client.py` — Bitget API client
+- `bitsentry/audit_engine.py` — Trade audit and logging
+- `bitsentry/risk_guardian.py` — Pre-trade risk enforcement
+- `bitsentry/position_monitor.py` — Real-time position tracking
+- `bitsentry/strategy_evaluator.py` — Strategy scoring and auditing
+- `bitsentry/api/server.py` — FastAPI REST server (11 endpoints)
+- `config/risk_rules.yaml` — Configurable risk parameters
+- `run.py` — Server launcher with startup banner
+
+## Setup
+
+```bash
+make install   # pip install -e .
+make run       # start server on http://127.0.0.1:8000
+make validate  # generate audit report + HTML
+make verify    # verify SHA-256 integrity hash
+```
+
+## API Endpoints
+
+| Method | Path | Description |
+|--------|------|-------------|
+| GET | `/health` | Server health + mode |
+| GET | `/positions` | Open positions with safety ratings |
+| GET | `/positions/summary` | GREEN/YELLOW/RED counts |
+| GET | `/positions/safe-to-trade` | Pre-trade exposure check |
+| POST | `/risk/check` | 5-layer risk middleware |
+| GET | `/strategy/leaderboard` | Strategies ranked by profit factor |
+| GET | `/strategy/{tag}` | Strategy health verdict |
+| POST | `/strategy/record` | Record a trade result |
+| GET | `/audit/report` | Full audit + SHA-256 hash |
+| GET | `/audit/verify` | Verify integrity hash |
+| GET | `/docs` | Swagger UI |
+
+## Stack
+
+Python 3.10+, FastAPI, SQLite, bgc CLI, Pydantic v2

bitsentry-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+bitsentry/__init__.py,sha256=3gblFNTKgGR-pu66wAlWuMJukQYL0wYA8UFGa1OngZQ,704
+bitsentry/audit_engine.py,sha256=YQirS8aNmMl7yJZgy0U3JC_nscTGeJwJejwarxTPG-c,12757
+bitsentry/bgc_client.py,sha256=_EfCpnjAZCfhm2GZ79rtfEZ_xN8jaaTOE3p1_oC087s,5704
+bitsentry/cli.py,sha256=J1ZN2sLdTl-Jb886I2R7p1to4EfvfnyyO6dduP8f6qY,288
+bitsentry/position_monitor.py,sha256=-iGHGX4skiaR90RrQF5dLbyop1MlZHKOdjoiMOWWHkI,8252
+bitsentry/reporter.py,sha256=dPeJWIur8-XVd0MR2bkZjRguVrxeyHB6tQZaHe_pmk0,8410
+bitsentry/risk_guardian.py,sha256=UYYWR7QJjDcSfYaRocOApDn6l0Hl-Yl_ECQZBx2DEkw,9469
+bitsentry/scheduler.py,sha256=SxX5lDEaOxvPwjoQ9k9u7YWypAelxLkSyBejads7Fz8,3137
+bitsentry/strategy_evaluator.py,sha256=4m6vD3oVSHrpstBOYaCsBOSOZIaLbz8uZNV5ApyRZHM,10080
+bitsentry/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bitsentry/api/server.py,sha256=rIyvfyqwTRQjyMiikhqPsgL4F8h2udH9zs5l7JW_Mv4,9256
+bitsentry/mcp/__init__.py,sha256=Hq-s7pLXZK_WbITMlnj_7Z8-fvJ-VNM8Fi-JPmJ_9gk,56
+bitsentry/mcp/server.py,sha256=S-a6NcRwj_zK9JtEN3toQ_jy0Dsd_WZHNUr_ZNCYVho,6404
+bitsentry-0.1.0.dist-info/METADATA,sha256=vqvtKuMTGUK0nTXw5XF_mofoWMnJF8NhWvT5sPnbPbc,2513
+bitsentry-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+bitsentry-0.1.0.dist-info/entry_points.txt,sha256=aRCcTaeNFZvVdATFQncTacz3fcE3h7Xzoz36_UQI4yY,49
+bitsentry-0.1.0.dist-info/RECORD,,

bitsentry-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

bitsentry-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bitsentry = bitsentry.cli:main