wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/import_export/parsers/societe_generale/strategy.py

@@ -0,0 +1,94 @@
+import datetime
+import logging
+import re
+from io import BytesIO
+
+import numpy as np
+import pandas as pd
+from wbportfolio.import_export.utils import extract_exchange_ticker
+
+logger = logging.getLogger("importers.parsers.jp_morgan.strategy")
+
+
+def file_name_parse(file_name):
+    dates = re.findall("([0-9]{8})", file_name)
+
+    assert len(dates) == 1, "Not exactly 1 date found in the filename"
+
+    return {"valuation_date": datetime.datetime.strptime(dates[0], "%Y%m%d").date()}
+
+
+def parse(import_source):
+    data = list()
+    prices = list()
+    df_dict = pd.read_excel(BytesIO(import_source.file.read()), engine="openpyxl", sheet_name=None)
+    for sheet_name, df in df_dict.items():
+        xx, yy = np.where(df == "Ticker")
+        if len(xx) == 1 and len(yy) == 1:
+            df_info = df.iloc[: xx[0] - 1, :].transpose()
+            df_info = df_info.rename(columns=df_info.iloc[0]).drop(df_info.index[0]).dropna(how="all")
+
+            strategy_ticker = df_info.loc[:, df_info.columns.str.contains("Ticker")].iloc[0, 0]
+            strategy_currency = df_info.loc[:, df_info.columns.str.contains("CCY")].iloc[0, 0]
+            valuation_date = df_info.loc[:, df_info.columns.str.contains("Date")].iloc[0, 0]
+            valuation_date = datetime.datetime.strptime(valuation_date, "%Y-%m-%d")
+            strategy_close = df_info.loc[:, df_info.columns.str.contains("Level")].iloc[0, 0]
+
+            df_positions = df.iloc[xx[0] :, yy[0] :]
+            df_positions = (
+                df_positions.rename(columns=df_positions.iloc[0]).drop(df_positions.index[0]).dropna(how="all")
+            )
+            df_positions = df_positions.rename(
+                columns={
+                    df_positions.columns[df_positions.columns.str.contains("Forex")][0]: "initial_currency_fx_rate",
+                    df_positions.columns[df_positions.columns.str.contains("Currency")][0]: "currency__key",
+                    df_positions.columns[df_positions.columns.str.contains("Weight")][0]: "weighting",
+                    df_positions.columns[df_positions.columns.str.contains("Level")][0]: "initial_price",
+                    df_positions.columns[df_positions.columns.str.contains("Ticker")][
+                        0
+                    ]: "underlying_instrument__ticker",
+                    df_positions.columns[df_positions.columns.str.contains("ISIN")][0]: "underlying_instrument__isin",
+                    df_positions.columns[df_positions.columns.str.contains("Name")][0]: "underlying_instrument__name",
+                }
+            )
+            for position in df_positions.to_dict("records"):
+                ticker, exchange = extract_exchange_ticker(position["underlying_instrument__ticker"])
+                if exchange:
+                    exchange = {"bbg_exchange_codes": exchange}
+                data.append(
+                    {
+                        "underlying_instrument": {
+                            "instrument_type": "equity",
+                            "ticker": ticker,
+                            "isin": position["underlying_instrument__isin"],
+                            "name": position["underlying_instrument__name"],
+                            "currency__key": position["currency__key"],
+                            "exchange": exchange,
+                        },
+                        "portfolio": {
+                            "instrument_type": "index",
+                            "ticker": strategy_ticker,
+                            "currency__key": strategy_currency,
+                        },
+                        "is_estimated": False,
+                        "exchange": exchange,
+                        "asset_type": "equity",
+                        "currency__key": position["currency__key"],
+                        "initial_currency_fx_rate": round(position["initial_currency_fx_rate"], 6),
+                        "weighting": round(position["weighting"], 6),
+                        "initial_price": round(position["initial_price"], 6),
+                        "date": valuation_date.strftime("%Y-%m-%d"),
+                    }
+                )
+            prices.append(
+                {
+                    "instrument": {
+                        "instrument_type": "index",
+                        "ticker": strategy_ticker,
+                        "currency__key": strategy_currency,
+                    },
+                    "date": valuation_date.strftime("%Y-%m-%d"),
+                    "net_value": strategy_close,
+                }
+            )
+    return {"data": data, "prices": prices}

