forexsmartbot 3.2.1__tar.gz → 3.2.2__tar.gz

{forexsmartbot-3.2.1 → forexsmartbot-3.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forexsmartbot
-Version: 3.2.1
+Version: 3.2.2
 Summary: Professional forex trading bot with advanced risk management and strategy plugins
 Author-email: VoxHash <contact@voxhash.dev>
 License: MIT

forexsmartbot-3.2.2/forexsmartbot/analytics/__init__.py

@@ -0,0 +1,43 @@
+"""
+Analytics module for ForexSmartBot v3.2.0
+Provides portfolio analytics, risk analytics, and advanced charting features.
+"""
+
+from .portfolio_analytics import PortfolioAnalytics
+from .risk_analytics import RiskAnalytics
+from .chart_patterns import ChartPatternRecognizer
+from .performance_attribution import PerformanceAttribution
+from .live_metrics import LiveMetricsSnapshot, build_live_metrics
+
+# Qt-backed widgets are optional (headless / test environments may lack PyQt6)
+try:
+    from .market_depth import MarketDepthWidget, MarketDepthProvider
+    from .correlation_matrix import CorrelationMatrixWidget, CorrelationAnalyzer
+    from .economic_calendar import EconomicCalendarWidget, EconomicCalendarProvider
+    from .trade_journal import TradeJournalWidget, TradeJournalManager
+except ImportError:  # pragma: no cover - UI optional
+    MarketDepthWidget = None  # type: ignore[misc, assignment]
+    MarketDepthProvider = None  # type: ignore[misc, assignment]
+    CorrelationMatrixWidget = None  # type: ignore[misc, assignment]
+    CorrelationAnalyzer = None  # type: ignore[misc, assignment]
+    EconomicCalendarWidget = None  # type: ignore[misc, assignment]
+    EconomicCalendarProvider = None  # type: ignore[misc, assignment]
+    TradeJournalWidget = None  # type: ignore[misc, assignment]
+    TradeJournalManager = None  # type: ignore[misc, assignment]
+
+__all__ = [
+    'PortfolioAnalytics',
+    'RiskAnalytics',
+    'ChartPatternRecognizer',
+    'PerformanceAttribution',
+    'MarketDepthWidget',
+    'MarketDepthProvider',
+    'CorrelationMatrixWidget',
+    'CorrelationAnalyzer',
+    'EconomicCalendarWidget',
+    'EconomicCalendarProvider',
+    'TradeJournalWidget',
+    'TradeJournalManager',
+    'LiveMetricsSnapshot',
+    'build_live_metrics',
+]

forexsmartbot-3.2.2/forexsmartbot/analytics/live_metrics.py

@@ -0,0 +1,161 @@
+"""
+Live portfolio and risk metrics for the analytics dashboard.
+
+Pure computation (no Qt) so the snapshot can be unit-tested and reused by
+dialogs, widgets, and remote monitors.
+"""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Sequence
+
+from ..core.interfaces import Trade
+from .portfolio_analytics import PortfolioAnalytics
+from .risk_analytics import RiskAnalytics
+
+
+@dataclass
+class LiveMetricsSnapshot:
+    """Point-in-time analytics snapshot for UI and monitoring."""
+
+    timestamp: datetime
+    equity: float
+    balance: float
+    realized_pnl: float
+    unrealized_pnl: float
+    daily_pnl: float
+    open_positions: int
+    total_trades: int
+    win_rate: float
+    profit_factor: float
+    sharpe_ratio: float
+    sortino_ratio: float
+    max_drawdown: float
+    max_drawdown_pct: float
+    current_drawdown: float
+    var_95: float
+    cvar_95: float
+    volatility: float
+    average_win: float
+    average_loss: float
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Serialize for tables / JSON."""
+        data = asdict(self)
+        data["timestamp"] = self.timestamp.isoformat()
+        return data
+
+    def card_metrics(self) -> List[tuple]:
+        """Primary KPI cards: (label, formatted value, tone)."""
+        tone_pnl = "positive" if self.daily_pnl >= 0 else "negative"
+        tone_eq = "positive" if self.unrealized_pnl + self.realized_pnl >= 0 else "negative"
+        return [
+            ("Equity", f"${self.equity:,.2f}", tone_eq),
+            ("Daily P&L", f"${self.daily_pnl:,.2f}", tone_pnl),
+            ("Win Rate", f"{self.win_rate:.1f}%", "neutral"),
+            ("Sharpe", f"{self.sharpe_ratio:.3f}", "neutral"),
+            ("Max DD", f"{self.max_drawdown_pct:.2f}%", "negative" if self.max_drawdown_pct else "neutral"),
+            ("VaR 95%", f"{self.var_95:.4f}", "neutral"),
+        ]
+
+
+def _portfolio_trades(portfolio) -> List[Trade]:
+    """Extract Trade list from Portfolio or trade sequence."""
+    if portfolio is None:
+        return []
+    if hasattr(portfolio, "trades"):
+        return list(portfolio.trades)
+    if isinstance(portfolio, Sequence):
+        return list(portfolio)
+    return []
+
+
+def _sync_portfolio_analytics(analytics: PortfolioAnalytics, portfolio) -> None:
+    """Load trades and equity curve from a live Portfolio."""
+    analytics.trades = _portfolio_trades(portfolio)
+    analytics.equity_curve = []
+    if portfolio is None:
+        return
+    timestamps = getattr(portfolio, "timestamps", None)
+    equity_history = getattr(portfolio, "equity_history", None)
+    if timestamps is not None and equity_history is not None:
+        ts = list(timestamps)
+        eq = list(equity_history)
+        n = min(len(ts), len(eq))
+        analytics.equity_curve = list(zip(ts[:n], eq[:n]))
+
+
+def _sync_risk_analytics(risk: RiskAnalytics, portfolio) -> None:
+    """Load trades into RiskAnalytics from a live Portfolio."""
+    risk.trades = _portfolio_trades(portfolio)
+
+
+def build_live_metrics(portfolio, *, now: Optional[datetime] = None) -> LiveMetricsSnapshot:
+    """
+    Build a live metrics snapshot from a Portfolio (or trade container).
+
+    Uses Portfolio balance/equity when available; otherwise derives from trades.
+    """
+    now = now or datetime.now()
+    portfolio_analytics = PortfolioAnalytics()
+    risk_analytics = RiskAnalytics()
+    _sync_portfolio_analytics(portfolio_analytics, portfolio)
+    _sync_risk_analytics(risk_analytics, portfolio)
+
+    summary = portfolio_analytics.get_performance_summary()
+    max_dd = portfolio_analytics.calculate_max_drawdown()
+    var_result = risk_analytics.calculate_var(confidence_level=0.95)
+    cvar_result = risk_analytics.calculate_cvar(confidence_level=0.95)
+
+    returns = risk_analytics._get_returns()
+    volatility = float(returns.std()) if len(returns) >= 2 else 0.0
+
+    if portfolio is not None and hasattr(portfolio, "get_total_equity"):
+        equity = float(portfolio.get_total_equity())
+        balance = float(portfolio.get_total_balance())
+        realized = float(portfolio.get_realized_pnl())
+        unrealized = float(portfolio.get_unrealized_pnl())
+        daily = float(portfolio.get_daily_pnl())
+        open_positions = len(getattr(portfolio, "positions", {}) or {})
+        current_dd = float(portfolio.get_current_drawdown()) * 100.0
+    else:
+        equity = 10000.0 + float(summary.get("total_pnl", 0.0))
+        balance = equity
+        realized = float(summary.get("total_pnl", 0.0))
+        unrealized = 0.0
+        daily = realized
+        open_positions = 0
+        current_dd = float(max_dd.get("max_drawdown_pct", 0.0))
+
+    profit_factor = summary.get("profit_factor", 0.0)
+    if profit_factor == float("inf"):
+        profit_factor = 0.0
+
+    sortino = summary.get("sortino_ratio", 0.0)
+    if sortino == float("inf"):
+        sortino = 0.0
+
+    return LiveMetricsSnapshot(
+        timestamp=now,
+        equity=equity,
+        balance=balance,
+        realized_pnl=realized,
+        unrealized_pnl=unrealized,
+        daily_pnl=daily,
+        open_positions=open_positions,
+        total_trades=int(summary.get("total_trades", 0)),
+        win_rate=float(summary.get("win_rate", 0.0)),
+        profit_factor=float(profit_factor),
+        sharpe_ratio=float(summary.get("sharpe_ratio", 0.0)),
+        sortino_ratio=float(sortino),
+        max_drawdown=float(max_dd.get("max_drawdown", 0.0)),
+        max_drawdown_pct=float(max_dd.get("max_drawdown_pct", 0.0)),
+        current_drawdown=current_dd,
+        var_95=float(var_result.get("var", 0.0)),
+        cvar_95=float(cvar_result.get("cvar", 0.0)),
+        volatility=volatility,
+        average_win=float(summary.get("average_win", 0.0)),
+        average_loss=float(summary.get("average_loss", 0.0)),
+    )

{forexsmartbot-3.2.1 → forexsmartbot-3.2.2}/forexsmartbot/analytics/portfolio_analytics.py

@@ -284,20 +284,29 @@ class PortfolioAnalytics:
         Calculate portfolio metrics (alias for get_performance_summary for compatibility).
         
         Args:
-            portfolio: Optional portfolio object (currently unused, kept for compatibility)
+            portfolio: Optional portfolio object; when provided, trades and equity
+                history are loaded for the calculation.
             
         Returns:
             Dictionary of performance metrics
         """
-        # If portfolio is provided and has trades, use them
-        if portfolio and hasattr(portfolio, 'trades') and portfolio.trades:
-            # Temporarily use portfolio's trades
-            original_trades = self.trades
-            self.trades = portfolio.trades
-            metrics = self.get_performance_summary()
+        if portfolio is None:
+            return self.get_performance_summary()
+
+        original_trades = self.trades
+        original_equity = self.equity_curve
+        try:
+            if hasattr(portfolio, "trades"):
+                self.trades = list(portfolio.trades)
+            timestamps = getattr(portfolio, "timestamps", None)
+            equity_history = getattr(portfolio, "equity_history", None)
+            if timestamps is not None and equity_history is not None:
+                ts = list(timestamps)
+                eq = list(equity_history)
+                n = min(len(ts), len(eq))
+                self.equity_curve = list(zip(ts[:n], eq[:n]))
+            return self.get_performance_summary()
+        finally:
             self.trades = original_trades
-            return metrics
-        
-        # Otherwise use internal trades
-        return self.get_performance_summary()
+            self.equity_curve = original_equity
 

{forexsmartbot-3.2.1 → forexsmartbot-3.2.2}/forexsmartbot/analytics/risk_analytics.py

@@ -7,7 +7,6 @@ import numpy as np
 import pandas as pd
 from typing import Dict, List, Optional, Tuple
 from datetime import datetime, timedelta
-from scipy import stats
 from ..core.interfaces import Trade, Position
 
 
@@ -245,6 +244,12 @@ class RiskAnalytics:
     def _calculate_parametric_var(self, returns: np.ndarray,
                                  confidence_level: float) -> float:
         """Calculate VaR using parametric (variance-covariance) method."""
+        try:
+            from scipy import stats
+        except ImportError as exc:
+            raise ImportError(
+                "scipy is required for parametric VaR; use method='historical'"
+            ) from exc
         mean_return = np.mean(returns)
         std_return = np.std(returns)
         

{forexsmartbot-3.2.1 → forexsmartbot-3.2.2}/forexsmartbot/ui/analytics_dialog.py

@@ -86,16 +86,32 @@ class AnalyticsDialog(QDialog):
     def update_portfolio_metrics(self, portfolio=None):
         """Update portfolio metrics table."""
         try:
-            metrics = self.analytics.calculate_metrics(portfolio)
-            
-            if not metrics:
+            from ..analytics.live_metrics import build_live_metrics
+
+            snapshot = build_live_metrics(portfolio)
+            metrics = {
+                "equity": snapshot.equity,
+                "balance": snapshot.balance,
+                "realized_pnl": snapshot.realized_pnl,
+                "unrealized_pnl": snapshot.unrealized_pnl,
+                "daily_pnl": snapshot.daily_pnl,
+                "total_trades": snapshot.total_trades,
+                "win_rate": snapshot.win_rate,
+                "profit_factor": snapshot.profit_factor,
+                "sharpe_ratio": snapshot.sharpe_ratio,
+                "sortino_ratio": snapshot.sortino_ratio,
+                "max_drawdown": snapshot.max_drawdown,
+                "max_drawdown_pct": snapshot.max_drawdown_pct,
+            }
+
+            if snapshot.total_trades == 0 and snapshot.open_positions == 0:
                 self.metrics_table.setRowCount(1)
                 self.metrics_table.setItem(0, 0, QTableWidgetItem("No data"))
                 self.metrics_table.setItem(0, 1, QTableWidgetItem("No trades available"))
                 return
-            
+
             self.metrics_table.setRowCount(len(metrics))
-            
+
             for i, (key, value) in enumerate(metrics.items()):
                 self.metrics_table.setItem(i, 0, QTableWidgetItem(str(key).replace('_', ' ').title()))
                 if isinstance(value, float):
@@ -134,24 +150,22 @@ class AnalyticsDialog(QDialog):
         self.update_risk_metrics(portfolio)
     
     def update_risk_metrics(self, portfolio=None):
-        """Update risk metrics table."""
+        """Update risk metrics table from portfolio trades when available."""
         try:
-            # Calculate VaR
-            var_result = self.risk_analytics.calculate_var(confidence_level=0.95)
-            
-            # Calculate CVaR
-            cvar_result = self.risk_analytics.calculate_cvar(confidence_level=0.95)
-            
-            # Combine metrics
+            from ..analytics.live_metrics import build_live_metrics
+
+            snapshot = build_live_metrics(portfolio)
             metrics = {
-                'VaR (95%)': var_result.get('var', 0.0),
-                'CVaR (95%)': cvar_result.get('cvar', 0.0),
-                'Max Drawdown': var_result.get('max_drawdown', 0.0),
-                'Volatility': var_result.get('volatility', 0.0)
+                "VaR (95%)": snapshot.var_95,
+                "CVaR (95%)": snapshot.cvar_95,
+                "Max Drawdown": snapshot.max_drawdown,
+                "Max Drawdown %": snapshot.max_drawdown_pct,
+                "Current Drawdown %": snapshot.current_drawdown,
+                "Volatility": snapshot.volatility,
             }
-            
+
             self.risk_table.setRowCount(len(metrics))
-            
+
             for i, (key, value) in enumerate(metrics.items()):
                 self.risk_table.setItem(i, 0, QTableWidgetItem(key))
                 if isinstance(value, float):

forexsmartbot-3.2.2/forexsmartbot/ui/analytics_widget.py

@@ -0,0 +1,202 @@
+"""
+Live Analytics Dashboard widget for main window integration.
+
+Shows KPI cards plus portfolio/risk tables, refreshed on a timer from the
+live Portfolio.
+"""
+
+from PyQt6.QtWidgets import (
+    QWidget, QVBoxLayout, QHBoxLayout, QLabel, QTableWidget,
+    QTableWidgetItem, QGroupBox, QGridLayout, QFrame, QSizePolicy,
+)
+from PyQt6.QtCore import Qt, QTimer
+from typing import Optional
+
+
+_CARD_STYLE = """
+QFrame#metricCard {{
+    background-color: palette(base);
+    border: 1px solid palette(mid);
+    border-radius: 6px;
+    padding: 8px;
+}}
+QLabel#cardValue {{
+    font-size: 18px;
+    font-weight: bold;
+}}
+QLabel#cardLabel {{
+    font-size: 11px;
+    color: palette(mid);
+}}
+"""
+
+_TONE_COLORS = {
+    "positive": "#2e7d32",
+    "negative": "#c62828",
+    "neutral": "",
+}
+
+
+class PortfolioAnalyticsWidget(QWidget):
+    """Live analytics dashboard: KPI cards + portfolio/risk metric tables."""
+
+    def __init__(self, portfolio, parent=None, refresh_ms: int = 5000):
+        super().__init__(parent)
+        self.portfolio = portfolio
+        self.refresh_ms = refresh_ms
+        self._card_value_labels = []
+        self.setup_ui()
+        self.setup_timer()
+        self.update_metrics()
+
+    def setup_ui(self):
+        """Setup UI."""
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(8, 8, 8, 8)
+        layout.setSpacing(10)
+
+        header = QHBoxLayout()
+        title = QLabel("Live Analytics")
+        title.setStyleSheet("font-size: 16px; font-weight: bold;")
+        header.addWidget(title)
+        header.addStretch()
+        self.updated_label = QLabel("Updated: —")
+        self.updated_label.setStyleSheet("font-size: 11px; color: palette(mid);")
+        header.addWidget(self.updated_label)
+        layout.addLayout(header)
+
+        self.cards_frame = QFrame()
+        self.cards_frame.setObjectName("metricCards")
+        cards_layout = QHBoxLayout(self.cards_frame)
+        cards_layout.setContentsMargins(0, 0, 0, 0)
+        cards_layout.setSpacing(8)
+        self._card_value_labels = []
+        for _ in range(6):
+            card, value_label = self._make_card("—", "—")
+            cards_layout.addWidget(card)
+            self._card_value_labels.append(value_label)
+        layout.addWidget(self.cards_frame)
+
+        tables = QHBoxLayout()
+        tables.setSpacing(10)
+
+        portfolio_group = QGroupBox("Portfolio")
+        portfolio_layout = QVBoxLayout(portfolio_group)
+        self.metrics_table = QTableWidget()
+        self.metrics_table.setColumnCount(2)
+        self.metrics_table.setHorizontalHeaderLabels(["Metric", "Value"])
+        self.metrics_table.horizontalHeader().setStretchLastSection(True)
+        self.metrics_table.setAlternatingRowColors(True)
+        self.metrics_table.setEditTriggers(QTableWidget.EditTrigger.NoEditTriggers)
+        self.metrics_table.setSelectionMode(QTableWidget.SelectionMode.NoSelection)
+        self.metrics_table.verticalHeader().setVisible(False)
+        portfolio_layout.addWidget(self.metrics_table)
+        tables.addWidget(portfolio_group)
+
+        risk_group = QGroupBox("Risk")
+        risk_layout = QVBoxLayout(risk_group)
+        self.risk_table = QTableWidget()
+        self.risk_table.setColumnCount(2)
+        self.risk_table.setHorizontalHeaderLabels(["Metric", "Value"])
+        self.risk_table.horizontalHeader().setStretchLastSection(True)
+        self.risk_table.setAlternatingRowColors(True)
+        self.risk_table.setEditTriggers(QTableWidget.EditTrigger.NoEditTriggers)
+        self.risk_table.setSelectionMode(QTableWidget.SelectionMode.NoSelection)
+        self.risk_table.verticalHeader().setVisible(False)
+        risk_layout.addWidget(self.risk_table)
+        tables.addWidget(risk_group)
+
+        layout.addLayout(tables)
+        self.setStyleSheet(_CARD_STYLE)
+
+    def _make_card(self, label: str, value: str):
+        """Create a KPI card frame; returns (frame, value_label)."""
+        frame = QFrame()
+        frame.setObjectName("metricCard")
+        frame.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
+        grid = QGridLayout(frame)
+        grid.setContentsMargins(10, 8, 10, 8)
+        value_label = QLabel(value)
+        value_label.setObjectName("cardValue")
+        value_label.setAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
+        name_label = QLabel(label)
+        name_label.setObjectName("cardLabel")
+        name_label.setAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
+        grid.addWidget(value_label, 0, 0)
+        grid.addWidget(name_label, 1, 0)
+        frame._name_label = name_label  # noqa: SLF001 — local card wiring
+        return frame, value_label
+
+    def setup_timer(self):
+        """Setup live refresh timer."""
+        self.update_timer = QTimer(self)
+        self.update_timer.timeout.connect(self.update_metrics)
+        self.update_timer.start(self.refresh_ms)
+
+    def set_portfolio(self, portfolio) -> None:
+        """Replace the portfolio source and refresh immediately."""
+        self.portfolio = portfolio
+        self.update_metrics()
+
+    def update_metrics(self):
+        """Refresh KPI cards and portfolio/risk tables from live portfolio."""
+        try:
+            from ..analytics.live_metrics import build_live_metrics
+
+            snapshot = build_live_metrics(self.portfolio)
+            self.updated_label.setText(
+                f"Updated: {snapshot.timestamp.strftime('%H:%M:%S')}"
+            )
+
+            for i, (label, value, tone) in enumerate(snapshot.card_metrics()):
+                if i >= len(self._card_value_labels):
+                    break
+                value_label = self._card_value_labels[i]
+                value_label.setText(value)
+                color = _TONE_COLORS.get(tone, "")
+                if color:
+                    value_label.setStyleSheet(f"font-size: 18px; font-weight: bold; color: {color};")
+                else:
+                    value_label.setStyleSheet("font-size: 18px; font-weight: bold;")
+                card = value_label.parent()
+                if card is not None and hasattr(card, "_name_label"):
+                    card._name_label.setText(label)
+
+            portfolio_rows = {
+                "Equity": f"${snapshot.equity:,.2f}",
+                "Balance": f"${snapshot.balance:,.2f}",
+                "Realized P&L": f"${snapshot.realized_pnl:,.2f}",
+                "Unrealized P&L": f"${snapshot.unrealized_pnl:,.2f}",
+                "Daily P&L": f"${snapshot.daily_pnl:,.2f}",
+                "Open Positions": str(snapshot.open_positions),
+                "Total Trades": str(snapshot.total_trades),
+                "Win Rate": f"{snapshot.win_rate:.1f}%",
+                "Profit Factor": f"{snapshot.profit_factor:.3f}",
+                "Sharpe Ratio": f"{snapshot.sharpe_ratio:.4f}",
+                "Sortino Ratio": f"{snapshot.sortino_ratio:.4f}",
+                "Avg Win": f"${snapshot.average_win:,.2f}",
+                "Avg Loss": f"${snapshot.average_loss:,.2f}",
+            }
+            self._fill_table(self.metrics_table, portfolio_rows)
+
+            risk_rows = {
+                "Max Drawdown": f"${snapshot.max_drawdown:,.2f}",
+                "Max Drawdown %": f"{snapshot.max_drawdown_pct:.2f}%",
+                "Current Drawdown %": f"{snapshot.current_drawdown:.2f}%",
+                "VaR (95%)": f"{snapshot.var_95:.4f}",
+                "CVaR (95%)": f"{snapshot.cvar_95:.4f}",
+                "Volatility": f"{snapshot.volatility:.4f}",
+            }
+            self._fill_table(self.risk_table, risk_rows)
+        except Exception as e:
+            self.metrics_table.setRowCount(1)
+            self.metrics_table.setItem(0, 0, QTableWidgetItem("Error"))
+            self.metrics_table.setItem(0, 1, QTableWidgetItem(str(e)))
+            self.risk_table.setRowCount(0)
+
+    @staticmethod
+    def _fill_table(table: QTableWidget, rows: dict) -> None:
+        table.setRowCount(len(rows))
+        for i, (key, value) in enumerate(rows.items()):
+            table.setItem(i, 0, QTableWidgetItem(key))
+            table.setItem(i, 1, QTableWidgetItem(value))

{forexsmartbot-3.2.1 → forexsmartbot-3.2.2}/forexsmartbot/ui/enhanced_main_window.py

@@ -2042,6 +2042,13 @@ class EnhancedMainWindow(QMainWindow):
             # Update positions display (fallback if MT4 sync didn't work)
             if not (self.broker and self.broker.is_connected()):
                 self.update_positions_display()
+
+            # Refresh live analytics dashboard when present
+            if hasattr(self, "portfolio_analytics_widget") and self.portfolio_analytics_widget:
+                try:
+                    self.portfolio_analytics_widget.set_portfolio(self.portfolio)
+                except Exception:
+                    pass
             
         except Exception as e:
             self.append_log(f"Real-time update error: {str(e)}")

{forexsmartbot-3.2.1 → forexsmartbot-3.2.2}/forexsmartbot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forexsmartbot
-Version: 3.2.1
+Version: 3.2.2
 Summary: Professional forex trading bot with advanced risk management and strategy plugins
 Author-email: VoxHash <contact@voxhash.dev>
 License: MIT

{forexsmartbot-3.2.1 → forexsmartbot-3.2.2}/forexsmartbot.egg-info/SOURCES.txt

@@ -30,6 +30,7 @@ forexsmartbot/analytics/chart_patterns.py
 forexsmartbot/analytics/correlation_matrix.py
 forexsmartbot/analytics/economic_calendar.py
 forexsmartbot/analytics/enhanced_chart.py
+forexsmartbot/analytics/live_metrics.py
 forexsmartbot/analytics/market_depth.py
 forexsmartbot/analytics/performance_attribution.py
 forexsmartbot/analytics/portfolio_analytics.py
@@ -132,6 +133,7 @@ forexsmartbot/utils/gpu_numpy.py
 forexsmartbot/utils/gpu_utils.py
 forexsmartbot/utils/native_indicators.py
 tests/test_config.py
+tests/test_live_metrics.py
 tests/test_multi_timeframe_strategy.py
 tests/test_native_indicators.py
 tests/test_risk.py

{forexsmartbot-3.2.1 → forexsmartbot-3.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "forexsmartbot"
-version = "3.2.1"
+version = "3.2.2"
 description = "Professional forex trading bot with advanced risk management and strategy plugins"
 authors = [{name = "VoxHash", email = "contact@voxhash.dev"}]
 license = {text = "MIT"}

forexsmartbot-3.2.2/tests/test_live_metrics.py

@@ -0,0 +1,70 @@
+"""Tests for live analytics metrics snapshot."""
+
+from datetime import datetime, timedelta
+
+from forexsmartbot.analytics.live_metrics import LiveMetricsSnapshot, build_live_metrics
+from forexsmartbot.analytics.portfolio_analytics import PortfolioAnalytics
+from forexsmartbot.core.interfaces import Trade
+from forexsmartbot.core.portfolio import Portfolio
+
+
+def _make_trade(pnl: float, day_offset: int = 0, qty: float = 1.0, entry: float = 1.10) -> Trade:
+    entry_time = datetime.now() - timedelta(days=2 + day_offset)
+    exit_time = datetime.now() - timedelta(days=day_offset)
+    return Trade(
+        symbol="EURUSD",
+        side=1,
+        quantity=qty,
+        entry_price=entry,
+        exit_price=entry + (pnl / qty if qty else 0),
+        pnl=pnl,
+        strategy="SMA_Crossover",
+        entry_time=entry_time,
+        exit_time=exit_time,
+    )
+
+
+class TestLiveMetrics:
+    def test_empty_portfolio_snapshot(self):
+        portfolio = Portfolio(initial_balance=10000.0)
+        snap = build_live_metrics(portfolio)
+        assert isinstance(snap, LiveMetricsSnapshot)
+        assert snap.equity == 10000.0
+        assert snap.total_trades == 0
+        assert snap.var_95 == 0.0
+        assert len(snap.card_metrics()) == 6
+
+    def test_snapshot_with_winning_and_losing_trades(self):
+        portfolio = Portfolio(initial_balance=10000.0)
+        portfolio.add_trade(_make_trade(50.0, day_offset=1))
+        portfolio.add_trade(_make_trade(-20.0, day_offset=0))
+        portfolio.update_equity(10030.0)
+
+        snap = build_live_metrics(portfolio)
+        assert snap.total_trades == 2
+        assert snap.realized_pnl == 30.0
+        assert snap.win_rate == 50.0
+        assert snap.average_win == 50.0
+        assert snap.average_loss == 20.0
+        assert snap.equity == portfolio.get_total_equity()
+        data = snap.to_dict()
+        assert "timestamp" in data
+        assert data["total_trades"] == 2
+
+    def test_portfolio_analytics_loads_equity_from_portfolio(self):
+        portfolio = Portfolio(initial_balance=10000.0)
+        portfolio.add_trade(_make_trade(100.0))
+        portfolio.update_equity(10100.0)
+        analytics = PortfolioAnalytics()
+        metrics = analytics.calculate_metrics(portfolio)
+        assert metrics["total_trades"] == 1
+        assert metrics["total_pnl"] == 100.0
+        # Internal state restored after calculate_metrics
+        assert analytics.trades == []
+
+    def test_card_metrics_tone_for_negative_daily_pnl(self):
+        portfolio = Portfolio(initial_balance=10000.0)
+        portfolio.add_trade(_make_trade(-40.0, day_offset=0))
+        snap = build_live_metrics(portfolio)
+        cards = dict((label, (value, tone)) for label, value, tone in snap.card_metrics())
+        assert cards["Daily P&L"][1] == "negative"