custom_alpaca_broker.py

# from lumibot.brokers.alpaca import Alpaca
# from lumibot.entities import Order, Asset
# from decimal import Decimal
# import logging

# class CustomAlpacaBroker(Alpaca):
#     """
#     Custom Alpaca broker that handles bracket orders properly
#     """
    
#     def __init__(self, *args, **kwargs):
#         super().__init__(*args, **kwargs)
#         self._bracket_params = {}  # Cache for bracket order parameters
    
    
#     def submit_order(self, order_data):
#         """Override submit_order to handle bracket orders properly"""
#         # Cache the bracket parameters if it's a bracket order
#         if isinstance(order_data, dict) and order_data.get('order_class') == 'bracket':
#             # For dictionary order data
#             take_profit = order_data.get('take_profit', {})
#             stop_loss = order_data.get('stop_loss', {})
#             self._bracket_params_temp = {
#                 'take_profit_price': take_profit.get('limit_price'),
#                 'stop_loss_price': stop_loss.get('stop_price'),
#                 'symbol': order_data.get('symbol'),
#                 'qty': order_data.get('qty'),
#                 'side': order_data.get('side')
#             }
#         elif hasattr(order_data, 'order_class') and order_data.order_class == 'bracket':
#             # For object order data
#             take_profit = getattr(order_data, 'take_profit', {})
#             stop_loss = getattr(order_data, 'stop_loss', {})
#             self._bracket_params_temp = {
#                 'take_profit_price': take_profit.get('limit_price') if isinstance(take_profit, dict) else None,
#                 'stop_loss_price': stop_loss.get('stop_price') if isinstance(stop_loss, dict) else None,
#                 'symbol': getattr(order_data, 'symbol', None),
#                 'qty': getattr(order_data, 'qty', None),
#                 'side': getattr(order_data, 'side', None)
#             }

#         # Submit the order
#         response = super().submit_order(order_data)
        
#         # For bracket orders, ensure we get and store the complete order with legs
#         if (isinstance(order_data, dict) and order_data.get('order_class') == 'bracket') or \
#            (hasattr(order_data, 'order_class') and order_data.order_class == 'bracket'):
#             try:
#                 from alpaca.trading.requests import GetOrderByIdRequest
#                 # Fetch complete order with legs and store it
#                 complete_order = self.trading_client.get_order_by_id(
#                     order_id=response.id,
#                     filter=GetOrderByIdRequest(nested=True)
#                 )
#                 if complete_order and hasattr(complete_order, 'legs') and complete_order.legs:
#                     # Store the leg IDs and full order details for future reference
#                     self._bracket_params[str(response.id)] = {
#                         'take_profit_price': self._bracket_params_temp['take_profit_price'],
#                         'stop_loss_price': self._bracket_params_temp['stop_loss_price'],
#                         'symbol': self._bracket_params_temp['symbol'],
#                         'qty': self._bracket_params_temp['qty'],
#                         'side': self._bracket_params_temp['side'],
#                         'legs': {leg.id: {
#                             'type': leg.type,
#                             'side': leg.side,
#                             'price': leg.limit_price or leg.stop_price
#                         } for leg in complete_order.legs}
#                     }
#                     logging.info(f"Stored bracket order legs for order {response.id}: {self._bracket_params[str(response.id)]}")
#                 else:
#                     logging.warning(f"Bracket order {response.id} created but no legs found in response")
#             except Exception as e:
#                 logging.warning(f"Could not fetch complete bracket order: {e}")
        
#         # Cleanup temp params
#         if hasattr(self, '_bracket_params_temp'):
#             delattr(self, '_bracket_params_temp')
        
#         return response
    
#     def _parse_broker_order(self, response, strategy_name, strategy_object=None):
#         """
#         Override the _parse_broker_order method to handle bracket orders better
#         """
#         try:
#             # If the symbol includes a slash, then it is a crypto order and only the first part of
#             # the symbol is the real symbol
#             if "/" in response.symbol:
#                 symbol = response.symbol.split("/")[0]
#             else:
#                 symbol = response.symbol
            
#             # Create the base Asset object
#             asset = Asset(
#                 symbol=symbol,
#                 asset_type=self.map_asset_type(response.asset_class),
#             )
            
#             # Determine stop price, limit price, etc.
#             order_type = response.order_type
#             order_class = response.order_class
#             limit_price = None
#             stop_price = None
#             stop_limit_price = None
            
