finbourne-sdk-utils 0.0.24__py3-none-any.whl

finbourne_sdk_utils/iam/roles.py

@@ -0,0 +1,74 @@
+import json
+
+import lusid
+import finbourne_access
+import finbourne_identity
+
+from finbourne_access import models as access_models
+from finbourne_identity import models as identity_models
+
+
+from finbourne_sdk_utils.cocoon.utilities import (
+    checkargs,
+)
+import logging
+
+
+@checkargs
+def create_role(
+    access_api_factory: finbourne_access.extensions.SyncApiClientFactory,
+    identity_api_factory: finbourne_identity.extensions.SyncApiClientFactory,
+    access_role_creation_request: access_models.RoleCreationRequest,
+) -> None:
+    """
+    Creates a role through both the access and identity APIs
+
+    Parameters
+    ----------
+    access_api_factory : finbourne_access.extensions.SyncApiClientFactory
+    identity_api_factory : finbourne_identity.extensions.id.SyncApiClientFactory
+        
+    access_role_creation_request : access_models.RoleCreationRequest
+        The role creation request to use
+
+    Returns
+    -------
+    responses: None
+
+    """
+    
+    access_roles_api = access_api_factory.build(finbourne_access.RolesApi)
+    
+    identity_roles_api = identity_api_factory.build(finbourne_identity.RolesApi)
+
+
+    # Create the role using the access API.
+    try:
+        access_roles_api.create_role(access_role_creation_request)
+        logging.info(
+            f"Role with code {access_role_creation_request.code} has been created via the access API"
+        )
+    except finbourne_access.ApiException as e:
+        detail = json.loads(e.body)
+        if detail["code"] not in [612, 613, 615]:  # RoleWithCodeAlreadyExists
+            raise e
+        logging.info(
+            f"Role with code {access_role_creation_request.code} has already been created via the access API"
+        )
+
+    # Create the same role using the identity API.
+    identity_role_creation_request = identity_models.CreateRoleRequest(
+        name=access_role_creation_request.code
+    )
+    try:
+        identity_roles_api.create_role(identity_role_creation_request)
+        logging.info(
+            f"Role with code {access_role_creation_request.code} has been created via the identity API"
+        )
+    except finbourne_identity.ApiException as e:
+        detail = json.loads(e.body)
+        if detail["code"] != 157:  # RoleWithCodeAlreadyExists
+            raise e
+        logging.info(
+            f"Role with code {access_role_creation_request.code} has already been created via the identity API"
+        )

finbourne_sdk_utils/jupyter_tools/__init__.py

@@ -0,0 +1,2 @@
+from finbourne_sdk_utils.jupyter_tools.stop_execution import StopExecution
+from finbourne_sdk_utils.jupyter_tools.hide_code_button import toggle_code

finbourne_sdk_utils/jupyter_tools/hide_code_button.py

@@ -0,0 +1,23 @@
+from IPython.core.display import display, HTML
+
+
+def toggle_code(button_message):
+
+    toggle_code_str = f"""
+    <form action="javascript:code_toggle()"><input type="submit" id="toggleButton" value="{button_message}"></form>
+    """
+
+    toggle_code_prepare_str = """
+         <script>
+         function code_toggle() {
+             if ($('div.cell.code_cell.rendered.selected div.input').css('display')!='none'){
+                 $('div.cell.code_cell.rendered.selected div.input').hide();
+             } else {
+                 $('div.cell.code_cell.rendered.selected div.input').show();
+             }
+         }
+         </script>
+
+     """
+
+    return display(HTML(toggle_code_str + toggle_code_prepare_str))

finbourne_sdk_utils/jupyter_tools/stop_execution.py

@@ -0,0 +1,14 @@
+from IPython import display
+
+
+class StopExecution(Exception):
+    """
+    This object is used to stop a notebook from running.
+    Example: raise StopExecution("Portfolio missing")
+    """
+
+    def __init__(self, message):
+        self.message = message
+
+    def _render_traceback_(self):
+        display(self.message)

