wbportfolio 1.43.1__py2.py3-none-any.whl

wbportfolio/import_export/parsers/sg_lux/customer_trade_slk.py

@@ -0,0 +1,80 @@
+import csv
+from io import StringIO
+
+import numpy as np
+import pandas as pd
+from wbportfolio.models import Product, Trade
+from xlrd import xldate_as_datetime
+
+from .sylk import SYLK
+from .utils import get_portfolio_id
+
+
+def parse(import_source):
+    data = list()
+    sylk_handler = SYLK()
+    for line in [_line.decode("cp1252") for _line in import_source.file.open("rb").readlines()]:
+        sylk_handler.parseline(line)
+
+    buffer = StringIO()
+    csvwriter = csv.writer(buffer, quotechar="'", delimiter=";", lineterminator="\n", quoting=csv.QUOTE_ALL)
+    for line in sylk_handler.stream_rows():
+        csvwriter.writerow(line)
+
+    buffer.seek(0)
+    content = buffer.read().replace('""', "")
+    df = pd.read_csv(StringIO(content), sep=";", quotechar="'", usecols=[1, 3, 4, 7, 10, 15, 16, 17, 18, 20, 21])
+    if not df.empty:
+        # Filter out all non transaction rows and remove record_desc col
+        df = df[df["record_desc"].str.strip() == "TRANSACTION"]
+        del df["record_desc"]
+
+        # Convert timestamps to json conform date strings
+        df["trans_date"] = df["trans_date"].apply(lambda x: xldate_as_datetime(x, datemode=0).date())
+        df["trans_date"] = df["trans_date"].apply(lambda x: x.strftime("%Y-%m-%d"))
+        df["settl_date"] = df["settl_date"].apply(lambda x: xldate_as_datetime(x, datemode=0).date())
+        df["settl_date"] = df["settl_date"].apply(lambda x: x.strftime("%Y-%m-%d"))
+
+        # Replace all nan values with empty str
+        df[["register_firstname", "cust_ref"]] = df[["register_firstname", "cust_ref"]].replace(np.nan, "", regex=True)
+
+        # Merge register_firstname and cust_ref and then remove both cols
+        df["note"] = df["register_firstname"] + df["cust_ref"]
+        del df["register_firstname"]
+
+        # Create Product Mapping and apply to df
+        product_mapping = {
+            product["isin"]: product["id"]
+            for product in Product.objects.filter(isin__in=df["isin"].unique()).values("id", "isin")
+        }
+        df["isin"] = df["isin"].apply(lambda x: product_mapping[x])
+
+        del df["cust_ref"]
+
+        # Rename Columns
+
+        df.columns = [
+            "register__register_reference",
+            "bank",
+            "underlying_instrument",
+            "transaction_date",
+            "value_date",
+            "external_id",
+            "price",
+            "shares",
+            "comment",
+        ]
+        df["transaction_subtype"] = df.shares.apply(
+            lambda x: Trade.Type.REDEMPTION.value if x < 0 else Trade.Type.SUBSCRIPTION.value
+        )
+        df["portfolio"] = df["underlying_instrument"].apply(lambda x: get_portfolio_id(x))
+        df["underlying_instrument"] = df["underlying_instrument"].apply(
+            lambda x: {"id": x, "instrument_type": "product"}
+        )
+        df["pending"] = False
+        # Convert df to list of dicts
+        data = df.to_dict("records")
+
+    return {
+        "data": data,
+    }

wbportfolio/import_export/parsers/sg_lux/customer_trade_without_pw.py

