wbportfolio 1.43.1__py2.py3-none-any.whl

wbportfolio/import_export/handlers/trade.py

@@ -0,0 +1,191 @@
+import math
+from datetime import datetime
+from decimal import Decimal
+from typing import Any, Dict, Optional
+
+from django.db import models
+from wbcore.contrib.currency.import_export.handlers import CurrencyImportHandler
+from wbcore.contrib.io.exceptions import DeserializationError
+from wbcore.contrib.io.imports import ImportExportHandler
+from wbfdm.import_export.handlers.instrument import InstrumentImportHandler
+from wbfdm.models import InstrumentType
+from wbportfolio.models.portfolio import Portfolio
+from wbportfolio.models.products import update_outstanding_shares_as_task
+from wbportfolio.utils import string_matching
+
+from .register import RegisterImportHandler
+
+
+class TradeImportHandler(ImportExportHandler):
+    MODEL_APP_LABEL: str = "wbportfolio.Trade"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.instrument_handler = InstrumentImportHandler(self.import_source)
+        self.register_handler = RegisterImportHandler(self.import_source)
+        self.currency_handler = CurrencyImportHandler(self.import_source)
+
+    def _data_changed(self, _object, change_data: Dict[str, Any], initial_data: Dict[str, Any], **kwargs):
+        if (new_register := change_data.get("register")) and (current_register := _object.register):
+            # we remplace the register only if the new one gives us more information
+            if new_register.register_reference == current_register.global_register_reference:
+                del change_data["register"]
+        return super()._data_changed(_object, change_data, initial_data, **kwargs)
+
+    def _deserialize(self, data: Dict[str, Any]):
+        if external_identifier2 := data.get("external_identifier2", None):
+            data["external_identifier2"] = str(external_identifier2)
+        if transaction_date_str := data.get("transaction_date", None):
+            data["transaction_date"] = datetime.strptime(transaction_date_str, "%Y-%m-%d").date()
+        if value_date_str := data.get("value_date", None):
+            data["value_date"] = datetime.strptime(value_date_str, "%Y-%m-%d").date()
+        if book_date_str := data.get("book_date", None):
+            data["book_date"] = datetime.strptime(book_date_str, "%Y-%m-%d").date()
+        if underlying_instrument := data.get("underlying_instrument", None):
+            data["underlying_instrument"] = self.instrument_handler.process_object(
+                underlying_instrument, only_security=False, read_only=True
+            )[0]
+        data["portfolio"] = Portfolio._get_or_create_portfolio(
+            self.instrument_handler, data.get("portfolio", data["underlying_instrument"])
+        )
+        if currency_data := data.get("currency", None):
+            data["currency"] = self.currency_handler.process_object(currency_data, read_only=True)[0]
+
+        if register_data := data.get("register", None):
+            data["register"] = self.register_handler.process_object(register_data)[0]
+
+        for field in self.model._meta.get_fields():
+            if not (value := data.get(field.name, None)) is None and isinstance(field, models.DecimalField):
+                q = 1 / (math.pow(10, 4))
+                data[field.name] = Decimal(value).quantize(Decimal(str(q)))
+
+        if "total_value" in data:
+            data["total_value"] = data["price"] * data["shares"]
+        if "total_value_fx_portfolio" in data:
+            data["total_value_fx_portfolio"] = data["price"] * data["shares"] * data["currency_fx_rate"]
+        data["marked_for_deletion"] = data.get("marked_for_deletion", False)
+
+    def _create_instance(self, data: Dict[str, Any], **kwargs) -> models.Model:
+        if "transaction_date" not in data:  # we might get only book date and not transaction date
+            data["transaction_date"] = data["book_date"]
+
+        return self.model.objects.create(**data, import_source=self.import_source)
+
+    def _get_instance(self, data: Dict[str, Any], history: Optional[models.QuerySet] = None, **kwargs) -> models.Model:
+        self.import_source.log += "\nGet Trade Instance."
+
+        if transaction_date := data.get("transaction_date"):
+            dates_lookup = {"transaction_date": transaction_date}
+        elif book_date := data.get("book_date"):
+            dates_lookup = {"book_date": book_date}
+        else:
+            raise DeserializationError("date lookup is missing from data")
+        self.import_source.log += f"\nParameter: Product={data['underlying_instrument']} Trade-Date={transaction_date} Shares={data['shares']}"
+
+        if history.exists():
+            queryset = history
+        else:
+            queryset = self.model.objects.filter(marked_for_deletion=False)
+
+        queryset = queryset.filter(
+            models.Q(underlying_instrument=data["underlying_instrument"])
+            & models.Q(**dates_lookup)
+            & models.Q(shares=data["shares"])
+        )
+
+        if _id := data.get("id", None):
+            self.import_source.log += f"ID {_id} provided -> Load CustomerTrade"
+            return self.model.objects.get(id=_id)
+        # We need to check for external identifiers
+        if external_id := data.get("external_id"):
+            self.import_source.log += f"\nExternal Identifier used: {external_id}"
+            queryset = queryset.filter(external_id=external_id)
+            if queryset.count() == 1:
+                self.import_source.log += f"External ID {external_id} provided -> Load CustomerTrade"
+                return queryset.first()
+
+        if portfolio := data.get("portfolio", None):
+            queryset = queryset.filter(portfolio=portfolio)
+        if queryset.exists():
+            if bank := data["bank"]:
+                self.import_source.log += (
+                    f"\n{queryset.count()} Trades found. The bank will tried to be matched against {bank}"
+                )
+                if queryset.filter(bank=bank).count() >= 1:  # exact match
+                    queryset = queryset.filter(bank=bank)
+                else:
+                    best_result = string_matching(bank, queryset.values_list("bank", flat=True))
+                    if best_result[1] >= 80:
+                        possible_trades = queryset.filter(bank=best_result[0])
+                        if possible_trades.count() > 1 and possible_trades.filter(claims__isnull=False).exists():
+                            possible_trades = possible_trades.filter(claims__isnull=False)
+                        if (
+                            possible_trades.count() >= 1
+                        ):  # If count is greater than 1, we get exact match so we return either trades
+                            queryset = possible_trades
+            if (queryset.count() > 1) and (price := data.get("price", None)):
+                if queryset.filter(price=price).count() == 1:
+                    queryset = queryset.filter(price=price)
+            if queryset.exists():
+                # We try to filter by price as well
+                trade = queryset.first()
+                if queryset.count() == 1:
+                    self.import_source.log += f"\nOne Trade found: {trade}"
+                if queryset.count() > 1:
+                    self.import_source.log += f"\nMultiple similar Trades found (returning first trade): {trade}"
+                return trade
+        self.import_source.log += "\nNo trade was successfully matched."
+
+    def _get_history(self, history: Dict[str, Any]) -> models.QuerySet:
+        trades = self.model.objects.filter(
+            exclude_from_history=False,
+            pending=False,
+            transaction_subtype__in=[
+                self.model.Type.SUBSCRIPTION,
+                self.model.Type.REDEMPTION,
+            ],  # we cannot exclude marked for deleted trade because otherwise they are never consider in the history
+        )
+        if transaction_date := history.get("transaction_date"):
+            trades = trades.filter(transaction_date__lte=transaction_date)
+        elif book_date := history.get("book_date"):
+            trades = trades.filter(book_date__lte=book_date)
+        if "underlying_instrument" in history:
+            trades = trades.filter(underlying_instrument__id=history["underlying_instrument"])
+        elif "underlying_instruments" in history:
+            trades = trades.filter(underlying_instrument__id__in=history["underlying_instruments"])
+        else:
+            raise ValueError("We cannot estimate history without at least the underlying instrument")
+        return trades
+
+    def _post_processing_objects(
+        self,
+        created_objs: list[models.Model],
+        modified_objs: list[models.Model],
+        unmodified_objs: list[models.Model],
+    ):
+        for instrument in set(
+            map(lambda x: x.underlying_instrument, filter(lambda t: t.is_customer_trade, created_objs + modified_objs))
+        ):
+            if instrument.instrument_type.key == "product":
+                update_outstanding_shares_as_task.delay(instrument.id)
+
+    def _post_processing_updated_object(self, _object):
+        if _object.marked_for_deletion:
+            _object.marked_for_deletion = False
+            _object.save()
+            self.import_source.log += "\nMarked for deletion reverted"
+        if _object.underlying_instrument.instrument_type == InstrumentType.PRODUCT:
+            _object.link_to_internal_trade()
+
+    def _post_processing_created_object(self, _object):
+        self._post_processing_updated_object(_object)
+
+    def _post_processing_history(self, history: models.QuerySet):
+        self.import_source.log += "===================="
+        self.import_source.log += "It was a historical import and the following Trades have to be deleted:"
+        for trade in history.order_by("transaction_date"):
+            self.import_source.log += (
+                f"{trade.transaction_date:%d.%m.%Y}: {trade.shares} {trade.bank} ==> Marked for deletion"
+            )
+            trade.marked_for_deletion = True
+            trade.save()

