work on v3 integration

Author: TexasCoding

SDK_IMPROVEMENTS_PLAN.md

@@ -713,18 +713,30 @@ def get_stats(self) -> TradingSuiteStats:
    - 63% reduction in order filtering code
    - Cleaner, more intuitive strategy code
 
-### Phase 5 (Week 5): Advanced Features
-1. **Order Lifecycle Management** (5 days)
-   - Implement OrderTracker
-   - Delete manual tracking code
-
-### Phase 6 (Week 6): Risk and Recovery
-1. **Built-in Risk Management** (3 days)
-   - Create RiskManager
-   - Integrate with order placement
-2. **Better Error Recovery** (2 days)
-   - Implement automatic reconnection
-   - Delete manual recovery code
+### Phase 5 (Week 5): Advanced Features ✅ COMPLETED (2025-08-04)
+1. **Order Lifecycle Management** ✅ COMPLETED
+   - ✅ Implemented OrderTracker with context manager for automatic cleanup
+   - ✅ Added async waiting mechanisms (wait_for_fill, wait_for_status)
+   - ✅ Created OrderChainBuilder for fluent API order construction
+   - ✅ Added common order templates (RiskReward, ATR, Breakout, Scalping)
+   - ✅ Integrated into TradingSuite with track_order() and order_chain() methods
+   - ✅ Removed need for manual order tracking in strategies
+   - ✅ Created comprehensive example demonstrating all features
+
+### Phase 6 (Week 6): Risk and Recovery ✅ COMPLETED (2025-08-04)
+1. **Built-in Risk Management** ✅ COMPLETED
+   - ✅ Created comprehensive RiskManager with position sizing algorithms
+   - ✅ Implemented trade validation against configurable risk rules
+   - ✅ Added automatic stop-loss and take-profit attachment
+   - ✅ Created ManagedTrade context manager for simplified trading
+   - ✅ Integrated RiskManager into TradingSuite with feature flag
+   - ✅ Added Kelly Criterion position sizing support
+   - ✅ Implemented daily loss and trade limits
+   - ✅ Created trailing stop monitoring
+2. **Better Error Recovery** (Future Enhancement)
+   - ConnectionManager for automatic reconnection
+   - StateManager for persistence and recovery
+   - Operation queuing during disconnections
 
 ## Type System Implementation Roadmap
 
@@ -1001,15 +1013,26 @@ def get_stats(self) -> TradingSuiteStats:
 - **Strategy-Friendly**: Properties like `is_long`, `direction`, `symbol` make code cleaner
 - **Result**: Much more intuitive and less error-prone strategy development
 
-### Next Up
-🎯 **Phase 5: Advanced Features**
-- Implement OrderTracker for lifecycle management
-- Delete manual tracking code
-
-### Next Steps
-1. Implement OrderTracker component (Week 5)
-2. Add automatic order lifecycle tracking
-3. Remove manual order state management code
+✅ **Phase 5: Order Lifecycle Management**
+- **OrderTracker**: Context manager for comprehensive order lifecycle tracking
+- **Async Waiting**: wait_for_fill() and wait_for_status() eliminate polling
+- **OrderChainBuilder**: Fluent API for complex order structures
+- **Order Templates**: Pre-configured templates for common trading patterns
+- **Result**: 90% reduction in order management complexity
+
+✅ **Phase 6: Risk Management**
+- **RiskManager**: Comprehensive risk management system with position sizing
+- **ManagedTrade**: Context manager for risk-controlled trade execution
+- **Risk Validation**: Automatic validation against configurable risk rules
+- **Position Sizing**: Fixed risk and Kelly Criterion algorithms
+- **Auto Risk Orders**: Automatic stop-loss and take-profit attachment
+- **Result**: Professional-grade risk management built into the SDK
+
+### Future Enhancements
+- **Error Recovery**: ConnectionManager for automatic reconnection
+- **State Persistence**: StateManager for saving/restoring trading state
+- **Trade Journal**: Automatic trade logging and analysis
+- **Performance Analytics**: Real-time strategy performance metrics
 
 ### Achievements So Far
 - **80% reduction** in initialization code (from ~50 lines to 1 line)