@@ -0,0 +1,57 @@
+import numpy as np
+import pandas as pd
+from wbportfolio.models import Product, Trade
+
+
+def get_portfolio(x):
+    product = Product.objects.get(id=x)
+    portfolio = product.primary_portfolio
+    return portfolio.id
+
+
+def parse(import_source):
+    data = list()
+
+    df = pd.read_excel(import_source.file.open(), usecols=[3, 4, 7, 10, 15, 16, 17, 18, 20, 21], engine="openpyxl")
+
+    # Filter out all non transaction rows and remove RECORD_DESC col
+    df = df[df["RECORD_DESC"].str.strip() == "TRANSACTION"]
+    del df["RECORD_DESC"]
+
+    # Convert timestamps to json conform date strings
+    df["TRANS_DATE"] = df["TRANS_DATE"].apply(lambda x: x.date().strftime("%Y-%m-%d"))
+    df["SETTL_DATE"] = df["SETTL_DATE"].apply(lambda x: x.date().strftime("%Y-%m-%d"))
+
+    # Replace all nan values with empty str
+    df[["REGISTER_FIRSTNAME", "CUST_REF"]] = df[["REGISTER_FIRSTNAME", "CUST_REF"]].replace(np.nan, "", regex=True)
+
+    # Merge REGISTER_FIRSTNAME and CUST_REF and then remove both cols
+    df["note"] = df["REGISTER_FIRSTNAME"] + df["CUST_REF"]
+    del df["REGISTER_FIRSTNAME"]
+    del df["CUST_REF"]
+
+    # Create Product Mapping and apply to df
+    product_mapping = {
+        product["isin"]: product["id"]
+        for product in Product.objects.filter(isin__in=df["ISIN"].unique()).values("id", "isin")
+    }
+    df["ISIN"] = df["ISIN"].apply(lambda x: product_mapping[x])
+
+    # Rename Columns
+    df.columns = [
+        "bank",
+        "underlying_instrument",
+        "transaction_date",
+        "value_date",
+        "external_id",
+        "price",
+        "shares",
+        "comment",
+    ]
+    df["transaction_subtype"] = df.shares.apply(lambda x: Trade.Type.REDEMPTION if x < 0 else Trade.Type.SUBSCRIPTION)
+    df["portfolio"] = df["underlying_instrument"].apply(lambda x: get_portfolio(x))
+    df["underlying_instrument"] = df["underlying_instrument"].apply(lambda x: {"id": x, "instrument_type": "product"})
+    # Convert df to list of dicts
+    data = list(df.T.to_dict().values())
+
+    return {"data": data}

wbportfolio/import_export/parsers/sg_lux/equity.py