wbportfolio/import_export/parsers/default_mapping.py

@@ -0,0 +1,30 @@
+import numpy as np
+import pandas as pd
+
+
+def parse(import_source):
+    data = []
+    if (
+        (data_backend := import_source.source.data_backend)
+        and (backend_class := data_backend.backend_class)
+        and (default_mapping := getattr(backend_class, "DEFAULT_MAPPING"))
+    ):
+        df = pd.read_json(import_source.file, orient="records")
+        if not df.empty:
+            if date_label := getattr(backend_class, "DATE_LABEL", None):
+                df[date_label] = pd.to_datetime(df[date_label])
+                df = df.sort_values(by=date_label, ascending=True)
+                if reindex_method := getattr(backend_class, "REINDEX_METHOD", None):
+                    df = df.set_index(date_label)
+                    timeline = pd.date_range(start=df.index.min(), end=df.index.max(), freq="B")
+                    df = df.reindex(timeline, method=reindex_method)
+                    df = df.reset_index(names=date_label)
+                df[date_label] = df[date_label].dt.strftime("%Y-%m-%d")
+        df = df.replace([np.inf, -np.inf, np.nan], None).rename(columns=default_mapping)
+        df = df.drop(columns=df.columns.difference([*default_mapping.values()]))
+
+        if none_nullable_fields := getattr(backend_class, "NONE_NULLABLE_FIELDS", None):
+            df = df.dropna(subset=none_nullable_fields, how="any")
+
+        data = df.to_dict("records")
+    return {"data": data}