#             # Get basic order properties
#             if hasattr(response, 'limit_price') and response.limit_price is not None:
#                 if order_type == Order.OrderType.STOP_LIMIT:
#                     stop_limit_price = response.limit_price
#                 else:
#                     limit_price = response.limit_price
                    
#             if hasattr(response, 'stop_price') and response.stop_price is not None:
#                 stop_price = response.stop_price
            
#             # Extract take profit and stop loss for bracket orders
#             take_profit_price = None
#             stop_loss_price = None
            
#             # For bracket orders, we need to handle child orders
#             if order_class == Order.OrderClass.BRACKET:
#                 # First try to get from legs
#                 if hasattr(response, 'legs') and response.legs:
#                     for leg in response.legs:
#                         if leg.order_type == 'limit':
#                             take_profit_price = leg.limit_price
#                         elif leg.order_type in ['stop', 'stop_limit']:
#                             stop_loss_price = leg.stop_price
                            
#                     # Log the leg statuses for debugging
#                     self._log_bracket_leg_status(response)
#                 else:
#                     # If no legs, try to get from cache
#                     if str(response.id) in self._bracket_params:
#                         cached = self._bracket_params[str(response.id)]
#                         take_profit_price = cached['take_profit_price']
#                         stop_loss_price = cached['stop_loss_price']
                
#                 # If we have strategy object, try to get from there as last resort
#                 if not (take_profit_price and stop_loss_price) and strategy_object is not None and hasattr(strategy_object, 'profit_target') and hasattr(strategy_object, 'stop_loss_price'):
#                     take_profit_price = strategy_object.profit_target
#                     stop_loss_price = strategy_object.stop_loss_price
                
#                 # If we still don't have both prices, log it and move on
#                 if not (take_profit_price and stop_loss_price):
#                     self.logger.warning(f"Unable to get take profit and stop loss prices for bracket order {response.id}")
            
#             # Handle trailing stop orders
#             trail_price = getattr(response, 'trail_price', None)
#             trail_percent = getattr(response, 'trail_percent', None)
            
#             # Create the Order object with all required parameters for its type
#             order_params = {
#                 "stop_price": stop_price,
#                 "stop_limit_price": stop_limit_price,
#                 "trail_price": trail_price,
#                 "trail_percent": trail_percent,
#                 "time_in_force": response.time_in_force,
#                 "order_class": order_class,
#                 "order_type": response.order_type if response.order_type != "trailing_stop" else Order.OrderType.TRAIL,
#                 "quote": Asset(symbol="USD", asset_type="forex"),
#             }
            
#             # Only add limit_price if this is not a bracket order or if it's the main order
#             if order_class != Order.OrderClass.BRACKET or not (take_profit_price or stop_loss_price):
#                 order_params["limit_price"] = limit_price
            
#             # Add take profit and stop loss for bracket orders
#             if order_class == Order.OrderClass.BRACKET:
#                 if take_profit_price:
#                     order_params["take_profit_price"] = float(take_profit_price)
#                 if stop_loss_price:
#                     order_params["stop_loss_price"] = float(stop_loss_price)
                
#                 # Keep as bracket order if we have both prices
#                 if take_profit_price and stop_loss_price:
#                     order_params["order_class"] = Order.OrderClass.BRACKET
#                 else:
#                     order_params["order_class"] = Order.OrderClass.SIMPLE
            
#             # Create the Order object
#             order = Order(
#                 strategy_name,
#                 asset,
#                 Decimal(response.qty),
#                 response.side,
#                 **order_params
#             )
            
#             # Set order ID and status
#             order.set_identifier(response.id)
#             order.status = response.status
#             order.update_raw(response)
            
#             # If this is a bracket order and it's filled, monitor the legs
#             if order.order_class == Order.OrderClass.BRACKET and order.status == 'filled':
#                 self._monitor_bracket_legs(order.identifier)
            
#             return order
            
#         except Exception as e:
#             logging.error(f"Error parsing broker order: {e}")
#             logging.error(f"Order response: {response}")
#             raise

#     def _log_bracket_leg_status(self, order):
#         """Helper method to log the status of bracket order legs"""
#         if not hasattr(order, 'legs') or not order.legs:
#             return
            
#         logging.info(f"Bracket order {order.id} leg status:")
#         logging.info(f"Main order status: {order.status}")
        
#         for leg in order.legs:
#             leg_type = "Take Profit" if leg.type == "limit" else "Stop Loss"
#             logging.info(f"{leg_type} leg {leg.id}:")
#             logging.info(f"  Status: {leg.status}")
#             logging.info(f"  Type: {leg.type}")
#             logging.info(f"  Side: {leg.side}")
#             logging.info(f"  Price: {leg.limit_price or leg.stop_price}")
            
