fix mypy issues

Author: TexasCoding

src/project_x_py/order_templates.py

@@ -35,7 +35,7 @@
 
 import logging
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from project_x_py.indicators import ATR
 from project_x_py.models import BracketOrderResponse
@@ -55,11 +55,10 @@ async def create_order(
         self,
         suite: "TradingSuite",
         side: int,
-        size: Optional[int] = None,
+        size: int | None = None,
         **kwargs: Any,
     ) -> BracketOrderResponse:
         """Create an order using this template."""
-        pass
 
 
 class RiskRewardTemplate(OrderTemplate):
@@ -73,7 +72,7 @@ class RiskRewardTemplate(OrderTemplate):
     def __init__(
         self,
         risk_reward_ratio: float = 2.0,
-        stop_distance: Optional[float] = None,
+        stop_distance: float | None = None,
         use_limit_entry: bool = True,
     ):
         """
@@ -92,9 +91,9 @@ async def create_order(
         self,
         suite: "TradingSuite",
         side: int,
-        size: Optional[int] = None,
-        risk_amount: Optional[float] = None,
-        risk_percent: Optional[float] = None,
+        size: int | None = None,
+        risk_amount: float | None = None,
+        risk_percent: float | None = None,
         entry_offset: float = 0,
         **kwargs: Any,
     ) -> BracketOrderResponse:
@@ -131,7 +130,7 @@ async def create_order(
             stop_dist = self.stop_distance
         else:
             # Use 1% of price as default
-            stop_dist = current_price * 0.01
+            stop_dist = current_price * 0.01 if current_price else 0.0
 
         # Calculate position size if needed
         if size is None:
@@ -215,7 +214,7 @@ async def create_order(
         self,
         suite: "TradingSuite",
         side: int,
-        size: Optional[int] = None,
+        size: int | None = None,
         use_limit_entry: bool = False,
         entry_offset: float = 0,
         **kwargs: Any,
@@ -236,7 +235,7 @@ async def create_order(
         # Get data for ATR calculation
         data = await suite.data.get_data(self.timeframe, bars=self.atr_period + 1)
         if data is None or len(data) < self.atr_period:
-            raise ValueError(f"Insufficient data for ATR calculation")
+            raise ValueError("Insufficient data for ATR calculation")
 
         # Calculate ATR
         data_with_atr = data.pipe(ATR, period=self.atr_period)
@@ -308,9 +307,9 @@ async def create_order(
         self,
         suite: "TradingSuite",
         side: int,
-        size: Optional[int] = None,
-        breakout_level: Optional[float] = None,
-        range_size: Optional[float] = None,
+        size: int | None = None,
+        breakout_level: float | None = None,
+        range_size: float | None = None,
         lookback_bars: int = 20,
         **kwargs: Any,
     ) -> BracketOrderResponse:
@@ -336,10 +335,9 @@ async def create_order(
             if not range_stats:
                 raise ValueError("Cannot calculate price range")
 
-            if side == 0:  # BUY - breakout above high
-                breakout_level = range_stats["high"]
-            else:  # SELL - breakout below low
-                breakout_level = range_stats["low"]
+            breakout_level = (
+                range_stats["high"] if side == 0 else range_stats["low"]
+            )  # BUY=high, SELL=low
 
             if range_size is None:
                 range_size = range_stats["range"]
@@ -415,7 +413,7 @@ async def create_order(
         self,
         suite: "TradingSuite",
         side: int,
-        size: Optional[int] = None,
+        size: int | None = None,
         check_spread: bool = True,
         **kwargs: Any,
     ) -> BracketOrderResponse:

src/project_x_py/order_tracker.py

@@ -55,13 +55,12 @@
 import asyncio
 import logging
 from types import TracebackType
-from typing import TYPE_CHECKING, Any, Optional, Type, Union
+from typing import TYPE_CHECKING, Any, Union
 
 from project_x_py.event_bus import EventType
 from project_x_py.models import BracketOrderResponse, Order, OrderPlaceResponse
 
 if TYPE_CHECKING:
-    from project_x_py.order_manager import OrderManager
     from project_x_py.trading_suite import TradingSuite
 
 logger = logging.getLogger(__name__)
@@ -84,7 +83,7 @@ class OrderTracker:
         - Thread-safe operation
     """
 
-    def __init__(self, trading_suite: "TradingSuite", order: Optional[Order] = None):
+    def __init__(self, trading_suite: "TradingSuite", order: Order | None = None):
         """
         Initialize OrderTracker.
 
@@ -96,14 +95,14 @@ def __init__(self, trading_suite: "TradingSuite", order: Optional[Order] = None)
         self.order_manager = trading_suite.orders
         self.event_bus = trading_suite.events
         self.order = order
-        self.order_id: Optional[int] = order.id if order else None
+        self.order_id: int | None = order.id if order else None
 
         # State tracking
         self._fill_event = asyncio.Event()
         self._status_events: dict[int, asyncio.Event] = {}
-        self._current_status: Optional[int] = order.status if order else None
-        self._filled_order: Optional[Order] = None
-        self._error: Optional[Exception] = None
+        self._current_status: int | None = order.status if order else None
+        self._filled_order: Order | None = None
+        self._error: Exception | None = None
 
         # Event handlers
         self._event_handlers: list[tuple[EventType, Any]] = []
@@ -116,9 +115,9 @@ async def __aenter__(self) -> "OrderTracker":
 
     async def __aexit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         """Exit the context manager and clean up."""
         await self.cleanup()
@@ -226,10 +225,10 @@ async def wait_for_fill(self, timeout: float = 30.0) -> Order:
                         "Order fill event received but order not filled"
                     )
 
-        except asyncio.TimeoutError:
+        except TimeoutError:
             raise TimeoutError(
                 f"Order {self.order_id} not filled within {timeout} seconds"
-            )
+            ) from None
 
     async def wait_for_status(self, status: int, timeout: float = 30.0) -> Order:
         """
