wbportfolio 1.52.0__py2.py3-none-any.whl → 1.59.4__py2.py3-none-any.whl

wbportfolio/import_export/parsers/jpmorgan/strategy.py

@@ -12,106 +12,80 @@ 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_quote": 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
+    if dates:
+        return {"valuation_date": datetime.datetime.strptime(dates[0], "%Y%m%d").date()}
+    return {}
 
 
 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"]
+    report_date = parts.get("valuation_date")
 
     # Iterate through the CSV File and parse the data into a list
     data = list()
-    parents_strategies = set()
+    if "Date" in df.columns:
+        df["Date"] = pd.to_datetime(df["Date"])
+    df.replace([np.inf, -np.inf, np.nan], None, inplace=True)
     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_quote = {
-            "ticker": ticker,
-            "exchange": exchange,
-            "isin": isin,
-            "name": name,
-            "currency__key": position_currency_key,
-            "instrument_type": instrument_type.lower(),
-        }
-        if isin:
-            underlying_quote["isin"] = isin
-        data.append(
-            {
-                "underlying_quote": underlying_quote,
-                "portfolio": {
-                    "instrument_type": "index",
-                    "ticker": strategy,
-                    "currency__key": strategy_currency_key,
-                },
+        valuation_date = strategy_data.get("Date", report_date)
+        if valuation_date:
+            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_quote = {
+                "ticker": ticker,
                 "exchange": exchange,
-                "is_estimated": False,
+                "isin": isin,
+                "name": name,
                 "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"),
+                "instrument_type": instrument_type.lower(),
             }
-        )
-        parents_strategies.add(strategy)
-    manual_data = manually_create_100_position(parents_strategies, valuation_date)
-    return {"data": data + manual_data}
+            if isin:
+                underlying_quote["isin"] = isin
+            data.append(
+                {
+                    "underlying_quote": underlying_quote,
+                    "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"),
+                }
+            )
+    return {"data": data}

wbportfolio/import_export/parsers/jpmorgan/valuation.py

@@ -13,8 +13,8 @@ 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"
-
+    if len(dates) != 1:
+        raise ValueError("Not exactly 1 date found in the filename")
     return {"valuation_date": datetime.datetime.strptime(dates[0], "%Y%m%d").date()}
 
 

wbportfolio/import_export/parsers/leonteq/customer_trade.py

@@ -1,4 +1,5 @@
 from contextlib import suppress
+from io import BytesIO
 
 import pandas as pd
 