@@ -0,0 +1,161 @@
+import datetime
+import re
+from contextlib import suppress
+
+import numpy as np
+import pandas as pd
+from wbportfolio.models import ProductGroup
+
+
+def file_name_parse(file_name):
+    dates = re.findall(r"([0-9]{4}-[0-9]{2}-[0-9]{2})", file_name)
+    isin = re.findall(r"\.([a-zA-Z0-9]*)_", file_name)
+
+    assert len(dates) == 2, "Not 2 dates found in the filename"
+    assert len(isin) == 1, "Not exactly 1 isin found in the filename"
+
+    return {
+        "isin": isin[0],
+        "valuation_date": datetime.datetime.strptime(dates[0], "%Y-%m-%d").date(),
+        "generation_date": datetime.datetime.strptime(dates[1], "%Y-%m-%d").date(),
+    }
+
+
+def get_exchange(row):
+    if str(row["Asset type code"]) == "VMOB" and row["Bloom Ticker"]:
+        with suppress(ValueError):
+            [_, exchange] = str(row["Bloom Ticker"]).replace(" Equity", "").replace(" EQUITY", "").split(" ")
+            return {"bbg_exchange_codes": exchange}
+    return None
+
+
+def get_underlying_instrument(row):
+    if str(row["Asset type code"]) == "VMOB":
+        data = {
+            "instrument_type": "equity",
+            "currency__key": row["currency__key"],
+            "isin": row["Asset Code"] or row["Security code"],
+            "name": row["Asset description"],
+        }
+        if bloomberg_ticker := row.get("Bloom Ticker", None):
+            tickers = str(bloomberg_ticker).replace(" Equity", "").replace(" EQUITY", "").split(" ")
+            if len(tickers) > 0:
+                data["ticker"] = tickers[0]
+            if len(tickers) > 1:
+                data["exchange"] = {"bbg_exchange_codes": tickers[1]}
+        return data
+    return None
+
+
+def parse(import_source):
+    # Load file into a CSV DictReader and convert the encoding to latin1 due to hyphonation
+    csv_file = import_source.file.open()
+    # csv_file = codecs.iterdecode(csv_file, "latin1")
+
+    cols = [0, 2, 4, 6, 7, 8, 10, 13, 27, 28, 64, 67]
+
+    df = pd.read_csv(csv_file, encoding="latin1", usecols=cols)
+    df = df.replace([np.inf, -np.inf, np.nan], None)
+    columns_map = {
+        "Code": "portfolio",
+        "underlying_instrument": "underlying_instrument",
+        "exchange__bbg_exchange_codes": "exchange__bbg_exchange_codes",
+        "NAV Date": "date",
+        "Quantity / Amount": "initial_shares",
+        "Price": "initial_price",
+        "Ccy": "currency__key",
+        "FX Rate": "initial_currency_fx_rate",
+        "asset_valuation_date": "asset_valuation_date",
+    }
+    df = df.rename(columns=columns_map)
+    # Substitute the Code for the ProductGroup ID
+    product_group_mapping = {
+        product_group.identifier: product_group.id
+        for product_group in ProductGroup.objects.filter(identifier__in=df["portfolio"].unique())
+    }
+
+    df["date"] = df["date"].apply(lambda x: x.replace("/", "-"))
+    df["initial_currency_fx_rate"] = df["initial_currency_fx_rate"].apply(lambda x: 1 / x if x else 1).round(5)
+
+    cash_mask = df["Accounting category"].isin(["T111"])
+    cash = (
+        df.loc[
+            cash_mask,
+            ["currency__key", "initial_currency_fx_rate", "portfolio", "date", "initial_price", "initial_shares"],
+        ]
+        .groupby(
+            [
+                "currency__key",
+                "portfolio",
+                "date",
+            ]
+        )
+        .agg(
+            {
+                "initial_currency_fx_rate": "mean",
+                "initial_price": "mean",
+                "initial_shares": "sum",
+            }
+        )
+        .reset_index()
+    ).copy()
+    cash["underlying_instrument"] = cash["currency__key"].apply(
+        lambda x: {"currency__key": x, "instrument_type": "cash"}
+    )
+
+    # cash_equivalents_mask, all asset type code that match TRES and which don't have accounting category T111
+    cash_equivalents_mask = df["Asset type code"].str.match("TRES") & ~df["Accounting category"].str.match("T111")
+
+    cash_equivalents = (
+        df.loc[
+            cash_equivalents_mask,
+            ["currency__key", "initial_currency_fx_rate", "portfolio", "date", "initial_price", "initial_shares"],
+        ]
+        .groupby(
+            [
+                "currency__key",
+                "portfolio",
+                "date",
+            ]
+        )
+        .agg(
+            {
+                "initial_currency_fx_rate": "mean",
+                "initial_price": "mean",
+                "initial_shares": "sum",
+            }
+        )
+        .reset_index()
+    ).copy()
+    cash_equivalents["underlying_instrument"] = cash_equivalents["currency__key"].apply(
+        lambda x: {"currency__key": x, "instrument_type": "cash_equivalent"}
+    )
+
+    # equities = df.loc[df["Accounting category"].str.match("010"), :].copy() # Historically, we filter out equity base on the "accounting category" that matches "010", we had issue with equity having the code "020". We decided to use the column "Asset type code" and filter out with the code "VCOM"
+    equities = df.loc[df["Asset type code"].str.match("VMOB"), :].copy()
+    if not equities.empty:
+        equities["underlying_instrument"] = equities.apply(lambda x: get_underlying_instrument(x), axis=1)
+        equities["exchange"] = equities.apply(lambda x: get_exchange(x), axis=1)
+        del equities["Accounting category"]
+        del equities["Asset type code"]
+        del equities["Bloom Ticker"]
+        del equities["Asset description"]
+    df = pd.concat([cash, equities, cash_equivalents])
+
+    df["asset_valuation_date"] = df["date"]
+    # Rename the columns
+
+    df = df.drop(df.columns.difference(columns_map.values()), axis=1)
+
+    df["is_estimated"] = False
+    df = df.replace([np.inf, -np.inf, np.nan], None)
+    df = df[df["underlying_instrument"].notnull()]
+
+    df["weighting"] = df.initial_currency_fx_rate * df.initial_price * df.initial_shares
+    portfolio_weights = df.groupby("portfolio")["weighting"].sum()
+    df["weighting"] = df.apply(lambda x: x["weighting"] / portfolio_weights.loc[x["portfolio"]], axis=1)
+    df["portfolio"] = df["portfolio"].apply(
+        lambda x: {"id": product_group_mapping[str(x)], "instrument_type": "product_group"}
+    )
+    csv_file.close()
+    return {"data": df.to_dict("records")}

wbportfolio/import_export/parsers/sg_lux/fees.py

