Add typing fixes

Author: TexasCoding

examples/02_order_management.py

@@ -32,6 +32,7 @@
     create_realtime_client,
     setup_logging,
 )
+from project_x_py.models import Order
 
 
 async def wait_for_user_confirmation(message: str) -> bool:
@@ -80,7 +81,11 @@ async def show_order_status(order_manager, order_id: int, description: str):
     else:
         # Fall back to API check for status
         print(f"   Order {order_id} not in real-time cache, checking API...")
-        api_order = await order_manager.get_order_by_id(order_id)
+        api_order: Order | None = await order_manager.get_order_by_id(order_id)
+        if not isinstance(api_order, Order):
+            print(f"   Order {order_id} not found in API either")
+            return
+
         if api_order:
             status_map = {1: "Open", 2: "Filled", 3: "Cancelled", 4: "Partially Filled"}
             status = status_map.get(api_order.status, f"Unknown ({api_order.status})")

examples/03_position_management.py

@@ -30,6 +30,7 @@
     create_realtime_client,
     setup_logging,
 )
+from project_x_py.position_manager import PositionManager
 from project_x_py.realtime_data_manager import RealtimeDataManager
 
 
@@ -74,7 +75,7 @@ async def try_get_data(days, interval):
     return None
 
 
-async def display_positions(position_manager):
+async def display_positions(position_manager: PositionManager):
     """Display current positions with detailed information."""
     print("\n📊 Current Positions:")
     print("-" * 80)
@@ -88,29 +89,24 @@ async def display_positions(position_manager):
     # Get portfolio P&L concurrently with position display
     pnl_task = asyncio.create_task(position_manager.get_portfolio_pnl())
 
+    portfolio_pnl = await pnl_task
     # Display each position
-    for symbol, position in positions.items():
-        print(f"\n{symbol}:")
-        print(f"  Quantity: {position.quantity}")
+    for position in positions:
+        print(f"\n{position.contractId}:")
+        print(f"  Quantity: {position.size}")
         print(f"  Average Price: ${position.averagePrice:.2f}")
-        print(f"  Position Value: ${position.positionValue:.2f}")
-        print(f"  Unrealized P&L: ${position.unrealizedPnl:.2f}")
-
-        # Show percentage change
-        if position.averagePrice > 0:
-            pnl_pct = (
-                position.unrealizedPnl / (position.quantity * position.averagePrice)
-            ) * 100
-            print(f"  P&L %: {pnl_pct:+.2f}%")
+        print(f"  Position Value: ${position.averagePrice:.2f}")
+        print(f"  Unrealized P&L: ${portfolio_pnl.get('unrealized_pnl', 0):.2f}")
 
     # Show portfolio totals
-    portfolio_pnl = await pnl_task
     print("\n" + "=" * 40)
-    print(f"Portfolio Total P&L: ${portfolio_pnl:.2f}")
+    print(f"Portfolio Total P&L: ${portfolio_pnl.get('net_pnl', 0):.2f}")
     print("=" * 40)
 
 
-async def monitor_positions_realtime(position_manager, duration_seconds=30):
+async def monitor_positions_realtime(
+    position_manager: PositionManager, duration_seconds: int = 30
+):
     """Monitor positions with real-time updates."""
     print(f"\n🔄 Monitoring positions for {duration_seconds} seconds...")
 

examples/05_orderbook_analysis.py

@@ -38,6 +38,7 @@
     create_realtime_client,
     setup_logging,
 )
+from project_x_py.orderbook import OrderBook
 
 
 async def display_best_prices(orderbook):
@@ -259,7 +260,7 @@ async def monitor_orderbook_feed(orderbook, duration_seconds=60):
     print(f"   Update Cycles: {update_count}", flush=True)
 
 
-async def demonstrate_all_orderbook_methods(orderbook):
+async def demonstrate_all_orderbook_methods(orderbook: OrderBook):
     """Comprehensive demonstration of all OrderBook methods."""
     print("\n🔍 Testing all available OrderBook methods...", flush=True)
     print(

examples/06_multi_timeframe_strategy.py

@@ -31,6 +31,7 @@
     create_trading_suite,
 )
 from project_x_py.indicators import RSI, SMA
+from project_x_py.models import BracketOrderResponse, Position
 
 
 class MultiTimeframeStrategy:
@@ -47,11 +48,13 @@ class MultiTimeframeStrategy:
 
     def __init__(
         self,
+        client: ProjectX,
         trading_suite: dict,
         symbol: str = "MNQ",
         max_position_size: int = 2,
         risk_percentage: float = 0.02,
     ):
+        self.client = client
         self.suite = trading_suite
         self.symbol = symbol
         self.max_position_size = max_position_size
@@ -245,19 +248,20 @@ async def generate_trading_signal(self):
     async def execute_signal(self, signal_data: dict):
         """Execute trading signal with proper risk management."""
         # Check current position
