Here's one of mine. Can't figure out how to fix the indents though.

?

def place_trailing_oca_bracket_order(self, order_details):

"""

Place a bracket-type OCA order with a trailing stop loss and an adjustable take profit order.

The stop loss is a trailing stop placed at a certain percentage away from the entry price.

The take profit starts as a stop order and converts to a trailing stop upon reaching a profit trigger.

"""

symbol = order_details["symbol"]

entry_quantity = order_details["quantity"]

time_bound = order_details.get("minutes_until_market_close", self.max_allowed_position_minutes)

# Max allowed time in mins

time_bound = min(time_bound, self.max_allowed_position_minutes)

# Determine position direction

action = order_details.get("side", "BUY").upper()

is_long = action == "BUY"

reverse_action = "SELL" if is_long else "BUY"

# Get minimum tick size

min_tick = self.get_min_tick(symbol)

strategy_params = order_details.get("strategy_params", {})

# Extract standard strategy parameters

stop_loss_percent = strategy_params.get("stop_loss_percent")

trailing_stop_percent = strategy_params.get("trailing_stop_percent")

profit_trigger_percent = strategy_params.get("profit_trigger_percent")

profit_lock_in_percent = strategy_params.get("profit_lock_in_percent")

trailing_profit_percent = strategy_params.get("trailing_profit_percent")

# Create entry order with adjusted price based on direction

if is_long:

entry_price = self.get_ask_price(symbol)

else:

entry_price = self.get_bid_price(symbol)

# Calculate price levels based on position direction

if is_long:

# Price adjustments for long positions

# Initial stop loss below entry price

initial_stop_loss_price = self.adjust_price_to_tick_size(entry_price * (1 - stop_loss_percent), min_tick)

initial_stop_loss_protection_price = (

self.adjust_price_to_tick_size(entry_price * (1 - stop_loss_percent), min_tick) - 1

)

# Profit trigger above entry price

profit_trigger_price = self.adjust_price_to_tick_size(entry_price * (1 + profit_trigger_percent), min_tick)

# Lock in price slightly below trigger price

profit_lock_in_price = self.adjust_price_to_tick_size(

entry_price * (1 + profit_lock_in_percent), min_tick

) # Must be lower than trigger for longs to protect profits

# Amount to trail by

trailing_stop_amount = self.adjust_price_to_tick_size(entry_price * trailing_profit_percent, min_tick)

else:

# Price adjustments for short positions

# Initial stop loss above entry price

initial_stop_loss_price = self.adjust_price_to_tick_size(entry_price * (1 + stop_loss_percent), min_tick)

initial_stop_loss_protection_price = (

self.adjust_price_to_tick_size(entry_price * (1 + stop_loss_percent), min_tick) + 1

)

# Profit trigger below entry price

profit_trigger_price = self.adjust_price_to_tick_size(entry_price * (1 - profit_trigger_percent), min_tick)

# Lock in price slightly above trigger price

profit_lock_in_price = self.adjust_price_to_tick_size(

entry_price * (1 - profit_lock_in_percent), min_tick

) # Must be higher than trigger for shorts to protect profits

# Amount to trail by

trailing_stop_amount = self.adjust_price_to_tick_size(entry_price * trailing_stop_percent, min_tick)

contract = self.get_contract(symbol)

prediction_id = order_details.get("prediction_id")

bracket_order = []

# Create entry order

entry_order = LimitOrder(

action=action,

totalQuantity=entry_quantity,

lmtPrice=entry_price,

orderId=self.ib.client.getReqId(),

transmit=False,

orderRef=f"{prediction_id}_entry",

tif="IOC",

)

bracket_order.append(entry_order)

# Create initial trailing stop loss order

stop_loss_order = Order(

action=reverse_action,

orderType="TRAIL",

totalQuantity=entry_quantity,

orderId=self.ib.client.getReqId(),

transmit=False,

parentId=entry_order.orderId,

orderRef=f"{prediction_id}_stop_loss",

ocaType=2,

outsideRth=True,

ocaGroup=prediction_id,

auxPrice=trailing_stop_amount, # Trailing amount using trailing_stop_percent

trailStopPrice=initial_stop_loss_price, # Initial stop price using stop_loss_percent

)

bracket_order.append(stop_loss_order)

# Create first take profit order (triggers at profit_trigger_percent and stops at profit_lock_in_percent)

take_profit_order = Order(

action=reverse_action,

orderType="STP",

totalQuantity=entry_quantity,

orderId=self.ib.client.getReqId(),

transmit=False,

parentId=entry_order.orderId,

orderRef=f"{prediction_id}_take_profit_stop",

ocaType=2,

outsideRth=True,

ocaGroup=prediction_id,

auxPrice=initial_stop_loss_protection_price,

triggerPrice=profit_trigger_price,

adjustedOrderType="STP",

adjustedStopPrice=profit_lock_in_price,

)

bracket_order.append(take_profit_order)

# Create time bound order (same for both market conditions)

time_bound_order = MarketOrder(

action=reverse_action,

totalQuantity=entry_quantity,

orderId=self.ib.client.getReqId(),

transmit=False,

parentId=entry_order.orderId,

outsideRth=True,

orderRef=f"{prediction_id}_time_bound",

ocaType=2,

ocaGroup=prediction_id,

)

# Add time condition to the time_bound_order

time_condition_after = TimeCondition()

time_condition_after.time = format_date(add_minutes_to_date(get_utc_now(), time_bound), "%Y%m%d-%H:%M:%S")

time_condition_after.isMore = True

time_bound_order.conditions.append(time_condition_after)

bracket_order.append(time_bound_order)

# Set the last order to transmit

bracket_order[-1].transmit = True

# Place all orders

trades = []

for order in bracket_order:

(f"Placing {order.orderRef} for {'long' if is_long else 'short'} position")

trade = self.ib.placeOrder(contract, order)

trades.append(trade)

(f"Order placed: {order.orderRef} with ID {order.orderId}")

return trades

?

?