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()
