Merge pull request #8 from TexasCoding/work_on_example_strategy

Work on example strategy

Author: TexasCoding

examples/06_multi_timeframe_strategy.py

@@ -22,6 +22,8 @@
 Date: July 2025
 """
 
+import signal
+import sys
 import time
 from decimal import Decimal
 
@@ -344,23 +346,106 @@ def display_strategy_analysis(strategy):
     return signal_data
 
 
+# Global variables for cleanup
+_cleanup_managers = {}
+_cleanup_initiated = False
+
+def _emergency_cleanup(signum=None, frame=None):
+    """Emergency cleanup function called on signal interruption."""
+    global _cleanup_initiated
+    if _cleanup_initiated:
+        print("\n🚨 Already cleaning up, please wait...")
+        return
+    
+    _cleanup_initiated = True
+    
+    if signum:
+        signal_name = signal.Signals(signum).name
+        print(f"\n🚨 Received {signal_name} signal - initiating emergency cleanup!")
+    else:
+        print("\n🚨 Initiating emergency cleanup!")
+    
+    if _cleanup_managers:
+        print("⚠️  Emergency position and order cleanup in progress...")
+        
+        try:
+            order_manager = _cleanup_managers.get("order_manager")
+            position_manager = _cleanup_managers.get("position_manager")
+            data_manager = _cleanup_managers.get("data_manager")
+            
+            if order_manager and position_manager:
+                # Get current state
+                positions = position_manager.get_all_positions()
+                orders = order_manager.search_open_orders()
+                
+                if positions or orders:
+                    print(f"🚫 Emergency: Cancelling {len(orders)} orders and closing {len(positions)} positions...")
+                    
+                    # Cancel all orders immediately
+                    for order in orders:
+                        try:
+                            order_manager.cancel_order(order.id)
+                            print(f"   ✅ Cancelled order {order.id}")
+                        except:
+                            print(f"   ❌ Failed to cancel order {order.id}")
+                    
+                    # Close all positions with market orders
+                    for pos in positions:
+                        try:
+                            close_side = 1 if pos.type == 1 else 0
+                            close_response = order_manager.place_market_order(
+                                contract_id=pos.contractId,
+                                side=close_side,
+                                size=pos.size
+                            )
+                            if close_response.success:
+                                print(f"   ✅ Emergency close order: {close_response.order_id}")
+                        except:
+                            print(f"   ❌ Failed to close position {pos.contractId}")
+                    
+                    print("⏳ Waiting 3 seconds for emergency orders to process...")
+                    time.sleep(3)
+                else:
+                    print("✅ No positions or orders to clean up")
+                    
+            # Stop data feed
+            if data_manager:
+                try:
+                    data_manager.stop_realtime_feed()
+                    print("🧹 Real-time feed stopped")
+                except:
+                    pass
+                    
+        except Exception as e:
+            print(f"❌ Emergency cleanup error: {e}")
+    
+    print("🚨 Emergency cleanup completed - check your trading platform!")
+    sys.exit(1)
+
 def wait_for_user_confirmation(message: str) -> bool:
     """Wait for user confirmation before proceeding."""
     print(f"\n⚠️  {message}")
     try:
         response = input("Continue? (y/N): ").strip().lower()
         return response == "y"
-    except EOFError:
-        # Handle EOF when input is piped (default to no for safety)
-        print("N (EOF detected - defaulting to No for safety)")
+    except (EOFError, KeyboardInterrupt):
+        # Handle EOF when input is piped or Ctrl+C during input
+        print("\nN (Interrupted - defaulting to No for safety)")
         return False
 
 
 def main():
     """Demonstrate multi-timeframe trading strategy."""
+    global _cleanup_managers
+    
+    # Register signal handlers for emergency cleanup
+    signal.signal(signal.SIGINT, _emergency_cleanup)   # Ctrl+C
+    signal.signal(signal.SIGTERM, _emergency_cleanup)  # Termination signal
+    
     logger = setup_logging(level="INFO")
     print("🚀 Multi-Timeframe Trading Strategy Example")
     print("=" * 60)
+    print("📋 Emergency cleanup registered (Ctrl+C will close positions/orders)")
 
     # Safety warning
     print("⚠️  WARNING: This strategy can place REAL ORDERS!")
@@ -406,18 +491,25 @@ def main():
             data_manager = trading_suite["data_manager"]
             order_manager = trading_suite["order_manager"]
             position_manager = trading_suite["position_manager"]
+            
+            # Store managers for emergency cleanup
+            _cleanup_managers["data_manager"] = data_manager
+            _cleanup_managers["order_manager"] = order_manager
+            _cleanup_managers["position_manager"] = position_manager
 
             print("✅ Trading suite created successfully")
             print(f"   Timeframes: {', '.join(timeframes)}")
+            print("🛡️  Emergency cleanup protection activated")
 
         except Exception as e:
             print(f"❌ Failed to create trading suite: {e}")
             return False
 
-        # Initialize with historical data
+        # Initialize with historical data (need enough for 50-period SMA on 4hr timeframe)
         print("\n📚 Initializing with historical data...")
-        if data_manager.initialize(initial_days=10):
-            print("✅ Historical data loaded (10 days)")
+        # 50 periods * 4 hours = 200 hours ≈ 8.3 days, so load 15 days to be safe
+        if data_manager.initialize(initial_days=15):
+            print("✅ Historical data loaded (15 days)")
         else:
             print("❌ Failed to load historical data")
             return False
@@ -537,6 +629,7 @@ def main():
 
         except KeyboardInterrupt:
             print("\n⏹️ Strategy monitoring stopped by user")
+            # Signal handler will take care of cleanup
 
         # Final analysis and statistics
         print("\n" + "=" * 50)
@@ -560,11 +653,24 @@ def main():
             print("   Position Details:")
             for pos in final_positions:
                 direction = "LONG" if pos.type == 1 else "SHORT"
-                pnl_info = position_manager.get_position_pnl(pos.contractId)
-                pnl = pnl_info.get("unrealized_pnl", 0) if pnl_info else 0
-                print(
-                    f"     {pos.contractId}: {direction} {pos.size} @ ${pos.averagePrice:.2f} (P&L: ${pnl:+.2f})"
-                )
+                
+                # Get current price for P&L calculation
+                try:
+                    current_price = data_manager.get_current_price()
+                    if current_price:
+                        pnl_info = position_manager.calculate_position_pnl(pos, current_price)
+                        pnl = pnl_info.get("unrealized_pnl", 0) if pnl_info else 0
+                        print(
+                            f"     {pos.contractId}: {direction} {pos.size} @ ${pos.averagePrice:.2f} (P&L: ${pnl:+.2f})"
+                        )
+                    else:
+                        print(
+                            f"     {pos.contractId}: {direction} {pos.size} @ ${pos.averagePrice:.2f} (P&L: N/A)"
+                        )
+                except Exception as e:
+                    print(
+                        f"     {pos.contractId}: {direction} {pos.size} @ ${pos.averagePrice:.2f} (P&L: Error - {e})"
+                    )
 
         # Show final signal analysis
         print("\n🧠 Final Strategy Analysis:")
@@ -599,19 +705,121 @@ def main():
 
     except KeyboardInterrupt:
         print("\n⏹️ Example interrupted by user")
+        # Signal handler will handle emergency cleanup
         return False
     except Exception as e:
         logger.error(f"❌ Multi-timeframe strategy example failed: {e}")
         print(f"❌ Error: {e}")
         return False
     finally:
-        # Cleanup
+        # Comprehensive cleanup - close positions and cancel orders
+        cleanup_performed = False
+        
+        if "order_manager" in locals() and "position_manager" in locals():
+            try:
+                print("\n" + "=" * 50)
+                print("🧹 STRATEGY CLEANUP")
+                print("=" * 50)
+                
+                # Get current positions and orders
+                final_positions = position_manager.get_all_positions()
+                final_orders = order_manager.search_open_orders()
+                
+                if final_positions or final_orders:
+                    print(f"⚠️  Found {len(final_positions)} open positions and {len(final_orders)} open orders")
+                    print("   For safety, all positions and orders should be closed when exiting.")
+                    
+                    # Ask for user confirmation to close everything
+                    if wait_for_user_confirmation("Close all positions and cancel all orders?"):
+                        cleanup_performed = True
+                        
+                        # Cancel all open orders first
+                        if final_orders:
+                            print(f"\n🚫 Cancelling {len(final_orders)} open orders...")
+                            cancelled_count = 0
+                            for order in final_orders:
+                                try:
+                                    if order_manager.cancel_order(order.id):
+                                        cancelled_count += 1
+                                        print(f"   ✅ Cancelled order {order.id}")
+                                    else:
+                                        print(f"   ❌ Failed to cancel order {order.id}")
+                                except Exception as e:
+                                    print(f"   ❌ Error cancelling order {order.id}: {e}")
+                            
+                            print(f"   📊 Successfully cancelled {cancelled_count}/{len(final_orders)} orders")
+                        
+                        # Close all open positions
+                        if final_positions:
+                            print(f"\n📤 Closing {len(final_positions)} open positions...")
+                            closed_count = 0
+                            
+                            for pos in final_positions:
+                                try:
+                                    direction = "LONG" if pos.type == 1 else "SHORT"
+                                    print(f"   🎯 Closing {direction} {pos.size} {pos.contractId} @ ${pos.averagePrice:.2f}")
+                                    
+                                    # Get current market price for market order
+                                    current_price = data_manager.get_current_price() if "data_manager" in locals() else None
+                                    
+                                    # Close position with market order (opposite side)
+                                    close_side = 1 if pos.type == 1 else 0  # Opposite of position type
+                                    
+                                    close_response = order_manager.place_market_order(
+                                        contract_id=pos.contractId,
+                                        side=close_side,
+                                        size=pos.size
+                                    )
+                                    
+                                    if close_response.success:
+                                        closed_count += 1
+                                        print(f"   ✅ Close order placed: {close_response.order_id}")
+                                    else:
+                                        print(f"   ❌ Failed to place close order: {close_response.error_message}")
+                                        
+                                except Exception as e:
+                                    print(f"   ❌ Error closing position {pos.contractId}: {e}")
+                            
+                            print(f"   📊 Successfully placed {closed_count}/{len(final_positions)} close orders")
+                            
+                            # Give orders time to fill
+                            if closed_count > 0:
+                                print("   ⏳ Waiting 5 seconds for orders to fill...")
+                                time.sleep(5)
+                                
+                                # Check final status
+                                remaining_positions = position_manager.get_all_positions()
+                                if remaining_positions:
+                                    print(f"   ⚠️  {len(remaining_positions)} positions still open - monitor manually")
+                                else:
+                                    print("   ✅ All positions successfully closed")
+                    else:
+                        print("   ℹ️  Cleanup skipped by user - positions and orders remain open")
+                        print("   ⚠️  IMPORTANT: Monitor your positions manually!")
+                else:
+                    print("✅ No open positions or orders to clean up")
+                    cleanup_performed = True
+                    
+            except Exception as e:
+                print(f"❌ Error during cleanup: {e}")
+        
+        # Stop real-time feed
         if "data_manager" in locals():
             try:
                 data_manager.stop_realtime_feed()
-                print("🧹 Real-time feed stopped")
+                print("\n🧹 Real-time feed stopped")
             except Exception as e:
-                print(f"⚠️  Cleanup warning: {e}")
+                print(f"⚠️  Feed stop warning: {e}")
+        
+        # Final safety message
+        if not cleanup_performed:
+            print("\n" + "⚠️ " * 20)
+            print("🚨 IMPORTANT SAFETY NOTICE:")
+            print("   - Open positions and orders were NOT automatically closed")
+            print("   - Please check your trading platform immediately")
+            print("   - Manually close any unwanted positions or orders")
+            print("   - Monitor your account for any unexpected activity")
+            print("⚠️ " * 20)
 
 
 if __name__ == "__main__":

examples/07_technical_indicators.py

@@ -440,7 +440,7 @@ def create_comprehensive_analysis(data):
             total_signals += 1
 
             # Momentum Analysis
-            rsi = row.get("rsi", 0)
+            rsi = row.get("rsi_14", 0)
 
             print("\n⚡ Momentum Indicators:")
             if 30 < rsi < 70:

src/project_x_py/position_manager.py

@@ -274,23 +274,28 @@ def _process_position_data(self, position_data: dict):
         - type=1 means "Long", type=2 means "Short"
         """
         try:
-            # According to ProjectX docs, the payload IS the position data directly
-            # No need to extract from "data" field
+            # Handle wrapped position data from real-time updates
+            # Real-time updates come as: {"action": 1, "data": {position_data}}
+            # But direct API calls might provide raw position data
+            actual_position_data = position_data
+            if "action" in position_data and "data" in position_data:
+                actual_position_data = position_data["data"]
+                self.logger.debug(f"Extracted position data from wrapper: action={position_data.get('action')}")
 
             # Validate payload format
-            if not self._validate_position_payload(position_data):
-                self.logger.error(f"Invalid position payload format: {position_data}")
+            if not self._validate_position_payload(actual_position_data):
+                self.logger.error(f"Invalid position payload format: {actual_position_data}")
                 return
 
-            contract_id = position_data.get("contractId")
+            contract_id = actual_position_data.get("contractId")
             if not contract_id:
-                self.logger.error(f"No contract ID found in {position_data}")
+                self.logger.error(f"No contract ID found in {actual_position_data}")
                 return
 
             # Check if this is a position closure
             # Position is closed when size == 0 (not when type == 0)
             # type=0 means "Undefined" according to PositionType enum, not closed
-            position_size = position_data.get("size", 0)
+            position_size = actual_position_data.get("size", 0)
             is_position_closed = position_size == 0
 
             # Get the old position before updating
@@ -309,11 +314,11 @@ def _process_position_data(self, position_data: dict):
                     self.order_manager.on_position_closed(contract_id)
 
                 # Trigger position_closed callbacks with the closure data
-                self._trigger_callbacks("position_closed", {"data": position_data})
+                self._trigger_callbacks("position_closed", {"data": actual_position_data})
             else:
                 # Position is open/updated - create or update position
                 # ProjectX payload structure matches our Position model fields
-                position = Position(**position_data)
+                position = Position(**actual_position_data)
                 self.tracked_positions[contract_id] = position
 
                 # Synchronize orders - update order sizes if position size changed
@@ -330,7 +335,7 @@ def _process_position_data(self, position_data: dict):
                 self.position_history[contract_id].append(
                     {
                         "timestamp": datetime.now(),
-                        "position": position_data.copy(),
+                        "position": actual_position_data.copy(),
                         "size_change": position_size - old_size,
                     }
                 )