wbportfolio/import_export/parsers/jpmorgan/customer_trade.py

@@ -0,0 +1,63 @@
+import datetime
+import re
+
+import numpy as np
+import pandas as pd
+from wbportfolio.import_export.utils import convert_string_to_number
+from wbportfolio.models import Product, Trade
+
+
+def file_name_parse(file_name):
+    dates = re.findall("([0-9]{8})", file_name)
+
+    assert len(dates) > 0
+
+    parts_dict = {"valuation_date": datetime.datetime.strptime(dates[0], "%Y%m%d").date()}
+
+    isin = re.findall("([A-Z]{2}[A-Z0-9]{9}[0-9]{1})", file_name)
+
+    if len(isin) > 0:
+        parts_dict["isin"] = isin[0]
+
+    return parts_dict
+
+
+def parse(import_source):
+    # Load files into a CSV DictReader
+    df = pd.read_csv(import_source.file, encoding="latin1", delimiter=",")
+    df = df.replace([np.inf, -np.inf, np.nan], None)
+    # Parse the Parts of the filename into the different parts
+    parts = file_name_parse(import_source.file.name)
+    df["Trade Date"] = pd.to_datetime(df["Trade Date"], format="%Y%m%d")
+    # Get the valuation date from the parts list
+    valuation_date = parts["valuation_date"]
+
+    # Iterate through the CSV File and parse the data into a list
+    data = list()
+    for nominal_data in df.to_dict("records"):
+        product = Product.objects.get(isin=nominal_data["ISIN"])
+        shares = convert_string_to_number(nominal_data["Quantity"])
+
+        # Check whether it is a buy or a sell and convert the value correspondely
+        shares = shares if nominal_data["Side"] == "S" else shares * -1
+        portfolio = product.primary_portfolio
+        data.append(
+            {
+                "underlying_instrument": {"id": product.id, "instrument_type": "product"},
+                "transaction_date": nominal_data["Trade Date"].strftime("%Y-%m-%d"),
+                "shares": shares,
+                "portfolio": portfolio.id,
+                # 'currency': product.currency.key,
+                "transaction_subtype": Trade.Type.REDEMPTION if shares < 0 else Trade.Type.SUBSCRIPTION,
+                "bank": nominal_data["CounterParty Name"],
+                "price": convert_string_to_number(nominal_data["Price"]),
+            }
+        )
+    import_data = {"data": data}
+    if "isin" in parts:
+        product = Product.objects.get(isin=parts["isin"])
+        import_data["history"] = {
+            "underlying_instrument": product.id,
+            "transaction_date": valuation_date.strftime("%Y-%m-%d"),
+        }
+    return import_data

