def calculate_limit_prices_for_direct_child_orders(
data: dataBlob,
instrument_order: instrumentOrder,
list_of_contract_orders: listOfOrders,
) -> listOfOrders:
"""
A direct child order only contains one contract id i.e. not an intramarket spread
:param data:
:param instrument_order:
:param list_of_contract_orders:
:return: list of contract orders
"""
list_of_contract_orders = [
add_limit_price_to_a_direct_child_order(data, instrument_order, child_order)
for child_order in list_of_contract_orders
]
flag_missing_orders = [
child_order is missing_order for child_order in list_of_contract_orders
]
if any(flag_missing_orders):
log = instrument_order.log_with_attributes(data.log)
log.critical(
"Couldn't adjust limit price for at least one child order %s: can't execute any child orders"
% str(instrument_order)
)
return listOfOrders([])
list_of_contract_orders = listOfOrders(list_of_contract_orders)
return list_of_contract_orders
def create_contract_orders_outright(
roll_spread_info: rollSpreadInformation, ) -> listOfOrders:
strategy = ROLL_PSEUDO_STRATEGY
first_order = contractOrder(
strategy,
roll_spread_info.instrument_code,
roll_spread_info.priced_contract_id,
-roll_spread_info.position_in_priced,
reference_price=roll_spread_info.reference_price_priced_contract,
roll_order=True,
order_type=CONTRACT_ORDER_TYPE_FOR_ROLL_ORDERS,
)
second_order = contractOrder(
strategy,
roll_spread_info.instrument_code,
roll_spread_info.forward_contract_id,
roll_spread_info.position_in_priced,
reference_price=roll_spread_info.reference_price_forward_contract,
roll_order=True,
order_type=CONTRACT_ORDER_TYPE_FOR_ROLL_ORDERS,
)
return listOfOrders([first_order, second_order])
def single_instrument_child_orders(
data: dataBlob, instrument_order: instrumentOrder) -> listOfOrders:
"""
Generate child orders for a single instrument (not rolls)
:param data: dataBlob. Required as uses roll data to determine appropriate instrument
:param instrument_order:
:return: A list of contractOrders to submit to the stack
"""
# We don't allow zero trades to be spawned
# Zero trades can enter the instrument stack, where they can potentially
# modify existing trades
if instrument_order.is_zero_trade():
return listOfOrders([])
# Get required contract(s) depending on roll status
list_of_child_contract_dates_and_trades = (
get_required_contract_trade_for_instrument(data, instrument_order))
list_of_contract_orders = list_of_contract_orders_from_list_of_child_date_and_trade(
instrument_order, list_of_child_contract_dates_and_trades)
# Get reference price for relevant contract(s)
# used for TCA
# Adjust price if reference contract is different from required contract
list_of_contract_orders = calculate_reference_prices_for_direct_child_orders(
data, instrument_order, list_of_contract_orders)
# Now get the limit prices, where relevant
# Adjust limit price if limit_contract is different from required contract
list_of_contract_orders = calculate_limit_prices_for_direct_child_orders(
data, instrument_order, list_of_contract_orders)
return list_of_contract_orders
def _put_adjusting_order_on_stack(self,
new_order: instrumentOrder,
existing_order_id_list: list,
allow_zero_orders: bool = False) -> int:
"""
Considering the unfilled orders already on the stack place an additional adjusting order
:param new_order:
:return:
"""
log = new_order.log_with_attributes(self.log)
existing_orders = listOfOrders([
self.get_order_with_id_from_stack(order_id)
for order_id in existing_order_id_list
])
adjusted_order = calculate_adjusted_order_given_existing_orders(
new_order, existing_orders, log)
if adjusted_order.is_zero_trade() and not allow_zero_orders:
# Trade we want is already in the system
error_msg = "Adjusted order %s is zero, zero orders not allowed" % str(
adjusted_order)
log.warn(error_msg)
raise zeroOrderException(error_msg)
order_id = self._put_order_on_stack_and_get_order_id(adjusted_order)
return order_id
def get_list_of_orders_from_order_id_list(
self, list_of_order_ids) -> listOfOrders:
order_list = []
for order_id in list_of_order_ids:
order = self.get_order_with_id_from_stack(order_id)
order_list.append(order)
return listOfOrders(order_list)
def add_commissions_to_list_of_orders(self, list_of_orders: listOfOrders) -> listOfOrders:
list_of_orders_with_commission = [
self.calculate_total_commission_for_broker_order(broker_order)
for broker_order in list_of_orders
]
list_of_orders_with_commission = listOfOrders(list_of_orders_with_commission)
return list_of_orders_with_commission
def apply_overrides(self, order_list: listOfOrders) -> listOfOrders:
new_order_list = [
self.apply_overrides_for_instrument_and_strategy(proposed_order)
for proposed_order in order_list
]
new_order_list = listOfOrders(new_order_list)
return new_order_list
def try_and_cancel_all_broker_orders_and_return_list_of_orders(self) -> listOfOrders:
list_of_broker_order_ids = self.broker_stack.get_list_of_order_ids()
list_of_broker_orders = []
for broker_order_id in list_of_broker_order_ids:
broker_order = self.cancel_broker_order_with_id_and_return_order(broker_order_id)
if broker_order is not missing_order:
list_of_broker_orders.append(broker_order)
list_of_broker_orders = listOfOrders(list_of_broker_orders)
return list_of_broker_orders
def get_list_of_orders_for_instrument_strategy(
self, instrument_strategy: instrumentStrategy) -> listOfOrders:
list_of_ids = self.get_list_of_order_ids_for_instrument_strategy(
instrument_strategy)
order_list = []
for order_id in list_of_ids:
order = self.get_order_with_orderid(order_id)
order_list.append(order)
order_list = listOfOrders(order_list)
return order_list
def list_of_orders_not_yet_cancelled(self, list_of_broker_orders: listOfOrders) -> listOfOrders:
new_list_of_orders = copy(list_of_broker_orders)
for broker_order in list_of_broker_orders:
# if an order is cancelled, remove from list
order_is_cancelled = self.check_order_cancelled(broker_order)
if order_is_cancelled:
log = broker_order.log_with_attributes(self.log)
new_list_of_orders.remove(broker_order)
log.msg("Order %s succesfully cancelled" % broker_order)
new_list_of_orders = listOfOrders(new_list_of_orders)
return new_list_of_orders
def list_of_contract_orders_from_list_of_child_date_and_trade(
instrument_order: instrumentOrder,
list_of_child_contract_dates_and_trades: list) -> listOfOrders:
list_of_contract_orders = [
contract_order_for_direct_instrument_child_date_and_trade(
instrument_order, child_date_and_trade)
for child_date_and_trade in list_of_child_contract_dates_and_trades
]
list_of_contract_orders = listOfOrders(list_of_contract_orders)
return list_of_contract_orders
def get_list_of_broker_orders_with_account_id(self, account_id: str=arg_not_supplied) -> listOfOrders:
"""
Get list of broker orders from IB, and return as my broker_order objects
:return: list of brokerOrder objects
"""
list_of_control_objects = self._get_list_of_broker_control_orders(
account_id=account_id
)
order_list = [
order_with_control.order for order_with_control in list_of_control_objects]
order_list = listOfOrders(order_list)
return order_list
def check_to_see_if_distributed_instrument_order(
self, list_of_contract_order_ids: list,
instrument_order: instrumentOrder) -> bool:
# A distributed instrument order is like this: buy 2 EDOLLAR instrument order
# split into buy 1 202306, buy 1 203209
contract_orders = listOfOrders([
self.contract_stack.get_order_with_id_from_stack(contract_id)
for contract_id in list_of_contract_order_ids
])
result = check_to_see_if_distributed_order(instrument_order,
contract_orders)
return result
def get_order_pd(
data,
list_method="get_historic_instrument_order_ids_in_date_range",
getter_method="get_historic_instrument_order_from_order_id",
):
start_date, end_date = get_report_dates()
data_orders = dataOrders(data)
list_func = getattr(data_orders, list_method)
getter_func = getattr(data_orders, getter_method)
order_id_list = list_func(start_date, end_date)
order_list = [getter_func(id) for id in order_id_list]
order_list_object = listOfOrders(order_list)
order_pd = order_list_object.as_pd()
return order_pd
def create_contract_orders_spread(roll_spread_info: rollSpreadInformation) -> listOfOrders:
strategy = ROLL_PSEUDO_STRATEGY
contract_id_list = [roll_spread_info.priced_contract_id, roll_spread_info.forward_contract_id]
trade_list = [-roll_spread_info.position_in_priced, roll_spread_info.position_in_priced]
spread_order = contractOrder(
strategy,
roll_spread_info.instrument_code,
contract_id_list,
trade_list,
reference_price=roll_spread_info.reference_price_spread,
roll_order=True,
order_type = CONTRACT_ORDER_TYPE_FOR_ROLL_ORDERS
)
return listOfOrders([spread_order])
def list_of_trades_given_optimal_and_actual_positions(
data: dataBlob, strategy_name: str,
optimal_positions: optimalPositions,
actual_positions: dict) -> listOfOrders:
upper_positions = optimal_positions.upper_positions
list_of_instruments = upper_positions.keys()
trade_list = [
trade_given_optimal_and_actual_positions(data, strategy_name,
instrument_code,
optimal_positions,
actual_positions)
for instrument_code in list_of_instruments
]
trade_list = listOfOrders(trade_list)
return trade_list
def get_order_pd(
data,
list_method="get_historic_instrument_order_ids_in_date_range",
getter_method="get_historic_instrument_order_from_order_id",
):
start_date = get_datetime_input("Start Date", allow_default=True)
end_date = get_datetime_input("End Date", allow_default=True)
data_orders = dataOrders(data)
list_func = getattr(data_orders, list_method)
getter_func = getattr(data_orders, getter_method)
order_id_list = list_func(start_date, end_date)
order_list = [getter_func(id) for id in order_id_list]
order_list_object = listOfOrders(order_list)
order_pd = order_list_object.as_pd()
return order_pd
def calculate_reference_prices_for_direct_child_orders(
data: dataBlob, instrument_order: instrumentOrder,
list_of_contract_orders: listOfOrders) -> listOfOrders:
"""
A direct child order only contains one contract id i.e. not an intramarket spread
:param data:
:param instrument_order:
:param list_of_contract_orders:
:return:
"""
list_of_contract_orders = [
add_reference_price_to_a_direct_child_order(data, instrument_order,
child_order)
for child_order in list_of_contract_orders
]
list_of_contract_orders = listOfOrders(list_of_contract_orders)
return list_of_contract_orders
def allocate_algo_to_list_of_contract_orders(
data: dataBlob, list_of_contract_orders: listOfOrders,
instrument_order: instrumentOrder) -> listOfOrders:
"""
:param data: dataBlog
:param instrument_order: parent instrument order
:param list_of_contract_orders:
:return: list of contract orders with algo added
"""
new_list_of_contract_orders = []
for contract_order in list_of_contract_orders:
contract_order = check_and_if_required_allocate_algo_to_single_contract_order(
data, contract_order, instrument_order)
new_list_of_contract_orders.append(contract_order)
new_list_of_contract_orders = listOfOrders(new_list_of_contract_orders)
return new_list_of_contract_orders
def list_of_trades_given_optimised_and_actual_positions(
data: dataBlob,
strategy_name: str,
optimised_positions_data: dict,
current_positions: dict,
) -> listOfOrders:
list_of_instruments = optimised_positions_data.keys()
trade_list = [
trade_given_optimal_and_actual_positions(
data,
strategy_name=strategy_name,
instrument_code=instrument_code,
optimised_position_entry=optimised_positions_data[instrument_code],
current_position=current_positions.get(instrument_code, 0),
) for instrument_code in list_of_instruments
]
trade_list = listOfOrders(trade_list)
return trade_list
def get_list_of_orders_from_storage(self) -> listOfOrders:
dict_of_stored_orders = self._get_dict_of_orders_from_storage()
list_of_orders = listOfOrders(dict_of_stored_orders.values())
return list_of_orders
