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 view_positions(data): data_broker = dataBroker(data) diag_positions = diagPositions(data) data_optimal = dataOptimalPositions(data) ans0 = data_optimal.get_pd_of_position_breaks() ans1 = diag_positions.get_all_current_strategy_instrument_positions() ans2 = data_broker.get_db_contract_positions_with_IB_expiries() ans3 = data_broker.get_all_current_contract_positions() print("Optimal vs actual") print(ans0.sort_values("breaks")) print("Strategy positions") print(ans1.as_pd_df().sort_values("instrument_code")) print("\n Contract level positions") print(ans2.as_pd_df().sort_values(["instrument_code", "contract_date"])) 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.as_pd_df().sort_values(["instrument_code", "contract_date"])) 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 updated_buffered_positions(data, strategy_name, system): log = data.log data_optimal_positions = dataOptimalPositions(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 ) data_optimal_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 get_list_of_strategies_from_optimal_positions( data: dataBlob = arg_not_supplied, ) -> list: data_optimal_positions = dataOptimalPositions(data) list_of_strategies = ( data_optimal_positions.get_list_of_strategies_with_optimal_position()) return list_of_strategies
def get_last_position_update_for_strategy_instrument(data, strategy_name, instrument_code): op = dataOptimalPositions(data) pos_data = op.get_optimal_position_as_df_for_strategy_and_instrument(strategy_name, instrument_code) 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_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) optimal_positions = dict( [ (instrument_code, optimal_position_data.get_current_optimal_position_for_strategy_and_instrument( strategy_name, instrument_code), ) for instrument_code in list_of_instruments]) 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 reconcile(): diag_positions = diagPositions(data) data_optimal = dataOptimalPositions(data) optimal_positions = data_optimal.get_pd_of_position_breaks().to_dict() strategies = {} for instrument in optimal_positions["breaks"].keys(): strategies[instrument] = { "break": optimal_positions["breaks"][instrument], "optimal": str(optimal_positions["optimal"][instrument]), "current": optimal_positions["current"][instrument], } positions = {} db_breaks = (diag_positions. get_list_of_breaks_between_contract_and_strategy_positions()) ib_breaks = [] gateway_ok = True try: asyncio.set_event_loop(asyncio.new_event_loop()) data_broker = dataBroker(data) db_contract_pos = ( data_broker.get_db_contract_positions_with_IB_expiries().as_pd_df( ).to_dict()) for idx in db_contract_pos["instrument_code"].keys(): code = db_contract_pos["instrument_code"][idx] contract_date = db_contract_pos["contract_date"][idx] position = db_contract_pos["position"][idx] positions[code + "-" + contract_date] = { "code": code, "contract_date": contract_date, "db_position": position, } ib_contract_pos = (data_broker.get_all_current_contract_positions(). as_pd_df().to_dict()) for idx in ib_contract_pos["instrument_code"].keys(): code = ib_contract_pos["instrument_code"][idx] contract_date = ib_contract_pos["contract_date"][idx] position = ib_contract_pos["position"][idx] positions[code + "-" + contract_date]["ib_position"] = position ib_breaks = ( data_broker. get_list_of_breaks_between_broker_and_db_contract_positions()) except: # IB gateway connection failed gateway_ok = False return { "strategy": strategies, "positions": positions, "db_breaks": db_breaks, "ib_breaks": ib_breaks, "gateway_ok": gateway_ok, }
def optimal_positions(data): strategy_name = get_valid_strategy_name_from_user(data=data) optimal_data = dataOptimalPositions(data) instrument_code_list = optimal_data.get_list_of_instruments_for_strategy_with_optimal_position(strategy_name) instrument_code = get_valid_code_from_list(instrument_code_list) if instrument_code is user_exit: return None data_series = optimal_data.get_optimal_position_as_df_for_strategy_and_instrument(strategy_name, instrument_code) print(data_series) return None
def get_optimal_positions_table_as_df(data: dataBlob, strategy_name: str) -> pd.DataFrame: data_optimal_positions = dataOptimalPositions(data) list_of_positions = ( data_optimal_positions. get_list_of_current_optimal_positions_for_strategy_name(strategy_name)) as_verbose_pd = list_of_positions.as_verbose_pd() if len(as_verbose_pd) == 0: return pd.DataFrame() subset_of_pd = as_verbose_pd[[ "dont_trade", "reduce_only", "weight_per_contract", "position_limit_weight", "optimum_weight", "start_weight", "maximum_weight", "minimum_weight", "previous_weight", "optimised_weight", "optimal_position", "position_limit_contracts", "previous_position", "optimised_position", ]] things_to_round = [ "optimal_position", "weight_per_contract", "position_limit_weight", "optimum_weight", "start_weight", "maximum_weight", "minimum_weight", "previous_weight", "optimised_weight", ] for column_name in things_to_round: subset_of_pd[column_name] = subset_of_pd[column_name].round(2) subset_of_pd = subset_of_pd.sort_values("optimum_weight") return subset_of_pd
def get_position_breaks(data): data_optimal = dataOptimalPositions(data) breaks_str0 = "Breaks Optimal vs actual %s" % str( data_optimal.get_list_of_optimal_position_breaks() ) diag_positions = diagPositions(data) breaks_str1 = "Breaks Instrument vs Contract %s" % str( diag_positions.get_list_of_breaks_between_contract_and_strategy_positions()) data_broker = dataBroker(data) breaks_str2 = "Breaks Broker vs Contract %s" % str( data_broker.get_list_of_breaks_between_broker_and_db_contract_positions()) return breaks_str0 + "\n " + breaks_str1 + "\n " + breaks_str2
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 optimal_positions(data): strategy_name = get_valid_strategy_name_from_user( data=data, source="optimal_positions") optimal_data = dataOptimalPositions(data) instrument_code_list = ( optimal_data. get_list_of_instruments_for_strategy_with_optimal_position( strategy_name)) instrument_code = get_valid_code_from_list(instrument_code_list) if instrument_code is user_exit: return None instrument_strategy = instrumentStrategy(instrument_code=instrument_code, strategy_name=strategy_name) data_series = optimal_data.get_optimal_position_as_df_for_instrument_strategy( instrument_strategy) print(data_series) return None
def updated_optimal_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: position_entry = construct_optimal_position_entry( data=data, system=system, instrument_code=instrument_code, ) instrument_strategy = instrumentStrategy( instrument_code=instrument_code, strategy_name=strategy_name) data_optimal_positions.update_optimal_position_for_instrument_strategy( instrument_strategy=instrument_strategy, raw_positions=True, position_entry=position_entry, ) log.msg("New Optimal position %s %s" % (str(position_entry), instrument_code))
def get_optimal_positions(data): data_optimal = dataOptimalPositions(data) opt_positions = data_optimal.get_pd_of_position_breaks() return opt_positions
def get_list_of_strategies_from_optimal_positions(data = arg_not_supplied): d = dataOptimalPositions(data) return d.get_list_of_strategies_with_optimal_position()