wbportfolio/import_export/parsers/societe_generale/valuation.py

@@ -0,0 +1,37 @@
+from io import BytesIO
+
+import numpy as np
+import pandas as pd
+from wbportfolio.import_export.utils import get_file_extension
+from wbportfolio.models import Product
+
+
+def parse(import_source):
+    if get_file_extension(import_source.file) == ".xlsx":
+        df = pd.read_excel(BytesIO(import_source.file.read()), engine="openpyxl", sheet_name="Position").dropna(
+            how="all"
+        )
+    elif get_file_extension(import_source.file) == ".xls":
+        df = pd.read_excel(BytesIO(import_source.file.read()), sheet_name="Position").dropna(how="all")
+    else:
+        raise Exception("File not supported")
+
+    xx, yy = np.where(df == "ISIN Code")
+    df = df.iloc[xx[0] :, yy[0] :]
+    df = df.rename(columns=df.iloc[0]).drop(df.index[0]).dropna(how="all")
+
+    df["Valuation Date"] = pd.to_datetime(df["Valuation Date"])
+
+    data = list()
+    for valuation in df.to_dict("records"):
+        product = Product.objects.get(isin=valuation["ISIN Code"])
+        data.append(
+            {
+                "instrument": {"instrument_type": "product", "id": product.id},
+                "date": valuation["Valuation Date"].strftime("%Y-%m-%d"),
+                "net_value": round(valuation["Bid"], 6),
+                "calculated": False,
+            }
+        )
+
+    return {"data": data}

wbportfolio/import_export/parsers/tellco/customer_trade.py

@@ -0,0 +1,64 @@
+import codecs
+import csv
+import datetime
+import re
+
+from wbportfolio.import_export.utils import convert_string_to_number
+from wbportfolio.models import Product, Trade
+
+product_mapping = {
+    "2304": {
+        "A": "CH0442615701",
+        "B": "CH0442770316",
+    },
+    "2316": {
+        "A": "CH0583763534",
+        "B": "CH0583763542",
+    },
+}
+
+
+def file_name_parse(file_name):
+    identifier = re.findall("([0-9]{4}).*", file_name)
+    assert len(identifier) == 1, "Not exactly one identifier was found."
+    return identifier[0]
+
+
+def parse(import_source):
+    # Get the identifier from the file name to know which product group it is
+    identifier = file_name_parse(import_source.file.name)
+
+    # Load file into a CSV DictReader
+    csv_file = import_source.file.open()
+    csv_file_type = type(csv_file.read())
+
+    # If the file is a byte string, then we need to convert it.
+    if csv_file_type is bytes:
+        csv_file = codecs.iterdecode(csv_file, "latin1")
+
+    # Read file into a CSV Dict Reader
+    csv_reader = csv.DictReader(csv_file, delimiter=";")
+
+    # Iterate through the CSV File and parse the data into a list
+    data = list()
+    for customer_trade in csv_reader:
+        product = Product.objects.get(isin=product_mapping[identifier][customer_trade["Anteilklasse"].strip()])
+
+        transaction_date = datetime.datetime.strptime(customer_trade["Datum"], "%Y%m%d").date()
+        shares = round(convert_string_to_number(customer_trade["Saldo - Anzahl"]), 4)
+        portfolio = product.primary_portfolio
+        data.append(
+            {
+                "underlying_instrument": {"id": product.id, "instrument_type": "product"},
+                "portfolio": portfolio.id,
+                "currency__key": product.currency.key,
+                "transaction_date": transaction_date.strftime("%Y-%m-%d"),
+                "value_date": transaction_date.strftime("%Y-%m-%d"),
+                "shares": shares,
+                "bank": "Tellco Trade",
+                "transaction_subtype": Trade.Type.REDEMPTION if shares < 0 else Trade.Type.SUBSCRIPTION,
+                "price": round(convert_string_to_number(customer_trade["NIW"]), 4),
+            }
+        )
+    csv_file.close()
+    return {"data": data}

wbportfolio/import_export/parsers/tellco/equity.py

