def actual_contract_position(data): diag_positions = diagPositions(data) instrument_code_list = diag_positions.get_list_of_instruments_with_any_position( ) instrument_code = get_valid_code_from_list(instrument_code_list) if instrument_code is user_exit: return None contract_code_list = ( diag_positions. get_list_of_contracts_with_any_contract_position_for_instrument( instrument_code)) contract_code = get_valid_code_from_list(contract_code_list) if contract_code is user_exit: return None pos_series = diag_positions.get_position_df_for_instrument_and_contract_id( instrument_code, contract_code) print(pos_series) return None
def get_actual_positions_for_strategy(self): """ Actual positions held by a strategy Useful to know, usually :return: dict, keys are instrument codes, values are positions """ data = self.data strategy_name = self.strategy_name diag_positions = diagPositions(data) list_of_instruments = ( diag_positions.get_list_of_instruments_for_strategy_with_position( strategy_name)) actual_positions = dict([( instrument_code, diag_positions.get_position_for_strategy_and_instrument( strategy_name, instrument_code), ) for instrument_code in list_of_instruments]) return actual_positions
def actual_instrument_position(data): diag_positions = diagPositions(data) strategy_name_list = diag_positions.get_list_of_strategies_with_positions() strategy_name = print_menu_of_values_and_get_response(strategy_name_list) if strategy_name is user_exit: return None instrument_code_list = ( diag_positions.get_list_of_instruments_for_strategy_with_position( strategy_name, ignore_zero_positions=False)) instrument_code = get_valid_code_from_list(instrument_code_list) if instrument_code is user_exit: return None instrument_strategy = instrumentStrategy(strategy_name=strategy_name, instrument_code=instrument_code) pos_series = diag_positions.get_position_df_for_instrument_strategy( instrument_strategy) print(pos_series) return None
def setup_roll_data(data: dataBlob, instrument_code: str) -> RollData: diag_positions = diagPositions(data) diag_contracts = dataContracts(data) original_roll_status = diag_positions.get_roll_state(instrument_code) priced_contract_date = diag_contracts.get_priced_contract_id( instrument_code) contract = futuresContract(instrument_code, priced_contract_date) position_priced_contract = ( diag_positions.get_position_for_contract(contract) ) allowable_roll_states = allowable_roll_state_from_current_and_position( original_roll_status, position_priced_contract ) roll_data = RollData(instrument_code, original_roll_status, position_priced_contract, allowable_roll_states) return roll_data
def get_position_for_instrument_code_at_timestamp(data_backtest, data, instrument_code): diag_positions = diagPositions(data) strategy_name = data_backtest.strategy_name instrument_strategy = instrumentStrategy(strategy_name=strategy_name, instrument_code=instrument_code) positions_over_time = diag_positions.get_position_df_for_instrument_strategy( instrument_strategy) if positions_over_time is missing_data: return np.nan datetime_cutoff = from_marker_to_datetime(data_backtest.timestamp) positions_over_time_ffill = positions_over_time.ffill() positions_before_cutoff = positions_over_time_ffill[:datetime_cutoff] if len(positions_before_cutoff) == 0: return np.nan final_position = positions_before_cutoff.iloc[-1].position return final_position
def actual_contract_position(data): diag_positions = diagPositions(data) instrument_code_list = diag_positions.get_list_of_instruments_with_any_position() instrument_code = get_valid_code_from_list(instrument_code_list) if instrument_code is user_exit: return None contract_code_list = ( diag_positions.get_list_of_contracts_with_any_contract_position_for_instrument( instrument_code ) ) contract_date_str = get_valid_code_from_list(contract_code_list) if contract_date_str is user_exit: return None # ignore warnings can be str contract = futuresContract(instrument_code, contract_date_str) pos_series = diag_positions.get_position_df_for_contract(contract) print(pos_series) return None
def apply_overrides_for_instrument_and_strategy(self, proposed_order): """ Apply an override to a trade :param strategy_name: str :param instrument_code: str :return: int, updated position """ diag_overrides = diagOverrides(self.data) diag_positions = diagPositions(self.data) strategy_name = proposed_order.strategy_name instrument_code = proposed_order.instrument_code original_position = diag_positions.get_position_for_strategy_and_instrument( strategy_name, instrument_code) override = diag_overrides.get_cumulative_override_for_strategy_and_instrument( strategy_name, instrument_code) revised_order = override.apply_override( original_position, proposed_order) if revised_order.trade != proposed_order.trade: self.log.msg( "%s/%s trade change from %d to %d because of override %s" % ( strategy_name, instrument_code, revised_order.trade, proposed_order.trade, str(override), ), strategy_name=strategy_name, instrument_code=instrument_code, ) return revised_order
def view_positions(data): data_broker = dataBroker(data) diag_positions = diagPositions(data) ans1=diag_positions.get_all_current_strategy_instrument_positions() ans2 = diag_positions.get_all_current_contract_positions() ans3 = data_broker.get_all_current_contract_positions() print("Strategy positions") print(ans1) print("\n Contract level positions") print(ans2) breaks = diag_positions.get_list_of_breaks_between_contract_and_strategy_positions() if len(breaks)>0: print("\nBREAKS between strategy and contract positions: %s\n" % str(breaks)) else: print("(No breaks positions consistent)") print("\n Broker positions") print(ans3) breaks = data_broker.get_list_of_breaks_between_broker_and_db_contract_positions() if len(breaks)>0: print("\nBREAKS between broker and DB stored contract positions: %s\n" % str(breaks)) else: print("(No breaks positions consistent)") return None
def get_my_positions(data): diag_positions = diagPositions(data) my_positions = diag_positions.get_all_current_contract_positions().as_pd_df() my_positions = my_positions.sort_values("instrument_code") return my_positions
def get_required_contract_trade_for_instrument(data, instrument_order): """ Return the contract to trade for a given instrument Depends on roll status and trade vs position: - roll_states = ['No_Roll', 'Passive', 'Force', 'Force_Outright', 'Roll_Adjusted'] If 'No Roll' then trade current contract If 'Passive', and no position in current contract: trade next contract If 'Passive', and reducing trade which leaves zero or something in current contract: trade current contract If 'Passive', and reducing trade which is larger than current contract position: trade current and next contract If 'Passive', and increasing trade: trade next contract If 'Force' or 'Force Outright' or 'Roll_Adjusted': don't trade :param instrument_order: :param data: dataBlog :return: tuple: list of child orders: each is a tuple: contract str or missing_contract, trade int """ instrument_code = instrument_order.instrument_code log = instrument_order.log_with_attributes(data.log) trade = instrument_order.trade.as_int() if trade is missing_order: log.critical("Instrument order can't be a spread order") return missing_contract diag_contracts = diagContracts(data) current_contract = diag_contracts.get_priced_contract_id(instrument_code) next_contract = diag_contracts.get_forward_contract_id(instrument_code) diag_positions = diagPositions(data) roll_state = diag_positions.get_roll_state(instrument_code) position_current_contract = ( diag_positions.get_position_for_instrument_and_contract_date( instrument_code, current_contract ) ) if roll_state == "No_Roll": log.msg( "No roll, allocating entire order %s to current contract %s" % (str(instrument_order), current_contract) ) return [(current_contract, trade)] elif roll_state in ["Force", "Force_Outright", "Roll_Adjusted"]: log.msg( "Roll state %s is rolling, not going to generate trade for order %s" % (roll_state, str(instrument_order))) return rolling_cant_trade elif roll_state == "Passive": return passive_roll_child_order( position_current_contract, current_contract, next_contract, trade, log, instrument_order, ) else: log.critical( "Roll state %s not understood: can't generate trade for %s" % (roll_state, str(instrument_order)) ) return missing_contract
def get_list_of_strategies(data): diag_positions = diagPositions(data) return diag_positions.get_list_of_strategies_with_positions()
def get_list_of_strategies_from_positions( data: dataBlob = arg_not_supplied) -> list: diag_positions = diagPositions(data) list_of_strategies = diag_positions.get_list_of_strategies_with_positions() return list_of_strategies
def check_if_forced_roll_required(self, instrument_code: str) -> bool: diag_positions = diagPositions(self.data) forced_roll_required = diag_positions.is_forced_roll_required(instrument_code) return forced_roll_required
def get_old_strategy_positions(data: dataBlob, old_strategy: str): diag_positions = diagPositions(data) old_positions = diag_positions.get_dict_of_actual_positions_for_strategy( old_strategy) return old_positions
def get_required_contract_trade_for_instrument( data: dataBlob, instrument_order: instrumentOrder ) -> list: """ Return the contract to trade for a given instrument Depends on roll status and trade vs position: - roll_states = ['No_Roll', 'Passive', 'Force', 'Force_Outright', 'Roll_Adjusted'] If 'No Roll' then trade current contract If 'Passive', and no position in current contract: trade next contract If 'Passive', and reducing trade which leaves zero or something in current contract: trade current contract If 'Passive', and reducing trade which is larger than current contract position: trade current and next contract If 'Passive', and increasing trade: trade next contract If 'Force' or 'Force Outright' or 'Roll_Adjusted': don't trade :param instrument_order: :param data: dataBlog :return: tuple: list of child orders: each is a tuple: contract str or missing_contract, trade int """ instrument_code = instrument_order.instrument_code log = instrument_order.log_with_attributes(data.log) trade = instrument_order.as_single_trade_qty_or_error() if trade is missing_order: log.critical("Instrument order can't be a spread order") return [] diag_positions = diagPositions(data) if diag_positions.is_roll_state_no_roll(instrument_code): diag_contracts = dataContracts(data) current_contract = diag_contracts.get_priced_contract_id(instrument_code) log.msg( "No roll, allocating entire order %s to current contract %s" % (str(instrument_order), current_contract) ) return [contractIdAndTrade(current_contract, trade)] elif diag_positions.is_roll_state_close(instrument_code): diag_contracts = dataContracts(data) current_contract = diag_contracts.get_priced_contract_id(instrument_code) log.msg( "Closing roll state, allocating entire order %s to current contract %s" % (str(instrument_order), current_contract) ) return [contractIdAndTrade(current_contract, trade)] elif diag_positions.is_roll_state_passive(instrument_code): # no log as function does it list_of_child_contract_dates_and_trades = passive_roll_child_order( data=data, instrument_order=instrument_order, trade=trade ) return list_of_child_contract_dates_and_trades elif diag_positions.is_type_of_active_rolling_roll_state(instrument_code): log.msg( "Roll state is active rolling, not going to generate trade for order %s" % (str(instrument_order)) ) return [] else: log.critical( "Roll state %s not understood: can't generate trade for %s" % ( diag_positions.get_name_of_roll_state(instrument_code), str(instrument_order), ) ) return []
def get_instruments_with_positions(data, strategy_name): diag_positions = diagPositions(data) instrument_list = diag_positions.get_list_of_instruments_for_strategy_with_position( strategy_name) return instrument_list
def generate_force_roll_orders(self): diag_positions = diagPositions(self.data) list_of_instruments = diag_positions.get_list_of_instruments_with_current_positions() for instrument_code in list_of_instruments: self.generate_force_roll_orders_for_instrument(instrument_code)
def get_list_of_instruments(data): diag_positions = diagPositions(data) instrument_list = diag_positions.get_list_of_instruments_with_any_position() return instrument_list
def check_if_forced_roll_required(self, instrument_code): diag_positions = diagPositions(self.data) return diag_positions.is_forced_roll_required(instrument_code)
def get_instruments_with_current_positions(self): diag_positions = diagPositions(self.data) instrument_list = diag_positions.get_list_of_instruments_with_current_positions( ) return instrument_list
def get_instruments_with_positions_all_strategies(data): diag_positions = diagPositions(data) instrument_list = diag_positions.get_list_of_instruments_with_current_positions( ) return instrument_list
def get_current_position_for_instrument(self, instrument_code): diag_positions = diagPositions(self.data) position = diag_positions.get_current_instrument_position_across_strategies( instrument_code) return position
def passive_roll_child_order( data: dataBlob, trade: int, instrument_order: instrumentOrder, ) -> list: log = instrument_order.log_with_attributes(data.log) diag_positions = diagPositions(data) instrument_code = instrument_order.instrument_code diag_contracts = dataContracts(data) current_contract = diag_contracts.get_priced_contract_id(instrument_code) next_contract = diag_contracts.get_forward_contract_id(instrument_code) contract = futuresContract(instrument_code, current_contract) position_current_contract = diag_positions.get_position_for_contract(contract) # Break out because so darn complicated if position_current_contract == 0: # Passive roll and no position in the current contract, start trading # the next contract log.msg( "Passive roll handling order %s, no position in current contract, entire trade in next contract %s" % (str(instrument_order), next_contract) ) return [contractIdAndTrade(next_contract, trade)] # ok still have a position in the current contract increasing_trade = sign(trade) == sign(position_current_contract) if increasing_trade: # Passive roll and increasing trade # Do it all in next contract log.msg( "Passive roll handling order %s, increasing trade, entire trade in next contract %s" % (str(instrument_order), next_contract) ) return [contractIdAndTrade(next_contract, trade)] # ok a reducing trade new_position = position_current_contract + trade sign_of_position_is_unchanged = sign(position_current_contract) == sign( new_position ) if new_position == 0 or sign_of_position_is_unchanged: # A reducing trade that we can do entirely in the current contract log.msg( "Passive roll handling order %s, reducing trade, entire trade in next contract %s" % (str(instrument_order), next_contract) ) return [contractIdAndTrade(current_contract, trade)] # OKAY to recap: it's a passive roll, but the trade will be split between # current and next list_of_child_contract_dates_and_trades = passive_trade_split_over_two_contracts( trade=trade, current_contract=current_contract, next_contract=next_contract, position_current_contract=position_current_contract, ) log.msg( "Passive roll handling order %s, reducing trade, split trade between contract %s and %s" % (str(instrument_order), current_contract, next_contract) ) return list_of_child_contract_dates_and_trades
def get_list_of_strategies_from_positions(data=arg_not_supplied): d = diagPositions(data) return d.get_list_of_strategies_with_positions()