@@ -0,0 +1,56 @@
+import codecs
+import csv
+import datetime
+import logging
+
+from wbportfolio.import_export.utils import convert_string_to_number
+from wbportfolio.models import Fees, Product
+
+logger = logging.getLogger("importers.parsers.sglux.fee")
+# Shares class mapping between ticker to identifier
+# {
+#     "ATNRFRP": "UNIT/RG",
+#     "ATNRFRC": "UNIT/RC",
+#     "ATNRFRE": "UNIT/R1",
+#     "ATNRFRU": "UNIT/R2",
+#     "ATNRFPP": "UNIT/PG",
+#     "ATNRFPC": "UNIT/PC",
+#     "ATNRFPE": "UNIT/P1",
+#     "ATNRFPU": "UNIT/P2",
+#     "ATNRFZU": "UNIT/H",
+#     "ATNRFAU": "UNIT/A",
+#     "ATNRFBU": "UNIT/B",
+#     "ATNRFFU": "UNIT/F"
+# }
+
+
+def parse(import_source):
+    fee_file = import_source.file.open()
+    fee_file = codecs.iterdecode(fee_file, "latin1")
+
+    # Read file into a CSV Dict Reader
+    fee_reader = csv.DictReader(fee_file, delimiter=",")
+
+    # Iterate through the CSV File and parse the data into a list
+    data = list()
+
+    for fee_data in fee_reader:
+        if (fee_description := fee_data["Fees description"]) and fee_description.startswith("Investment Manager fees"):
+            share_class = fee_data["Class"]  # .split("\\")[1][0]
+            product = Product.objects.get(
+                parent__identifier=fee_data["Code"], currency__key=fee_data["Local ccy"], identifier=share_class
+            )
+            date = datetime.datetime.strptime(fee_data["NAV Date"], "%Y/%m/%d")
+            data.append(
+                {
+                    "portfolio": product.primary_portfolio.id,
+                    "linked_product": product.id,
+                    "transaction_date": date.strftime("%Y-%m-%d"),
+                    "calculated": False,
+                    "transaction_subtype": Fees.Type.MANAGEMENT,
+                    "total_value": round(convert_string_to_number(fee_data.get("Fees - Local ccy", 0)), 6),
+                }
+            )
+
+    fee_file.close()
+    return {"data": data}

wbportfolio/import_export/parsers/sg_lux/perf_fees.py

@@ -0,0 +1,51 @@
+import codecs
+import csv
+import datetime
+import logging
+import re
+
+from wbportfolio.import_export.utils import convert_string_to_number
+from wbportfolio.models import Fees, Product
+
+logger = logging.getLogger("importers.parsers.sglux.perf_fees")
+
+
+def parse(import_source):
+    fee_file = import_source.file.open()
+    fee_file = codecs.iterdecode(fee_file, "latin1")
+
+    # Read file into a CSV Dict Reader
+    # fee_reader = csv.DictReader(fee_file, delimiter=',')
+    fee_reader = csv.reader(fee_file)
+    isin = re.findall("([A-Z]{2}[A-Z0-9]{9}[0-9]{1})", import_source.file.name)[0]
+    product = Product.objects.get(isin=isin)
+
+    # Iterate through the CSV File and parse the data into a list
+    data = list()
+
+    for fee_data in fee_reader:
+        date = datetime.datetime.strptime(fee_data[0], "%m/%d/%Y")
+        data.append(
+            {
+                "portfolio": product.primary_portfolio.id,
+                "linked_product": product.id,
+                "transaction_date": date.strftime("%Y-%m-%d"),
+                "calculated": False,
+                "transaction_subtype": Fees.Type.PERFORMANCE,
+                "total_value": round(convert_string_to_number(fee_data[1]), 6),
+            }
+        )
+        data.append(
+            {
+                "portfolio": product.primary_portfolio.id,
+                "linked_product": product.id,
+                "transaction_date": date.strftime("%Y-%m-%d"),
+                "calculated": False,
+                "transaction_subtype": Fees.Type.PERFORMANCE_CRYSTALIZED,
+                "total_value": round(convert_string_to_number(fee_data[2]), 6),
+            }
+        )
+
+    fee_file.close()
+
+    return {"data": data}

wbportfolio/import_export/parsers/sg_lux/portfolio_cash_flow.py

@@ -0,0 +1,29 @@
+from datetime import datetime
+
+import pandas as pd
+from wbportfolio.models import ProductGroup
+
+
+def parse(import_source):
+    csv_file = import_source.file.open()
+
+    df = pd.read_csv(csv_file, encoding="latin1", usecols=[0, 2, 4, 18])
+
+    value_date = df["NAV Date"].iloc[0]
+    total_assets = df.groupby("Code").sum("Market Value FCY")
+    cash = df[df["Asset type code"] == "TRES"].groupby("Code").sum("Market Value FCY")
+
+    data = []
+
+    for code in df["Code"].unique():
+        data.append(
+            {
+                "portfolio": ProductGroup.objects.get(identifier=code).portfolio.id,
+                "value_date": datetime.strptime(value_date, "%Y/%m/%d").strftime("%Y-%m-%d"),
+                "total_assets": total_assets.T[code].iloc[0],
+                "cash": cash.T[code].iloc[0],
+                "pending": False,
+            }
+        )
+
+    return {"data": data}

