wbportfolio 1.50.14__py2.py3-none-any.whl → 1.51.0__py2.py3-none-any.whl

wbportfolio/analysis/claims.py

@@ -228,7 +228,12 @@ class ConsolidatedTradeSummary:
                 ),
                 fill_value=0,
             )
-            return df.reset_index().dropna()[["id", "aum_sparkline"]].groupby("id").agg(list)
+            df = df.reset_index().dropna()[["id", "date", "aum_sparkline"]]
+            return (
+                df.groupby("id")
+                .apply(lambda o: list(zip(o["date"].dt.strftime("%Y-%m-%d"), o["aum_sparkline"])))
+                .rename("aum_sparkline")
+            )
         return pd.DataFrame()
 
     def get_initial_investment_date_df(self) -> pd.DataFrame:

wbportfolio/import_export/handlers/dividend.py

@@ -23,7 +23,7 @@ class DividendImportHandler(ImportExportHandler):
         data["value_date"] = datetime.strptime(data["value_date"], "%Y-%m-%d").date()
         from wbportfolio.models import Portfolio
 
-        data["portfolio"] = Portfolio.all_objects.get(id=data["portfolio"])
+        data["portfolio"] = Portfolio._get_or_create_portfolio(self.instrument_handler, data.get("portfolio"))
         instrument = self.instrument_handler.process_object(
             data["underlying_instrument"], only_security=False, read_only=True
         )[0]
@@ -61,12 +61,22 @@ class DividendImportHandler(ImportExportHandler):
         return self.model.objects.create(**data, import_source=self.import_source)
 
     def _get_history(self: models.Model, history: Dict[str, Any]) -> models.QuerySet:
+        from wbportfolio.models import Product
+
         val_date = datetime.strptime(history["transaction_date"], "%Y-%m-%d")
-        if portfolio_id := history.get("portfolio", None):
-            dividends = self.model.objects.filter(transaction_date__lte=val_date, portfolio=portfolio_id)
-            if underlying_instrument_id := history.get("underlying_instrument", None):
-                dividends = dividends.filter(underlying_instrument=underlying_instrument_id)
+        try:
+            product = Product.objects.get(**history.get("product", {}))
+            dividends = self.model.objects.filter(transaction_date__lte=val_date, portfolio=product.primary_portfolio)
+            if underlying_instrument_data := history.get("underlying_instrument"):
+                if isinstance(underlying_instrument_data, dict):
+                    dividends = dividends.filter(
+                        **{f"underlying_instrument__{k}": v for k, v in underlying_instrument_data.items()}
+                    )
+                else:
+                    dividends = dividends.filter(underlying_instrument__id=underlying_instrument_data)
             return dividends
+        except Product.DoesNotExist:
+            return self.models.objects.none()
 
     def _post_processing_history(self: models.Model, history: models.QuerySet):
         self.import_source.log += "===================="

wbportfolio/import_export/handlers/fees.py

@@ -1,11 +1,10 @@
 from datetime import datetime
 
 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.models.instruments import Cash
 
-from wbportfolio.models.products import Product
-
 
 class FeesImportHandler(ImportExportHandler):
     MODEL_APP_LABEL: str = "wbportfolio.Fees"
@@ -22,9 +21,17 @@ class FeesImportHandler(ImportExportHandler):
         if book_date_str := data.get("book_date", None):
             data["book_date"] = datetime.strptime(book_date_str, "%Y-%m-%d").date()
 
-        from wbportfolio.models import Portfolio
+        from wbportfolio.models import Portfolio, Product
+
+        try:
+            linked_product_data = data.pop("linked_product", None)
+            if isinstance(linked_product_data, dict):
+                data["linked_product"] = Product.objects.get(**linked_product_data)
+            else:
+                data["linked_product"] = Product.objects.get(id=linked_product_data)
+        except Product.DoesNotExist:
+            raise DeserializationError("There is no valid linked product for in this row.")
 
-        data["linked_product"] = Product.objects.get(id=data["linked_product"])
         if "porfolio" in data:
             data["portfolio"] = Portfolio.all_objects.get(id=data["portfolio"])
         else:

wbportfolio/import_export/handlers/trade.py

@@ -35,7 +35,7 @@ class TradeImportHandler(ImportExportHandler):
         return super()._data_changed(_object, change_data, initial_data, **kwargs)
 
     def _deserialize(self, data: Dict[str, Any]):