@@ -10,7 +11,7 @@ def parse(import_source):
     df = pd.DataFrame()
     try:
         df = pd.read_excel(
-            import_source.file.read(),
+            BytesIO(import_source.file.read()),
             engine="openpyxl",
             index_col=1,
             sheet_name="TRANSACTION CONSOLIDATION",
@@ -25,7 +26,8 @@ def parse(import_source):
             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
+                price = trade["NET PRICE"] * product.share_price
+                price_gross = trade["GROSS PRICE"] * product.share_price
                 portfolio = product.primary_portfolio
                 data.append(
                     {
@@ -38,10 +40,8 @@ def parse(import_source):
                         "bank": "Leonteq Cash Transfer",
                         "currency__key": product.currency.key,
                         "price": price,
-                        "total_value": trade["NET AMOUNT"],
-                        "total_value_gross": trade["GROSS AMOUNT"],
+                        "price_gross": price_gross,
                         "currency_fx_rate": trade["BOOKING FX"],
-                        "total_value_fx_portfolio": trade["BOOKING NET AMOUNT"],
                     }
                 )
 

wbportfolio/import_export/parsers/leonteq/fees.py

@@ -1,3 +1,5 @@
+from io import BytesIO
+
 import pandas as pd
 
 from wbportfolio.models import Fees
@@ -8,7 +10,11 @@ def parse(import_source):
     df = pd.DataFrame()
     try:
         df = pd.read_excel(
-            import_source.file.read(), engine="openpyxl", sheet_name="FEE_CONSOLIDATION", header=[0, 2], skiprows=1
+            BytesIO(import_source.file.read()),
+            engine="openpyxl",
+            sheet_name="FEE_CONSOLIDATION",
+            header=[0, 2],
+            skiprows=1,
         ).dropna(axis=1)
     except (ValueError, IndexError):
         pass
@@ -19,15 +25,13 @@ def parse(import_source):
 
             product_fees_df = product_fees_df.rename(
                 columns={
-                    "TRADE DATE": "transaction_date",
+                    "TRADE DATE": "fee_date",
                     "INDEX SPONSOR FEE": "total_value",
                     "BUSINESS EVENT": "transaction_subtype",
                 }
             )
 
-            product_fees_df.loc[:, "transaction_date"] = pd.to_datetime(
-                product_fees_df.loc[:, "transaction_date"], dayfirst=True
-            )
+            product_fees_df.loc[:, "fee_date"] = pd.to_datetime(product_fees_df.loc[:, "fee_date"], dayfirst=True)
 
             management_fees_eur = product_fees_df[
                 product_fees_df.loc[:, "transaction_subtype"] == "Management Fee EUR"
@@ -50,8 +54,8 @@ def parse(import_source):
             product_fees_df = product_fees_df.where(pd.notnull(product_fees_df), None)
             for fees in product_fees_df.to_dict("records"):
                 base_data = {
-                    "linked_product": {"isin": isin},
-                    "transaction_date": fees["transaction_date"].strftime("%Y-%m-%d"),
+                    "product": {"isin": isin},
+                    "fee_date": fees["fee_date"].strftime("%Y-%m-%d"),
                     "calculated": False,
                 }
 

wbportfolio/import_export/parsers/leonteq/trade.py

@@ -10,7 +10,8 @@ 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"
+    if len(isin) != 1:
+        raise ValueError("Not exactly 1 isin found in the filename")
 
     return {"isin": isin[0]}
 
@@ -24,11 +25,8 @@ _fields_map = {
     "TOTAL QUANTITY": "shares",
     "GROSS PRICE": "price_gross",
     "NET PRICE": "price",
-    "total_value_gross": "total_value_gross",
     "currency_fx_rate": "currency_fx_rate",
     "NET AMOUNT": "total_value",
-    "GROSS AMOUNT": "total_value_gross_fx_portfolio",
-    "total_value_fx_portfolio": "total_value_fx_portfolio",
     "N°": "external_id",
 }
 
@@ -78,8 +76,6 @@ def parse(import_source):
     df["exchange"] = df["IDENTIFIER"].apply(lambda x: _get_exchange(x))
     df["currency_fx_rate"] = df["BOOKING FX"] * df["BASE CCY FX"]
 
-    df["total_value_gross"] = df["total_value_gross_fx_portfolio"] / df["BOOKING FX"]
-    df["total_value_fx_portfolio"] = df["total_value"] * df["currency_fx_rate"]
     df = df.drop(df.columns.difference(_fields_map.values()), axis=1)
     df["portfolio"] = product.primary_portfolio.id
 

wbportfolio/import_export/parsers/natixis/d1_fees.py

@@ -37,8 +37,8 @@ def parse(import_source):
             management_fees = row[management_fees_column].value
 
             base_data = {
-                "linked_product": {"isin": isin},
-                "transaction_date": valuation_date.strftime("%Y-%m-%d"),
+                "product": {"isin": isin},
+                "fee_date": valuation_date.strftime("%Y-%m-%d"),
                 "calculated": False,
             }
             if management_fees != 0:

wbportfolio/import_export/parsers/natixis/dividend.py

@@ -10,10 +10,9 @@ COLUMN_MAP = {
     "Div Crncy": "currency__key",
     "Quantity": "shares",
     "Fx Rate": "currency_fx_rate",
-    "Net Amount": "total_value_fx_portfolio",
     "Retro in%": "retrocession",
     "Gross Div": "price_gross",
-    "Ex Div Date": "transaction_date",
+    "Ex Div Date": "ex_date",
     "Value Date": "value_date",
 }
 
@@ -29,25 +28,21 @@ def parse(import_source):
         lambda x: _get_exchange_from_ticker(x)
     )
     df["underlying_instrument__ticker"] = df["underlying_instrument__ticker"].apply(lambda x: _get_ticker(x))
-    df["transaction_date"] = pd.to_datetime(df["transaction_date"], dayfirst=True).dt.strftime("%Y-%m-%d")
+    df["ex_date"] = pd.to_datetime(df["ex_date"], dayfirst=True).dt.strftime("%Y-%m-%d")
     df["value_date"] = pd.to_datetime(df["value_date"], dayfirst=True).dt.strftime("%Y-%m-%d")
     df = df[df["underlying_instrument__isin"].str.contains("([A-Z]{2})([A-Z0-9]{9})([0-9]{1})", regex=True)]
-    float_columns = ["shares", "total_value_fx_portfolio", "price_gross", "currency_fx_rate", "retrocession"]
+    float_columns = ["shares", "price_gross", "currency_fx_rate", "retrocession"]
     for float_column in float_columns:
         df[float_column] = df[float_column].str.replace(" ", "").astype("float")
     df = df.drop(columns=df.columns.difference(COLUMN_MAP.values()))
 
     df["retrocession"] = df["retrocession"] / 100.0
-    df["total_value"] = df["total_value_fx_portfolio"] / df["currency_fx_rate"]
-    df["price"] = df["total_value"] / df["shares"] / df["retrocession"]
-    df["total_value_gross"] = df["price_gross"] * df["shares"] * df["retrocession"]
-    df["total_value_gross_fx_portfolio"] = df["total_value_gross"] * df["currency_fx_rate"]
     df["portfolio"] = [{"instrument_type": "product", **product_data}] * df.shape[0]
     df = df.replace([np.inf, -np.inf, np.nan], None)
     return {
         "data": df.to_dict("records"),
         "history": {
-            "transaction_date": parts["valuation_date"].strftime("%Y-%m-%d"),
+            "value_date": parts["valuation_date"].strftime("%Y-%m-%d"),
             "product": product_data,
         },
     }

wbportfolio/import_export/parsers/natixis/equity.py

@@ -1,3 +1,5 @@
+from zipfile import BadZipFile
+
 import numpy as np
 import pandas as pd
 
@@ -29,15 +31,28 @@ def _apply_adjusting_factor(row):
 def parse(import_source):
     # Parse the Parts of the filename into the different parts
     parts = file_name_parse_isin(import_source.file.name)
-
     # Get the valuation date and investment from the parts list
     valuation_date = parts["valuation_date"]
     product_data = parts["product"]
 
     # Load file into a CSV DictReader
-    df = pd.read_csv(import_source.file, encoding="utf-16", delimiter=";")
+    if import_source.file.name.lower().endswith(".csv"):
+        df = pd.read_csv(import_source.file, encoding="utf-16", delimiter=";")
+    else:
+        try:
+            df = pd.read_excel(import_source.file, engine="openpyxl", sheet_name="Basket Valuation")
+        except BadZipFile:
+            df = pd.read_excel(import_source.file, engine="xlrd", sheet_name="Basket Valuation")
+        xx, yy = np.where(df.isin(["Ticker", "Code"]))
+        if xx.size > 0 and yy.size > 0:
+            df = df.iloc[xx[0] :, yy[0] :]
+            df = df.rename(columns=df.iloc[0]).drop(df.index[0]).dropna(how="all")
+            df["Quotity/Adj. factor"] = 1.0
+            df = df.rename(columns={"Code": "Ticker"})
+        else:
+            return {}
     df = df.rename(columns=FIELD_MAP)
-    df = df.dropna(subset=["initial_price"])
+    df = df.dropna(subset=["initial_price", "Name"], how="any")
     df["initial_price"] = df["initial_price"].astype("str").str.replace(" ", "").astype("float")
     df["underlying_quote"] = df[["Ticker", "Name", "currency__key"]].apply(
         lambda x: _get_underlying_instrument(*x), axis=1
@@ -50,7 +65,10 @@ def parse(import_source):
     df = df.drop(columns=df.columns.difference(FIELD_MAP.values()))
 
     df["portfolio__instrument_type"] = "product"
-    df["portfolio__isin"] = product_data["isin"]
+    if "isin" in product_data:
+        df["portfolio__isin"] = product_data["isin"]
+    if "ticker" in product_data:
+        df["portfolio__ticker"] = product_data["ticker"]
     df["is_estimated"] = False
     df["date"] = valuation_date.strftime("%Y-%m-%d")
     df["asset_valuation_date"] = pd.to_datetime(df["asset_valuation_date"], dayfirst=True).dt.strftime("%Y-%m-%d")

wbportfolio/import_export/parsers/natixis/fees.py

@@ -4,7 +4,7 @@ from pandas.tseries.offsets import BDay
 from .utils import file_name_parse_isin
 
 FIELD_MAP = {
-    "Date": "transaction_date",
+    "Date": "fee_date",
     "Manag. Fees Natixis": "ISSUER",
     "Manag. Fees Client": "MANAGEMENT",
     "Perf fees amount": "PERFORMANCE",
@@ -21,30 +21,28 @@ def parse(import_source):
     df = pd.read_csv(import_source.file, encoding="utf-8", delimiter=";")
     df = df.rename(columns=FIELD_MAP)
     df = df.drop(columns=df.columns.difference(FIELD_MAP.values()))
-    df["transaction_date"] = pd.to_datetime(df["transaction_date"], dayfirst=True)
+    df["fee_date"] = pd.to_datetime(df["fee_date"], dayfirst=True)
 
     # Switch the weeekend day fees to the next monday
-    df["transaction_date"] = df["transaction_date"].apply(lambda x: x + BDay(1) if x.weekday() in [5, 6] else x)
+    df["fee_date"] = df["fee_date"].apply(lambda x: x + BDay(1) if x.weekday() in [5, 6] else x)
 
     # Ensure float columns are number
     for col in ["MANAGEMENT", "ISSUER", "PERFORMANCE"]:
         df[col] = df[col].astype("str").str.replace(" ", "").astype("float")
 
     # Groupby and sum similar fees (e.g. Monday)
-    df = df.groupby("transaction_date").sum().reset_index()
+    df = df.groupby("fee_date").sum().reset_index()
     df = pd.melt(
         df,
-        id_vars=["transaction_date"],
+        id_vars=["fee_date"],
         value_vars=["MANAGEMENT", "ISSUER", "PERFORMANCE"],
         var_name="transaction_subtype",
         value_name="total_value",
     )
     df = df[df["total_value"] != 0]
 
-    df["linked_product"] = [product] * df.shape[0]
-    df["transaction_date"] = df["transaction_date"].dt.strftime("%Y-%m-%d")
+    df["product"] = [product] * df.shape[0]
+    df["fee_date"] = df["fee_date"].dt.strftime("%Y-%m-%d")
     df["calculated"] = False
     df["total_value_gross"] = df["total_value"]
-    df["total_value_fx_portfolio"] = df["total_value"]
-    df["total_value_gross_fx_portfolio"] = df["total_value"]
     return {"data": df.to_dict("records")}

wbportfolio/import_export/parsers/natixis/utils.py

@@ -1,6 +1,7 @@
-import datetime
 import re
 
+from django.utils.dateparse import parse_date
+
 from wbportfolio.models import Product
 
 INSTRUMENT_MAP_NAME = {"EDA23_AtonRa Z class": "LU2170995018"}
@@ -53,21 +54,14 @@ def _get_underlying_instrument(bbg_code, name, currency, instrument_type="equity
 
 
 def file_name_parse_isin(file_name):
-    dates = re.findall(r"_([0-9]{4}-?[0-9]{2}-?[0-9]{2})", file_name)
-    identifier = re.findall(r"([A-Z]{2}(?![A-Z]{10}\b)[A-Z0-9]{10})_", file_name)
-    assert len(dates) == 2, "Not 2 dates found in the filename"
-    assert len(identifier) == 1, "Not exactly 1 identifier found in the filename"
-    try:
-        valuation_date = datetime.datetime.strptime(dates[0], "%Y-%m-%d").date()
-    except ValueError:
-        valuation_date = datetime.datetime.strptime(dates[0], "%Y%m%d").date()
-    try:
-        generation_date = datetime.datetime.strptime(dates[1], "%Y-%m-%d").date()
-    except ValueError:
-        generation_date = datetime.datetime.strptime(dates[1], "%Y%m%d").date()
-
-    return {
-        "product": {"isin": identifier[0]},
-        "valuation_date": valuation_date,
-        "generation_date": generation_date,
-    }
+    dates = re.findall(r"_([0-9]{4}[-_]?[0-9]{2}[-_]?[0-9]{2})", file_name)
+    isin = re.findall(r"([A-Z]{2}(?![A-Z]{10}\b)[A-Z0-9]{10})_", file_name)
+    ticker = re.findall(r"(NX[A-Z]*)_", file_name)
+    if len(dates) == 0:
+        raise ValueError("Not dates found in the filename")
+    res = {"valuation_date": parse_date(dates[0].replace("_", "-"))}
+    if len(isin) >= 1:
+        res["product"] = {"isin": isin[0]}
+    elif len(ticker) == 1:
+        res["product"] = {"ticker": ticker[0]}
+    return res

wbportfolio/import_export/parsers/sg_lux/customer_trade_pending_slk.py

@@ -129,7 +129,7 @@ def parse(import_source):
         )
 
         df["bank"] = df["REGISTER_DEAL_NAME"]
-        df["external_identifier2"] = df["NORDER"]
+        df["external_id_alternative"] = df["NORDER"]
         df["register__register_reference"] = df["REGISTER_ID1"]
         df["external_id"] = df.apply(assemble_transaction_reference, axis=1)
 

wbportfolio/import_export/parsers/sg_lux/equity.py

@@ -11,9 +11,10 @@ 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"
+    if len(dates) != 2:
+        raise ValueError("Not 2 dates found in the filename")
+    if len(isin) != 1:
+        raise ValueError("Not exactly 1 isin found in the filename")
 
     return {
         "isin": isin[0],
@@ -76,13 +77,13 @@ def parse(import_source):
     }
 
     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)
+    df["initial_currency_fx_rate"] = df["initial_currency_fx_rate"].apply(lambda x: 1 / x if x else 1).round(14)
 
     cash_mask = df["Accounting category"].isin(["T111"])
     cash = (
         df.loc[
             cash_mask,
-            ["currency__key", "initial_currency_fx_rate", "portfolio", "date", "initial_price", "initial_shares"],
+            ["currency__key", "initial_currency_fx_rate", "portfolio", "date", "initial_shares"],
         ]
         .groupby(
             [
@@ -94,21 +95,20 @@ def parse(import_source):
         .agg(
             {
                 "initial_currency_fx_rate": "mean",
-                "initial_price": "mean",
                 "initial_shares": "sum",
             }
         )
         .reset_index()
     ).copy()
     cash["underlying_quote"] = cash["currency__key"].apply(lambda x: {"currency__key": x, "instrument_type": "cash"})
-
+    cash["initial_price"] = 1.0
     # 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"],
+            ["currency__key", "initial_currency_fx_rate", "portfolio", "date", "initial_shares"],
         ]
         .groupby(
             [
@@ -120,7 +120,6 @@ def parse(import_source):
         .agg(
             {
                 "initial_currency_fx_rate": "mean",
-                "initial_price": "mean",
                 "initial_shares": "sum",
             }
         )
@@ -129,9 +128,11 @@ def parse(import_source):
     cash_equivalents["underlying_quote"] = cash_equivalents["currency__key"].apply(
         lambda x: {"currency__key": x, "instrument_type": "cash_equivalent"}
     )
+    cash_equivalents["initial_price"] = 1.0
 
     # 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_quote"] = equities.apply(lambda x: get_underlying_quote(x), axis=1)
         equities["exchange"] = equities.apply(lambda x: get_exchange(x), axis=1)
@@ -140,7 +141,6 @@ def parse(import_source):
         del equities["Bloom Ticker"]
         del equities["Asset description"]
     df = pd.concat([cash, equities, cash_equivalents])
-
     df["asset_valuation_date"] = df["date"]
     # Rename the columns
 

wbportfolio/import_export/parsers/sg_lux/fees.py

@@ -40,12 +40,12 @@ def parse(import_source):
             date = datetime.datetime.strptime(fee_data["NAV Date"], "%Y/%m/%d")
             data.append(
                 {
-                    "linked_product": {
+                    "product": {
                         "parent__identifier": fee_data["Code"],
                         "currency__key": fee_data["Local ccy"],
                         "identifier": share_class,
                     },
-                    "transaction_date": date.strftime("%Y-%m-%d"),
+                    "fee_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),

wbportfolio/import_export/parsers/sg_lux/perf_fees.py

@@ -26,7 +26,7 @@ def parse(import_source):
         date = datetime.datetime.strptime(fee_data[0], "%m/%d/%Y")
         data.append(
             {
-                "linked_product": {"isin": isin},
+                "product": {"isin": isin},
                 "transaction_date": date.strftime("%Y-%m-%d"),
                 "calculated": False,
                 "transaction_subtype": Fees.Type.PERFORMANCE,
@@ -35,7 +35,7 @@ def parse(import_source):
         )
         data.append(
             {
-                "linked_product": {"isin": isin},
+                "product": {"isin": isin},
                 "transaction_date": date.strftime("%Y-%m-%d"),
                 "calculated": False,
                 "transaction_subtype": Fees.Type.PERFORMANCE_CRYSTALIZED,