finbourne_sdk_utils/logger/LusidLogger.py

@@ -0,0 +1,41 @@
+import logging
+import coloredlogs
+
+
+class LusidLogger:
+    def __init__(self, log_level="info", logging_file=None):
+        self.begin_logger(log_level, logging_file)
+        pass
+
+    @staticmethod
+    def begin_logger(log_level, logging_file) -> None:
+        """
+        This function gets an instance of the root logger and sets the log_level. 
+        :param log_level: A string defining what log level to set logger at
+        :param logging_file: Path to file to store log messages
+        :return:
+        """
+        set_logger_level = {
+            "notset": logging.NOTSET,
+            "info": logging.INFO,
+            "debug": logging.DEBUG,
+            "error": logging.ERROR,
+            "critical": logging.CRITICAL,
+        }
+
+        if not log_level:
+            log_level = "info"
+
+        if log_level not in set_logger_level.keys():
+            raise Exception(
+                f"logging level provided ({log_level}) is not in list of valid logging levels {list(set_logger_level.keys())}"
+            )
+
+        # set up logging
+        if logging_file:
+            print(f"Logging to {logging_file}")
+            logging.basicConfig(filename=logging_file)
+
+        root_logger = logging.getLogger()
+        root_logger.setLevel(set_logger_level[log_level])
+        coloredlogs.install(level=set_logger_level[log_level], logger=root_logger)

finbourne_sdk_utils/logger/__init__.py

@@ -0,0 +1 @@
+from finbourne_sdk_utils.logger.LusidLogger import LusidLogger

finbourne_sdk_utils/lpt/back_compat.py

@@ -0,0 +1,20 @@
+# Make backwards compatibility adjustments
+# When reading old files
+def convert(frame_type, df):
+
+    # Security is now known as instrument_id
+    if "security_uid" in df.columns.values:
+        df.rename(columns={"security_uid": "instrument_uid"}, inplace=True)
+
+    # Some older dividend files may not have the pay date column
+    # In this case we duplicate the record date
+    if frame_type == "div":
+        if "payment_date" not in df.columns.values:
+            df["payment_date"] = df["record_date"]
+
+    # Some older pricing files call the instr column 'sec'
+    if frame_type == "prc":
+        if "instr" not in df.columns.values:
+            df["sec"] = df["instr"]
+
+    return df

finbourne_sdk_utils/lpt/cash_ladder.py