wbportfolio/import_export/parsers/sg_lux/portfolio_future_cash_flow.py

@@ -0,0 +1,36 @@
+from contextlib import suppress
+from datetime import datetime
+
+import pandas as pd
+from wbportfolio.models import Portfolio
+
+
+def parse(import_source):
+    csv_file = import_source.file.open()
+
+    df = pd.read_csv(csv_file)
+
+    def get_portfolio_id(row) -> int | None:
+        with suppress(Portfolio.DoesNotExist):
+            return Portfolio.objects.get(instruments__children__isin__in=[row["Isin"]]).pk
+
+    df = df[~df["Isin"].isnull()]
+    df["Trade date"] = df["Trade date"].ffill()
+    df["portfolio"] = df.apply(get_portfolio_id, axis=1)
+    df = df[["Trade date", "portfolio", "Net Ref ccy"]]
+    df = df.groupby(["Trade date", "portfolio"]).sum().to_dict()
+
+    data = []
+    for keys, cash_flow_forecast in df["Net Ref ccy"].items():
+        data.append(
+            {
+                "value_date": datetime.strptime(keys[0], "%d/%m/%Y").strftime("%Y-%m-%d"),
+                "portfolio": keys[1],
+                "cash_flow_forecast": cash_flow_forecast,
+                "pending": True,
+            }
+        )
+
+    return {
+        "data": data,
+    }

wbportfolio/import_export/parsers/sg_lux/registers.py