@@ -274,13 +273,13 @@ async def wait_for_status(self, status: int, timeout: float = 30.0) -> Order:
                     f"Status event received but order not in expected state {status}"
                 )
 
-        except asyncio.TimeoutError:
+        except TimeoutError:
             raise TimeoutError(
                 f"Order {self.order_id} did not reach status {status} within {timeout} seconds"
-            )
+            ) from None
 
     async def modify_or_cancel(
-        self, new_price: Optional[float] = None, new_size: Optional[int] = None
+        self, new_price: float | None = None, new_size: int | None = None
     ) -> bool:
         """
         Attempt to modify the order, or cancel if modification fails.
@@ -318,7 +317,7 @@ async def modify_or_cancel(
             logger.error(f"Failed to cancel order {self.order_id}: {e}")
             raise
 
-    async def get_current_status(self) -> Optional[Order]:
+    async def get_current_status(self) -> Order | None:
         """
         Get the current order status.
 
@@ -379,15 +378,15 @@ def __init__(self, trading_suite: "TradingSuite"):
 
         # Order configuration
         self.entry_type = "market"
-        self.side: Optional[int] = None
-        self.size: Optional[int] = None
-        self.entry_price: Optional[float] = None
-        self.contract_id: Optional[str] = None
+        self.side: int | None = None
+        self.size: int | None = None
+        self.entry_price: float | None = None
+        self.contract_id: str | None = None
 
         # Risk orders
-        self.stop_loss: Optional[dict[str, Any]] = None
-        self.take_profit: Optional[dict[str, Any]] = None
-        self.trail_stop: Optional[dict[str, Any]] = None
+        self.stop_loss: dict[str, Any] | None = None
+        self.take_profit: dict[str, Any] | None = None
+        self.trail_stop: dict[str, Any] | None = None
 
     def market_order(self, size: int, side: int = 0) -> "OrderChainBuilder":
         """Configure a market order as entry."""
@@ -420,24 +419,24 @@ def for_instrument(self, contract_id: str) -> "OrderChainBuilder":
         return self
 
     def with_stop_loss(
-        self, offset: Optional[float] = None, price: Optional[float] = None
+        self, offset: float | None = None, price: float | None = None
     ) -> "OrderChainBuilder":
         """Add a stop loss to the order chain."""
         self.stop_loss = {"offset": offset, "price": price}
         return self
 
     def with_take_profit(
         self,
-        offset: Optional[float] = None,
-        price: Optional[float] = None,
+        offset: float | None = None,
+        price: float | None = None,
         limit: bool = True,
     ) -> "OrderChainBuilder":
         """Add a take profit to the order chain."""
         self.take_profit = {"offset": offset, "price": price, "limit": limit}
         return self
 
     def with_trail_stop(
-        self, offset: float, trigger_offset: Optional[float] = None
+        self, offset: float, trigger_offset: float | None = None
     ) -> "OrderChainBuilder":
         """Add a trailing stop to the order chain."""
         self.trail_stop = {"offset": offset, "trigger_offset": trigger_offset}
@@ -570,13 +569,11 @@ async def execute(self) -> BracketOrderResponse:
 class OrderLifecycleError(Exception):
     """Exception raised when order lifecycle encounters an error."""
 
-    pass
-
 
 # Convenience function for creating order trackers
 def track_order(
     trading_suite: "TradingSuite",
-    order: Optional[Union[Order, OrderPlaceResponse, int]] = None,
+    order: Union[Order, OrderPlaceResponse, int] | None = None,
 ) -> OrderTracker:
     """
     Create an OrderTracker instance.
@@ -598,7 +595,7 @@ def track_order(
     """
     tracker = OrderTracker(trading_suite)
     if order:
-        if isinstance(order, (Order, OrderPlaceResponse)):
+        if isinstance(order, Order | OrderPlaceResponse):
             tracker.track(order)
         else:  # int
             tracker.order_id = order

src/project_x_py/risk_manager/core.py

@@ -236,10 +236,12 @@ async def validate_trade(
                 )
 
             # Check trading hours if restricted
-            if self.config.restrict_trading_hours:
-                if not self._is_within_trading_hours():
-                    is_valid = False
-                    reasons.append("Outside allowed trading hours")
+            if (
+                self.config.restrict_trading_hours
+                and not self._is_within_trading_hours()
+            ):
+                is_valid = False
+                reasons.append("Outside allowed trading hours")
 
             # Check for correlated positions
             correlated_count = await self._count_correlated_positions(
@@ -379,7 +381,7 @@ async def attach_risk_orders(
             )
             if use_trailing and self.config.trailing_stop_distance > 0:
                 # Monitor position for trailing stop activation
-                asyncio.create_task(
+                _trailing_task = asyncio.create_task(  # noqa: RUF006
                     self._monitor_trailing_stop(
                         position,
                         {