@@ -0,0 +1,86 @@
+import codecs
+import csv
+import datetime
+
+import pandas as pd
+from wbcore.contrib.currency.models import Currency
+from wbportfolio.import_export.utils import convert_string_to_number
+from wbportfolio.models import ProductGroup
+
+
+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")
+
+    # Read file into a CSV Dict Reader
+    csv_reader = csv.DictReader(csv_file, delimiter=";")
+
+    # Iterate through the CSV File and parse the data into a list
+    data = list()
+    for basket in csv_reader:
+        if basket["Assetart"] == "CPON" or (
+            basket["Assetart"] == "TRES" and "Sichtguthaben" not in basket["Assetbezeichnung"]
+        ):
+            continue
+        product_group = ProductGroup.objects.get(identifier=basket["Fonds-Nr."].strip())
+        valuation_date = datetime.datetime.strptime(basket["Datum"], "%Y%m%d")
+
+        currency_key = basket["Währung"]
+        currency = Currency.objects.get(key=currency_key)
+        group_currency = Currency.objects.get(key=basket["Assetwährung"])
+
+        if basket["Assetart"] == "TRES":
+            initial_currency_fx_rate = convert_string_to_number(basket["Wertpapierkurs"])
+
+            ticker = "CASH"
+            title = currency.title
+            initial_price = 1
+            underlying_instrument = {
+                "instrument_type": "cash",
+                "ticker": ticker,
+                "name": title,
+                "currency__key": currency.key,
+            }
+        elif basket["Assetart"] == "VMOB":
+            instrument_type = "equity"
+            if "STRUKT" in basket.get("TL2", ""):
+                instrument_type = "product"
+            initial_currency_fx_rate = float(currency.convert(valuation_date, group_currency))
+            initial_price = basket["Wertpapierkurs"]
+
+            exchange = f'X{basket["Bloomberg Code"]}' if basket["Bloomberg Code"] else None
+            underlying_instrument = {
+                "instrument_type": instrument_type,
+                "isin": basket["ISIN"],
+                "exchange": {"mic_code": exchange},
+                "name": basket["Assetbezeichnung"],
+                "currency__key": currency.key,
+            }
+
+        initial_shares = basket["Stk / Nominal"]
+
+        data.append(
+            {
+                "underlying_instrument": underlying_instrument,
+                "exchange": underlying_instrument.get("exchange", None),
+                "portfolio": {
+                    "instrument_type": "product_group",
+                    "id": product_group.id,
+                },
+                "is_estimated": False,
+                "currency__key": currency_key,
+                "date": valuation_date.strftime("%Y-%m-%d"),
+                "asset_valuation_date": valuation_date.strftime("%Y-%m-%d"),
+                "initial_price": round(convert_string_to_number(initial_price), 4),
+                "initial_currency_fx_rate": initial_currency_fx_rate,
+                "initial_shares": round(convert_string_to_number(initial_shares), 4),
+            }
+        )
+    csv_file.close()
+
+    df = pd.DataFrame(data)  # quick Hack to compute weighting on import
+    df["weighting"] = df.initial_currency_fx_rate * df.initial_price * df.initial_shares
+    df["weighting"] = df.weighting / df.weighting.sum()
+
+    return {"data": df.to_dict("records")}

wbportfolio/import_export/parsers/tellco/valuation.py

@@ -0,0 +1,52 @@
+import codecs
+import csv
+import datetime
+import re
+
+from wbportfolio.models import Product
+
+
+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 parse(import_source):
+    # Load file into a CSV DictReader
+    csv_file = import_source.file.open()
+    # csv_file_type = type(csv_file.read())
+
+    # # If the file is a byte string, then we need to convert it.
+    # if csv_file_type is bytes:
+    csv_file = codecs.iterdecode(csv_file, "latin1")
+
+    # # Read file into a CSV Dict Reader
+    csv_reader = csv.DictReader(csv_file, delimiter=";")
+
+    # # Iterate through the CSV File and parse the data into a list
+    data = list()
+
+    for valuation in csv_reader:
+        valuation_date = datetime.datetime.strptime(valuation["Bewertungsdatum"], "%Y%m%d").date()
+        product = Product.objects.get(isin=valuation["ISIN"])
+        if valuation_date.weekday() not in [5, 6]:
+            data.append(
+                {
+                    "instrument": {"instrument_type": "product", "id": product.id},
+                    "date": valuation_date.strftime("%Y-%m-%d"),
+                    "net_value": float(valuation["Nettoinventarwert"]),
+                    "calculated": False,
+                }
+            )
+
+    csv_file.close()
+    return {"data": data}

