def _create_comparison(self, instrument_code: str, price_date_str: str, forward_date_str: str): """ :param instrument_code: symbol for instrument. :param price_date_str: Contract ID for the priced contract - for example; "20220500" :param forward_date_str: Contract ID for the forward contract - for example; "20220500" :return: a dataframe where prices from the priced and forward contracts are merged together. columns separated with suffixes _price and _forward """ price_contract = futuresContract(instrument_object=instrument_code, contract_date_object=price_date_str) forward_contract = futuresContract( instrument_object=instrument_code, contract_date_object=forward_date_str) contract_prices = arcticFuturesContractPriceData() price_prices = contract_prices.get_prices_for_contract_object( price_contract) forward_prices = contract_prices.get_prices_for_contract_object( forward_contract) merged_contracts = pd.merge(price_prices, forward_prices, how='outer', left_index=True, right_index=True, suffixes=('_price', '_forward')) return merged_contracts
def clone_single_contract(instrument_from: str, instrument_to: str, contract_date: str): data_in = db_data_individual_prices.get_prices_for_contract_object( futuresContract(instrument_from, contract_date)) db_data_individual_prices.write_prices_for_contract_object( futuresContract(instrument_to, contract_date), futures_price_data=data_in)
def setup_roll_data_with_state_reporting( data: dataBlob, instrument_code: str ) -> RollDataWithStateReporting: 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 = int(diag_positions.get_position_for_contract(contract)) allowable_roll_states = allowable_roll_state_from_current_and_position( original_roll_status, position_priced_contract ) days_until_roll = diag_contracts.days_until_roll(instrument_code) relative_volume = relative_volume_in_forward_contract_versus_price( data=data, instrument_code=instrument_code ) if np.isnan(relative_volume): relative_volume = 0.0 roll_data_with_state = RollDataWithStateReporting( instrument_code=instrument_code, original_roll_status=original_roll_status, position_priced_contract=position_priced_contract, allowable_roll_states_as_list_of_str=allowable_roll_states, days_until_roll=days_until_roll, relative_volume=relative_volume, ) return roll_data_with_state
def update_positions_for_individual_contract_leg( self, instrument_code, contract_id, trade_done, time_date=None ): #FIXME CHANGE TO CONTRACT if time_date is None: time_date = datetime.datetime.now() contract = futuresContract(instrument_code, contract_id) current_position = self.diag_positions.get_position_for_contract(contract) new_position = current_position + trade_done self.data.db_contract_position.update_position_for_contract_object( contract, new_position, date=time_date) # check new_position_db = self.diag_positions.get_position_for_contract(contract) self.log.msg( "Updated position of %s/%s from %d to %d; new position in db is %d" % ( instrument_code, contract_id, current_position, new_position, new_position_db, ) )
def get_contract_chain(instrument_code, data): diag_contracts = diagContracts(data) diag_prices = diagPrices(data) roll_parameters = diag_contracts.get_roll_parameters(instrument_code) # Get the last contract currently being used multiple_prices = diag_prices.get_multiple_prices(instrument_code) current_contract_dict = multiple_prices.current_contract_dict() current_contract_list = list(current_contract_dict.values()) furthest_out_contract_date = max(current_contract_list) furthest_out_contract = contractDateWithRollParameters( contractDate(furthest_out_contract_date), roll_parameters) # To give us wiggle room, and ensure we start collecting the new forward a # little in advance final_contract = furthest_out_contract.next_priced_contract() contract_date_chain = ( final_contract.get_unexpired_contracts_from_now_to_contract_date()) # We have a list of contract_date objects, need futureContracts # create a 'bare' instrument object instrument_object = futuresInstrument(instrument_code) contract_object_chain_as_list = [ futuresContract(instrument_object, contract_date_object) for contract_date_object in contract_date_chain ] contract_object_chain = listOfFuturesContracts( contract_object_chain_as_list) return contract_object_chain
def get_trade_df_for_contract(data, instrument_code, contract_id): data_orders = dataOrders(data) contract = futuresContract(instrument_code, contract_id) list_of_trades = data_orders.get_fills_history_for_contract(contract) list_of_trades_as_pd_df = list_of_trades.as_pd_df() return list_of_trades_as_pd_df
def get_price_series_for_contract(data, instrument_code, contract_id): diag_prices = diagPrices(data) contract = futuresContract(instrument_code, contract_id) all_prices = diag_prices.get_prices_for_contract_object(contract) price_series = all_prices.return_final_prices() return price_series
def get_roll_spread_information(data: dataBlob, instrument_code: str) -> rollSpreadInformation: diag_positions = diagPositions(data) diag_contracts = dataContracts(data) diag_prices = diagPrices(data) priced_contract_id = diag_contracts.get_priced_contract_id(instrument_code) forward_contract_id = diag_contracts.get_forward_contract_id( instrument_code) contract = futuresContract(instrument_code, priced_contract_id) position_in_priced = diag_positions.get_position_for_contract(contract) reference_date, last_matched_prices = tuple( diag_prices.get_last_matched_date_and_prices_for_contract_list( instrument_code, [priced_contract_id, forward_contract_id] ) ) reference_price_priced_contract, reference_price_forward_contract = last_matched_prices return rollSpreadInformation(priced_contract_id=priced_contract_id, forward_contract_id = forward_contract_id, reference_price_forward_contract=reference_price_forward_contract, reference_price_priced_contract=reference_price_priced_contract, position_in_priced = int(position_in_priced), reference_date=reference_date, instrument_code=instrument_code)
def init_arctic_with_csv_futures_contract_prices_for_code( instrument_code: str, datapath: str, csv_config=arg_not_supplied ): print(instrument_code) csv_prices = csvFuturesContractPriceData(datapath, config=csv_config) arctic_prices = arcticFuturesContractPriceData() print("Getting .csv prices may take some time") csv_price_dict = csv_prices.get_all_prices_for_instrument(instrument_code) print("Have .csv prices for the following contracts:") print(str(csv_price_dict.keys())) for contract_date_str, prices_for_contract in csv_price_dict.items(): print("Processing %s" % contract_date_str) print(".csv prices are \n %s" % str(prices_for_contract)) contract = futuresContract(instrument_code, contract_date_str) print("Contract object is %s" % str(contract)) print("Writing to arctic") arctic_prices.write_prices_for_contract_object( contract, prices_for_contract, ignore_duplication=True ) print("Reading back prices from arctic to check") written_prices = arctic_prices.get_prices_for_contract_object(contract) print("Read back prices are \n %s" % str(written_prices))
def _contract_given_contractid(self, contractid: str): instrument_code, contract_date_str = self._contract_tuple_given_keyname( contractid ) # ignore IDE warning as we also accept str here return futuresContract(instrument_code, contract_date_str)
def is_instrument_code_and_contract_date_okay_to_trade( self, instrument_code, contract_id ): #FIXME REMOVE futures_contract = futuresContract(instrument_code, contract_id) check_open = self.is_contract_okay_to_trade(futures_contract) return check_open
def less_than_one_hour_of_trading_leg_for_instrument_code_and_contract_date( self, instrument_code, contract_date): # FIXME REMOVE contract = futuresContract(instrument_code, contract_date) result = self.less_than_one_hour_of_trading_leg_for_contract(contract) return result
def get_dict_of_new_prices_and_contractid( instrument_code: str, contract_date_dict: setOfNamedContracts, data: dataBlob) -> dictFuturesNamedContractFinalPricesWithContractID: """ :param instrument_code: str :param contract_list: dict of 'yyyymmdd' str, keynames 'CARRY, PRICE, FORWARD' :param data: :return: dict of futures contract prices for each contract, plus contract id column """ diag_prices = diagPrices(data) # get prices for relevant contracts, return as dict labelled with column # for contractids relevant_contract_prices = dict() for key, contract_date_str in contract_date_dict.items(): contract = futuresContract(instrument_code, contract_date_str) price_series = diag_prices.get_prices_for_contract_object(contract) relevant_contract_prices[key] = price_series.return_final_prices() relevant_contract_prices = dictNamedFuturesContractFinalPrices( relevant_contract_prices) new_prices_dict = (dictFuturesNamedContractFinalPricesWithContractID. create_from_two_dicts(relevant_contract_prices, contract_date_dict)) return new_prices_dict
def get_trading_hours_for_instrument_code_and_contract_date( self, instrument_code, contract_date ): contract_object = futuresContract(instrument_code, contract_date) result = self.get_trading_hours_for_contract(contract_object) return result
def is_instrument_code_and_contract_date_okay_to_trade( self, instrument_code, contract_date ): contract_object = futuresContract(instrument_code, contract_date) result = self.is_contract_okay_to_trade(contract_object) return result
def _filename_given_instrument_code_and_contract_date( self, instrument_code, contract_date ): contract_object = futuresContract(instrument_code, contract_date) return get_filename_for_package( self._datapath, "%s_%s.csv" % (instrument_code, contract_object.date))
def update_expiries_for_position_list_with_IB_expiries( self, original_position_list: listOfContractPositions ) -> listOfContractPositions: for idx, position_entry in enumerate(original_position_list): position_entry = original_position_list[idx] original_contract = position_entry.contract actual_expiry = self.get_actual_expiry_date_for_single_contract( original_contract) if actual_expiry is missing_contract: log = original_contract.specific_log(self.data.log) log.warn( "Contract %s is missing from IB probably expired - need to manually close on DB" % str(original_contract)) contract = original_contract else: expiry_date_as_str = actual_expiry.as_str() instrument_code = position_entry.instrument_code contract = futuresContract(instrument_code, expiry_date_as_str) position = position_entry.position new_entry = contractPosition(position, contract) original_position_list[idx] = new_entry return original_position_list
def get_position_df_for_instrument_and_contract_id( self, instrument_code:str, contract_id:str ): #FIXME REMOVE # ignore warnings can be str contract = futuresContract(instrument_code, contract_id) return self.get_position_df_for_contract(contract)
def get_valid_contract_object_from_user(data, instrument_code=None, include_priced_contracts=False): instrument_code, contract_date_str = get_valid_instrument_code_and_contractid_from_user( data, instrument_code=instrument_code, include_priced_contracts=include_priced_contracts) return futuresContract(instrument_code, contract_date_str)
def get_position_series_for_contract(data, instrument_code:str, contract_id:str): diag_positions = diagPositions(data) contract = futuresContract(instrument_code, contract_id) pos_series = diag_positions.get_position_df_for_contract(contract) if pos_series is missing_data: return pd.Series() return pd.Series(pos_series.position)
def contracts_with_price_data_for_instrument_code(self, instrument_code: str) -> listOfFuturesContracts: futures_instrument_with_ib_data = self.futures_instrument_data.get_futures_instrument_object_with_IB_data(instrument_code) list_of_date_str = self.ibconnection.broker_get_futures_contract_list(futures_instrument_with_ib_data) list_of_contracts = [futuresContract(instrument_code, date_str) for date_str in list_of_date_str] list_of_contracts = listOfFuturesContracts(list_of_contracts) return list_of_contracts
def get_position_for_instrument_and_contract_date( self, instrument_code: str, contract_date: str) -> float: # FIXME REMOVE if contract_date is missing_contract: return 0 contract = futuresContract(instrument_code, contract_date) position = self.get_position_for_contract(contract) return position
def get_trading_hours_for_instrument(data, instrument_code): diag_contracts = dataContracts(data) contract_id = diag_contracts.get_priced_contract_id(instrument_code) contract = futuresContract(instrument_code, contract_id) data_broker = dataBroker(data) trading_hours = data_broker.get_trading_hours_for_contract(contract) return trading_hours
def _get_all_instruments_priced_contracts_from_db(self): instrument_list = self._get_all_instruments() data_contracts = self.data_contracts priced_contracts = [ futuresContract( instrument_code, data_contracts.get_priced_contract_id(instrument_code)) for instrument_code in instrument_list ] return priced_contracts
def get_valid_contract_object_from_user( data: dataBlob, instrument_code: str = None, only_include_priced_contracts: bool = False) -> futuresContract: instrument_code, contract_date_str = get_valid_instrument_code_and_contractid_from_user( data, instrument_code=instrument_code, only_include_priced_contracts=only_include_priced_contracts) contract = futuresContract(instrument_code, contract_date_str) return contract
def get_smoothed_volume_for_contract( self, instrument_code: str, contract_date_str: str ) -> float: if contract_date_str is missing_contract: return 0.0 contract = futuresContract(instrument_code, contract_date_str) volumes = self.get_daily_volumes_for_contract(contract) final_volume = get_smoothed_volume_ignoring_old_data(volumes) return final_volume
def get_trading_hours_for_instrument(data: dataBlob, instrument_code: str) -> listOfOpeningTimes: diag_contracts = dataContracts(data) contract_id = diag_contracts.get_priced_contract_id(instrument_code) contract = futuresContract(instrument_code, contract_id) data_broker = dataBroker(data) trading_hours = data_broker.get_trading_hours_for_contract(contract) return trading_hours
def _perform_contract_method_for_order(self, order, method, **kwargs): contract_object = futuresContract(order.instrument_code, order.contract_id) trade_list_for_multiple_legs = order.trade.qty method_to_call = getattr(self, method) result = method_to_call( contract_object, trade_list_for_multiple_legs=trade_list_for_multiple_legs, **kwargs) return result
def _object_given_instrumentCode_and_contractDate(self, instrument_code, contract_date): """ Quickly go from eg "EDOLLAR" "201801" to an object :param instrument_code: str :param contract_date: str :return: futuresContract """ contract_object = futuresContract(instrument_code, contract_date) return contract_object
def get_contracts_with_price_data(self): """ :return: list of contracts """ list_of_contract_tuples = self._get_contract_tuples_with_price_data() list_of_contracts = [ futuresContract(contract_tuple[0], contract_tuple[1]) for contract_tuple in list_of_contract_tuples ] return list_of_contracts