def test_list_of_same_lusid_objects_no_to_dict(self):
with self.assertRaises(TypeError) as error:
bad_list = ["random_string_1", "random_string_2"]
lusid_response_to_data_frame(bad_list)
self.assertEqual(
error.exception.args[0],
"All object items in list must have a to_dict() method",
)
def test_list_of_different_lusid_objects(self):
with self.assertRaises(TypeError) as error:
list_response = [
self.test_instrument_response_1,
self.test_instrument_response_2,
self.holding_1,
]
lusid_response_to_data_frame(list_response)
self.assertEqual(
error.exception.args[0], "All items in list must be of same data type",
)
def test_list_of_lusid_objects(self):
list_response = [
self.test_instrument_response_1,
self.test_instrument_response_2,
]
instrument_df = lusid_response_to_data_frame(list_response)
self.assertEqual(type(instrument_df), pd.DataFrame)
self.assertEqual(
instrument_df.columns.to_list(),
[
"lusid_instrument_id",
"version",
"name",
"identifiers.ClientInternal",
"identifiers.Figi",
"identifiers.Isin",
"identifiers.LusidInstrumentId",
"identifiers.Ticker",
"state",
],
)
self.assertEqual(instrument_df["lusid_instrument_id"].to_list()[0],
"LUID_TEST1")
def test_response_to_df_rename_mapping_with_column_not_exist(self):
rename_mapping = {
"instrument_uid": "Instrument ID",
"holding_type": "Holding Type",
"test_not_exist": "Units",
"settled_units": "Settled Units",
"cost.amount": "Quantity",
"cost.currency": "Cost Currency",
}
test_holdings_response = lusid.models.versioned_resource_list_of_portfolio_holding.VersionedResourceListOfPortfolioHolding(
version=1, values=[self.holding_1])
holdings_df = lusid_response_to_data_frame(
test_holdings_response,
rename_properties=False,
column_name_mapping=rename_mapping,
)
df_columns = holdings_df.columns
self.assertEqual(type(holdings_df), pd.DataFrame)
self.assertEqual(holdings_df.loc[0]["Instrument ID"], "LUID_123")
self.assertEqual(
set(["Holding Type", "Quantity", "Cost Currency"]),
set(["Holding Type", "Quantity",
"Cost Currency"]).intersection(set(df_columns)),
)
self.assertNotIn("settled_units", df_columns)
def test_response_to_df_rename_mapping_format(self):
rename_mapping = {
"instrument_uid": "Instrument ID",
"holding_type": "Holding Type",
"units": "Units",
"settled_units": "Settled Units",
"cost.amount": "Quantity",
"cost.currency": "Cost Currency",
}
test_holdings_response = lusid.models.versioned_resource_list_of_portfolio_holding.VersionedResourceListOfPortfolioHolding(
version=1, values=[self.holding_1])
holdings_df = lusid_response_to_data_frame(
test_holdings_response,
rename_properties=True,
column_name_mapping=rename_mapping,
)
df_columns = holdings_df.columns
self.assertEqual(type(holdings_df), pd.DataFrame)
self.assertEqual(holdings_df.loc[0]["Instrument ID"], "LUID_123")
self.assertIn("PortionClass(MultiAssetScope-SubHoldingKeys)",
df_columns)
self.assertTrue(
set([
"Holding Type", "Units", "Settled Units", "Quantity",
"Cost Currency"
]).issubset(set(df_columns)))
def test_instrument_response_to_df(self):
instrument_df = lusid_response_to_data_frame(
self.test_instrument_response_1)
self.assertEqual(type(instrument_df), pd.DataFrame)
self.assertEqual(instrument_df.loc["lusid_instrument_id"][0],
"LUID_TEST1")
def get_holdings_df():
rename_cols = {
"properties.Holding/default/SourcePortfolioId.value.label_value":
"Portfolio",
"holding_type": "HoldingType",
"units": "CashImpact",
"settled_units": "SettledUnits",
"cost.currency": "Currency",
"transaction.transaction_id": "TransactionId",
"transaction.type": "TransactionType",
"instrument_uid": "HoldingsInstrumeny",
"transaction.instrument_uid": "CommitmentInstrument",
"transaction.settlement_date": "SettlementDate"
}
cols = list(rename_cols.values())
holdings_df = lusid_response_to_data_frame(
api_factory.build(lusid.api.TransactionPortfoliosApi).get_holdings(
scope=scope, code=portfolio_code,
effective_at=start_date)).rename(columns=rename_cols)
holdings_df = holdings_df[cols][holdings_df["HoldingType"] != "P"]
holdings_df["SettlementDate"] = pd.to_datetime(
holdings_df["SettlementDate"], utc=True)
holdings_df = holdings_df[holdings_df["Currency"] == currency]
return holdings_df
def test_empty_list_lusid_response(self):
empty_list = []
empty_df = lusid_response_to_data_frame(empty_list)
print(empty_df)
self.assertEqual(empty_df.empty, True)
def test_response_to_df(self):
test_holdings_response = lusid.models.versioned_resource_list_of_portfolio_holding.VersionedResourceListOfPortfolioHolding(
version=1,
values=[self.holding_no_props_1, self.holding_no_props_2])
holdings_df = lusid_response_to_data_frame(test_holdings_response)
self.assertEqual(type(holdings_df), pd.DataFrame)
self.assertEqual(holdings_df.loc[0]["instrument_uid"], "LUID_XQ6VSO8F")
def test_transaction_alias_response_to_df(self):
transaction_alias_response = lusid.models.transaction_configuration_type_alias.TransactionConfigurationTypeAlias(
type="Buy",
description="Purchase",
transaction_class="Basic",
transaction_group="Default",
transaction_roles="LongLonger",
)
transaction_alias_df = lusid_response_to_data_frame(
transaction_alias_response)
transaction_alias_df_format = lusid_response_to_data_frame(
transaction_alias_response, rename_properties=True)
self.assertEqual(type(transaction_alias_df), pd.DataFrame)
self.assertEqual(transaction_alias_df.loc["transaction_class"][0],
"Basic")
self.assertEqual(type(transaction_alias_df_format), pd.DataFrame)
self.assertEqual(
transaction_alias_df_format.loc["transaction_class"][0], "Basic")
def test_instrument_response_to_df(self):
test_instrument_response = lusid.models.instrument.Instrument(
lusid_instrument_id="LUID_TEST",
version=1,
name="Test LUID",
identifiers={},
state="Active",
)
instrument_df = lusid_response_to_data_frame(test_instrument_response)
self.assertIsInstance(instrument_df, pd.DataFrame)
self.assertEqual(instrument_df.loc["lusid_instrument_id"][0],
"LUID_TEST")
def test_response_to_df_format(self):
test_holdings_response = lusid.models.versioned_resource_list_of_portfolio_holding.VersionedResourceListOfPortfolioHolding(
version=1, values=[self.holding_1])
holdings_df = lusid_response_to_data_frame(test_holdings_response,
rename_properties=True)
df_columns = holdings_df.columns
self.assertEqual(type(holdings_df), pd.DataFrame)
self.assertEqual(holdings_df.loc[0]["instrument_uid"], "LUID_123")
self.assertIn("PortionClass(MultiAssetScope-SubHoldingKeys)",
df_columns)
self.assertIn("shares_out(MultiAssetScope-Properties)", df_columns)
self.assertNotIn("JunkBadColumn(SubHoldingKey)", df_columns)
def test_response_to_df(self):
holding_1 = lusid.models.portfolio_holding.PortfolioHolding(
cost={
"amount": 549997.05,
"currency": "GBP"
},
cost_portfolio_ccy={
"amount": 0.0,
"currency": "GBP"
},
holding_type="P",
instrument_uid="LUID_XQ6VSO8F",
properties={},
settled_units=137088.0,
sub_holding_keys={},
transaction=None,
units=137088.0,
)
holding_2 = lusid.models.portfolio_holding.PortfolioHolding(
cost={
"amount": 12345.05,
"currency": "GBP"
},
cost_portfolio_ccy={
"amount": 0.0,
"currency": "GBP"
},
holding_type="P",
instrument_uid="LUID_123",
properties={},
settled_units=1372222.0,
sub_holding_keys={},
transaction=None,
units=1372228.0,
)
test_holdings_response = lusid.models.versioned_resource_list_of_portfolio_holding.VersionedResourceListOfPortfolioHolding(
version=1, values=[holding_1, holding_2])
holdings_df = lusid_response_to_data_frame(test_holdings_response)
self.assertIsInstance(holdings_df, pd.DataFrame)
self.assertEqual(holdings_df.loc[0]["instrument_uid"], "LUID_XQ6VSO8F")
def test_response_none(self):
self.assertRaises(TypeError,
lambda: lusid_response_to_data_frame(None))
def test_response_to_df_fail(self):
self.assertRaises(TypeError,
lambda: lusid_response_to_data_frame("test_string"))
def add_trades_to_balance():
trades_unedited = add_daily_balances()["TransactionId"].to_list()
trades = [trade for trade in trades_unedited if str(trade) != "nan"]
trades_for_filter = f"{trades}"[1:-1]
trades_response = transaction_portfolio_api.get_transactions(
scope=scope,
code=portfolio_code,
filter=f"transactionId in ({trades_for_filter})",
property_keys=[
"Instrument/default/Name", f"Transaction/{scope}/TradeStatus"
])
rename_cols = {
f"properties.Transaction/{scope}/TradeStatus.value.label_value":
"TradeStatus",
"transaction_id":
"TransactionId",
"properties.Instrument/default/Name.value.label_value":
"InstrumentName"
}
cols = list(rename_cols.values())
trades_df = lusid_response_to_data_frame(trades_response).rename(
columns=rename_cols)
trades_df = trades_df[cols]
cash_ladder = add_daily_balances().merge(trades_df, how="outer")
cash_ladder["CashLadderStatus"] = np.where(
cash_ladder["HoldingType"] == "B", "SOD Balance",
np.where(
pd.isnull(cash_ladder["CashLadderStatus"]),
"Cash impact from a " + cash_ladder['TransactionType'] +
" transaction", cash_ladder["CashLadderStatus"]))
cash_ladder["ReportOrder"] = np.where(
cash_ladder["HoldingType"] == "B", 0,
np.where(
pd.notnull(cash_ladder["TransactionId"])
& pd.isnull(cash_ladder["ReportOrder"]), 1,
cash_ladder["ReportOrder"]))
cash_ladder["SettlementDate"] = np.where(
cash_ladder["HoldingType"] == "B",
pd.to_datetime(start_date, utc=True),
cash_ladder["SettlementDate"])
cash_ladder["TransactionId"] = np.where(
pd.isnull(cash_ladder["TransactionId"]), "",
cash_ladder["TransactionId"])
cash_ladder["InstrumentName"] = np.where(
pd.isnull(cash_ladder["InstrumentName"]), "",
cash_ladder["InstrumentName"])
cash_ladder["TradeStatus"] = np.where(
pd.isnull(cash_ladder["TradeStatus"]), "",
cash_ladder["TradeStatus"])
cash_ladder = cash_ladder.sort_values(
["SettlementDate", "ReportOrder"])
cash_ladder["ReportRunTime"] = datetime.now().strftime(format="%X")
cash_ladder["SettlementDate"] = cash_ladder["SettlementDate"].apply(
lambda x: x.strftime(format="%Y-%m-%d"))
cols_for_report = [
"ReportRunTime", "SettlementDate", "Currency", "Portfolio",
"CashLadderStatus", "InstrumentName", "CashImpact",
"TransactionId", "TradeStatus"
]
cash_ladder_report = cash_ladder[cols_for_report]
cash_ladder_report.loc[:, "Currency"] = currency
cash_ladder_report = cash_ladder_report.reset_index(
drop=True).drop_duplicates()
return cash_ladder_report
