wbportfolio 2.2.1__py2.py3-none-any.whl

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}

wbportfolio/import_export/parsers/leonteq/fees.py

@@ -0,0 +1,70 @@
+import pandas as pd
+from wbportfolio.models import Fees, Product
+
+
+def parse(import_source):
+    data = list()
+    df = pd.DataFrame()
+    try:
+        df = pd.read_excel(
+            import_source.file.read(), engine="openpyxl", sheet_name="FEE_CONSOLIDATION", header=[0, 2], skiprows=1
+        ).dropna(axis=1)
+    except (ValueError, IndexError):
+        pass
+
+    if not df.empty:
+        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",
+                    "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
+            )
+
+            management_fees_eur = product_fees_df[
+                product_fees_df.loc[:, "transaction_subtype"] == "Management Fee EUR"
+            ]
+            performance_fees_eur = product_fees_df[
+                product_fees_df.loc[:, "transaction_subtype"] == "Performance Fee EUR"
+            ]
+            management_fees_eur["transaction_subtype"] = Fees.Type.MANAGEMENT
+            performance_fees_eur["transaction_subtype"] = Fees.Type.PERFORMANCE
+
+            concat_list = []
+            if not management_fees_eur.empty:
+                concat_list.append(management_fees_eur)
+            if not performance_fees_eur.empty:
+                concat_list.append(performance_fees_eur)
+            product_fees_df = pd.concat(
+                concat_list,
+                axis=0,
+            )
+            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,
+                    "transaction_date": fees["transaction_date"].strftime("%Y-%m-%d"),
+                    "calculated": False,
+                }
+
+                total_value_gross = fees.get("total_value_gross", fees["total_value"])
+                if total_value_gross != 0 or fees["total_value"] != 0:
+                    data.append(
+                        {
+                            "transaction_subtype": fees["transaction_subtype"],
+                            "total_value": fees["total_value"],
+                            "total_value_gross": total_value_gross,
+                            **base_data,
+                        }
+                    )
+
+    return {"data": data}

wbportfolio/import_export/parsers/leonteq/trade.py

@@ -0,0 +1,94 @@
+import re
+from io import BytesIO
+
+import numpy as np
+import pandas as pd
+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]}
+
+
+# TODO: finish it
+_fields_map = {
+    "underlying_instrument": "underlying_instrument",
+    "transaction_subtype": "transaction_subtype",
+    "DATE": "transaction_date",
+    "INSTRUMENT CCY": "currency__key",
+    "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",
+}
+
+
+def parse(import_source):
+    data = list()
+    parts = file_name_parse(import_source.file.name)
+    product = Product.objects.get(isin=parts["isin"])
+
+    df = pd.read_excel(BytesIO(import_source.file.read()), engine="openpyxl", sheet_name="Transactions")
+
+    def _get_exchange(identifier):
+        ticker, exchange, _ = identifier.split(" ")
+        if exchange:
+            return {"bbg_exchange_codes": exchange}
+
+    def _get_underlying_instrument(row):
+        if row["EVENT"] == "AMC CASH":
+            return product.id
+        else:
+            ticker, exchange, _ = row["IDENTIFIER"].split(" ")
+            return {
+                "ticker": ticker,
+                "exchange": {"bbg_exchange_codes": exchange},
+                "name": row["NAME"],
+                "currency__key": row["currency__key"],
+                "instrument_type": "equity",
+            }
+
+    xx, yy = np.where(df == "N°")
+    df = df.iloc[xx[0] :, yy[0] :]
+    df = df.rename(columns=df.iloc[0]).drop(df.index[0]).dropna(how="all")
+    df["transaction_subtype"] = None
+    df = df.rename(columns={"INSTRUMENT CCY  ": "INSTRUMENT CCY"})
+    df = df.rename(columns=_fields_map)
+
+    df["transaction_date"] = pd.to_datetime(df["transaction_date"], dayfirst=True).dt.strftime("%Y-%m-%d")
+    df["shares"] = -1 * df["shares"]
+
+    df.loc[(df["EVENT"] == "BUY") & (df["ASSET CLASS"] == "SHARE"), "transaction_subtype"] = "BUY"
+    df.loc[(df["EVENT"] == "SELL") & (df["ASSET CLASS"] == "SHARE"), "transaction_subtype"] = "SELL"
+    df.loc[(df["EVENT"] == "AMC CASH") & (df["shares"] < 0), "transaction_subtype"] = "REDEMPTION"
+    df.loc[(df["EVENT"] == "AMC CASH") & (df["shares"] > 0), "transaction_subtype"] = "SUBSCRIPTION"
+
+    df = df[df["transaction_subtype"].notnull()]
+    df["underlying_instrument"] = df.apply(lambda x: _get_underlying_instrument(x), axis=1)
+    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
+
+    customer_trade_index_mask = (df["transaction_subtype"] == "REDEMPTION") | (
+        df["transaction_subtype"] == "SUBSCRIPTION"
+    )
+    df.loc[customer_trade_index_mask, "shares"] = df.loc[customer_trade_index_mask, "shares"] / product.share_price
+    for field in ["price", "price_gross"]:
+        df.loc[customer_trade_index_mask, field] = df.loc[customer_trade_index_mask, field] * product.share_price
+    df["bank"] = "Leonteq Cash Transfer"
+    data = df.to_dict("records")
+
+    return {"data": data}