#         # Check if this order is in our cached bracket params
#         if str(order.id) in self._bracket_params:
#             cached = self._bracket_params[str(order.id)]
#             logging.info(f"Cached bracket params: {cached}")
            
#             # Verify leg IDs match what we have cached
#             cached_legs = set(cached['legs'].keys())
#             current_legs = {leg.id for leg in order.legs}
            
#             if cached_legs != current_legs:
#                 logging.warning(f"Mismatch between cached leg IDs {cached_legs} and current leg IDs {current_legs}")
                
#     def get_bracket_order_status(self, order_id):
#         """Get the complete status of a bracket order including all legs"""
#         try:
#             from alpaca.trading.requests import GetOrderByIdRequest
#             order = self.trading_client.get_order_by_id(
#                 order_id=order_id,
#                 filter=GetOrderByIdRequest(nested=True)
#             )
            
#             if not order:
#                 return None
                
#             result = {
#                 'main_order': {
#                     'status': order.status,
#                     'filled_qty': order.filled_qty,
#                     'filled_avg_price': order.filled_avg_price if hasattr(order, 'filled_avg_price') else None
#                 },
#                 'legs': []
#             }
            
#             if hasattr(order, 'legs') and order.legs:
#                 for leg in order.legs:
#                     leg_info = {
#                         'id': leg.id,
#                         'type': leg.type,
#                         'status': leg.status,
#                         'side': leg.side,
#                         'price': leg.limit_price or leg.stop_price
#                     }
#                     result['legs'].append(leg_info)
                    
#             return result
            
#         except Exception as e:
#             logging.error(f"Error getting bracket order status: {e}")
#             return None

#     def _monitor_bracket_legs(self, order_id):
#         """Monitor and potentially resubmit bracket order legs if they're unexpectedly canceled"""
#         try:
#             status = self.get_bracket_order_status(order_id)
#             if not status:
#                 return
            
#             # Only proceed if main order is filled
#             if status['main_order']['status'] != 'filled':
#                 return
                
#             # Get the original bracket parameters
#             if str(order_id) not in self._bracket_params:
#                 logging.warning(f"No cached parameters found for bracket order {order_id}")
#                 return
                
#             params = self._bracket_params[str(order_id)]
            
#             # Check if any legs are canceled
#             for leg in status['legs']:
#                 if leg['status'] == 'canceled':
#                     logging.warning(f"Bracket leg {leg['id']} was unexpectedly canceled. Attempting to resubmit...")
                    
#                     # Determine if this is take profit or stop loss
#                     is_take_profit = leg['type'] == 'limit'
                    
#                     # Create new order for the canceled leg
#                     from alpaca.trading.requests import LimitOrderRequest, StopLimitOrderRequest
                    
#                     if is_take_profit:
#                         new_order = LimitOrderRequest(
#                             symbol=params['symbol'],
#                             qty=params['qty'],
#                             side='sell' if params['side'] == 'buy' else 'buy',  # Reverse of original order
#                             type='limit',
#                             time_in_force='gtc',
#                             limit_price=params['take_profit_price']
#                         )
#                     else:
#                         new_order = StopLimitOrderRequest(
#                             symbol=params['symbol'],
#                             qty=params['qty'],
#                             side='sell' if params['side'] == 'buy' else 'buy',  # Reverse of original order
#                             type='stop_limit',
#                             time_in_force='gtc',
#                             stop_price=params['stop_loss_price'],
#                             limit_price=params['stop_loss_price'] * 0.99 if params['side'] == 'buy' else params['stop_loss_price'] * 1.01
#                         )
                    
#                     try:
#                         new_leg = self.trading_client.submit_order(new_order)
#                         logging.info(f"Successfully resubmitted {leg['type']} leg for bracket order {order_id}")
                        
#                         # Update our cached leg information
#                         self._bracket_params[str(order_id)]['legs'][new_leg.id] = {
#                             'type': leg['type'],
#                             'side': new_leg.side,
#                             'price': new_leg.limit_price or new_leg.stop_price
#                         }
                        
#                     except Exception as e:
#                         logging.error(f"Failed to resubmit bracket leg: {e}")
                        
#         except Exception as e:
#             logging.error(f"Error monitoring bracket legs: {e}")

# # Make sure the class is available for import
# __all__ = ['CustomAlpacaBroker']