def state_change_to_roll_adjusted_prices( data: dataBlob, instrument_code: str, original_roll_state: RollState, confirm_adjusted_price_change: bool = True, ): # Going to roll adjusted prices update_positions = updatePositions(data) roll_result = roll_adjusted_and_multiple_prices( data=data, instrument_code=instrument_code, confirm_adjusted_price_change=confirm_adjusted_price_change, ) if roll_result is success: # Return the state back to default (no roll) state data.log.msg( "Successful roll! Returning roll state of %s to %s" % (instrument_code, default_state) ) update_positions.set_roll_state(instrument_code, default_state) else: data.log.msg( "Something has gone wrong with rolling adjusted of %s! Returning roll state to previous state of %s" % (instrument_code, original_roll_state) ) update_positions.set_roll_state(instrument_code, original_roll_state)
def modify_roll_state( data: dataBlob, instrument_code: str, original_roll_state: RollState, roll_state_required: RollState, confirm_adjusted_price_change: bool = True, ): if roll_state_required is no_change_required: return if roll_state_required is original_roll_state: return update_positions = updatePositions(data) if original_roll_state is roll_close_state: roll_state_was_closed_now_something_else(data, instrument_code) update_positions.set_roll_state(instrument_code, roll_state_required) if roll_state_required is roll_adj_state: state_change_to_roll_adjusted_prices( data=data, instrument_code=instrument_code, original_roll_state=original_roll_state, confirm_adjusted_price_change=confirm_adjusted_price_change, ) if roll_state_required is roll_close_state: roll_state_is_now_closing(data, instrument_code)
def updated_buffered_positions(data, strategy_name, system): log = data.log update_positions = updatePositions(data) list_of_instruments = system.get_instrument_list() for instrument_code in list_of_instruments: try: lower_buffer, upper_buffer = get_position_buffers_from_system( system, instrument_code) position_entry = construct_position_entry(data, system, instrument_code, lower_buffer, upper_buffer) update_positions.update_optimal_position_for_strategy_and_instrument( strategy_name, instrument_code, position_entry) log.msg( "New buffered positions %.3f %.3f" % (position_entry.lower_position, position_entry.upper_position), instrument_code=instrument_code) except Exception as e: log.critical("Couldn't get or update buffered positions error %s" % e, instrument_code=instrument_code) return success
def handle_completed_instrument_order(self, instrument_order_id): ## Check children all done instrument_order = self.instrument_stack.get_order_with_id_from_stack(instrument_order_id) list_of_broker_order_id, list_of_contract_order_id = self.\ get_all_children_and_grandchildren_for_instrument_order_id(instrument_order_id) completely_filled = self.\ confirm_all_children_and_grandchildren_are_filled(list_of_broker_order_id, list_of_contract_order_id) if not completely_filled: return success # If we have got this far then all our children are filled, and the parent is filled contract_order_list = self.contract_stack.get_list_of_orders_from_order_id_list(list_of_contract_order_id) broker_order_list = self.broker_stack.get_list_of_orders_from_order_id_list(list_of_broker_order_id) # update positions position_updater = updatePositions(self.data) position_updater.update_positions_with_instrument_and_contract_orders(instrument_order, contract_order_list) # Update historic order database order_data = dataOrders(self.data) order_data.add_historic_orders_to_data(instrument_order, contract_order_list, broker_order_list) # Make orders inactive # A subsequent process will delete them self.deactivate_family_of_orders(instrument_order_id, list_of_contract_order_id, list_of_broker_order_id) return success
def handle_completed_instrument_order(self, instrument_order_id, allow_partial_completions=False, allow_zero_completions=False): ## Check children all done list_of_broker_order_id, list_of_contract_order_id = self.\ get_all_children_and_grandchildren_for_instrument_order_id(instrument_order_id) completely_filled = self.\ confirm_all_children_and_grandchildren_are_filled(list_of_broker_order_id, list_of_contract_order_id, allow_partial_completions=allow_partial_completions, allow_zero_completions = allow_zero_completions) if not completely_filled: return success # If we have got this far then all our children are filled, and the parent is filled # We need to seperate out broker and contract spread orders into their individual components # When we do this the original orders are deactivated # the instrument order has it's children removed and replaced by the components of each spread order # the contract order self.split_up_spread_orders(instrument_order_id) # we need to do this again in case of any splits list_of_broker_order_id, list_of_contract_order_id = self.\ get_all_children_and_grandchildren_for_instrument_order_id(instrument_order_id) contract_order_list = self.contract_stack.get_list_of_orders_from_order_id_list( list_of_contract_order_id) broker_order_list = self.broker_stack.get_list_of_orders_from_order_id_list( list_of_broker_order_id) instrument_order = self.instrument_stack.get_order_with_id_from_stack( instrument_order_id) # Make orders inactive # A subsequent process will delete them self.deactivate_family_of_orders(instrument_order_id, list_of_contract_order_id, list_of_broker_order_id) # update positions position_updater = updatePositions(self.data) position_updater.update_positions_with_instrument_and_contract_orders( instrument_order, contract_order_list) # Update historic order database order_data = dataOrders(self.data) order_data.add_historic_orders_to_data(instrument_order, contract_order_list, broker_order_list) return success
def apply_position_change_to_instrument(self, instrument_order, total_filled_qty, apply_entire_trade= False): current_fill = instrument_order.fill if apply_entire_trade: new_fill = current_fill else: if total_filled_qty==current_fill: ## no change needed here return success new_fill = total_filled_qty - current_fill position_updater = updatePositions(self.data) result = position_updater.update_strategy_position_table_with_instrument_order(instrument_order, new_fill) return result
def interactive_update_roll_status(): """ Update the roll state for a particular instrument This includes the option, where possible, to switch the adjusted price series on to a new contract :param instrument_code: str :return: None """ with dataBlob(log_name="Interactive_Update-Roll-Status") as data: instrument_code = get_valid_instrument_code_from_user(data=data) # First get the roll info # This will also update to console config = roll_report_config.new_config_with_modified_output("console") config.modify_kwargs(instrument_code=instrument_code) report_results = run_report_with_data_blob(config, data) if report_results is failure: print("Can't run roll report, so can't change status") return failure current_roll_status, roll_state_required = get_required_roll_state( data, instrument_code) if roll_state_required is no_state_available: return failure update_positions = updatePositions(data) update_positions.set_roll_state(instrument_code, roll_state_required) if roll_state_required is roll_adj_state: # Going to roll adjusted prices roll_result = _roll_adjusted_and_multiple_prices( data, instrument_code) if roll_result is success: # Return the state back to default (no roll) state data.log.msg( "Successful roll! Returning roll state of %s to %s" % (instrument_code, default_state)) update_positions.set_roll_state(instrument_code, default_state) else: data.log.msg( "Something has gone wrong with rolling adjusted of %s! Returning roll state to previous state of %s" % (instrument_code, current_roll_status)) update_positions.set_roll_state(instrument_code, current_roll_status) return success
def handle_completed_instrument_order(self, instrument_order_id): ## Check children all done instrument_order = self.instrument_stack.get_order_with_id_from_stack( instrument_order_id) list_of_contract_order_id = instrument_order.children if list_of_contract_order_id is no_children: list_of_contract_order_id = [] for contract_order_id in list_of_contract_order_id: completely_filled = self.contract_stack.is_completed( contract_order_id) if not completely_filled: ## OK We can't do this unless all our children are filled return success # If we have got this far then all our children are filled, and the parent is filled list_of_contract_orders = [] for contract_order_id in list_of_contract_order_id: list_of_contract_orders.append( self.contract_stack.get_order_with_id_from_stack( contract_order_id)) position_updater = updatePositions(self.data) # Update strategy position table position_updater.update_strategy_position_table_with_instrument_order( instrument_order) # Update contract position table for contract_order in list_of_contract_orders: position_updater.update_contract_position_table_with_contract_order( contract_order) order_data = dataOrders(self.data) # Update historic order database order_data.add_historic_instrument_order_to_data(instrument_order) for contract_order in list_of_contract_orders: order_data.add_historic_contract_order_to_data(contract_order) # Make orders inactive # A subsequent process will delete them self.instrument_stack.deactivate_order(instrument_order_id) for contract_order_id in list_of_contract_order_id: self.contract_stack.deactivate_order(contract_order_id) return success
def apply_position_change_to_instrument( self, original_instrument_order: instrumentOrder, total_filled_qty: tradeQuantity, apply_entire_trade: bool=False ): current_fill = original_instrument_order.fill if apply_entire_trade: new_fill = current_fill else: new_fill = total_filled_qty - current_fill if new_fill.equals_zero(): return None position_updater = updatePositions(self.data) position_updater.update_strategy_position_table_with_instrument_order( original_instrument_order, new_fill)
def apply_position_change_to_contracts( self, contract_order, total_filled_qty, apply_entire_trade=False ): current_fills = contract_order.fill if apply_entire_trade: new_fills = current_fills else: if total_filled_qty == current_fills: # no change needed here return success new_fills = total_filled_qty - current_fills position_updater = updatePositions(self.data) result = position_updater.update_contract_position_table_with_contract_order( contract_order, new_fills) return result
def apply_position_change_to_stored_contract_positions( self, contract_order_before_fill: contractOrder, total_filled_qty: tradeQuantity, apply_entire_trade: bool=False ): current_fills = contract_order_before_fill.fill if apply_entire_trade: # used for balance trades new_fills = current_fills else: new_fills = total_filled_qty - current_fills if new_fills.equals_zero(): # nothing to do return None position_updater = updatePositions(self.data) position_updater.update_contract_position_table_with_contract_order( contract_order_before_fill, new_fills)
def modify_roll_state(data: dataBlob, instrument_code: str, roll_state_required: RollState): update_positions = updatePositions(data) update_positions.set_roll_state(instrument_code, roll_state_required)