wbportfolio/import_export/parsers/ubs/api/asset_position.py

@@ -0,0 +1,106 @@
+import json
+
+import numpy as np
+import pandas as pd
+from wbcore.contrib.currency.models import CurrencyFXRates
+from wbportfolio.import_export.utils import extract_exchange_ticker
+
+BASE_MAPPING = {
+    "instrument": "underlying_instrument__name",
+    "ric": "underlying_instrument__refinitiv_identifier_code",
+    "bbTicker": "underlying_instrument__ticker",
+    "isin": "underlying_instrument__isin",
+    "sedol": "underlying_instrument__sedol",
+    "valoren": "underlying_instrument__valoren",
+    "assetClass": "underlying_instrument__instrument_type",
+    "percentageWeight": "weighting",
+    "shares": "initial_shares",
+    "localClose": "initial_price",
+    "currency": "currency__key",
+    "fxMultiplier": "initial_currency_fx_rate",
+}
+
+INSTRUMENT_MAPPING = {
+    "EQUITY": {},
+    "INDEX": {},
+    "ETF": {},
+    "UBS_SECURITY": {},
+    "FUTURE": {"contracts": "contracts"},
+    "CASH": {"currencyAmount": "initial_shares"},
+    "CASH_COMP": {
+        "currencyAmount": "initial_shares",
+    },
+    "BOND": {"creditRating": "credit_rating", "maturityDate": "maturity_date"},
+    "OPTION": {
+        "description": "description",
+        "strike": "strike",
+        "sizeOfContract": "size_of_contract",
+        "exerciseStyle": "exercise_style",
+        "optionType": "option_type",
+        "expiryDate": "expiry_date",
+        "underlying__description": "underlying__description",
+        "underlying__ric": "underlying__refinitiv_identifier_code",
+        "underlying__bbTicker": "underlying__ticker",
+        "underlying__assetClass": "underlying__instrument_type",
+    },
+}
+
+INSTRUMENT_TYPE_MAP = {
+    "EQUITY": "equity",
+    "INDEX": "index",
+    "ETF": "etf",
+    "UBS_SECURITY": "equity",
+    "FUTURE": "future",
+    "CASH": "cash",
+    "CASH_COMP": "cash",
+    "BOND": "bond",
+    "OPTION": "option",
+}
+
+
+def parse(import_source):
+    content = json.load(import_source.file)
+    data = list()
+    if (
+        (constituents := content.get("constituents", None))
+        and (val_date := content.get("asOfDate", None))
+        and (amc := content.get("amc", None))
+    ):
+        for asset_class, asset_data in constituents.items():
+            if asset_class in INSTRUMENT_MAPPING.keys():
+                asset_class_map = INSTRUMENT_MAPPING[asset_class]
+                _map = {**asset_class_map, **BASE_MAPPING}
+                df = pd.json_normalize(asset_data, sep="__")
+                df = df.replace([np.inf, -np.inf, np.nan], None)
+                df = df.rename(columns=_map).dropna(how="all", axis=1)
+                df["weighting"] = df["weighting"] / 100.0
+                df["date"] = val_date
+                df["portfolio__instrument_type"] = "product"
+                df["portfolio__isin"] = amc["isin"]
+                df["underlying_instrument__currency__key"] = df["currency__key"]
+                df["underlying_instrument__instrument_type"] = df.underlying_instrument__instrument_type.apply(
+                    lambda x: INSTRUMENT_TYPE_MAP[x]
+                )
+                if asset_class == "CASH":
+                    df["initial_price"] = 1.0
+                    df["initial_currency_fx_rate"] = (
+                        df["currency__key"]
+                        .apply(
+                            lambda x: CurrencyFXRates.objects.filter(currency__key=x, date__lte=val_date)
+                            .latest("date")
+                            .value
+                        )
+                        .astype(float)
+                    )
+                df["is_estimated"] = False
+                if "underlying_instrument__ticker" in df.columns:
+                    df["underlying_instrument__exchange"] = df["underlying_instrument__ticker"].apply(
+                        lambda x: {"bbg_exchange_codes": extract_exchange_ticker(x)[1]}
+                    )
+                    df["underlying_instrument__ticker"] = df["underlying_instrument__ticker"].apply(
+                        lambda x: extract_exchange_ticker(x)[0]
+                    )
+                if "underlying_instrument__exchange" in df.columns:
+                    df["exchange"] = df["underlying_instrument__exchange"]
+                data.extend(df.to_dict("records"))
+    return {"data": data}