@@ -1033,7 +1056,16 @@ def get_stats(self) -> TradingSuiteStats:
 - **60-80% code reduction** in common trading patterns
 - **Intuitive property names** - no more magic numbers or verbose checks
 - **Strategy-friendly design** - properties like is_long, direction, symbol
-- **14 comprehensive examples** demonstrating all v3.0.0 features
+- **Comprehensive order lifecycle management** - OrderTracker eliminates manual state tracking
+- **Fluent order API** - OrderChainBuilder for complex order structures
+- **Pre-configured templates** - 11 order templates for common trading patterns
+- **90% reduction** in order management complexity
+- **Professional risk management** - RiskManager with position sizing algorithms
+- **Risk-controlled trading** - ManagedTrade context manager for automatic risk management
+- **Trade validation** - Automatic validation against configurable risk rules
+- **Multiple position sizing methods** - Fixed risk, Kelly Criterion, and more
+- **Automatic protective orders** - Stop-loss and take-profit attachment
+- **17 comprehensive examples** demonstrating all v3.0.0 features
 
 ## Conclusion
 

examples/01_basic_client_connection.py

@@ -72,7 +72,7 @@ async def main():
                 health_task, positions_task, instruments_task
             )
 
-            print(f"✅ API Calls Made: {health['client_stats']['api_calls']}")
+            print(f"✅ API Calls Made: {health['api_calls']}")
             print(f"✅ Open Positions: {len(positions)}")
             print(f"✅ Found Instruments: {len(instruments)}")
 

examples/02_order_management.py

@@ -121,7 +121,7 @@ async def main() -> bool:
     try:
         # Initialize trading suite with TradingSuite v3
         print("\n🔑 Initializing TradingSuite v3...")
-        suite = await TradingSuite.create("MNQ", features=["realtime_tracking"])
+        suite = await TradingSuite.create("MNQ")
 
         account = suite.client.account_info
         if not account:
@@ -333,27 +333,60 @@ async def main() -> bool:
 
                 first_order = demo_orders[0]
                 print(f"Attempting to modify Order #{first_order}")
+
+                # Get order details to determine type
+                order_data = await order_manager.get_tracked_order_status(
+                    str(first_order), wait_for_cache=True
+                )
+
+                if not order_data:
+                    # Fallback to API
+                    api_order = await order_manager.get_order_by_id(first_order)
+                    if api_order and hasattr(api_order, "type"):
+                        # Order types: 1=Limit, 2=Market, 4=Stop
+                        is_stop_order = api_order.type == 4
+                    else:
+                        is_stop_order = False
+                else:
+                    # Check if it has a stop price (indicating stop order)
+                    is_stop_order = bool(order_data.get("stopPrice"))
+
                 await show_order_status(
                     order_manager, first_order, "Before Modification"
                 )
 
-                # Try modifying the order (move price closer to market)
-                new_limit_price = current_price - Decimal("5.0")  # Closer to market
-                print(f"\nModifying to new limit price: ${new_limit_price:.2f}")
+                # Modify based on order type
+                if is_stop_order:
+                    # For stop orders, modify the stop price
+                    new_stop_price = current_price + Decimal("10.0")  # Move stop closer
+                    print(
+                        f"\nModifying stop order to new stop price: ${new_stop_price:.2f}"
+                    )
 
