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 process_args(api, args):
def fetch_page(page_token):
if args.monitor:
print("Fetching page:", page_token, str(datetime.datetime.now()))
return api.call.list_portfolios(page=page_token, limit=args.batch)
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
df = page_all_results(fetch_page, got_page)
if not args.portfolios:
df = df.groupby("Scopes", as_index=False).sum()
return lpt.trim_df(
df, args.limit, sort=["Scope", "Portfolio"] if args.portfolios else "Scopes",
)
def process_args(api, args):
colmap = {"P:" + p: p[10:] for p in args.properties}
def fetch_page(page_token):
return api.call.list_portfolios_for_scope(
args.scope,
property_keys=args.properties,
limit=2000,
page=page_token)
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)
return lpt.trim_df(page_all_results(fetch_page, got_page),
args.limit,
sort=ID_CODE)
def success(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"]
return lpt.trim_df(df, args.limit, sort=["Scope", "Portfolio"])
else:
df = (pd.DataFrame({
"Scopes": [v.id.scope for v in result.content.values]
}).groupby("Scopes").size().reset_index())
return lpt.trim_df(df, args.limit, sort="Scopes")
def success(result):
return lpt.trim_df(
lpt.to_df(
result,
["scope", "domain", "code", "type", "display_name"],
),
args.limit,
sort=["scope", "domain", "code"],
)
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 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 success(result):
def get_value(p):
return (
p.key,
p.value.metric_value.value
if p.value.metric_value is not None else p.value.label_value,
p.effective_from,
)
df = pd.DataFrame.from_records(
[get_value(p) for p in result.content.properties.values()],
columns=["key", "value", "effective_from"],
)
return lpt.trim_df(df, args.limit, sort="key")
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 process_args(api, args):
results = []
def fetch_page(page_token):
return api.call.list_portfolios(page=page_token)
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
page = Either(None)
while True:
page = fetch_page(page.right).bind(got_page)
if page.is_left():
return page
if page.right == None:
break
return lpt.trim_df(
pd.concat(results, ignore_index=True, sort=False),
args.limit,
sort=["Scope", "Portfolio"] if args.portfolios else "Scopes",
)
def list_instruments(ids):
id_columns = {"identifiers.KEY:{}".format(v): v for v in ids["Id"].values}
def fetch_page(page_token):
return api.call.list_instruments(
limit=args.batch,
page=page_token,
instrument_property_keys=args.properties,
filter=args.filter,
)
results = []
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
page = Either(None)
while True:
page = fetch_page(page.right).bind(got_page)
if page.is_left():
return page
if page.right == None:
break
return lpt.trim_df(
pd.concat(results, ignore_index=True, sort=False), args.limit, sort="name"
)
def finished(error=None):
if error is not None:
lpt.display_error(error)
if len(records) == 0:
print("No results")
exit(-1)
df = pd.DataFrame.from_records(records)
leading_cols = ["#", "Start-Time", "Date", "PV", "Duration", "LUSID", "Id"]
cols = set(df.columns.values)
other_cols = list(sorted(cols - set(leading_cols)))
for col in other_cols:
df[col] = df[col].fillna(0).astype(int)
return lpt.trim_df(df[leading_cols + other_cols], args.limit)
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 get_success(result):
holdings = [make_holding(adj) for adj in result.content.adjustments]
df = pd.concat(holdings, ignore_index=True, sort=True)
return lpt.trim_df(df, args.limit)
def success(r):
df = lpt.to_df(r.content, ["id"])
return lpt.trim_df(df, args.limit)
def success(result):
(stats, df) = result
if args.instrument:
df = df[df[INSTR_COL] == args.instrument]
return lpt.trim_df(df, args.limit)
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_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)
