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