def success(result):
df = lpt.to_df(
result,
["identifier_type", "is_unique_identifier_type", "property_key"])
df.columns = ["Id", "Unique", "Key"]
return lpt.trim_df(df, args.limit, sort="Id")
def success(result):
colmap = {"P:" + p: p[10:] for p in args.properties}
df = lpt.to_df(
result.content,
["id.code", "display_name", "created", "parent_portfolio_id"] +
list(colmap.keys()),
).rename(columns=colmap)
return lpt.trim_df(df, args.limit, sort="id.code")
def success(result):
idents = [f"identifiers.KEY:{v}" for v in args.identifiers]
columns = ["lusid_instrument_id", "name"]
columns.extend(idents)
if args.properties:
columns.extend(["P:" + v for v in args.properties])
df = lpt.to_df(result.content.values.values(), columns)
return df.rename(columns=dict(zip(idents, args.identifiers)))
def success(result):
return lpt.trim_df(
lpt.to_df(
result,
["scope", "domain", "code", "type", "display_name"],
),
args.limit,
sort=["scope", "domain", "code"],
)
def list_success(result):
return lpt.trim_df(
lpt.to_df(
result,
[
"effective_at", "unmatched_holding_method",
"version.as_at_date"
],
),
args.limit,
sort="effective_at",
)
def got_page(result):
return lpt.to_df(
result.content,
[
ID_CODE,
"display_name",
"base_currency",
"description",
"created",
"parent_portfolio_id",
] + list(colmap.keys()),
).rename(columns=colmap)
def success(result):
flat = [i for r in result.content for i in r.mastered_instruments]
if len(flat) > 0:
identifiers = sorted(
set.union(*[set(i.identifiers.keys()) for i in flat]))
df = lpt.to_df(
flat,
["name"] +
["identifiers.KEY:" + i + ".value" for i in identifiers],
)
df.columns = ["Name"] + identifiers
return df
else:
return "No Matches"
def success(result):
shkeys = [
"SHK:" + shk for hld in result.content.values[:1]
for shk in hld.sub_holding_keys.keys()
]
properties = ["P:" + p for p in args.properties]
df = lpt.to_df(result, [c[0] for c in columns] + shkeys + properties)
df.columns = ([c[1]
for c in columns] + [k.split("/")[2] for k in shkeys] +
[p[8:] for p in args.properties])
return (result.stats, df)
def make_holding(adj):
lots = lpt.to_df(adj.tax_lots, taxlot_fields)
lots["instrument_uid"] = adj.instrument_uid
identifiers.update(adj.instrument_identifiers.keys())
# TODO: sub-holding-keys and properties
for k, v in adj.instrument_identifiers.items():
lots[k] = v
if adj.sub_holding_keys is not None:
for k, v in adj.sub_holding_keys.items():
lots[f"SHK:{k}"] = v.value.label_value
return lots
def success(result):
columns = [
("quote_id.effective_at", "Date"),
("quote_id.quote_series_id.instrument_id_type", "Instrument Type"),
("quote_id.quote_series_id.instrument_id", "Instrument"),
("metric_value.value", "Quote"),
("metric_value.unit", "Unit"),
("quote_id.quote_series_id.quote_type", "Type"),
("quote_id.quote_series_id.price_source", "Source"),
("quote_id.quote_series_id.provider", "Provider"),
("as_at", "AsAt"),
]
df = lpt.to_df(list(result.content.values.values()),
[c[0] for c in columns])
return lpt.trim_df(df.rename(columns=dict(columns)), args.limit)
def got_page(result):
if args.portfolios:
df = lpt.to_df(
result,
["id.scope", "id.code", "is_derived", "type", "parent_portfolio_id"],
)
df.columns = ["Scope", "Portfolio", "Derived", "Type", "Parent"]
else:
df = (
pd.DataFrame({"Scopes": [v.id.scope for v in result.content.values]})
.groupby("Scopes")
.size()
.reset_index()
)
return df
def got_page(result):
columns = ["lusid_instrument_id", "name"]
columns.extend(sorted(id_columns.keys()))
columns.extend(f"P:{c}" for c in args.properties)
df = lpt.to_df(result, columns).dropna(axis=1, how="all")
df.rename(columns=id_columns, inplace=True)
results.append(df)
links = [l for l in result.content.links if l.relation == "NextPage"]
if len(links) > 0:
match = rexp.match(links[0].href)
if match:
print("{} {}".format(len(results), match.group(1)))
return urllib.parse.unquote(match.group(1))
return None
def success(txns):
available_columns = [
("C", "transaction_status", "Status"),
("B", "transaction_id", "TxnId"),
("B", "type", "Type"),
("B", "P:Instrument/default/Name", "Instrument"),
("B", "instrument_uid", "LUID"),
("B", "transaction_date", "TradeDate"),
("A", "settlement_date", "SettleDate"),
("B", "units", "Units"),
("A", "transaction_price.price", "Price"),
("A", "transaction_currency", "TradeCcy"),
("A", "total_consideration.currency", "SettleCcy"),
("A", "total_consideration.amount", "SettleAmt"),
("A", "exchange_rate", "ExchRate"),
("A", "P:Trade/default/TradeToPortfolioRate", "PortRate"),
("C", "entry_date_time", "EntryDate"),
("C", "cancel_date_time", "CancelDate"),
]
# Pick appropriate set of columns based on arguments
col_subset = "B" if args.brief else "AB"
if args.cancels:
col_subset += "C"
columns = [c for c in available_columns if c[0] in col_subset]
columns.extend(
[
("X", "P:" + v, v.replace("Instrument/default/", ""))
for v in args.properties or []
]
)
df = lpt.to_df(txns, [c[1] for c in columns])
# Rename the column headings
df.columns = [c[2] for c in columns]
return lpt.trim_df(df, args.limit)
def got_page(result):
if args.portfolios:
df = lpt.to_df(
result,
[
"id.scope", "id.code", "is_derived", "type",
"parent_portfolio_id"
],
)
df.columns = ["Scope", "Portfolio", "Derived", "Type", "Parent"]
else:
df = (pd.DataFrame({
"Scopes": [v.id.scope for v in result.content.values]
}).groupby("Scopes").size().reset_index())
results.append(df)
links = [l for l in result.content.links if l.relation == "NextPage"]
if len(links) > 0:
match = rexp.match(links[0].href)
if match:
return urllib.parse.unquote(match.group(1))
return None
def success_list_groups(result):
df = lpt.to_df(result.content,
["id.code", "display_name", "description"])
return lpt.trim_df(df, args.limit, sort="id.code")
def success(r):
df = lpt.to_df([err[1] for err in r.content.failed.items()],
["id", "detail"])
df.columns = ["FAILED-INSTRUMENT", "ERROR"]
return lpt.trim_df(df, args.limit, sort="FAILED-INSTRUMENT")
def success(r):
df = lpt.to_df(r.content, ["id"])
return lpt.trim_df(df, args.limit)
def success_get_group(result):
df = lpt.to_df(result.content.portfolios, [
"scope",
"code",
])
return lpt.trim_df(df, args.limit, sort=["scope", "code"])
def success(constituents):
print(constituents.content)
exit()
df = lpt.to_df(constituents, [])
return lpt.trim_df(df, args.limit)
