mypy fixes

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, Optional
+from typing import TYPE_CHECKING, Any, Optional
 
 from project_x_py.indicators import ATR
 from project_x_py.models import BracketOrderResponse
@@ -52,7 +52,11 @@ class OrderTemplate(ABC):
 
     @abstractmethod
     async def create_order(
-        self, suite: "TradingSuite", side: int, size: Optional[int] = None, **kwargs
+        self,
+        suite: "TradingSuite",
+        side: int,
+        size: Optional[int] = None,
+        **kwargs: Any,
     ) -> BracketOrderResponse:
         """Create an order using this template."""
         pass
@@ -92,7 +96,7 @@ async def create_order(
         risk_amount: Optional[float] = None,
         risk_percent: Optional[float] = None,
         entry_offset: float = 0,
-        **kwargs,
+        **kwargs: Any,
     ) -> BracketOrderResponse:
         """
         Create an order with fixed risk/reward ratio.
@@ -109,7 +113,7 @@ async def create_order(
             BracketOrderResponse with order details
         """
         # Get current price
-        current_price = await suite.data.get_latest_price()
+        current_price = await suite.data.get_current_price()
         if not current_price:
             raise ValueError("Cannot get current price")
 
@@ -138,8 +142,10 @@ async def create_order(
                 size = int(risk_amount / (stop_dist * tick_value))
             elif risk_percent:
                 # Get account balance
-                account = await suite.client.get_account_info()
-                risk_amount = account.balance * risk_percent
+                account = suite.client.account_info
+                if not account:
+                    raise ValueError("No account information available")
+                risk_amount = float(account.balance) * risk_percent
                 instrument = await suite.client.get_instrument(suite.instrument)
                 tick_value = instrument.tickValue if instrument else 1.0
                 size = int(risk_amount / (stop_dist * tick_value))
@@ -149,6 +155,9 @@ async def create_order(
         # Build order chain
         builder = OrderChainBuilder(suite)
 
+        if size is None:
+            raise ValueError("Size is required")
+
         if self.use_limit_entry:
             builder.limit_order(size=size, price=entry_price, side=side)
         else:
@@ -206,10 +215,10 @@ async def create_order(
         self,
         suite: "TradingSuite",
         side: int,
-        size: int,
+        size: Optional[int] = None,
         use_limit_entry: bool = False,
         entry_offset: float = 0,
-        **kwargs,
+        **kwargs: Any,
     ) -> BracketOrderResponse:
         """
         Create an order with ATR-based stops.
@@ -234,7 +243,7 @@ async def create_order(
         current_atr = float(data_with_atr[f"atr_{self.atr_period}"][-1])
 
         # Get current price
-        current_price = await suite.data.get_latest_price()
+        current_price = await suite.data.get_current_price()
         if not current_price:
             raise ValueError("Cannot get current price")
 
@@ -251,6 +260,9 @@ async def create_order(
         # Build order
         builder = OrderChainBuilder(suite)
 
+        if size is None:
+            raise ValueError("Size is required")
+
         if use_limit_entry:
             if side == 0:  # BUY
                 entry_price = current_price - entry_offset
@@ -296,11 +308,11 @@ async def create_order(
         self,
         suite: "TradingSuite",
         side: int,
-        size: int,
+        size: Optional[int] = None,
         breakout_level: Optional[float] = None,
         range_size: Optional[float] = None,
         lookback_bars: int = 20,
-        **kwargs,
+        **kwargs: Any,
     ) -> BracketOrderResponse:
         """
         Create a breakout order.
@@ -335,12 +347,16 @@ async def create_order(
         # Calculate entry price
         if side == 0:  # BUY
             entry_price = breakout_level + self.breakout_offset
+            if range_size is None:
+                raise ValueError("Range size is required")
             stop_price = (
                 breakout_level if self.stop_at_level else breakout_level - range_size
             )
             target_price = entry_price + (range_size * self.target_range_multiplier)
         else:  # SELL
             entry_price = breakout_level - self.breakout_offset
+            if range_size is None:
+                raise ValueError("Range size is required")
             stop_price = (
                 breakout_level if self.stop_at_level else breakout_level + range_size
             )
@@ -353,6 +369,9 @@ async def create_order(
         )
 
         # Build order
+        if size is None:
+            raise ValueError("Size is required")
+
         builder = (
             OrderChainBuilder(suite)
             .stop_order(size=size, price=entry_price, side=side)
@@ -396,9 +415,9 @@ async def create_order(
         self,
         suite: "TradingSuite",
         side: int,
-        size: int,
+        size: Optional[int] = None,
         check_spread: bool = True,
-        **kwargs,
+        **kwargs: Any,
     ) -> BracketOrderResponse:
         """
         Create a scalping order.
@@ -422,10 +441,10 @@ async def create_order(
         # Check spread if requested
         if check_spread and hasattr(suite, "orderbook") and suite.orderbook:
             orderbook = suite.orderbook
-            spread_info = await orderbook.get_spread()
+            spread = await orderbook.get_bid_ask_spread()
 
-            if spread_info:
-                spread_ticks = spread_info["spread"] / tick_size
+            if spread is not None:
+                spread_ticks = spread / tick_size
                 if spread_ticks > self.max_spread_ticks:
                     raise ValueError(
                         f"Spread too wide: {spread_ticks:.1f} ticks "
@@ -439,11 +458,14 @@ async def create_order(
         # Build order
         builder = OrderChainBuilder(suite)
 
+        if size is None:
+            raise ValueError("Size is required")
+
         if self.use_market_entry:
             builder.market_order(size=size, side=side)
         else:
             # Use limit at best bid/ask
-            current_price = await suite.data.get_latest_price()
+            current_price = await suite.data.get_current_price()
             if not current_price:
                 raise ValueError("Cannot get current price")
             builder.limit_order(size=size, price=current_price, side=side)

src/project_x_py/order_tracker.py

@@ -54,7 +54,8 @@
 
 import asyncio
 import logging
-from typing import TYPE_CHECKING, Any, Optional, Union
+from types import TracebackType
+from typing import TYPE_CHECKING, Any, Optional, Type, Union
 
 from project_x_py.event_bus import EventType
 from project_x_py.models import BracketOrderResponse, Order, OrderPlaceResponse
@@ -113,7 +114,12 @@ async def __aenter__(self) -> "OrderTracker":
         await self._setup_event_handlers()
         return self
 
-    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
         """Exit the context manager and clean up."""
         await self.cleanup()
 
@@ -212,7 +218,7 @@ async def wait_for_fill(self, timeout: float = 30.0) -> Order:
                 return self._filled_order
             else:
                 # Fetch latest order data
-                order = await self.order_manager.get_order(self.order_id)
+                order = await self.order_manager.get_order_by_id(self.order_id)
                 if order and order.status == 2:  # FILLED
                     return order
                 else:
@@ -249,7 +255,7 @@ async def wait_for_status(self, status: int, timeout: float = 30.0) -> Order:
 
         # Check if already at target status
         if self._current_status == status:
-            order = await self.order_manager.get_order(self.order_id)
+            order = await self.order_manager.get_order_by_id(self.order_id)
             if order:
                 return order
 
@@ -260,7 +266,7 @@ async def wait_for_status(self, status: int, timeout: float = 30.0) -> Order:
                 raise self._error
 
             # Fetch latest order data
-            order = await self.order_manager.get_order(self.order_id)
+            order = await self.order_manager.get_order_by_id(self.order_id)
             if order and order.status == status:
                 return order
             else:
@@ -457,9 +463,11 @@ async def execute(self) -> BracketOrderResponse:
             raise ValueError("Contract ID is required")
 
         contract_id = self.contract_id or self.suite.instrument_id
+        if not contract_id:
+            raise ValueError("Contract ID is required")
 
         # Calculate risk order prices if needed
-        current_price = await self.suite.data.get_latest_price()
+        current_price = await self.suite.data.get_current_price()
         if not current_price:
             raise ValueError("Cannot get current price for risk calculations")
 
@@ -499,13 +507,15 @@ async def execute(self) -> BracketOrderResponse:
             bracket_entry_price = (
                 entry_price if self.entry_type != "market" else current_price
             )
+            assert self.side is not None  # Already checked above
+            assert self.size is not None  # Already checked above
             result = await self.order_manager.place_bracket_order(
                 contract_id=contract_id,
                 side=self.side,
                 size=self.size,
                 entry_price=bracket_entry_price,
-                stop_loss_price=stop_loss_price,
-                take_profit_price=take_profit_price,
+                stop_loss_price=stop_loss_price or 0.0,
+                take_profit_price=take_profit_price or 0.0,
                 entry_type=self.entry_type,
             )
 
@@ -523,13 +533,17 @@ async def execute(self) -> BracketOrderResponse:
                     contract_id=contract_id, side=self.side, size=self.size
                 )
             elif self.entry_type == "limit":
+                if self.entry_price is None:
+                    raise ValueError("Entry price is required for limit orders")
                 response = await self.order_manager.place_limit_order(
                     contract_id=contract_id,
                     side=self.side,
                     size=self.size,
-                    price=self.entry_price,
+                    limit_price=self.entry_price,
                 )
             else:  # stop
+                if self.entry_price is None:
+                    raise ValueError("Entry price is required for stop orders")
                 response = await self.order_manager.place_stop_order(
                     contract_id=contract_id,
                     side=self.side,

src/project_x_py/orderbook/memory.py

@@ -402,7 +402,9 @@ async def get_memory_stats(self) -> OrderbookStats:
             spreads = [
                 float(ask["price"]) - float(bid["price"])
                 for bid, ask in zip(
-                    self.orderbook.best_bid_history, self.orderbook.best_ask_history
+                    self.orderbook.best_bid_history,
+                    self.orderbook.best_ask_history,
+                    strict=False,
                 )
                 if float(bid["price"]) > 0 and float(ask["price"]) > 0
             ]

src/project_x_py/orderbook/profile.py

@@ -500,8 +500,8 @@ async def get_spread_analysis(
                 spread_values = [s["spread"] for s in recent_spreads]
                 current_spread = spread_values[-1]
                 avg_spread = sum(spread_values) / len(spread_values)
-                min_spread = min(spread_values)
-                max_spread = max(spread_values)
+                _min_spread = min(spread_values)
+                _max_spread = max(spread_values)
 
                 # Calculate volatility
                 variance = sum((s - avg_spread) ** 2 for s in spread_values) / len(
@@ -519,16 +519,16 @@ async def get_spread_analysis(
                     )
 
                     if second_half_avg > first_half_avg * 1.1:
-                        spread_trend = "widening"
+                        _spread_trend = "widening"
                     elif second_half_avg < first_half_avg * 0.9:
-                        spread_trend = "tightening"
+                        _spread_trend = "tightening"
                     else:
-                        spread_trend = "stable"
+                        _spread_trend = "stable"
                 else:
-                    spread_trend = "insufficient_data"
+                    _spread_trend = "insufficient_data"
 
                 # Calculate spread distribution
-                spread_distribution = {
+                _spread_distribution = {
                     "tight": len([s for s in spread_values if s <= avg_spread * 0.8]),
                     "normal": len(
                         [
@@ -544,7 +544,7 @@ async def get_spread_analysis(
                 current_time = datetime.now(self.orderbook.timezone)
 
                 # Get current orderbook state for liquidity metrics
-                best_prices = self.orderbook._get_best_bid_ask_unlocked()
+                _best_prices = self.orderbook._get_best_bid_ask_unlocked()
                 bid_liquidity = 0.0
                 ask_liquidity = 0.0
                 total_liquidity = 0.0

src/project_x_py/position_manager/analytics.py

@@ -46,7 +46,7 @@
 """
 
 from datetime import datetime
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 
 from project_x_py.models import Position
 from project_x_py.types.response_types import (
@@ -153,7 +153,7 @@ async def calculate_position_pnl(
             pnl_per_contract = price_change
 
         unrealized_pnl = pnl_per_contract * position.size
-        market_value = current_price * position.size
+        _market_value = current_price * position.size
 
         # Calculate additional fields for PositionAnalysisResponse
         position_value = abs(

src/project_x_py/position_manager/core.py

@@ -76,7 +76,6 @@
 from project_x_py.position_manager.risk import RiskManagementMixin
 from project_x_py.position_manager.tracking import PositionTrackingMixin
 from project_x_py.types.config_types import PositionManagerConfig
-from project_x_py.types.stats_types import PositionManagerStats
 from project_x_py.utils import (
     LogMessages,
     ProjectXLogger,

src/project_x_py/position_manager/reporting.py

@@ -274,10 +274,10 @@ async def export_portfolio_report(
             "portfolio_summary": {
                 "total_positions": len(positions),
                 "total_pnl": pnl_data["total_pnl"],
-                "total_exposure": risk_data["total_exposure"],
-                "portfolio_risk": risk_data["portfolio_risk"],
+                "total_exposure": risk_data["current_risk"],
+                "portfolio_risk": risk_data["max_risk"],
             },
-            "positions": pnl_data["positions"],
+            "positions": positions,
             "risk_analysis": risk_data,
             "statistics": stats,
             "alerts": {