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