-        from wbportfolio.models.transactions.trade_proposals import TradeProposal
+        from wbportfolio.models import Product, TradeProposal
 
         if underlying_instrument := data.get("underlying_instrument", None):
             data["underlying_instrument"] = self.instrument_handler.process_object(
@@ -62,6 +62,7 @@ class TradeImportHandler(ImportExportHandler):
             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]
 
@@ -69,6 +70,17 @@ class TradeImportHandler(ImportExportHandler):
                 data["register"] = self.register_handler.process_object(register_data)[0]
 
             data["marked_for_deletion"] = data.get("marked_for_deletion", False)
+        if underlying_instrument := data.get("underlying_instrument"):
+            if nominal := data.pop("nominal", None):
+                try:
+                    product = Product.objects.get(id=underlying_instrument.id)
+                    data["shares"] = nominal / product.share_price
+                except Product.DoesNotExist:
+                    raise DeserializationError(
+                        "We cannot compute the number of shares from the nominal value as we cannot find the product share price."
+                    )
+        else:
+            raise DeserializationError("We couldn't find a valid underlying instrument this row.")
 
         for field in self.model._meta.get_fields():
             if not (value := data.get(field.name, None)) is None and isinstance(field, models.DecimalField):
@@ -165,8 +177,14 @@ class TradeImportHandler(ImportExportHandler):
                 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"])
+            if underlying_instrument_data := history.get("underlying_instrument"):
+                if isinstance(underlying_instrument_data, dict):
+                    trades = trades.filter(
+                        **{f"underlying_instrument__{k}": v for k, v in underlying_instrument_data.items()}
+                    )
+                else:
+                    trades = trades.filter(underlying_instrument__id=underlying_instrument_data)
+
             elif "underlying_instruments" in history:
                 trades = trades.filter(underlying_instrument__id__in=history["underlying_instruments"])
             else:

wbportfolio/import_export/parsers/jpmorgan/customer_trade.py

@@ -40,22 +40,21 @@ def parse(import_source):
     # 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"])
+        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
         bank = nominal_data["CounterParty Name"]
         if (
             len(bank_exclusion_list) == 0 or bank.strip().lower() not in bank_exclusion_list
         ):  # we do basic string comparison to exclude appropriate banks. We might want to include regex if bank data is inconsistent
             data.append(
                 {
-                    "underlying_instrument": {"id": product.id, "instrument_type": "product"},
+                    "underlying_instrument": {"isin": isin, "instrument_type": "product"},
                     "transaction_date": nominal_data["Trade Date"].strftime("%Y-%m-%d"),
                     "shares": shares,
-                    "portfolio": portfolio.id,
+                    "portfolio": {"isin": isin, "instrument_type": "product"},
                     # 'currency': product.currency.key,
                     "transaction_subtype": Trade.Type.REDEMPTION if shares < 0 else Trade.Type.SUBSCRIPTION,
                     "bank": bank,

wbportfolio/import_export/parsers/jpmorgan/fees.py

@@ -6,7 +6,7 @@ import numpy as np
 import pandas as pd
 
 from wbportfolio.import_export.utils import convert_string_to_number
-from wbportfolio.models import Fees, Product
+from wbportfolio.models import Fees
 
 logger = logging.getLogger("importers.parsers.jpmorgan.fee")
 
@@ -31,11 +31,10 @@ def parse(import_source):
     data = list()
 
     for fee_data in df.to_dict("records"):
-        product = Product.objects.get(isin=fee_data["ISIN"])
+        isin = fee_data["ISIN"]
         fee_date = fee_data["Date"]
         base_data = {
-            "portfolio": product.primary_portfolio.id,
-            "linked_product": product.id,
+            "linked_product": {"isin": isin},
             "transaction_date": fee_date.strftime("%Y-%m-%d"),
             "calculated": False,
         }

wbportfolio/import_export/parsers/jpmorgan/valuation.py

@@ -6,7 +6,6 @@ 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")
 
@@ -27,12 +26,11 @@ def parse(import_source):
     # 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},
+                "instrument": {"instrument_type": "product", "isin": price_data["ISIN"]},
                 "date": date.strftime("%Y-%m-%d"),
                 "net_value": round(convert_string_to_number(price_data["Indicative_MID"]), 4),
                 "calculated": False,

wbportfolio/import_export/parsers/leonteq/equity.py

@@ -5,8 +5,6 @@ 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",
@@ -45,7 +43,6 @@ def parse(import_source):
                 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_quote__instrument_type"] == "CASH":
                         ticker = exchange = "CASH"
@@ -75,7 +72,7 @@ def parse(import_source):
                             "initial_shares": position["initial_shares"],
                             "weighting": position["weighting"],
                             "exchange": {"bbg_exchange_codes": exchange},
-                            "portfolio": {"instrument_type": "product", "id": product.id},
+                            "portfolio": {"instrument_type": "product", "isin": sheet_name},
                         }
                     )
 