@@ -0,0 +1,210 @@
+import csv
+from io import StringIO
+
+import numpy as np
+import pandas as pd
+from wbcore.contrib.geography.models import Geography
+from wbportfolio.models import Register
+from xlrd import xldate_as_datetime
+
+from .sylk import SYLK
+
+
+def convert_string_to_number(string):
+    try:
+        return float(string.replace(" ", "").replace(",", ""))
+    except ValueError:
+        return 0.0
+
+
+def parse(import_source):
+    data = list()
+
+    sylk_handler = SYLK()
+    for line in [_line.decode("cp1252") for _line in import_source.file.open("rb").readlines()]:
+        sylk_handler.parseline(line)
+
+    buffer = StringIO()
+    csvwriter = csv.writer(buffer, quotechar="'", delimiter=";", lineterminator="\n", quoting=csv.QUOTE_ALL)
+    for line in sylk_handler.stream_rows():
+        csvwriter.writerow(line)
+
+    buffer.seek(0)
+    content = buffer.read().replace('""', "")
+    df = pd.read_csv(
+        StringIO(content),
+        sep=";",
+        quotechar="'",
+        usecols=[
+            2,
+            3,
+            4,
+            5,
+            8,
+            9,
+            10,
+            12,
+            13,
+            14,
+            15,
+            16,
+            17,
+            18,
+            19,
+            20,
+            21,
+            22,
+            23,
+            24,
+            25,
+            26,
+            27,
+            28,
+            29,
+            30,
+            32,
+            33,
+            34,
+            36,
+            42,
+            43,
+            46,
+            47,
+            48,
+            49,
+            50,
+            55,
+            56,
+            57,
+            58,
+        ],
+    )
+
+    # Convert timestamps to json conform date strings
+    df["ESTABLISHMENT_DATE"] = df["ESTABLISHMENT_DATE"].apply(lambda x: xldate_as_datetime(x, datemode=0).date())
+    df["ESTABLISHMENT_DATE"] = df["ESTABLISHMENT_DATE"].apply(lambda x: x.strftime("%Y-%m-%d"))
+
+    df = df.replace(np.nan, "", regex=True)
+    # df = df.astype(str)
+    df["GLOBAL_REGISTER_NUMBER"] = df["GLOBAL_REGISTER_NUMBER"].apply(lambda x: str(int(x)) if x else "")
+
+    # Merge TextFields
+    df["custodian_address"] = df[["ADRESS_LINE_1_4", "ADRESS_LINE_2_4", "ADRESS_LINE_3_4", "ADRESS_LINE_4_4"]].apply(
+        lambda x: "<br />".join(x.dropna().astype(str)), axis=1
+    )
+
+    def concat_status(x):
+        status = []
+
+        if code := x["BLOCK_CODE"]:
+            try:
+                status.append(f"{int(code):04}")
+            except ValueError:
+                status.append(code)
+        if desc := x["BLOCK_CODE_DESCRIPTION"]:
+            status.append(desc)
+
+        for n in range(1, 5):
+            if code := x[f"BLOCK_CODE_{n}"]:
+                try:
+                    status.append(f"{int(code):04}")
+                except ValueError:
+                    status.append(code)
+            if desc := x[f"DESCRIPTION_BC{n}"]:
+                status.append(desc)
+
+        return "<br />".join(status)
+
+    df["status_message"] = df.apply(concat_status, axis=1)
+
+    # Map Status
+    def apply_status(x):
+        if x.get("status_message", None) and x["ACTIVE_INACTIVE"] != "INACTIVE":
+            return Register.RegisterStatus.WARNING
+
+        mapping = {
+            "ACTIVE": Register.RegisterStatus.ACTIVE,
+            "INACTIVE": Register.RegisterStatus.INACTIVE,
+        }
+        return mapping[x["ACTIVE_INACTIVE"]]
+
+    df["status"] = df.apply(apply_status, axis=1)
+
+    # Remove not used columns
+    del df["ADRESS_LINE_1_4"]
+    del df["ADRESS_LINE_2_4"]
+    del df["ADRESS_LINE_3_4"]
+    del df["ADRESS_LINE_4_4"]
+    del df["BLOCK_CODE"]
+    del df["BLOCK_CODE_DESCRIPTION"]
+    del df["BLOCK_CODE_1"]
+    del df["DESCRIPTION_BC1"]
+    del df["BLOCK_CODE_2"]
+    del df["DESCRIPTION_BC2"]
+    del df["BLOCK_CODE_3"]
+    del df["DESCRIPTION_BC3"]
+    del df["BLOCK_CODE_4"]
+    del df["DESCRIPTION_BC4"]
+    del df["ACTIVE_INACTIVE"]
+
+    # Map Countries
+    country_code_mapping = {
+        country["code_2"]: country["id"] for country in Geography.countries.all().values("id", "code_2")
+    }
+    country_code_mapping["XX"] = country_code_mapping["ZZ"]
+    country_title_mapping = {
+        country["name"].lower(): country["id"] for country in Geography.countries.all().values("id", "name")
+    }
+    country_title_mapping["great-britain"] = Geography.countries.get(code_2="GB").id
+    country_title_mapping["man (isle of)"] = Geography.countries.get(code_2="IM").id
+
+    df["CITIZENSHIP"] = df["CITIZENSHIP"].apply(lambda x: country_code_mapping[x])
+    df["RESIDENCE"] = df["RESIDENCE"].apply(lambda x: country_code_mapping[x])
+    df["CPAYS"] = df["CPAYS"].apply(lambda x: country_code_mapping[x])
+    df["COUNTRY"] = df["COUNTRY"].apply(lambda x: country_title_mapping[x.lower()])
+    df["CITY"] = df["CITY"].str.title()
+    # Map Investor Type
+    investor_mapping = {
+        "0006": Register.RegisterInvestorType.BANK,
+        "0011": Register.RegisterInvestorType.NOMINEE,
+        "0003": Register.RegisterInvestorType.GLOBAL,
+        "0007": Register.RegisterInvestorType.NON_FINANCIAL_ENTITY,
+    }
+    df["INVESTOR_TYPE_CODE"] = df["INVESTOR_TYPE_CODE"].apply(lambda x: investor_mapping[f"{x:04}"])
+
+    # Rename Columns
+    df.columns = [
+        "register_reference",
+        "opened",
+        "register_name_1",
+        "register_name_2",
+        "custodian_reference",
+        "custodian_name_1",
+        "custodian_name_2",
+        "custodian_postcode",
+        "custodian_city",
+        "custodian_country",
+        "investor_type",
+        "global_register_reference",
+        "citizenship",
+        "residence",
+        "external_register_reference",
+        "sales_reference",
+        "dealer_reference",
+        "outlet_reference",
+        "outlet_name",
+        "outlet_address",
+        "outlet_postcode",
+        "outlet_country",
+        "opened_reference_1",
+        "opened_reference_2",
+        "updated_reference_1",
+        "updated_reference_1",
+        "custodian_address",
+        "status_message",
+        "status",
+    ]
+    # Convert df to list of dicts
+    data = list(df.T.to_dict().values())
+
+    return {"data": data}