wbportfolio/import_export/parsers/jpmorgan/fees.py

@@ -0,0 +1,64 @@
+import datetime
+import logging
+import re
+
+import numpy as np
+import pandas as pd
+from wbportfolio.import_export.utils import convert_string_to_number
+from wbportfolio.models import Fees, Product
+
+logger = logging.getLogger("importers.parsers.jpmorgan.fee")
+
+
+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):
+    df = pd.read_csv(import_source.file, encoding="utf-16", delimiter=",")
+    df["Date"] = pd.to_datetime(df["Date"])
+
+    columns_fees = df.columns.difference(["ISIN", "CCY"])
+    df[columns_fees] = df[columns_fees].where(pd.notnull(df[columns_fees]), 0)
+    df = df.replace([np.inf, -np.inf, np.nan], None)
+
+    # Iterate through the CSV File and parse the data into a list
+    data = list()
+
+    for fee_data in df.to_dict("records"):
+        product = Product.objects.get(isin=fee_data["ISIN"])
+        fee_date = fee_data["Date"]
+        base_data = {
+            "portfolio": product.primary_portfolio.id,
+            "linked_product": product.id,
+            "transaction_date": fee_date.strftime("%Y-%m-%d"),
+            "calculated": False,
+        }
+        data.append(
+            {
+                "transaction_subtype": Fees.Type.PERFORMANCE,
+                "total_value": round(convert_string_to_number(fee_data.get("Perf_Fee * Units", 0)), 4),
+                "total_value_gross": round(convert_string_to_number(fee_data.get("Perf_Fee * Units", 0)), 4),
+                **base_data,
+            }
+        )
+        data.append(
+            {
+                "transaction_subtype": Fees.Type.MANAGEMENT,
+                "total_value": round(convert_string_to_number(fee_data.get("Mgmt_Fee * Units", 0)), 4),
+                **base_data,
+            }
+        )
+        data.append(
+            {
+                "transaction_subtype": Fees.Type.ISSUER,
+                "total_value": round(convert_string_to_number(fee_data.get("JPM_Fee * Units", 0)), 4),
+                **base_data,
+            }
+        )
+
+    return {"data": data}

wbportfolio/import_export/parsers/jpmorgan/strategy.py

@@ -0,0 +1,116 @@
+import datetime
+import logging
+import re
+
+import numpy as np
+import pandas as pd
+from wbportfolio.import_export.utils import convert_string_to_number
+
+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 manually_create_100_position(parent_strategies, valuation_date):
+    data = []
+    from wbportfolio.models import Index, Product
+
+    for strategy_ticker in parent_strategies:
+        if index := Index.objects.filter(ticker=strategy_ticker).first():
+            for product in Product.objects.filter(ticker=strategy_ticker):
+                valuations = product.valuations.filter(date__lte=valuation_date)
+                last_price = 0
+                if valuations.exists():
+                    last_price = float(valuations.latest("date").net_value)
+                data.append(
+                    {
+                        "underlying_instrument": index.id,
+                        "portfolio": {"instrument_type": "product", "id": product.id},
+                        "currency__key": index.currency.key,
+                        "initial_currency_fx_rate": 1.0,
+                        "weighting": 1.0,
+                        "is_estimated": True,  # this position is not a real position, it is created by the importer.
+                        "initial_price": last_price,
+                        "date": valuation_date.strftime("%Y-%m-%d"),
+                    }
+                )
+    return data
+
+
+def parse(import_source):
+    # Load file into a CSV DictReader
+
+    df = pd.read_csv(import_source.file, encoding="utf-16", delimiter=",")
+    df = df.replace([np.inf, -np.inf, np.nan], None)
+
+    # Parse the Parts of the filename into the different parts
+    parts = file_name_parse(import_source.file.name)
+
+    # Get the valuation date from the parts list
+    valuation_date = parts["valuation_date"]
+
+    # Iterate through the CSV File and parse the data into a list
+    data = list()
+    parents_strategies = set()
+    for strategy_data in df.to_dict("records"):
+        bbg_tickers = strategy_data["BBG Ticker"].split(" ")
+        exchange = None
+        if len(bbg_tickers) == 2:
+            ticker = bbg_tickers[0]
+            instrument_type = bbg_tickers[1]
+        elif len(bbg_tickers) == 3:
+            ticker = bbg_tickers[0]
+            exchange = bbg_tickers[1]
+            instrument_type = bbg_tickers[2]
+
+        strategy = strategy_data["Strategy Ticker"].replace("Index", "").strip()
+        strategy_currency_key = strategy_data["Strategy CCY"]
+
+        position_currency_key = strategy_data["Position CCY"]
+
+        isin = strategy_data["Position ISIN"]
+        name = strategy_data["Position Description"]
+        initial_price = convert_string_to_number(strategy_data["Prices"])
+        initial_currency_fx_rate = convert_string_to_number(strategy_data["Fx Rates"])
+        if exchange:
+            exchange = {"bbg_exchange_codes": exchange}
+        try:
+            weighting = convert_string_to_number(strategy_data["Weight In Percent"].replace("%", "")) / 100
+        except Exception:
+            weighting = 0.0
+        underlying_instrument = {
+            "ticker": ticker,
+            "exchange": exchange,
+            "isin": isin,
+            "name": name,
+            "currency__key": position_currency_key,
+            "instrument_type": instrument_type.lower(),
+        }
+        if isin:
+            underlying_instrument["isin"] = isin
+        data.append(
+            {
+                "underlying_instrument": underlying_instrument,
+                "portfolio": {
+                    "instrument_type": "index",
+                    "ticker": strategy,
+                    "currency__key": strategy_currency_key,
+                },
+                "exchange": exchange,
+                "is_estimated": False,
+                "currency__key": position_currency_key,
+                "initial_currency_fx_rate": initial_currency_fx_rate,
+                "weighting": weighting,
+                "initial_price": initial_price,
+                "date": valuation_date.strftime("%Y-%m-%d"),
+            }
+        )
+        parents_strategies.add(strategy)
+    manual_data = manually_create_100_position(parents_strategies, valuation_date)
+    return {"data": data + manual_data}