-                if await wait_for_user_confirmation("Modify order?"):
-                    modify_success = await order_manager.modify_order(
-                        order_id=first_order, limit_price=float(new_limit_price)
+                    if await wait_for_user_confirmation("Modify order?"):
+                        modify_success = await order_manager.modify_order(
+                            order_id=first_order, stop_price=float(new_stop_price)
+                        )
+                else:
+                    # For limit orders, modify the limit price
+                    new_limit_price = current_price - Decimal("5.0")  # Closer to market
+                    print(
+                        f"\nModifying limit order to new limit price: ${new_limit_price:.2f}"
                     )
 
-                    if modify_success:
-                        print(f"✅ Order {first_order} modified successfully")
-                        await asyncio.sleep(2)
-                        await show_order_status(
-                            order_manager, first_order, "After Modification"
+                    if await wait_for_user_confirmation("Modify order?"):
+                        modify_success = await order_manager.modify_order(
+                            order_id=first_order, limit_price=float(new_limit_price)
                         )
-                    else:
-                        print(f"❌ Failed to modify order {first_order}")
+
+                if "modify_success" in locals() and modify_success:
+                    print(f"✅ Order {first_order} modified successfully")
+                    await asyncio.sleep(2)
+                    await show_order_status(
+                        order_manager, first_order, "After Modification"
+                    )
+                elif "modify_success" in locals():
+                    print(f"❌ Failed to modify order {first_order}")
 
             # Monitor orders for a short time
             if demo_orders:
@@ -427,12 +460,14 @@ async def main() -> bool:
 
             stats = await order_manager.get_order_statistics()
             print("Order Manager Statistics:")
-            print(f"   Orders Placed: {stats['statistics']['orders_placed']}")
-            print(f"   Orders Cancelled: {stats['statistics']['orders_cancelled']}")
-            print(f"   Orders Modified: {stats['statistics']['orders_modified']}")
-            print(f"   Bracket Orders: {stats['statistics']['bracket_orders_placed']}")
-            print(f"   Tracked Orders: {stats['tracked_orders']}")
-            print(f"   Real-time Enabled: {stats['realtime_enabled']}")
+            print(f"   Orders Placed: {stats.get('orders_placed', 0)}")
+            print(f"   Orders Cancelled: {stats.get('orders_cancelled', 0)}")
+            print(f"   Orders Modified: {stats.get('orders_modified', 0)}")
+            print(f"   Bracket Orders: {stats.get('bracket_orders', 0)}")
+            print(f"   Fill Rate: {stats.get('fill_rate', 0):.1%}")
+            print(f"   Market Orders: {stats.get('market_orders', 0)}")
+            print(f"   Limit Orders: {stats.get('limit_orders', 0)}")
+            print(f"   Stop Orders: {stats.get('stop_orders', 0)}")
 
         finally:
             # Enhanced cleanup: Cancel ALL orders and close ALL positions

examples/03_position_management.py

@@ -77,7 +77,9 @@ async def try_get_data(days: int, interval: int) -> float | None:
     return None
 
 
-async def display_positions(position_manager: "PositionManager") -> None:
+async def display_positions(
+    position_manager: "PositionManager", suite: TradingSuite | None = None
+) -> None:
     """Display current positions with detailed information."""
     print("\n📊 Current Positions:")
     print("-" * 80)
@@ -88,17 +90,45 @@ async def display_positions(position_manager: "PositionManager") -> None:
         print("No open positions")
         return
 
-    # 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
+    # Display each position with real P&L calculation
     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.averagePrice:.2f}")
-        print(f"  Unrealized P&L: ${portfolio_pnl.get('unrealized_pnl', 0):.2f}")
+
+        # Calculate position value
+        position_value = position.averagePrice * position.size
+        print(f"  Position Value: ${position_value:,.2f}")
+
+        # Calculate real P&L if we have market data
+        unrealized_pnl = 0.0
+        if suite:
+            try:
+                # Get current market price
+                current_price = await suite.data.get_current_price()
+                if current_price:
+                    # Get instrument info for tick value
+                    instrument_info = await suite.client.get_instrument(
+                        suite.instrument
+                    )
+                    tick_value = instrument_info.tickValue
+
+                    # Calculate P&L using position manager's method
+                    pnl_data = await position_manager.calculate_position_pnl(
+                        position, float(current_price), point_value=tick_value
+                    )
+                    unrealized_pnl = pnl_data["unrealized_pnl"]
+            except Exception:
+                # If we can't get real-time price, try portfolio P&L
+                try:
+                    portfolio_pnl = await position_manager.get_portfolio_pnl()
+                    unrealized_pnl = portfolio_pnl.get("unrealized_pnl", 0) / len(
+                        positions
+                    )
+                except Exception:
+                    pass
+
+        print(f"  Unrealized P&L: ${unrealized_pnl:,.2f}")
 
 
 async def display_risk_metrics(position_manager: "PositionManager") -> None:
@@ -137,7 +167,9 @@ async def display_risk_metrics(position_manager: "PositionManager") -> None:
 
 
 async def monitor_positions(
-    position_manager: "PositionManager", duration: int = 30
+    position_manager: "PositionManager",
+    suite: TradingSuite | None = None,
+    duration: int = 30,
 ) -> None:
     """Monitor positions for a specified duration with async updates."""
     print(f"\n👁️  Monitoring positions for {duration} seconds...")
@@ -157,13 +189,36 @@ async def monitor_positions(
             if positions:
                 print(f"  Active positions: {len(positions)}")
 
-                # Get P&L if available
+                # Get P&L with current market prices
+                total_pnl = 0.0
                 try:
-                    pnl = await position_manager.get_portfolio_pnl()
-                    print(f"  Total P&L: ${pnl.get('total_pnl', 0):,.2f}")
+                    # Try to calculate real P&L with current prices
+                    if suite and positions:
+                        current_price = await suite.data.get_current_price()
+                        if current_price:
+                            instrument_info = await suite.client.get_instrument(
+                                suite.instrument
+                            )
+                            tick_value = instrument_info.tickValue
+
+                            for position in positions:
+                                pnl_data = (
+                                    await position_manager.calculate_position_pnl(
+                                        position,
+                                        float(current_price),
+                                        point_value=tick_value,
+                                    )
+                                )
+                                total_pnl += pnl_data["unrealized_pnl"]
+                    else:
+                        # Fallback to portfolio P&L
+                        pnl = await position_manager.get_portfolio_pnl()
+                        total_pnl = pnl.get("total_pnl", 0)
                 except Exception:
                     pass
 
+                print(f"  Total P&L: ${total_pnl:,.2f}")
+
                 # Get summary if available
                 if hasattr(position_manager, "get_portfolio_summary"):
                     try:
@@ -194,7 +249,6 @@ async def main() -> bool:
         print("\n🔑 Initializing TradingSuite v3...")
         suite = await TradingSuite.create(
             "MNQ",
-            features=["realtime_tracking"],
             timeframes=["1min", "5min"],
         )
 
@@ -208,7 +262,7 @@ async def main() -> bool:
 
         if existing_positions:
             print(f"Found {len(existing_positions)} existing positions")
-            await display_positions(suite.positions)
+            await display_positions(suite.positions, suite)
         else:
             print("No existing positions found")
 
@@ -218,11 +272,14 @@ async def main() -> bool:
             )
             print("   (This will place a REAL order on the market)")
 
-            # Get current price for order placement
+            # Get instrument info and current price for order placement
+            instrument_info = await suite.client.get_instrument("MNQ")
+            contract_id = instrument_info.id
             current_price = await get_current_market_price(suite)
 
             if current_price:
                 print(f"\n   Current MNQ price: ${current_price:.2f}")
+                print(f"   Contract ID: {contract_id}")
                 print("   Test order: BUY 1 MNQ at market")
 
                 # Wait for user confirmation
@@ -236,7 +293,7 @@ async def main() -> bool:
                     if response == "y":
                         print("\n   Placing market order...")
                         order_response = await suite.orders.place_market_order(
-                            contract_id="MNQ",
+                            contract_id=contract_id,
                             side=0,
                             size=1,  # Buy
                         )
@@ -266,7 +323,7 @@ async def main() -> bool:
             print("=" * 80)
 
             # 1. Display current positions
-            await display_positions(suite.positions)
+            await display_positions(suite.positions, suite)
 
             # 2. Show risk metrics
             await display_risk_metrics(suite.positions)
@@ -313,7 +370,7 @@ async def main() -> bool:
             print("=" * 80)
 
             # Monitor for 30 seconds
-            await monitor_positions(suite.positions, duration=30)
+            await monitor_positions(suite.positions, suite, duration=30)
 
             # 6. Offer to close positions
             if await suite.positions.get_all_positions():