wbportfolio/import_export/parsers/ubs/api/fees.py

@@ -0,0 +1,31 @@
+import json
+
+import pandas as pd
+from wbportfolio.models import Fees, Product
+
+BASE_MAPPING = {"managementFee": "total_value", "performanceFee": "total_value", "date": "transaction_date"}
+
+
+def parse(import_source):
+    def _process_df(df, product):
+        df = df.rename(columns=BASE_MAPPING).dropna(how="all", axis=1)
+        df = df.drop(columns=df.columns.difference(BASE_MAPPING.values()))
+        df["currency__key"] = product.currency.key
+        df["linked_product"] = product.id
+        df["underlying_instrument"] = product.id
+        df["portfolio"] = product.primary_portfolio.id
+        return df
+
+    content = json.load(import_source.file)
+    data = []
+    if product := Product.objects.filter(isin=content.get("isin", None)).first():
+        if mngt_data := content.get("management_fees", None):
+            df = _process_df(pd.DataFrame(mngt_data), product)
+            df["transaction_subtype"] = Fees.Type.MANAGEMENT.value
+            data.extend(df.to_dict("records"))
+        if perf_data := content.get("performance_fees", None):
+            df = _process_df(pd.DataFrame(perf_data), product)
+            df["transaction_subtype"] = Fees.Type.PERFORMANCE.value
+            data.extend(df.to_dict("records"))
+
+    return {"data": data}

wbportfolio/import_export/parsers/ubs/api/instrument_price.py

@@ -0,0 +1,20 @@
+import json
+
+BASE_MAPPING = {
+    "isin": "instrument__isin",
+    "certificatePosition": "outstanding_shares",
+    "currency": "instrument__currency__key",
+    "aum": "market_capitalization",
+    "rpl": "net_value",
+}
+
+
+def parse(import_source):
+    content = json.load(import_source.file)
+    data = {}
+    if (amc := content.get("amc", None)) and (val_date := content.get("asOfDate", None)):
+        data = {"date": val_date}
+        for k, v in amc.items():
+            if k in BASE_MAPPING:
+                data[BASE_MAPPING[k]] = v
+    return {"data": [data]}

wbportfolio/import_export/parsers/ubs/customer_trade.py

@@ -0,0 +1,60 @@
+from io import BytesIO
+from typing import Dict
+
+import numpy as np
+import pandas as pd
+from wbcore.contrib.io.models import ImportSource
+from wbportfolio.models import Product, Trade
+
+
+def parse_row(obj: Dict, import_source: ImportSource) -> Dict:
+    try:
+        isin = obj["underlying_instrument__isin"]
+        product = Product.objects.get(isin=isin)
+        shares = obj["shares"]
+        if import_source.source.import_parameters.get("negate_shares", False):
+            shares = -1 * shares
+        portfolio = product.primary_portfolio
+        return {
+            "underlying_instrument": {"id": product.id, "instrument_type": "product"},
+            "currency__key": product.currency.key,
+            "portfolio": portfolio.id,
+            "transaction_date": obj["transaction_date"].strftime("%Y-%m-%d"),
+            "shares": shares,
+            "bank": obj["custodian"],
+            "transaction_subtype": Trade.Type.REDEMPTION if shares < 0 else Trade.Type.SUBSCRIPTION,
+            "price": round(obj["price"], 6),
+        }
+    except Product.DoesNotExist:
+        import_source.log += f"Product with ISIN {isin} does not exists."
+
+
+def parse(import_source):
+    df = pd.read_excel(BytesIO(import_source.file.read()), engine="openpyxl")
+    if "Trade Date" not in df.columns:
+        xx, yy = np.where(df == "Trade Date")
+        df = df.iloc[xx[0] :, yy[0] :]
+        df = df.rename(columns=df.iloc[0]).drop(df.index[0]).dropna(how="all")
+    df = df.rename(columns=lambda x: x.lower())
+    df = df.rename(
+        columns={
+            "trade date": "transaction_date",
+            "isin": "underlying_instrument__isin",
+            "client side": "client_side",
+            "net quantity": "shares",
+            "price": "price",
+            "custodian": "custodian",
+            "name": "custodian",
+            "buy/sell": "client_side",
+            "nominal": "shares",
+        }
+    )
+    df["transaction_date"] = pd.to_datetime(df["transaction_date"])
+    df["underlying_instrument__isin"] = df["underlying_instrument__isin"].str.strip()
+    df = df.replace([np.inf, -np.inf, np.nan], None)
+    df.loc[df["custodian"].isnull(), "custodian"] = "N/A"
+    data = list()
+    for d in df.to_dict("records"):
+        data.append(parse_row(d, import_source))
+
+    return {"data": data}

