refactor(trading): Improve TradingSuite stability and configuration

Author: TexasCoding

src/project_x_py/risk_manager/core.py

@@ -83,6 +83,11 @@ def __init__(
         self._current_risk = Decimal("0")
         self._max_drawdown = Decimal("0")
 
+    def set_position_manager(self, position_manager: PositionManagerProtocol) -> None:
+        """Set the position manager after initialization to resolve circular dependency."""
+        self.positions = position_manager
+        self.position_manager = position_manager
+
     async def calculate_position_size(
         self,
         entry_price: float,

src/project_x_py/trading_suite.py

@@ -38,7 +38,7 @@
 from enum import Enum
 from pathlib import Path
 from types import TracebackType
-from typing import Any
+from typing import Any, cast
 
 import orjson
 import yaml
@@ -60,6 +60,7 @@
     OrderManagerConfig,
     PositionManagerConfig,
 )
+from project_x_py.types.protocols import ProjectXClientProtocol
 from project_x_py.types.stats_types import ComponentStats, TradingSuiteStats
 from project_x_py.utils import ProjectXLogger
 
@@ -87,16 +88,33 @@ def __init__(
         initial_days: int = 5,
         auto_connect: bool = True,
         timezone: str = "America/Chicago",
+        order_manager_config: OrderManagerConfig | None = None,
+        position_manager_config: PositionManagerConfig | None = None,
+        data_manager_config: DataManagerConfig | None = None,
+        orderbook_config: OrderbookConfig | None = None,
+        risk_config: RiskConfig | None = None,
     ):
         self.instrument = instrument
         self.timeframes = timeframes or ["5min"]
         self.features = features or []
         self.initial_days = initial_days
         self.auto_connect = auto_connect
         self.timezone = timezone
+        self.order_manager_config = order_manager_config
+        self.position_manager_config = position_manager_config
+        self.data_manager_config = data_manager_config
+        self.orderbook_config = orderbook_config
+        self.risk_config = risk_config
 
     def get_order_manager_config(self) -> OrderManagerConfig:
-        """Get configuration for OrderManager."""
+        """
+        Get configuration for OrderManager.
+
+        Returns:
+            OrderManagerConfig: The configuration for the OrderManager.
+        """
+        if self.order_manager_config:
+            return self.order_manager_config
         return {
             "enable_bracket_orders": Features.RISK_MANAGER in self.features,
             "enable_trailing_stops": True,
@@ -105,7 +123,14 @@ def get_order_manager_config(self) -> OrderManagerConfig:
         }
 
     def get_position_manager_config(self) -> PositionManagerConfig:
-        """Get configuration for PositionManager."""
+        """
+        Get configuration for PositionManager.
+
+        Returns:
+            PositionManagerConfig: The configuration for the PositionManager.
+        """
+        if self.position_manager_config:
+            return self.position_manager_config
         return {
             "enable_risk_monitoring": Features.RISK_MANAGER in self.features,
             "enable_correlation_analysis": Features.PERFORMANCE_ANALYTICS
@@ -114,7 +139,14 @@ def get_position_manager_config(self) -> PositionManagerConfig:
         }
 
     def get_data_manager_config(self) -> DataManagerConfig:
-        """Get configuration for RealtimeDataManager."""
+        """
+        Get configuration for RealtimeDataManager.
+
+        Returns:
+            DataManagerConfig: The configuration for the RealtimeDataManager.
+        """
+        if self.data_manager_config:
+            return self.data_manager_config
         return {
             "max_bars_per_timeframe": 1000,
             "enable_tick_data": True,
@@ -124,7 +156,14 @@ def get_data_manager_config(self) -> DataManagerConfig:
         }
 
     def get_orderbook_config(self) -> OrderbookConfig:
-        """Get configuration for OrderBook."""
+        """
+        Get configuration for OrderBook.
+
+        Returns:
+            OrderbookConfig: The configuration for the OrderBook.
+        """
+        if self.orderbook_config:
+            return self.orderbook_config
         return {
             "max_depth_levels": 100,
             "max_trade_history": 1000,
@@ -133,7 +172,14 @@ def get_orderbook_config(self) -> OrderbookConfig:
         }
 
     def get_risk_config(self) -> RiskConfig:
-        """Get configuration for RiskManager."""
+        """
+        Get configuration for RiskManager.
+
+        Returns:
+            RiskConfig: The configuration for the RiskManager.
+        """
+        if self.risk_config:
+            return self.risk_config
         return RiskConfig(
             max_risk_per_trade=0.01,  # 1% per trade
             max_daily_loss=0.03,  # 3% daily loss
@@ -208,30 +254,25 @@ def __init__(
         self.journal = None  # TODO: Future enhancement
         self.analytics = None  # TODO: Future enhancement
 
-        # Initialize risk manager first if enabled (needed by PositionManager)
-        if Features.RISK_MANAGER in config.features:
-            # Create RiskManager without position_manager first
-            self.risk_manager = RiskManager(
-                project_x=client,
-                order_manager=self.orders,
-                event_bus=self.events,
-                position_manager=None,  # Will be set after PositionManager is created
-                config=config.get_risk_config(),
-            )
-
-        # Now create PositionManager with risk_manager
+        # Create PositionManager first
         self.positions = PositionManager(
             client,
             event_bus=self.events,
-            risk_manager=self.risk_manager,
-            data_manager=self.data,  # type: ignore
+            risk_manager=None,  # Will be set later
+            data_manager=self.data,
             config=config.get_position_manager_config(),
         )
 
-        # Update RiskManager with position_manager reference if it exists
-        if self.risk_manager:
-            self.risk_manager.position_manager = self.positions
-            self.risk_manager.positions = self.positions  # Also set positions attribute
+        # Initialize risk manager if enabled and inject dependencies
+        if Features.RISK_MANAGER in config.features:
+            self.risk_manager = RiskManager(
+                project_x=cast(ProjectXClientProtocol, client),
+                order_manager=self.orders,
+                event_bus=self.events,
+                position_manager=self.positions,
+                config=config.get_risk_config(),
+            )
+            self.positions.risk_manager = self.risk_manager
 
         # State tracking
         self._connected = False
@@ -791,53 +832,64 @@ def get_stats(self) -> TradingSuiteStats:
         # Build component stats
         components: dict[str, ComponentStats] = {}
         if self.orders:
+            last_activity_obj = self.orders.stats.get("last_order_time")
             components["order_manager"] = ComponentStats(
                 name="OrderManager",
                 status="connected" if self.orders else "disconnected",
                 uptime_seconds=uptime_seconds,
-                last_activity=None,
-                error_count=0,
-                memory_usage_mb=0.0,
+                last_activity=last_activity_obj.isoformat()
+                if last_activity_obj
+                else None,
+                error_count=0,  # TODO: Implement error tracking in OrderManager
+                memory_usage_mb=0.0,  # TODO: Implement memory tracking in OrderManager
             )
 
         if self.positions:
+            last_activity_obj = self.positions.stats.get("last_position_update")
             components["position_manager"] = ComponentStats(
                 name="PositionManager",
                 status="connected" if self.positions else "disconnected",
                 uptime_seconds=uptime_seconds,
-                last_activity=None,
-                error_count=0,
-                memory_usage_mb=0.0,
+                last_activity=last_activity_obj.isoformat()
+                if last_activity_obj
+                else None,
+                error_count=0,  # TODO: Implement error tracking in PositionManager
+                memory_usage_mb=0.0,  # TODO: Implement memory tracking in PositionManager
             )
 
         if self.data:
+            last_activity_obj = self.data.memory_stats.get("last_update")
             components["data_manager"] = ComponentStats(
                 name="RealtimeDataManager",
                 status="connected" if self.data else "disconnected",
                 uptime_seconds=uptime_seconds,
-                last_activity=None,
-                error_count=0,
-                memory_usage_mb=0.0,
+                last_activity=last_activity_obj.isoformat()
+                if last_activity_obj
+                else None,
+                error_count=self.data.memory_stats.get("data_validation_errors", 0),
+                memory_usage_mb=self.data.memory_stats.get("memory_usage_mb", 0.0),
             )
 
         if self.orderbook:
             components["orderbook"] = ComponentStats(
                 name="OrderBook",
                 status="connected" if self.orderbook else "disconnected",
                 uptime_seconds=uptime_seconds,
-                last_activity=None,
-                error_count=0,
-                memory_usage_mb=0.0,
+                last_activity=self.orderbook.last_orderbook_update.isoformat()
+                if self.orderbook.last_orderbook_update
+                else None,
+                error_count=0,  # TODO: Implement error tracking in OrderBook
+                memory_usage_mb=0.0,  # TODO: Implement memory tracking in OrderBook
             )
 
         if self.risk_manager:
             components["risk_manager"] = ComponentStats(
                 name="RiskManager",
                 status="active" if self.risk_manager else "inactive",
                 uptime_seconds=uptime_seconds,
-                last_activity=None,
-                error_count=0,
-                memory_usage_mb=0.0,
+                last_activity=None,  # TODO: Implement activity tracking in RiskManager
+                error_count=0,  # TODO: Implement error tracking in RiskManager
+                memory_usage_mb=0.0,  # TODO: Implement memory tracking in RiskManager
             )
 
         return {