def updated_buffered_positions(data: dataBlob, strategy_name: str, system: System): log = data.log data_optimal_positions = dataOptimalPositions(data) list_of_instruments = system.get_instrument_list() for instrument_code in list_of_instruments: lower_buffer, upper_buffer = get_position_buffers_from_system( system, instrument_code) position_entry = construct_position_entry( data=data, system=system, instrument_code=instrument_code, lower_buffer=lower_buffer, upper_buffer=upper_buffer, ) instrument_strategy = instrumentStrategy( instrument_code=instrument_code, strategy_name=strategy_name) data_optimal_positions.update_optimal_position_for_instrument_strategy( instrument_strategy=instrument_strategy, position_entry=position_entry) log.msg( "New buffered positions %.3f %.3f" % (position_entry.lower_position, position_entry.upper_position), instrument_code=instrument_code, )
def get_raw_optimal_position_data(self) -> dict: # This is the 'raw' data, positions pre-optimisation # dict of optimalPositionWithReference data = self.data strategy_name = self.strategy_name optimal_position_data = dataOptimalPositions(data) list_of_instruments = optimal_position_data.get_list_of_instruments_for_strategy_with_optimal_position( strategy_name, raw_positions=True) list_of_instrument_strategies = [ instrumentStrategy(strategy_name=strategy_name, instrument_code=instrument_code) for instrument_code in list_of_instruments ] raw_optimal_positions = dict([( instrument_strategy.instrument_code, optimal_position_data. get_current_optimal_position_for_instrument_strategy( instrument_strategy, raw_positions=True), ) for instrument_strategy in list_of_instrument_strategies]) return raw_optimal_positions
def cut_down_proposed_instrument_trade_okay(self, instrument_trade): strategy_name = instrument_trade.strategy_name instrument_code = instrument_trade.instrument_code proposed_trade = instrument_trade.as_single_trade_qty_or_error() ## want to CUT DOWN rather than bool possible trades ## FIXME: ## underneath should be using tradeQuantity and position objects ## these will handle abs cases plus legs if required in future # :FIXME instrument_strategy = instrumentStrategy( strategy_name=strategy_name, instrument_code=instrument_code) max_trade_ok_against_instrument_strategy = \ self.check_if_proposed_trade_okay_against_instrument_strategy_constraint(instrument_strategy, proposed_trade) max_trade_ok_against_instrument = \ self.check_if_proposed_trade_okay_against_instrument_constraint(instrument_code, proposed_trade) ## FIXME THIS IS UGLY WOULD BE BETTER IF DONE INSIDE TRADE SIZE OBJECT mini_max_trade = sign(proposed_trade) * \ min([abs(max_trade_ok_against_instrument), abs(max_trade_ok_against_instrument_strategy)]) mini_max_trade = tradeQuantity(mini_max_trade) instrument_trade = instrument_trade.replace_required_trade_size_only_use_for_unsubmitted_trades( mini_max_trade) return instrument_trade
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 cut_down_proposed_instrument_trade_for_position_limits( self, order: instrumentOrder): strategy_name = order.strategy_name instrument_code = order.instrument_code instrument_strategy = instrumentStrategy( strategy_name=strategy_name, instrument_code=instrument_code) max_order_ok_against_instrument_strategy = \ self._check_if_proposed_trade_okay_against_instrument_strategy_constraint(instrument_strategy, order) max_order_ok_against_instrument = \ self._check_if_proposed_trade_okay_against_instrument_constraint(instrument_code, order) new_order = order.\ single_leg_trade_qty_with_lowest_abs_value_trade_from_order_list( [ max_order_ok_against_instrument, max_order_ok_against_instrument_strategy ] ) return new_order
def change_position_limit_for_instrument_strategy(data): view_position_limit(data) data_position_limits = dataPositionLimits(data) strategy_name = get_valid_strategy_name_from_user(data, allow_all=False, source="positions") instrument_code = get_valid_instrument_code_from_user(data, allow_all=False) new_position_limit = get_and_convert( "New position limit?", type_expected=int, allow_default=True, default_value=-1, default_str="No limit", ) instrument_strategy = instrumentStrategy(instrument_code=instrument_code, strategy_name=strategy_name) if new_position_limit == -1: data_position_limits.delete_position_limit_for_instrument_strategy( instrument_strategy) else: new_position_limit = abs(new_position_limit) data_position_limits.set_position_limit_for_instrument_strategy( instrument_strategy, new_position_limit)
def get_fills_for_instrument(data, instrument_code, strategy_name): data_orders = dataOrders(data) instrument_strategy = instrumentStrategy(instrument_code=instrument_code, strategy_name=strategy_name) list_of_fills = data_orders.get_fills_history_for_instrument_strategy(instrument_strategy) return list_of_fills
def _element_object_from_row(dfrow): instrument_strategy = instrumentStrategy( strategy_name=dfrow[KEY_STRATEGY_NAME], instrument_code=dfrow[KEY_INSTRUMENT_CODE], ) return instrumentStrategyPosition(dfrow[KEY_POSITION], instrument_strategy)
def get_current_optimal_position_for_strategy_and_instrument( self, strategy_name, instrument_code ): # FIX ME REMOVE instrument_strategy = instrumentStrategy(strategy_name=strategy_name, instrument_code=instrument_code) return self.get_current_optimal_position_for_instrument_strategy(instrument_strategy)
def get_position_df_for_strategy_and_instrument( self, strategy_name:str, instrument_code:str ): #FIXME THINK ABOUT REMOVING instrument_strategy = instrumentStrategy(strategy_name=strategy_name, instrument_code=instrument_code) position_df = self.get_position_df_for_instrument_strategy_object(instrument_strategy) return position_df
def update_instrument_strategy_limit_with_new_limit( self, strategy_name, instrument_code, period_days, new_limit): #FIXME DELETE REPLACE WITH '2' instrument_strategy = instrumentStrategy( strategy_name=strategy_name, instrument_code=instrument_code) self.update_instrument_strategy_limit_with_new_limit2( instrument_strategy, period_days, new_limit)
def get_current_position_for_strategy_and_instrument( self, strategy_name, instrument_code): #FIXME THINK ABOUT REMOVING instrument_strategy = instrumentStrategy( strategy_name=strategy_name, instrument_code=instrument_code) position = self.get_current_position_for_instrument_strategy( instrument_strategy) return position
def get_trade_df_for_instrument(data, instrument_code, strategy_name): data_orders = dataOrders(data) instrument_strategy = instrumentStrategy(instrument_code=instrument_code, strategy_name=strategy_name) list_of_trades = data_orders.get_fills_history_for_instrument_strategy(instrument_strategy) list_of_trades_as_pd_df = list_of_trades.as_pd_df() return list_of_trades_as_pd_df
def update_override_for_strategy_instrument(self, strategy_name, instrument_code, new_override): # FIXME REMOVE instrument_strategy = instrumentStrategy( strategy_name=strategy_name, instrument_code=instrument_code) self.update_override_for_instrument_strategy(instrument_strategy, new_override)
def set_abs_position_limit_for_strategy_instrument(self, strategy_name, instrument_code, new_position_limit): #FIXME DELETE instrument_strategy = instrumentStrategy( strategy_name=strategy_name, instrument_code=instrument_code) self.set_position_limit_for_instrument_strategy( instrument_strategy, new_position_limit)
def get_current_position_for_instrument_code( 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) current_position = diag_positions.get_current_position_for_instrument_strategy(instrument_strategy) return current_position
def instrument_strategy_with_raw_tag( instrument_strategy: instrumentStrategy, ) -> instrumentStrategy: original_strategy_name = copy(instrument_strategy.strategy_name) strategy_name = strategy_name_with_raw_tag(original_strategy_name) new_instrument_strategy = instrumentStrategy( strategy_name=strategy_name, instrument_code=instrument_strategy.instrument_code) return new_instrument_strategy
def get_position_series_for_instrument_strategy( data, instrument_code, strategy_name): diag_positions = diagPositions(data) instrument_strategy = instrumentStrategy(strategy_name=strategy_name, instrument_code=instrument_code) pos_series = diag_positions.get_position_df_for_instrument_strategy(instrument_strategy) if pos_series is missing_data: return pd.Series() return pd.Series(pos_series.position)
def get_optimal_positions(self) -> optimalPositions: data = self.data strategy_name = self.strategy_name optimal_position_data = dataOptimalPositions(data) list_of_instruments = optimal_position_data.get_list_of_instruments_for_strategy_with_optimal_position( strategy_name) list_of_instrument_strategies = [ instrumentStrategy(strategy_name=strategy_name, instrument_code=instrument_code) for instrument_code in list_of_instruments ] optimal_positions = dict([( instrument_strategy.instrument_code, optimal_position_data. get_current_optimal_position_for_instrument_strategy( instrument_strategy), ) for instrument_strategy in list_of_instrument_strategies]) ref_dates = dict([ (instrument_code, opt_position.date) for instrument_code, opt_position in optimal_positions.items() ]) upper_positions = dict([ (instrument_code, opt_position.upper_position) for instrument_code, opt_position in optimal_positions.items() ]) lower_positions = dict([ (instrument_code, opt_position.lower_position) for instrument_code, opt_position in optimal_positions.items() ]) reference_prices = dict([ (instrument_code, opt_position.reference_price) for instrument_code, opt_position in optimal_positions.items() ]) reference_contracts = dict([ (instrument_code, opt_position.reference_contract) for instrument_code, opt_position in optimal_positions.items() ]) optimal_positions = optimalPositions( upper_positions=upper_positions, lower_positions=lower_positions, reference_prices=reference_prices, reference_contracts=reference_contracts, ref_dates=ref_dates, ) return optimal_positions
def _from_trade_limit_dict_to_required_dict(trade_limit_dict: dict) -> dict: if INSTRUMENT_STRATEGY_KEY in trade_limit_dict.keys(): ## NEW STYLE return trade_limit_dict ## OLD STYLE instrument_strategy = instrumentStrategy(instrument_code=trade_limit_dict.pop(LEGACY_INSTRUMENT_KEY), strategy_name=trade_limit_dict.pop(LEGACY_STRATEGY_KEY)) trade_limit_dict[INSTRUMENT_STRATEGY_KEY] = instrument_strategy.key return trade_limit_dict
def _from_result_dict_to_isd(result_dict: dict) -> instrumentStrategyKeyAndDays: if INSTRUMENT_STRATEGY_KEY in result_dict.keys(): ## NEW STYLE instrument_strategy_key = result_dict[INSTRUMENT_STRATEGY_KEY] else: ## LEGACY instrument_strategy = instrumentStrategy(strategy_name=result_dict[LEGACY_STRATEGY_KEY], instrument_code=result_dict[LEGACY_INSTRUMENT_KEY]) instrument_strategy_key = instrument_strategy.key return instrumentStrategyKeyAndDays(instrument_strategy_key, result_dict[PERIOD_KEY])
def get_reduce_only_keys(data: dataBlob, strategy_name: str, list_of_instruments: list) -> list: no_trade_keys = [ instrument_code for instrument_code in list_of_instruments if get_override_for_instrument_strategy( data, instrument_strategy=instrumentStrategy( instrument_code=instrument_code, strategy_name=strategy_name), ) == REDUCE_ONLY_OVERRIDE ] return no_trade_keys
def get_maximum_position_contracts( data, strategy_name: str, list_of_instruments: list) -> portfolioWeights: maximum_position_contracts = dict([( instrument_code, get_maximum_position_contracts_for_instrument_strategy( data, instrument_strategy=instrumentStrategy( strategy_name=strategy_name, instrument_code=instrument_code)), ) for instrument_code in list_of_instruments]) return portfolioWeights(maximum_position_contracts)
def update_strategy_instrument_override(data): view_overrides(data) update_overrides = updateOverrides(data) instrument_code = get_valid_instrument_code_from_user(data) strategy_name = get_valid_strategy_name_from_user(data=data, source="positions") instrument_strategy = instrumentStrategy(instrument_code=instrument_code, strategy_name=strategy_name) new_override = get_overide_object_from_user() ans = input("Are you sure? (y/other)") if ans == "y": update_overrides.update_override_for_instrument_strategy( instrument_strategy=instrument_strategy, new_override=new_override)
def get_last_position_update_for_strategy_instrument(data, strategy_name, instrument_code): op = dataOptimalPositions(data) instrument_strategy = instrumentStrategy(instrument_code=instrument_code, strategy_name=strategy_name) pos_data = op.get_optimal_position_as_df_for_instrument_strategy( instrument_strategy) if pos_data is missing_data: return None last_update = pos_data.index[-1] key = "%s/%s" % (strategy_name, instrument_code) return genericUpdate(key, last_update)
def get_list_of_perc_pandl_series_for_strategy_all_instruments( self, strategy_name: str): instrument_list = get_list_of_instruments_held_for_a_strategy( self.data, strategy_name) if len(instrument_list) == 0: return missing_data, missing_data pandl_list = [ self.perc_pandl_series_for_strategy_instrument_vs_total_capital( instrumentStrategy(strategy_name, instrument_code)) for instrument_code in instrument_list ] return instrument_list, pandl_list
def backup_strategy_position_data(data): strategy_list = get_list_of_strategies(data) instrument_list = (data.mongo_contract_position. get_list_of_instruments_with_any_position()) for strategy_name in strategy_list: for instrument_code in instrument_list: instrument_strategy = instrumentStrategy( strategy_name=strategy_name, instrument_code=instrument_code) mongo_data = data.mongo_strategy_position.get_position_as_df_for_instrument_strategy_object( instrument_strategy) if mongo_data is missing_data: continue data.csv_strategy_position.write_position_df_for_instrument_strategy( instrument_strategy, mongo_data) data.log.msg("Backed up %s %s strategy position data" % (instrument_code, strategy_name))
def reset_limit_for_instrument_strategy(data): trade_limits = dataTradeLimits(data) instrument_code = get_valid_instrument_code_from_user(data) period_days = get_and_convert( "Period of days?", type_expected=int, allow_default=True, default_value=1 ) strategy_name = get_valid_strategy_name_from_user(data=data, source="positions") ans = input("Reset means trade 'clock' will restart. Are you sure? (y/other)") if ans == "y": instrument_strategy = instrumentStrategy( instrument_code=instrument_code, strategy_name=strategy_name ) trade_limits.reset_instrument_strategy_limit( instrument_strategy=instrument_strategy, period_days=period_days )
def write_optimised_positions_data_for_code( data: dataBlob, strategy_name: str, instrument_code: str, optimised_position_entry: optimalPositionWithDynamicCalculations, ): data_optimal_positions = dataOptimalPositions(data) instrument_strategy = instrumentStrategy(instrument_code=instrument_code, strategy_name=strategy_name) data.log.msg( "Adding optimal position for %s: %s" % (str(instrument_strategy), optimised_position_entry.verbose_repr())) data_optimal_positions.update_optimal_position_for_instrument_strategy( instrument_strategy=instrument_strategy, position_entry=optimised_position_entry)
def get_dict_of_actual_positions_for_strategy(self, strategy_name: str) -> dict: list_of_instruments = self.get_list_of_instruments_for_strategy_with_position( strategy_name) list_of_instrument_strategies = [ instrumentStrategy(strategy_name=strategy_name, instrument_code=instrument_code) for instrument_code in list_of_instruments ] actual_positions = dict([( instrument_strategy.instrument_code, self.get_current_position_for_instrument_strategy( instrument_strategy), ) for instrument_strategy in list_of_instrument_strategies]) return actual_positions