@@ -0,0 +1,191 @@
+import pandas as pd
+import numpy as np
+import dateutil
+import sys
+import argparse
+
+SDATE = "settlement_date"
+CCY = "security_uid"
+QTY = "units"
+TYPE = "holding_type"
+CUM = "cum"
+ORDER = "sort"
+JOIN = "join"
+
+TOOLTIP = "Demo Cash-Ladder report"
+
+
+def cash_ladder(api, scope, portfolio, date):
+
+    qry_date = pd.to_datetime(date, utc=True)
+
+    # Function to make sure there are cash positions
+    def check_contents(df):
+        if len(df) == 0:
+            print(
+                "Portfolio {} in scope {} contains no cash on {:%Y-%m-%d}".format(
+                    portfolio, scope, start_date
+                )
+            )
+            exit()
+
+    # Run one-day earlier, this gives us the beginning of day for the
+    # required qry_date
+    start_date = qry_date + pd.DateOffset(days=-1)
+    df = api.qry_holdings(scope, portfolio, start_date)
+    check_contents(df)
+
+    # To convert holdings data frame into cash ladder
+    # we need to filter out Position types
+    df = df[df[TYPE] != "P"].copy()
+    check_contents(df)
+
+    # Set date for current balances
+    df[SDATE] = pd.to_datetime(df[SDATE].fillna(start_date), utc=True).dt.date
+
+    # Consolidate
+    df = df[[CCY, SDATE, TYPE, QTY]].groupby([CCY, SDATE, TYPE], as_index=False).sum()
+
+    # Populate BOD/EOD records
+
+    start_date = start_date.date()  # change form for working with frame data
+    # Get unique list of dates, but make sure it includes the qry_date
+    dates = pd.concat(
+        [df[[SDATE]], pd.DataFrame({SDATE: [qry_date.date()]})], ignore_index=True
+    ).drop_duplicates()
+    dates = dates[dates[SDATE] > start_date]
+    ccys = df[[CCY]].drop_duplicates()
+
+    ccys[JOIN] = 1
+    dates[JOIN] = 1
+    dates[QTY] = 0
+    dates[ORDER] = 1
+    dates[TYPE] = "Opening Cash Balance"
+    bod = ccys.merge(dates, on=JOIN)
+    eod = bod.copy()
+    eod[ORDER] = 6
+    eod[TYPE] = eod[CCY].str.slice(4) + " Summary"
+
+    df[ORDER] = df[TYPE].map({"C": 2, "A": 3, "R": 4, "F": 5})
+    df[TYPE] = df[TYPE].map(
+        {
+            "C": "Trades to settle",
+            "R": "Receivables",
+            "A": "Dividends",
+            "F": "Forward Fx",
+        }
+    )
+
+    df = (
+        pd.concat([bod, eod, df], ignore_index=True)
+        .sort_values([CCY, SDATE, ORDER])
+        .reset_index(drop=True)
+    )
+
+    # Calculate cumulative quantity
+    df[CUM] = df[[CCY, QTY]].groupby([CCY], as_index=False).cumsum()[QTY]
+
+    # Put cumulative balance onto BOD/EOD records
+    subset = df[df[ORDER].isin([1, 6])]
+    df.loc[subset.index, QTY] = subset[CUM]
+
+    # Filter out T-1 balances (just used to provide BOD balance)
+
+    df = df[df[SDATE] > start_date]
+
+    # Pivot the data
+    data = df.set_index([CCY, ORDER, TYPE, SDATE], drop=True).unstack(fill_value=0)
+
+    return data[QTY]
+
+
+def alt_cash_ladder(api, scope, portfolio, date):
+    qry_date = pd.to_datetime(date, utc=True)
+    # Run one-day earlier, this gives us the beginning of day for the
+    # required qry_date
+    start_date = qry_date + pd.DateOffset(days=-1)
+    df = api.qry_holdings(scope, portfolio, start_date)
+
+    # filter out Position types
+    df = df[df["holding_type"] != "P"]
+
+    df["settlement_date"] = pd.to_datetime(
+        df["settlement_date"].fillna(qry_date), utc=True
+    ).dt.date
+    df = df.sort_values(["security_uid", "settlement_date"])
+    df["balance"] = (
+        df[["security_uid", "units"]]
+        .groupby(["security_uid"], as_index=False)
+        .cumsum()["units"]
+    )
+
+    columns = [
+        "security_uid",
+        "settlement_date",
+        "commitment",
+        "holding_type",
+        "commitment_security_uid",
+        "units",
+        "balance",
+    ]
+
+    df = df[columns].rename(
+        columns={
+            "security_uid": "Currency",
+            "settlement_date": "Cash Date",
+            "commitment": "Transaction Type",
+            "holding_type": "Cash Type",
+            "units": "Local Cash Amount",
+        }
+    )
+    return df
+
+
+def parse(extend=None):
+    parser = argparse.ArgumentParser(description="Get Transactions")
+    parser.add_argument("scope", help="Scope")
+    parser.add_argument("portfolio", help="Portfolio id")
+    parser.add_argument("date", metavar="YYYY-MM-DD", help="date")
+    parser.add_argument(
+        "-f", "--filename", metavar="filename.csv", help="write to this file"
+    )
+    parser.add_argument(
+        "-a", "--alternative", action="store_true", help="alternative view"
+    )
+    parser.add_argument(
+        "--secrets-file",
+        dest="secrets",
+        default="secrets.json",
+        help="path to secrets file",
+    )
+    if extend:
+        extend(parser)
+    return parser.parse_args()
+
+
+def process_args(args):
+    api = lse.api(args.secrets)
+    if args.alternative:
+        df = alt_cash_ladder(api, args.scope, args.portfolio, args.date)
+    else:
+        df = cash_ladder(api, args.scope, args.portfolio, args.date)
+
+    if args.filename:
+        df.to_csv(args.filename)
+    else:
+        pd.set_option("display.width", None)
+        pd.options.display.float_format = "{:,.2f}".format
+        pd.set_option("display.max_rows", 1000)
+        print(df)
+
+
+def main():
+    process_args(parse())
+
+
+if __name__ == "__main__":
+    import lse
+
+    main()
+else:
+    from . import lse