wbportfolio/import_export/parsers/leonteq/valuation.py

@@ -0,0 +1,39 @@
+from io import BytesIO
+
+import numpy as np
+import pandas as pd
+from wbportfolio.models import Product
+
+
+def parse(import_source):
+    data = list()
+    df = pd.DataFrame()
+    try:
+        df = pd.read_excel(
+            BytesIO(import_source.file.read()), engine="openpyxl", sheet_name="VALUATION_CONSOLIDATION"
+        ).dropna(how="all")
+    except (ValueError, IndexError):
+        pass
+
+    if not df.empty:
+        xx, yy = np.where(df == "HISTORICAL VALUATION")
+        df = df.iloc[xx[0] :, yy[0] :]
+        df = df.rename(columns=df.iloc[0]).drop(df.index[0]).dropna(how="all")
+        df = df.drop(df.index[0]).set_index("HISTORICAL VALUATION")
+        df.index = pd.to_datetime(df.index, dayfirst=True)
+
+        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},
+                            "date": date.strftime("%Y-%m-%d"),
+                            "net_value": value,
+                            "calculated": False,
+                        }
+                    )
+
+    return {"data": data}

wbportfolio/import_export/parsers/natixis/customer_trade.py

@@ -0,0 +1,62 @@
+import numpy as np
+import pandas as pd
+from wbportfolio.models import Trade
+
+from .utils import file_name_parse
+
+UNVALID_CUSTODIANS = ["init"]
+
+FIELD_MAP = {
+    "Trade Date": "transaction_date",
+    "Value Date": "value_date",
+    "Counterparty": "bank",
+    "Identifier": "external_id",
+    "Note price in%": "price",
+    "Nominal Increase/Decrease": "shares",
+}
+
+
+def _check_if_count_towards_total_aum(row, df):
+    previous_accumulated_shares = row["Accumulated Nominal"] - row["shares"]
+    dff = df[
+        (df["transaction_date"] < row["transaction_date"]) & (df["Accumulated Nominal"] == previous_accumulated_shares)
+    ]
+    return not dff["shares"].sum() == row["shares"]
+
+
+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)
+
+    # Get the valuation date and product from the parts list
+    valuation_date = parts["valuation_date"]
+    product = 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
+
+    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")},
+    }

wbportfolio/import_export/parsers/natixis/d1_customer_trade.py

@@ -0,0 +1,66 @@
+import datetime
+
+import xlrd
+from wbportfolio.models import Product, Trade
+
+
+def get_isin(sheet):
+    for row in sheet.get_rows():
+        if row[0].value == "ISIN":
+            return row[1].value
+
+
+def parse(import_source):
+    book = xlrd.open_workbook(file_contents=import_source.file.read())
+
+    product_sheet = book.sheet_by_name("Certificate")
+    valuation_sheet = book.sheet_by_name("Report")
+
+    product = Product.objects.get(isin=get_isin(product_sheet))
+
+    date_column = None
+    net_value_column = None
+    nominal_column = None
+
+    max_date = datetime.date(1900, 1, 1)
+
+    data = list()
+    for i, row in enumerate(valuation_sheet.get_rows()):
+        if i == 0:
+            for column in range(0, valuation_sheet.ncols):
+                if "Date" in row[column].value:
+                    date_column = column
+                if "price" in row[column].value:
+                    net_value_column = column
+                if "Nominal" == row[column].value:
+                    nominal_column = column
+
+        else:
+            transaction_date = xlrd.xldate.xldate_as_datetime(row[date_column].value, 0).date()
+            max_date = max(max_date, transaction_date)
+            net_value = row[net_value_column].value
+
+            shares_today = row[nominal_column].value / product.share_price
+
+            try:
+                shares_yesterday = valuation_sheet.cell_value(i + 1, nominal_column) / product.share_price
+                trade = shares_today - shares_yesterday
+            except IndexError:
+                trade = shares_today
+
+            if trade and trade != 0:
+                data.append(
+                    {
+                        "underlying_instrument": {"id": product.id, "instrument_type": "product"},
+                        "transaction_date": transaction_date.strftime("%Y-%m-%d"),
+                        "shares": trade,
+                        "transaction_subtype": Trade.Type.REDEMPTION if trade < 0 else Trade.Type.SUBSCRIPTION,
+                        "bank": "Natixis Internal Trade",
+                        "price": net_value,
+                    }
+                )
+
+    return {
+        "data": data,
+        "history": {"underlying_instrument": product.id, "transaction_date": max_date.strftime("%Y-%m-%d")},
+    }