def what_trade_is_possible(self, strategy_name, instrument_code, proposed_trade): #FIXME DELETE instrument_strategy = instrumentStrategy( instrument_code=instrument_code, strategy_name=strategy_name) return self.what_trade_is_possible_for_strategy_instrument( instrument_strategy, proposed_trade)
def get_cumulative_override_for_strategy_and_instrument( self, strategy_name, instrument_code): # FIXME REMOVE instrument_strategy = instrumentStrategy( strategy_name=strategy_name, instrument_code=instrument_code) return \ self.get_cumulative_override_for_instrument_strategy(instrument_strategy)
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.trade.as_int() ## 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)]) instrument_trade = instrument_trade.replace_trade_only_use_for_unsubmitted_trades( mini_max_trade) return instrument_trade
def update_optimal_position_for_strategy_and_instrument( self, strategy_name, instrument_code, position_entry ): #FIXME REMOVE self.update_optimal_position_for_instrument_strategy( instrumentStrategy(strategy_name=strategy_name, instrument_code=instrument_code), position_entry)
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 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 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_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 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 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_tradeable_object_and_optimal_position(self, strategy_name, instrument_code): optimal_position = ( self.get_current_optimal_position_for_strategy_and_instrument( strategy_name, instrument_code)) tradeable_object = instrumentStrategy(strategy_name, instrument_code) tradeable_object_and_optimal_position = tradeableObjectAndOptimalPosition( tradeable_object, optimal_position) return tradeable_object_and_optimal_position
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 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 get_all_instrument_strategies_with_limits( self) -> listOfInstrumentStrategies: dict_of_keys = {MARKER_KEY: MARKER_STRATEGY_INSTRUMENT} list_of_dicts = self.mongo_data.get_list_of_result_dicts_for_dict_keys( dict_of_keys) list_of_instrument_strategies = [ instrumentStrategy(strategy_name=db_entry[STRATEGY_KEY], instrument_code=db_entry[INSTRUMENT_KEY]) for db_entry in list_of_dicts ] list_of_instrument_strategies = listOfInstrumentStrategies( list_of_instrument_strategies) return list_of_instrument_strategies
def update_strategy_position_table_with_instrument_order( self, instrument_order, new_fill ): """ Alter the strategy position table according to instrument order fill value :param instrument_order: :return: """ # FIXME WOULD BE NICE IF COULD GET DIRECTLY FROM ORDER strategy_name = instrument_order.strategy_name instrument_code = instrument_order.instrument_code instrument_strategy = instrumentStrategy(strategy_name=strategy_name, instrument_code=instrument_code) current_position = self.diag_positions.get_current_position_for_instrument_strategy(instrument_strategy) trade_done = new_fill.as_int() if trade_done is missing_order: self.log.critical("Instrument orders can't be spread orders!") return failure new_position = current_position + trade_done self.data.db_strategy_position.update_position_for_instrument_strategy_object( instrument_strategy, new_position) self.log.msg( "Updated position of %s/%s from %d to %d because of trade %s %d" % ( strategy_name, instrument_code, current_position, new_position, str(instrument_order), instrument_order.order_id, ) ) return success
def reset_instrument_strategy_limit(self, strategy_name, instrument_code, period_days): #FIXME REPLACE WITH 2 instrument_strategy = instrumentStrategy( strategy_name=strategy_name, instrument_code=instrument_code) self.reset_instrument_strategy_limit2(instrument_strategy, period_days)
def instrument_strategy_for_instrument_only( instrument_code) -> instrumentStrategy: return instrumentStrategy(strategy_name="", instrument_code=instrument_code)
def get_optimal_position_as_df_for_strategy_and_instrument( self, strategy_name: str, instrument_code: str ): # FIX ME REMOVE return self.get_optimal_position_as_df_for_instrument_strategy(instrumentStrategy(instrument_code=instrument_code, strategy_name=strategy_name))
def remove_trade(self, strategy_name, instrument_code, trade): instrument_strategy = instrumentStrategy( strategy_name=strategy_name, instrument_code=instrument_code) self.remove_trade_for_instrument_strategy(instrument_strategy, trade)
def add_trade(self, strategy_name, instrument_code, trade): #FIXME REMOVE instrument_strategy = instrumentStrategy( strategy_name=strategy_name, instrument_code=instrument_code) self.add_trade_for_instrument_strategy(instrument_strategy, trade)
def delete_position_limit_for_strategy_instrument(self, strategy_name: str, instrument_code: str): ## FIXME DELETE instrument_strategy = instrumentStrategy( strategy_name=strategy_name, instrument_code=instrument_code) self.delete_position_limit_for_instrument_strategy(instrument_strategy)
def __init__(self, position: int, strategy_name: str, instrument_code: str): tradeable_object = instrumentStrategy(strategy_name, instrument_code) super().__init__(position, tradeable_object)