finbourne_sdk_utils/lpt/connect_lusid.py

@@ -0,0 +1,64 @@
+import os
+from urllib.request import quote
+
+import lusid
+
+from .refreshing_token import RefreshingToken
+
+config_mapping = {
+    "FBN_TOKEN_URL": "tokenUrl",
+    "FBN_USERNAME": "username",
+    "FBN_PASSWORD": "password",
+    "FBN_CLIENT_ID": "clientId",
+    "FBN_CLIENT_SECRET": "clientSecret",
+    "FBN_LUSID_API_URL": "apiUrl",
+}
+
+
+def check_for_missing_config(config):
+    return [
+        {"Env variable": env_var, "Secrets file key": config_key}
+        for env_var, config_key in config_mapping.items()
+        if not os.getenv(env_var, config["api"][config_key])
+    ]
+
+
+def connect(config, **kwargs):
+    if "api" not in config.keys():
+        config["api"] = {}
+        config["api"]["tokenUrl"] = None
+        config["api"]["username"] = None
+        config["api"]["password"] = None
+        config["api"]["clientId"] = None
+        config["api"]["clientSecret"] = None
+        config["api"]["apiUrl"] = None
+
+    missing_config = check_for_missing_config(config)
+    if len(missing_config) > 0:
+        raise Exception(f"Missing the following config: {missing_config}")
+
+    token_url = os.getenv("FBN_TOKEN_URL", config["api"]["tokenUrl"])
+    username = os.getenv("FBN_USERNAME", config["api"]["username"])
+    password = quote(os.getenv("FBN_PASSWORD", config["api"]["password"]), "*!")
+    client_id = quote(os.getenv("FBN_CLIENT_ID", config["api"]["clientId"]), "*!")
+    client_secret = quote(
+        os.getenv("FBN_CLIENT_SECRET", config["api"]["clientSecret"]), "*!"
+    )
+    api_url = os.getenv("FBN_LUSID_API_URL", config["api"]["apiUrl"])
+
+    token_request_body = (
+        "grant_type=password&username={0}".format(username)
+        + "&password={0}&scope=openid client groups".format(password)
+        + "&client_id={0}&client_secret={1}".format(client_id, client_secret)
+    )
+
+    headers = {
+        "Accept": "application/json",
+        "Content-Type": "application/x-www-form-urlencoded",
+    }
+
+    config = lusid.Configuration()
+    config.access_token = RefreshingToken(token_url, token_request_body, headers)
+    config.host = api_url
+
+    return (lusid.SyncApiClient(configuration=config), lusid)

finbourne_sdk_utils/lpt/connect_none.py

@@ -0,0 +1,5 @@
+import lusid
+
+
+def connect(config, **kwargs):
+    return (None, lusid.models)

finbourne_sdk_utils/lpt/connect_token.py

@@ -0,0 +1,9 @@
+import lusid
+
+
+def connect(config):
+    lusid_config = lusid.Configuration()
+    lusid_config.access_token = config["token"]
+    lusid_config.host = config["apiUrl"]
+
+    return lusid.SyncApiClient(lusid_config), lusid