def build_attribute_dict(diag_logs, lookback_days): attribute_dict = {} not_finished = True while not_finished: print("Attributes selected so far %s" % str(attribute_dict)) list_of_attributes = diag_logs.get_list_of_unique_log_attribute_keys( attribute_dict=attribute_dict, lookback_days=lookback_days ) print("Which attribute to filter by?") attribute_name = print_menu_of_values_and_get_response(list_of_attributes) list_of_attribute_values = ( diag_logs.get_unique_list_of_values_for_log_attribute( attribute_name, attribute_dict=attribute_dict, lookback_days=lookback_days, ) ) print("Which value for %s ?" % attribute_name) attribute_value = print_menu_of_values_and_get_response( list_of_attribute_values ) attribute_dict[attribute_name] = attribute_value ans = input("Have you finished? (RETURN: No, anything else YES)") if not ans == "": not_finished = False break return attribute_dict
def get_valid_fx_code_from_user( data: dataBlob = arg_not_supplied, allow_none=False, none_str="None" ) -> str: if data is arg_not_supplied: data = dataBlob() all_fx_codes = get_list_of_fxcodes(data) if allow_none: fx_code = print_menu_of_values_and_get_response( all_fx_codes, default_str=none_str ) else: fx_code = print_menu_of_values_and_get_response(all_fx_codes) return fx_code
def get_rolling_master_function(): MANUAL_INPUT = "Manually input instrument codes and manually decide when to roll" MENU_OPTIONS = [ MANUAL_INPUT, "Cycle through instrument codes automatically, but manually decide when to roll", "Cycle through instrument codes automatically, auto decide when to roll, manually confirm rolls", "Cycle through instrument codes automatically, auto decide when to roll, automatically roll", ] function_list = [ update_roll_status_manual_cycle, update_roll_status_auto_cycle_manual_decide, update_roll_status_auto_cycle_manual_confirm, update_roll_status_full_auto, ] print("How do you want to do your rolls today?") selection = print_menu_of_values_and_get_response( MENU_OPTIONS, default_str=MANUAL_INPUT ) selection_idx = MENU_OPTIONS.index(selection) function_to_call = function_list[selection_idx] return function_to_call
def get_roll_state_required(roll_data: RollDataWithStateReporting) -> RollState: invalid_input = True while invalid_input: roll_data.display_roll_query_banner() roll_state_required_as_str = print_menu_of_values_and_get_response( roll_data.allowable_roll_states_as_list_of_str ) if roll_state_required_as_str != roll_data.original_roll_status_as_string: # check if changing print("") check = input( "Changing roll state for %s from %s to %s, are you sure y/n to try again/<RETURN> to exit: " % ( roll_data.instrument_code, roll_data.original_roll_status_as_string, roll_state_required_as_str, ) ) print("") if check == "y": # happy return RollState[roll_state_required_as_str] elif check == "": print("Okay, we're done") return no_change_required else: print("OK. Choose again.") # back to top of loop continue else: print("No change") return no_change_required
def view_individual_order(data): list_of_order_types = [ "Instrument / Strategy", "Instrument / Contract", "Broker level", ] print("Which order queue?") order_type = print_menu_of_values_and_get_response(list_of_order_types) order_id = get_and_convert( "Order number?", type_expected=int, default_value=None, default_str="CANCEL" ) if order_id is None: return None data_orders = dataOrders(data) if order_type == list_of_order_types[0]: order = data_orders.get_historic_instrument_order_from_order_id(order_id) elif order_type == list_of_order_types[1]: order = data_orders.get_historic_contract_order_from_order_id(order_id) elif order_type == list_of_order_types[2]: order = data_orders.get_historic_broker_order_from_order_id(order_id) else: print("Don't know what to do") return None print(order.full_repr()) return None
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 enter_manual_contract_order(data, instrument_order): strategy_name = instrument_order.strategy_name instrument_code = instrument_order.instrument_code qty = instrument_order.trade leg_count = get_and_convert("How many legs?", type_expected=int, default_value=1) contract_id_list = [] for leg_idx in range(leg_count): print("Choose contract for leg %d" % leg_idx) _, contract_date = get_valid_instrument_code_and_contractid_from_user( data, instrument_code=instrument_code ) contract_id_list.append(contract_date) trade_qty_list = [] for trade_idx in range(leg_count): trade_qty = get_and_convert( "Enter quantity for leg %d" % trade_idx, type_expected=int, allow_default=False, ) trade_qty_list.append(trade_qty) if sum(trade_qty_list) != sum(qty): print( "Sum of instrument quantity %s is different from sum of contract quantity %s" % (str(qty), str(trade_qty_list)) ) print("It's unlikely you meant to do this...") NO_ALGO = "None: allow system to allocate" algo_to_use = print_menu_of_values_and_get_response( list_of_algos, default_str=NO_ALGO ) if algo_to_use == NO_ALGO: algo_to_use = "" limit_price = get_and_convert( "Limit price? (will override instrument order limit price, will be ignored by some algo types", type_expected=float, default_str="None", default_value=None, ) order_type = map_instrument_order_type_to_contract_order_type( instrument_order.order_type ) contract_order = contractOrder( strategy_name, instrument_code, contract_id_list, trade_qty_list, algo_to_use=algo_to_use, order_type=order_type, reference_price=None, limit_price=limit_price, manual_trade=True, ) return contract_order
def get_roll_state_required(self) -> str: invalid_input = True while invalid_input: self.display_roll_query_banner() roll_state_required_as_str = print_menu_of_values_and_get_response( self.allowable_roll_states_as_list_of_str) if roll_state_required_as_str != self.original_roll_status_as_string: # check if changing print("") check = input( "Changing roll state for %s from %s to %s, are you sure y/n to try again/<RETURN> to exit: " % (self.instrument_code, self.original_roll_status_as_string, roll_state_required_as_str)) print("") if check == "y": # happy self.set_new_roll_state(roll_state_required_as_str) return roll_state_required_as_str elif check == "": print("Okay, we're done") return no_state_available else: print("OK. Choose again.") # back to top of loop continue else: print("No change") return no_state_available
def get_valid_fx_code_from_user(data: dataBlob = arg_not_supplied) -> str: if data is arg_not_supplied: data = dataBlob() all_fx_codes = get_list_of_fxcodes(data) fx_code = print_menu_of_values_and_get_response(all_fx_codes) return fx_code
def capital_strategy(data): data_capital = dataCapital(data) strat_list = data_capital.get_list_of_strategies_with_capital() strategy_name = print_menu_of_values_and_get_response( strat_list, default_str=strat_list[0] ) capital_series = data_capital.get_capital_pd_series_for_strategy(strategy_name) print(capital_series.tail(30)) return None
def interactively_choose_timestamp(strategy_name: str, data: dataBlob = arg_not_supplied): data_backtest = dataBacktest(data) list_of_timestamps = sorted( data_backtest.get_list_of_timestamps_for_strategy(strategy_name)) # most recent last print("Choose the backtest to load:\n") timestamp = print_menu_of_values_and_get_response( list_of_timestamps, default_str=list_of_timestamps[-1]) return timestamp
def get_state_to_use_for_held_position() -> RollState: print( "Choose state to automatically assume if we have a position in priced contract AND roll state is currently NO ROLL" ) select_state_for_position_held = print_menu_of_values_and_get_response( STATE_OPTIONS_AS_STR, default_str=STATE_OPTIONS_AS_STR[0]) state_when_position_held = STATE_OPTIONS[STATE_OPTIONS_AS_STR.index( select_state_for_position_held)] return state_when_position_held
def get_valid_strategy_name_from_user(data: dataBlob = arg_not_supplied, allow_all: bool = False, all_code: str = "ALL", source: str = "config"): all_strategies = get_list_of_strategies(data=data, source=source) if allow_all: default_strategy = all_code else: default_strategy = all_strategies[0] strategy_name = print_menu_of_values_and_get_response( all_strategies, default_str=default_strategy) return strategy_name
def update_system_backtests(): ## function if called from script with dataBlob(log_name="Update-System_Backtest") as data: list_of_strategies = get_list_of_strategies_for_process(data, process_name) ALL = "ALL" print("Which strategy?") strategy_name = print_menu_of_values_and_get_response(list_of_strategies, default_str=ALL) if not strategy_name == ALL: list_of_strategies = [strategy_name] for strategy_name in list_of_strategies: system_backtest_runner = strategyRunner(data, strategy_name, process_name, backtest_function) system_backtest_runner.run_strategy_method()
def update_strategy_orders(): ## function if called from script with dataBlob(log_name="Update-Strategy-Orders") as data: list_of_strategies = get_list_of_strategies_for_process( data, process_name) ALL = "ALL" print("Which strategy?") strategy_name = print_menu_of_values_and_get_response( list_of_strategies, default_str=ALL) if not strategy_name == ALL: list_of_strategies = [strategy_name] for strategy_name in list_of_strategies: strategy_order_generator = strategyRunner( data, strategy_name, process_name, name_of_main_generator_method) strategy_order_generator.run_strategy_method()