wbportfolio/import_export/parsers/jpmorgan/valuation.py

@@ -0,0 +1,41 @@
+import datetime
+import logging
+import re
+
+import numpy as np
+import pandas as pd
+from wbportfolio.import_export.utils import convert_string_to_number
+from wbportfolio.models import Product
+
+logger = logging.getLogger("importers.parsers.jpmorgan.index")
+
+
+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):
+    # Load files into a CSV DictReader
+    df = pd.read_csv(import_source.file, encoding="utf-16", delimiter=",")
+    df = df.replace([np.inf, -np.inf, np.nan], None)
+
+    # Iterate through the CSV File and parse the data into a list
+    data = list()
+    for price_data in df.to_dict("records"):
+        product = Product.objects.get(isin=price_data["ISIN"])
+        date = datetime.datetime.strptime(price_data["Date"], "%d-%b-%y")
+
+        data.append(
+            {
+                "instrument": {"instrument_type": "product", "id": product.id},
+                "date": date.strftime("%Y-%m-%d"),
+                "net_value": round(convert_string_to_number(price_data["Indicative_MID"]), 4),
+                "calculated": False,
+            }
+        )
+
+    return {"data": data}

wbportfolio/import_export/parsers/leonteq/customer_trade.py

@@ -0,0 +1,47 @@
+from contextlib import suppress
+
+import pandas as pd
+from wbportfolio.models import Product, Trade
+
+
+def parse(import_source):
+    data = list()
+    df = pd.DataFrame()
+    try:
+        df = pd.read_excel(
+            import_source.file.read(),
+            engine="openpyxl",
+            index_col=1,
+            sheet_name="TRANSACTION CONSOLIDATION",
+            skiprows=3,
+        ).dropna(axis=1)
+        df["DATE"] = pd.to_datetime(df["DATE"], dayfirst=True)
+        df = df[df["EVENT"] == "AMC Cash"]
+    except (ValueError, IndexError):
+        pass
+    if not df.empty:
+        for external_id, trade in df.to_dict("index").items():
+            with suppress(Product.DoesNotExist):
+                product = Product.objects.get(isin=trade["AMC ISIN"])
+                shares = (-1 * trade["TOTAL QUANTITY"]) / product.share_price
+                price = trade["GROSS PRICE"] * product.share_price
+                portfolio = product.primary_portfolio
+                data.append(
+                    {
+                        "underlying_instrument": {"id": product.id, "instrument_type": "product"},
+                        "portfolio": portfolio.id,
+                        "transaction_date": trade["DATE"].strftime("%Y-%m-%d"),
+                        "shares": shares,
+                        "external_id": external_id,
+                        "transaction_subtype": Trade.Type.REDEMPTION if shares < 0 else Trade.Type.SUBSCRIPTION,
+                        "bank": "Leonteq Cash Transfer",
+                        "currency__key": product.currency.key,
+                        "price": price,
+                        "total_value": trade["NET AMOUNT"],
+                        "total_value_gross": trade["GROSS AMOUNT"],
+                        "currency_fx_rate": trade["BOOKING FX"],
+                        "total_value_fx_portfolio": trade["BOOKING NET AMOUNT"],
+                    }
+                )
+
+    return {"data": data}