-        positions = await self.position_manager.get_all_positions()
-        current_position = positions.get(self.symbol)
+        positions: list[Position] = await self.position_manager.get_all_positions()
+        current_position = next(
+            (pos for pos in positions if pos.contractId == self.symbol), None
+        )
 
         # Position size limits
-        if (
-            current_position
-            and abs(current_position.quantity) >= self.max_position_size
-        ):
+        if current_position and abs(current_position.size) >= self.max_position_size:
             self.logger.info("Max position size reached, skipping signal")
             return
 
         # Get account info for position sizing
-        account_balance = float(self.order_manager.project_x.account_info.balance)
+        account_balance = (
+            float(self.client.account_info.balance) if self.client.account_info else 0
+        )
 
         # Calculate position size based on risk
         entry_price = signal_data["price"]
@@ -285,11 +289,11 @@ async def execute_signal(self, signal_data: dict):
             return
 
         # Get active contract
-        instruments = await self.order_manager.project_x.search_instruments(self.symbol)
+        instruments = await self.client.search_instruments(self.symbol)
         if not instruments:
             return
 
-        contract_id = instruments[0].activeContract
+        contract_id = instruments[0].id
 
         # Place bracket order
         self.logger.info(
@@ -313,8 +317,14 @@ async def execute_signal(self, signal_data: dict):
                 take_profit_price=take_profit,
             )
 
+            if not isinstance(response, BracketOrderResponse):
+                self.logger.error(f"❌ Unexpected order type: {type(response)}")
+                return
+
             if response and response.success:
-                self.logger.info(f"✅ Order placed successfully: {response.orderId}")
+                self.logger.info(
+                    f"✅ Order placed successfully: {response.entry_order_id}"
+                )
             else:
                 self.logger.error("❌ Order placement failed")
 
@@ -434,6 +444,7 @@ def signal_handler(signum, frame):
 
             # Create and configure strategy
             strategy = MultiTimeframeStrategy(
+                client=client,
                 trading_suite=suite,
                 symbol="MNQ",
                 max_position_size=2,

examples/07_technical_indicators.py

@@ -179,7 +179,7 @@ async def on_data_update(timeframe):
         update_count += 1
 
         # Get latest data
-        data = await data_manager.get_data(timeframe)
+        data: pl.DataFrame | None = await data_manager.get_data(timeframe)
         if data is None:
             return
 
@@ -189,8 +189,7 @@ async def on_data_update(timeframe):
             return
 
         # Calculate key indicators
-        data = data.pipe(RSI, period=14)
-        data = data.pipe(SMA, period=20)
+        data = data.pipe(RSI, period=14).pipe(SMA, period=20)
 
         last_row = data.tail(1)
         timestamp = datetime.now().strftime("%H:%M:%S")

examples/08_order_and_position_tracking.py

@@ -3,17 +3,17 @@
 Order and Position Tracking Demo
 
 This demo script demonstrates the automatic order cleanup functionality when positions are closed,
-using proper async components (AsyncOrderManager, AsyncPositionManager, AsyncRealtimeDataManager).
+using proper components (OrderManager, PositionManager, RealtimeDataManager).
 
 It creates a bracket order and monitors positions and orders in real-time, showing how the system
 automatically cancels remaining orders when a position is closed (either by stop loss, take profit,
 or manual closure from the broker).
 
 Features demonstrated:
-- Proper async components for all operations
+- Proper components for all operations
 - Automatic order cleanup when positions close
 - Non-blocking real-time monitoring with clear status updates
-- Proper async cleanup on exit (cancels open orders and closes positions)
+- Proper cleanup on exit (cancels open orders and closes positions)
 - Concurrent operations for improved performance
 
 Usage:
@@ -35,6 +35,7 @@
 from datetime import datetime
 
 from project_x_py import ProjectX, create_trading_suite
+from project_x_py.models import BracketOrderResponse, Order, Position
 
 
 class OrderPositionDemo:
@@ -113,6 +114,10 @@ async def create_demo_bracket_order(self) -> bool:
                 account_id=account_info.id,
             )
 
+            if not isinstance(bracket_response, BracketOrderResponse):
+                print(f"❌ Unexpected bracket order type: {type(bracket_response)}")
+                return False
+
             if bracket_response and bracket_response.success:
                 print("✅ Bracket order created successfully!")
                 print(f"   Entry Order ID: {bracket_response.entry_order_id}")
@@ -171,6 +176,8 @@ async def display_status(self):
             if positions:
                 print("\n🏦 Position Details:")
                 for pos in positions:
+                    if not isinstance(pos, Position):
+                        continue
                     direction = (
                         "LONG"
                         if pos.type == 1
@@ -200,6 +207,9 @@ async def display_status(self):
             if orders:
                 print("\n📝 Order Details:")
                 for order in orders:
+                    if not isinstance(order, Order):
+                        print(f"   ❌ Unexpected order type: {type(order)}")
+                        continue
                     order_type = "UNKNOWN"
                     if hasattr(order, "type"):
                         order_type = order.type
@@ -303,13 +313,20 @@ async def cleanup_all_positions_and_orders(self):
                 print(f"📋 Cancelling {len(orders)} open orders...")
                 cancel_tasks = []
                 for order in orders:
+                    if not isinstance(order, Order):
+                        continue
                     cancel_tasks.append(
                         self.suite["order_manager"].cancel_order(order.id)
                     )
 
                 # Wait for all cancellations to complete
-                results = await asyncio.gather(*cancel_tasks, return_exceptions=True)
-                for order, result in zip(orders, results, strict=False):
+                cancel_results: list[Order | BaseException] = await asyncio.gather(
+                    *cancel_tasks, return_exceptions=True
+                )
+                for order, result in zip(orders, cancel_results, strict=False):
+                    if not isinstance(order, Order):
+                        print(f"   ❌ Unexpected order type: {type(order)}")
+                        continue
                     if isinstance(result, Exception):
                         print(f"   ❌ Error cancelling order {order.id}: {result}")
                     elif result:
@@ -318,7 +335,9 @@ async def cleanup_all_positions_and_orders(self):
                         print(f"   ⚠️ Failed to cancel order {order.id}")
 
             # Close all open positions
-            positions = await self.suite["position_manager"].get_all_positions()
+            positions: list[Position] = await self.suite[
+                "position_manager"
+            ].get_all_positions()
             if positions:
                 print(f"🏦 Closing {len(positions)} open positions...")
                 close_tasks = []
@@ -330,7 +349,9 @@ async def cleanup_all_positions_and_orders(self):
                     )
 
                 # Wait for all positions to close
-                results = await asyncio.gather(*close_tasks, return_exceptions=True)
+                results: list[Position | BaseException] = await asyncio.gather(
+                    *close_tasks, return_exceptions=True
+                )
                 for position, result in zip(positions, results, strict=False):
                     if isinstance(result, Exception):
                         print(
@@ -355,7 +376,7 @@ async def cleanup_all_positions_and_orders(self):
             print(f"❌ Error during cleanup: {e}")
 
     async def run(self, client: ProjectX):
-        """Main async demo execution."""
+        """Main demo execution."""
         self.setup_signal_handlers()
         self.client = client
 
@@ -376,9 +397,9 @@ async def run(self, client: ProjectX):
             print(f"❌ Failed to authenticate: {e}")
             return False
 
-        # Create async trading suite
+        # Create trading suite
         try:
-            print("\n🔧 Setting up async trading suite...")
+            print("\n🔧 Setting up trading suite...")
             jwt_token = self.client.session_token
             self.suite = await create_trading_suite(
                 instrument="MNQ",
@@ -388,10 +409,10 @@ async def run(self, client: ProjectX):
                 timeframes=["5min"],  # Minimal timeframes for demo
             )
 
-            print("✅ Async trading suite created with automatic order cleanup enabled")
+            print("✅ Trading suite created with automatic order cleanup enabled")
 
         except Exception as e:
-            print(f"❌ Failed to create async trading suite: {e}")
+            print(f"❌ Failed to create trading suite: {e}")
             return False
 
         # Connect real-time client and initialize data feed
@@ -442,7 +463,7 @@ async def run(self, client: ProjectX):
 
 
 async def main():
-    """Main async entry point."""
+    """Main entry point."""
     demo = OrderPositionDemo()
     try:
         async with ProjectX.from_env() as client:

examples/09_get_check_available_instruments.py

@@ -1,19 +1,19 @@
 #!/usr/bin/env python3
 """
-Async Interactive Instrument Search Demo for ProjectX
+Interactive Instrument Search Demo for ProjectX
 
-This async version demonstrates:
+This version demonstrates:
 - Using ProjectX client with async context manager
 - Async instrument search with await client.search_instruments()
 - Async best match selection with await client.get_instrument()
 - Non-blocking user input handling
 - Background performance stats monitoring
-- Proper async authentication flow
+- Proper authentication flow
 
 Key differences from sync version:
 - Uses ProjectX instead of ProjectX
 - All API calls use await (search_instruments, get_instrument)
-- Async context manager (async with)
+- Context manager (with)
 - Can run background tasks while accepting user input
 """
 
@@ -108,13 +108,13 @@ def show_common_symbols():
 
 
 async def get_user_input(prompt):
-    """Get user input asynchronously"""
+    """Get user input"""
     loop = asyncio.get_event_loop()
     return await loop.run_in_executor(None, input, prompt)
 
 
 async def run_interactive_search(client):
-    """Run the interactive search loop"""
+    """Run the interactive search loop."""
     show_common_symbols()
 
     print("\nHow the search works:")
@@ -145,7 +145,7 @@ async def run_interactive_search(client):
 
 
 async def main():
-    """Main async entry point"""
+    """Main entry point."""
     print("╔═══════════════════════════════════════════════════════╗")
     print("║   Async ProjectX Instrument Search Interactive Demo   ║")
     print("╚═══════════════════════════════════════════════════════╝")