wbportfolio/import_export/parsers/leonteq/fees.py

@@ -1,6 +1,6 @@
 import pandas as pd
 
-from wbportfolio.models import Fees, Product
+from wbportfolio.models import Fees
 
 
 def parse(import_source):
@@ -17,7 +17,6 @@ def parse(import_source):
         for isin in df.columns.unique(level=0):
             product_fees_df = df.loc[:, isin]
 
-            product = Product.objects.get(isin=isin)
             product_fees_df = product_fees_df.rename(
                 columns={
                     "TRADE DATE": "transaction_date",
@@ -51,8 +50,7 @@ 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 = {
-                    "portfolio": product.primary_portfolio.id,
-                    "linked_product": product.id,
+                    "linked_product": {"isin": isin},
                     "transaction_date": fees["transaction_date"].strftime("%Y-%m-%d"),
                     "calculated": False,
                 }

wbportfolio/import_export/parsers/leonteq/valuation.py

@@ -3,8 +3,6 @@ from io import BytesIO
 import numpy as np
 import pandas as pd
 
-from wbportfolio.models import Product
-
 
 def parse(import_source):
     data = list()
@@ -26,11 +24,10 @@ def parse(import_source):
         for date, valuations in df.to_dict("index").items():
             date = date.to_pydatetime()
             for isin, value in valuations.items():
-                product = Product.objects.get(isin=isin)
                 if date.weekday() not in [5, 6]:
                     data.append(
                         {
-                            "instrument": {"instrument_type": "product", "id": product.id},
+                            "instrument": {"instrument_type": "product", "isin": isin},
                             "date": date.strftime("%Y-%m-%d"),
                             "net_value": value,
                             "calculated": False,

wbportfolio/import_export/parsers/natixis/customer_trade.py

@@ -3,7 +3,7 @@ import pandas as pd
 
 from wbportfolio.models import Trade
 
-from .utils import file_name_parse
+from .utils import file_name_parse_isin
 
 UNVALID_CUSTODIANS = ["init"]
 
@@ -13,51 +13,47 @@ FIELD_MAP = {
     "Counterparty": "bank",
     "Identifier": "external_id",
     "Note price in%": "price",
-    "Nominal Increase/Decrease": "shares",
+    "Nominal Increase/Decrease": "nominal",
 }
 
 
 def _check_if_count_towards_total_aum(row, df):
-    previous_accumulated_shares = row["Accumulated Nominal"] - row["shares"]
+    previous_accumulated_shares = row["Accumulated Nominal"] - row["nominal"]
     dff = df[
         (df["transaction_date"] < row["transaction_date"]) & (df["Accumulated Nominal"] == previous_accumulated_shares)
     ]
-    return not dff["shares"].sum() == row["shares"]
+    return not dff["nominal"].sum() == row["nominal"]
 
 
 def parse(import_source):
     # Load file into a CSV DictReader
     df = pd.read_csv(import_source.file, encoding="utf-8", delimiter=";")
     df = df.rename(columns=FIELD_MAP)
-    parts = file_name_parse(import_source.file.name)
+    parts = file_name_parse_isin(import_source.file.name)
 
     # Get the valuation date and product from the parts list
     valuation_date = parts["valuation_date"]
-    product = parts["product"]
+    product_data = parts["product"]
 
     df["transaction_date"] = pd.to_datetime(df["transaction_date"], format="%d/%m/%Y").dt.strftime("%Y-%m-%d")
     df["value_date"] = pd.to_datetime(df["value_date"], format="%d/%m/%Y").dt.strftime("%Y-%m-%d")
     df["bank"] = df["bank"].str.strip()
-    df["shares"] = df["shares"] / product.share_price
 
     df["bank"] = df["bank"].fillna("<not specified>")
 
     # Use the accumulated nominal (outstanding shares) to detect internal natixis accounting trade that shouldn't be imported
     # If a trade is marked "INIT" and the previous trade sum equals to that trade shares, we assume these two groups are double accounted and we don't import the INIT trade
-    df["Accumulated Nominal"] = df["Accumulated Nominal"] / product.share_price
     df["count_towards_total_aum"] = df.apply(_check_if_count_towards_total_aum, args=[df], axis=1)
     init_rows = df[~df["count_towards_total_aum"] & df["bank"].str.lower().isin(UNVALID_CUSTODIANS)].index
     df = df.drop(init_rows)
 
     df = df.drop(columns=df.columns.difference(FIELD_MAP.values()))
 
-    df["portfolio"] = product.primary_portfolio.id
-    df["currency__key"] = product.currency.key
-    df["underlying_instrument"] = product.id
-    df.loc[df["shares"] < 0, "transaction_subtype"] = Trade.Type.REDEMPTION
-    df.loc[df["shares"] >= 0, "transaction_subtype"] = Trade.Type.SUBSCRIPTION
-
+    df["portfolio"] = [{"instrument_type": "product", **product_data}] * df.shape[0]
+    df["underlying_instrument"] = df["portfolio"]
+    df.loc[df["nominal"] < 0, "transaction_subtype"] = Trade.Type.REDEMPTION
+    df.loc[df["nominal"] >= 0, "transaction_subtype"] = Trade.Type.SUBSCRIPTION
     return {
         "data": df.replace([np.inf, -np.inf, np.nan], None).to_dict(orient="records"),
-        "history": {"underlying_instrument": product.id, "transaction_date": valuation_date.strftime("%Y-%m-%d")},
+        "history": {"underlying_instrument": product_data, "transaction_date": valuation_date.strftime("%Y-%m-%d")},
     }

wbportfolio/import_export/parsers/natixis/d1_customer_trade.py

@@ -2,7 +2,7 @@ import datetime
 
 import xlrd
 
-from wbportfolio.models import Product, Trade
+from wbportfolio.models import Trade
 
 
 def get_isin(sheet):
@@ -16,8 +16,7 @@ def parse(import_source):
 
     product_sheet = book.sheet_by_name("Certificate")
     valuation_sheet = book.sheet_by_name("Report")
-
-    product = Product.objects.get(isin=get_isin(product_sheet))
+    isin = get_isin(product_sheet)
 
     date_column = None
     net_value_column = None
@@ -41,20 +40,20 @@ def parse(import_source):
             max_date = max(max_date, transaction_date)
             net_value = row[net_value_column].value
 
-            shares_today = row[nominal_column].value / product.share_price
+            nominal_today = row[nominal_column].value
 
             try:
-                shares_yesterday = valuation_sheet.cell_value(i + 1, nominal_column) / product.share_price
-                trade = shares_today - shares_yesterday
+                nominal_yesterday = valuation_sheet.cell_value(i + 1, nominal_column)
+                trade = nominal_today - nominal_yesterday
             except IndexError:
-                trade = shares_today
+                trade = nominal_today
 
             if trade and trade != 0:
                 data.append(
                     {
-                        "underlying_instrument": {"id": product.id, "instrument_type": "product"},
+                        "underlying_instrument": {"isin": "isin", "instrument_type": "product"},
                         "transaction_date": transaction_date.strftime("%Y-%m-%d"),
-                        "shares": trade,
+                        "nominal": trade,
                         "transaction_subtype": Trade.Type.REDEMPTION if trade < 0 else Trade.Type.SUBSCRIPTION,
                         "bank": "Natixis Internal Trade",
                         "price": net_value,
@@ -63,5 +62,5 @@ def parse(import_source):
 
     return {
         "data": data,
-        "history": {"underlying_instrument": product.id, "transaction_date": max_date.strftime("%Y-%m-%d")},
+        "history": {"underlying_instrument": {"isin": isin}, "transaction_date": max_date.strftime("%Y-%m-%d")},
     }

wbportfolio/import_export/parsers/natixis/d1_equity.py

@@ -1,7 +1,5 @@
 import xlrd
 
-from wbportfolio.models import Product
-
 
 def get_isin(sheet):
     for row in sheet.get_rows():
@@ -11,8 +9,7 @@ def get_isin(sheet):
 
 def parse(import_source):
     book = xlrd.open_workbook(file_contents=import_source.file.read())
-
-    product = Product.objects.get(isin=get_isin(book.sheet_by_name("Certificate")))
+    isin = get_isin(book.sheet_by_name("Certificate"))
     equity_sheet = book.sheet_by_name("Report - details")
 
     # date_column = None
@@ -42,18 +39,16 @@ def parse(import_source):
                 initial_currency_fx_rate = equity_sheet.cell_value(_i, 6)
                 initial_price = equity_sheet.cell_value(_i, 10)
 
-                ticker = Product.objects.get(isin=isin).ticker
-
                 data.append(
                     {
-                        "underlying_quote": {"instrument_type": "product", "ticker": ticker},
+                        "underlying_quote": {"instrument_type": "product", "isin": isin},
                         "currency__key": currency_key,
                         "date": valuation_date.strftime("%Y-%m-%d"),
                         "asset_valuation_date": valuation_date.strftime("%Y-%m-%d"),
                         "initial_price": initial_price,
                         "initial_currency_fx_rate": initial_currency_fx_rate,
                         "initial_shares": initial_shares,
-                        "portfolio": {"id": product.id, "instrument_type": "product"},
+                        "portfolio": {"isin": isin, "instrument_type": "product"},
                     }
                 )
 
@@ -62,16 +57,13 @@ def parse(import_source):
                     "underlying_quote": {
                         "instrument_type": "cash",
                         "ticker": "CASH",
-                        "name": f"1 {product.currency.key} AMC",
-                        "currency__key": product.currency.key,
                     },
                     "date": valuation_date.strftime("%Y-%m-%d"),
                     "asset_valuation_date": valuation_date.strftime("%Y-%m-%d"),
                     "initial_price": 1.0,
                     "initial_currency_fx_rate": 1.0,
-                    "currency__key": product.currency.key,
                     "initial_shares": equity_sheet.cell_value(first_row + 1, 6),
-                    "portfolio": {"id": product.id, "instrument_type": "product"},
+                    "portfolio": {"isin": isin, "instrument_type": "product"},
                 }
             )
 

wbportfolio/import_export/parsers/natixis/d1_fees.py

@@ -1,6 +1,6 @@
 import xlrd
 
-from wbportfolio.models import Fees, Product
+from wbportfolio.models import Fees
 
 
 def get_isin(sheet):
@@ -11,8 +11,7 @@ def get_isin(sheet):
 
 def parse(import_source):
     book = xlrd.open_workbook(file_contents=import_source.file.read())
-
-    product = Product.objects.get(isin=get_isin(book.sheet_by_name("Certificate")))
+    isin = get_isin(book.sheet_by_name("Certificate"))
     valuation_sheet = book.sheet_by_name("Report")
 
     date_column = None
@@ -38,8 +37,7 @@ def parse(import_source):
             management_fees = row[management_fees_column].value
 
             base_data = {
-                "portfolio": product.primary_portfolio.id,
-                "linked_product": product.id,
+                "linked_product": {"isin": isin},
                 "transaction_date": valuation_date.strftime("%Y-%m-%d"),
                 "calculated": False,
             }

wbportfolio/import_export/parsers/natixis/d1_trade.py

@@ -1,6 +1,6 @@
 import xlrd
 
-from wbportfolio.models import Product, Trade
+from wbportfolio.models import Trade
 
 
 def get_isin(sheet):
@@ -11,8 +11,7 @@ def get_isin(sheet):
 
 def parse(import_source):
     book = xlrd.open_workbook(file_contents=import_source.file.read())
-
-    product = Product.objects.get(isin=get_isin(book.sheet_by_name("Certificate")))
+    isin = get_isin(book.sheet_by_name("Certificate"))
     valuation_sheet = book.sheet_by_name("Transaction Fees")
 
     trade_date_column = None
@@ -20,7 +19,6 @@ def parse(import_source):
     price_column = None
     currency_fx_rate_column = None
     isin_column = None
-    execution_fees_column = None
 
     data = list()
     for i, row in enumerate(valuation_sheet.get_rows()):
@@ -41,28 +39,21 @@ def parse(import_source):
                 if "Reference" == row[column].value:
                     isin_column = column
 
-                if "Exec Fees" in row[column].value:
-                    execution_fees_column = column
-
         else:
             transaction_date = xlrd.xldate.xldate_as_datetime(row[trade_date_column].value, 0)
             shares = row[shares_column].value
             price = row[price_column].value
             currency_fx_rate = row[currency_fx_rate_column].value
-            row[execution_fees_column].value
-
-            traded_product = Product.objects.get(isin=row[isin_column].value)
 
             data.append(
                 {
-                    "portfolio": product.primary_portfolio.id,
+                    "portfolio": {"instrument_type": "product", "isin": isin},
                     "transaction_subtype": Trade.Type.REBALANCE,
                     "transaction_date": transaction_date.strftime("%Y-%m-%d"),
                     "shares": shares,
                     "price": price,
-                    "currency__key": traded_product.currency.key,
                     "currency_fx_rate": currency_fx_rate,
-                    "underlying_instrument": {"id": traded_product.id, "instrument_type": "product"},
+                    "underlying_instrument": {"isin": row[isin_column], "instrument_type": "product"},
                     # 'execution_fees_percent': 0,
                     # 'market_fees_percent': 0,
                 }

wbportfolio/import_export/parsers/natixis/d1_valuation.py

@@ -1,7 +1,5 @@
 import xlrd
 
-from wbportfolio.models import Product
-
 
 def get_isin(sheet):
     for row in sheet.get_rows():
@@ -11,8 +9,7 @@ def get_isin(sheet):
 
 def parse(import_source):
     book = xlrd.open_workbook(file_contents=import_source.file.read())
-
-    product = Product.objects.get(isin=get_isin(book.sheet_by_name("Certificate")))
+    isin = get_isin(book.sheet_by_name("Certificate"))
     valuation_sheet = book.sheet_by_name("Report")
 
     date_column = None
@@ -32,7 +29,7 @@ def parse(import_source):
 
             data.append(
                 {
-                    "instrument": {"instrument_type": "product", "id": product.id},
+                    "instrument": {"instrument_type": "product", "isin": isin},
                     "date": valuation_date.strftime("%Y-%m-%d"),
                     "net_value": net_value,
                     "calculated": False,

wbportfolio/import_export/parsers/natixis/dividend.py

@@ -1,7 +1,7 @@
 import numpy as np
 import pandas as pd
 
-from .utils import _get_exchange_from_ticker, _get_ticker, file_name_parse
+from .utils import _get_exchange_from_ticker, _get_ticker, file_name_parse_isin
 
 COLUMN_MAP = {
     "Ticker": "underlying_instrument__ticker",
@@ -19,8 +19,8 @@ COLUMN_MAP = {
 
 
 def parse(import_source):
-    parts = file_name_parse(import_source.file.name)
-    product = parts["product"]
+    parts = file_name_parse_isin(import_source.file.name)
+    product_data = parts["product"]
 
     df = pd.read_csv(import_source.file, sep=";", skipinitialspace=True)
     df = df.rename(columns=COLUMN_MAP).astype("str")
@@ -42,12 +42,12 @@ def parse(import_source):
     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"] = product.primary_portfolio.id
+    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"),
-            "portfolio": product.primary_portfolio.id,
+            "product": product_data,
         },
     }

wbportfolio/import_export/parsers/natixis/equity.py

@@ -1,7 +1,7 @@
 import numpy as np
 import pandas as pd
 
-from .utils import _get_underlying_instrument, file_name_parse
+from .utils import _get_underlying_instrument, file_name_parse_isin
 
 FIELD_MAP = {
     "Close": "initial_price",
@@ -28,11 +28,11 @@ def _apply_adjusting_factor(row):
 
 def parse(import_source):
     # Parse the Parts of the filename into the different parts
-    parts = file_name_parse(import_source.file.name)
+    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 = parts["product"]
+    product_data = parts["product"]
 
     # Load file into a CSV DictReader
     df = pd.read_csv(import_source.file, encoding="utf-16", delimiter=";")
@@ -50,7 +50,7 @@ def parse(import_source):
     df = df.drop(columns=df.columns.difference(FIELD_MAP.values()))
 
     df["portfolio__instrument_type"] = "product"
-    df["portfolio__id"] = product.id
+    df["portfolio__isin"] = product_data["isin"]
     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")