wbportfolio/import_export/parsers/ubs/equity.py

@@ -0,0 +1,97 @@
+import datetime
+import re
+
+import xlrd
+from wbportfolio.models import Product
+
+
+def file_name_parse(file_name):
+    isin = re.findall("([A-Z]{2}[A-Z0-9]{9}[0-9]{1})", file_name)
+
+    assert len(isin) == 1, "Not exactly 1 isin found in the filename"
+
+    return {"isin": isin[0]}
+
+
+def parse(import_source):
+    book = xlrd.open_workbook(file_contents=import_source.file.read())
+
+    parts = file_name_parse(import_source.file.name)
+
+    product = Product.objects.get(isin=parts["isin"])
+
+    equity_sheet = book.sheet_by_name("Equity")
+    cash_sheet = book.sheet_by_name("Cash")
+
+    date = None
+    first_row = None
+    last_row = None
+
+    for row_index, row in enumerate(equity_sheet.get_rows()):
+        if "Statement as at Close of Business" in row[1].value:
+            date = datetime.datetime.strptime(row[1].value.split(":")[1].strip(), "%d-%b-%Y").date()
+
+        if "Instrument" in row[1].value:
+            first_row = row_index + 1
+
+        if row[1].value == "" and first_row is not None:
+            last_row = row_index
+            break
+
+    data = list()
+    for row in range(first_row, last_row, 1):
+        initial_shares = round(equity_sheet.cell_value(row, 8), 4)
+        close = round(equity_sheet.cell_value(row, 9), 4)
+        initial_currency_fx_rate = round(equity_sheet.cell_value(row, 11), 4)
+
+        bbg = equity_sheet.cell_value(row, 3)
+        ric = equity_sheet.cell_value(row, 2)
+        try:
+            ticker, exchange = bbg.split(" ")[0:2]
+        except Exception:
+            ticker, exchange = bbg, None
+        exchange_data = {"bbg_exchange_codes": exchange}
+        data.append(
+            {
+                "underlying_instrument": {
+                    "instrument_type": "equity",
+                    "ticker": ticker,
+                    "exchange": exchange_data,
+                    "name": equity_sheet.cell_value(row, 1),
+                    "currency__key": equity_sheet.cell_value(row, 10),
+                    "refinitiv_identifier_code": ric,
+                },
+                "portfolio": {"instrument_type": "product", "id": product.id},
+                "is_estimated": False,
+                "exchange": exchange_data,
+                "initial_shares": initial_shares,
+                "date": date.strftime("%Y-%m-%d"),
+                "asset_valuation_date": date.strftime("%Y-%m-%d"),
+                "initial_price": close,
+                "currency__key": equity_sheet.cell_value(row, 10),
+                "initial_currency_fx_rate": initial_currency_fx_rate,
+            }
+        )
+
+    for row_index, row in enumerate(cash_sheet.get_rows()):
+        if "Currency" == row[1].value:
+            data.append(
+                {
+                    "underlying_instrument": {
+                        "instrument_type": "cash",
+                        "currency__key": cash_sheet.cell_value(row_index + 1, 1),
+                    },
+                    "portfolio": {"instrument_type": "product", "id": product.id},
+                    "is_estimated": False,
+                    "name": cash_sheet.cell_value(row_index + 1, 1),
+                    "initial_shares": round(cash_sheet.cell_value(row_index + 1, 2), 4),
+                    "date": date.strftime("%Y-%m-%d"),
+                    "asset_valuation_date": date.strftime("%Y-%m-%d"),
+                    "initial_price": 1.0,
+                    "currency__key": cash_sheet.cell_value(row_index + 1, 1),
+                    "initial_currency_fx_rate": 1.0,
+                }
+            )
+            break
+
+    return {"data": data}