wbportfolio/import_export/parsers/leonteq/equity.py

@@ -0,0 +1,81 @@
+import re
+from datetime import datetime
+from io import BytesIO
+
+import numpy as np
+import pandas as pd
+from wbportfolio.models import Product
+
+FIELD_MAP = {
+    "CCY": "currency__key",
+    "CURRENT PRICE": "initial_price",
+    "FX": "initial_currency_fx_rate",
+    "TOTAL UNITS": "initial_shares",
+    "TYPE": "underlying_instrument__instrument_type",
+    "NAME": "underlying_instrument__name",
+    "ISIN": "underlying_instrument__isin",
+    "WEIGHT (%)": "weighting",
+}
+
+
+def parse(import_source):
+    data = list()
+
+    isin_regex = "([A-Z]{2}[A-Z0-9]{9}[0-9]{1})"
+
+    dict_df = pd.read_excel(BytesIO(import_source.file.read()), engine="openpyxl", sheet_name=None)
+
+    for sheet_name, df in dict_df.items():
+        if len(re.findall(isin_regex, sheet_name)) > 0:
+            valuation_date = datetime.strptime(df.iloc[0, 1].split("AMC OVERVIEW REPORT AS OF ")[-1], "%d.%m.%Y")
+            if valuation_date.weekday() not in [5, 6]:
+                xx, yy = np.where(df == "COMPOSITION DATA")
+                df = df.iloc[xx[0] + 1 :, yy[0] :]
+                df = df.rename(columns=df.iloc[0]).drop(df.index[0]).dropna(how="all").rename(columns=FIELD_MAP)
+
+                df = df[
+                    (df["underlying_instrument__instrument_type"].isin(["CASH", "SHARE"]))
+                    & (df["N"].astype("str").str.isnumeric())
+                ]
+
+                equities_index = df["underlying_instrument__instrument_type"] == "SHARE"
+                df.loc[~equities_index, "initial_shares"] = df.loc[~equities_index, "TOTAL VALUE"]
+                df.loc[~equities_index, "initial_price"] = 1.0
+                df.initial_currency_fx_rate = df.initial_currency_fx_rate.fillna(1.0)
+                # df["weighting"] = df.initial_currency_fx_rate * df.initial_price * df.initial_shares
+                # df["weighting"] = df.weighting / df.weighting.sum()
+                product = Product.objects.get(isin=sheet_name)
+                for position in df.to_dict("records"):
+                    if position["underlying_instrument__instrument_type"] == "CASH":
+                        ticker = exchange = "CASH"
+                    else:
+                        ticker, exchange, _ = str(position["BBG TICKER / IDENTIFIER"]).split(" ")
+
+                    if position["underlying_instrument__instrument_type"] == "SHARE":
+                        underlying_instrument = {
+                            "ticker": ticker,
+                            "exchange": {"bbg_exchange_codes": exchange},
+                            "name": position["underlying_instrument__name"],
+                            "currency__key": position["currency__key"],
+                            "instrument_type": "equity",
+                            "isin": position["underlying_instrument__isin"],
+                        }
+                    else:
+                        underlying_instrument = {"currency__key": position["currency__key"], "instrument_type": "cash"}
+                    data.append(
+                        {
+                            "underlying_instrument": underlying_instrument,
+                            "currency__key": position["currency__key"],
+                            "is_estimated": False,
+                            "date": valuation_date.strftime("%Y-%m-%d"),
+                            "asset_valuation_date": valuation_date.strftime("%Y-%m-%d"),
+                            "initial_price": position["initial_price"],
+                            "initial_currency_fx_rate": position["initial_currency_fx_rate"],
+                            "initial_shares": position["initial_shares"],
+                            "weighting": position["weighting"],
+                            "exchange": {"bbg_exchange_codes": exchange},
+                            "portfolio": {"instrument_type": "product", "id": product.id},
+                        }
+                    )
+
+    return {"data": data}