wbportfolio 1.43.1__py2.py3-none-any.whl

wbportfolio/import_export/parsers/natixis/equity.py

@@ -0,0 +1,60 @@
+import numpy as np
+import pandas as pd
+
+from .utils import _get_underlying_instrument, file_name_parse
+
+FIELD_MAP = {
+    "Close": "initial_price",
+    "Nb of shares": "initial_shares",
+    "Fx Rate": "initial_currency_fx_rate",
+    "Valuation Date": "asset_valuation_date",
+    "Quoted Crncy": "currency__key",
+    "exchange": "exchange",
+    "underlying_instrument": "underlying_instrument",
+}
+
+
+def _apply_adjusting_factor(row):
+    """
+    If the position is a product position, then the adjusting factor adjusts the shares otherwise, it adjusts the price.
+
+    No idea why though
+    """
+    if row["underlying_instrument"]["instrument_type"] == "product":
+        return pd.Series([row["initial_price"], row["initial_shares"] * row["Quotity/Adj. factor"]])
+    else:
+        return pd.Series([row["initial_price"] * row["Quotity/Adj. factor"], row["initial_shares"]])
+
+
+def parse(import_source):
+    # Parse the Parts of the filename into the different parts
+    parts = file_name_parse(import_source.file.name)
+
+    # Get the valuation date and investment from the parts list
+    valuation_date = parts["valuation_date"]
+    product = parts["product"]
+
+    # Load file into a CSV DictReader
+    df = pd.read_csv(import_source.file, encoding="utf-16", delimiter=";")
+    df = df.rename(columns=FIELD_MAP)
+    df = df.dropna(subset=["initial_price"])
+    df["initial_price"] = df["initial_price"].astype("str").str.replace(" ", "").astype("float")
+    df["underlying_instrument"] = df[["Ticker", "Name", "currency__key"]].apply(
+        lambda x: _get_underlying_instrument(*x), axis=1
+    )
+    df["initial_price"] = df["initial_price"].replace(0, np.nan).fillna(1.0)
+    df[["initial_price", "initial_shares"]] = df[
+        ["initial_price", "initial_shares", "Quotity/Adj. factor", "underlying_instrument"]
+    ].apply(lambda x: _apply_adjusting_factor(x), axis=1)
+    df["exchange"] = df.underlying_instrument.apply(lambda x: x.get("exchange", None))
+    df = df.drop(columns=df.columns.difference(FIELD_MAP.values()))
+
+    df["portfolio__instrument_type"] = "product"
+    df["portfolio__id"] = product.id
+    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")
+
+    df["weighting"] = df.initial_currency_fx_rate * df.initial_price * df.initial_shares
+    df["weighting"] = df.weighting / df.weighting.sum()
+    return {"data": df.to_dict("records")}

wbportfolio/import_export/parsers/natixis/fees.py

@@ -0,0 +1,53 @@
+import pandas as pd
+from pandas.tseries.offsets import BDay
+
+from .utils import file_name_parse
+
+FIELD_MAP = {
+    "Date": "transaction_date",
+    "Manag. Fees Natixis": "ISSUER",
+    "Manag. Fees Client": "MANAGEMENT",
+    "Perf fees amount": "PERFORMANCE"
+    # "Currency": "currency"
+}
+
+
+def parse(import_source):
+    # Parse the Parts of the filename into the different parts
+    parts = file_name_parse(import_source.file.name)
+    # Get the valuation date and investment from the parts list
+    parts["valuation_date"]
+    product = parts["product"]
+
+    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)
+
+    # 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)
+
+    # 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 = pd.melt(
+        df,
+        id_vars=["transaction_date"],
+        value_vars=["MANAGEMENT", "ISSUER", "PERFORMANCE"],
+        var_name="transaction_subtype",
+        value_name="total_value",
+    )
+    df = df[df["total_value"] != 0]
+
+    df["portfolio"] = product.primary_portfolio.id
+    df["linked_product"] = product.id
+    df["transaction_date"] = df["transaction_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/trade.py

@@ -0,0 +1,63 @@
+import pandas as pd
+from wbportfolio.models import Trade
+
+from .utils import _get_underlying_instrument, file_name_parse
+
+
+def _parse_trade_type(type):
+    choices = {
+        "Decrease": Trade.Type.DECREASE,
+        "Increase": Trade.Type.INCREASE,
+        "Rebalancing": Trade.Type.REBALANCE,
+        "Buy": Trade.Type.BUY,
+        "Sell": Trade.Type.SELL,
+    }
+
+    return choices[type]
+
+
+def parse(import_source):
+    data = list()
+    df = pd.read_csv(import_source.file, sep=";")
+    if not df.empty:
+        # Parse the Parts of the filename into the different parts
+        parts = file_name_parse(import_source.file.name)
+
+        # Get the valuation date and investment from the parts list
+        product = parts["product"]
+
+        # Iterate through the CSV File and parse the data into a list
+        df["underlying_instrument"] = df[["BLOOMBERG CODE", "NAME", "QUOTED_CRNCY"]].apply(
+            lambda x: _get_underlying_instrument(*x), axis=1
+        )
+        df["exchange"] = df.underlying_instrument.apply(lambda x: x.get("exchange", None))
+        columns_map = {
+            "underlying_instrument": "underlying_instrument",
+            "TRADE DATE": "transaction_date",
+            "EXECUTED QTY": "shares",
+            "EXECUTED PRICE": "price",
+            "FX RATE": "currency_fx_rate",
+            "NET PRICE(Stock crncy)": "price",
+            "PRICE(USD)": "price_gross",
+            "TRADE TYPE": "transaction_subtype",
+            "QUOTED_CRNCY": "currency__key",
+        }
+        df = df.rename(columns=columns_map)
+        float_fields = ["shares", "price", "currency_fx_rate", "price", "price_gross"]
+        for field in float_fields:
+            if field in df:
+                df[field] = df[field].apply(
+                    lambda x: float(x.replace("-", "").replace(" ", "") if isinstance(x, str) else x)
+                )
+
+        df["price"] = df.apply(
+            lambda x: x["price"] * x["QUOTITY/ADJ. FACTOR"] if "QUOTITY/ADJ. FACTOR" in x else x["price"], axis=1
+        )
+        df.transaction_date = pd.to_datetime(df.transaction_date, dayfirst=True)
+        df.transaction_date = df.transaction_date.apply(lambda x: x.strftime("%Y-%m-%d"))
+        df["transaction_subtype"] = df["transaction_subtype"].apply(lambda x: _parse_trade_type(x))
+        df = df.drop(columns=df.columns.difference(columns_map.values()))
+        df["portfolio"] = product.primary_portfolio.id
+        df["bank"] = "Natixis Cash Transfer"
+        data = df.to_dict("records")
+    return {"data": data}

wbportfolio/import_export/parsers/natixis/utils.py

@@ -0,0 +1,76 @@
+import datetime
+import re
+
+from django.db.models import Q
+from wbportfolio.models import Product
+
+INSTRUMENT_MAP_NAME = {"EDA23_AtonRa Z class": Product.objects.get(isin="LU2170995018")}
+
+
+def _get_exchange_from_ticker(ticker):
+    try:
+        ticker, exchange = ticker.split(" ")
+    except Exception:
+        ticker, exchange = ticker, None
+    return exchange
+
+
+def _get_ticker(ticker):
+    return ticker.split(" ")[0]
+
+
+def _get_underlying_instrument(bbg_code, name, currency, instrument_type="equity", isin=None, cash_position=False):
+    if product := INSTRUMENT_MAP_NAME.get(bbg_code, None):
+        return {"id": product.id}
+
+    exchange = _get_exchange_from_ticker(bbg_code)
+    ticker = _get_ticker(bbg_code)
+
+    cash_position = cash_position or "CASH" == bbg_code or len(re.findall("(CASH [A-Z]{3})", bbg_code)) > 0
+    if cash_position:
+        underlying_instrument = {"instrument_type": "cash", "currency__key": currency}
+    else:
+        underlying_instrument = {
+            "exchange": {"bbg_exchange_codes": exchange},
+            "currency__key": currency,
+            "name": name.split(" @")[0].split("/")[
+                0
+            ],  # we remove anything after @ and also any trailing symbol (which represents some country information at natixis)
+            "ticker": ticker,
+            "instrument_type": instrument_type,
+        }
+        if not isin:
+            isin_re = re.findall("([A-Z]{2}[A-Z0-9]{9}[0-9]{1})", ticker)
+            if len(isin_re) > 0:
+                isin = isin_re[0]
+                # Natixis gives us ISIN as ticker for product. in that case, we registered the isin but we remove the ticker
+                underlying_instrument["instrument_type"] = "product"
+                del underlying_instrument["ticker"]
+            elif Product.objects.filter(ticker=ticker).exists():
+                underlying_instrument["instrument_type"] = "product"
+        if isin:
+            underlying_instrument["isin"] = isin
+    return underlying_instrument
+
+
+def file_name_parse(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()
+
+    product = Product.objects.get(Q(ticker=identifier[0]) | Q(isin=identifier[0]))
+
+    return {
+        "product": product,
+        "valuation_date": valuation_date,
+        "generation_date": generation_date,
+    }

wbportfolio/import_export/parsers/natixis/valuation.py

@@ -0,0 +1,46 @@
+import codecs
+import csv
+import datetime
+
+from wbportfolio.import_export.utils import convert_string_to_number
+
+from .utils import file_name_parse
+
+
+def parse(import_source):
+    # Load file into a CSV DictReader
+    csv_file = import_source.file.open(mode="rt")
+    csv_file_type = type(csv_file.read())
+
+    # If the file is a byte string, then we need to convert it.
+    if csv_file_type is bytes:
+        csv_file = codecs.iterdecode(csv_file, "utf-8")
+
+    # Read file into a CSV Dict Reader
+    csv_reader = csv.DictReader(csv_file, delimiter=";")
+
+    # Parse the Parts of the filename into the different parts
+    parts = file_name_parse(import_source.file.name)
+
+    # Get the valuation date and investment from the parts list
+    parts["valuation_date"]
+    product = parts["product"]
+
+    # Iterate through the CSV File and parse the data into a list
+    data = list()
+
+    for valuation in csv_reader:
+        date = datetime.datetime.strptime(valuation["Date"], "%d/%m/%Y").date()
+        if date.weekday() not in [5, 6]:
+            data.append(
+                {
+                    "instrument": {"instrument_type": "product", "id": product.id},
+                    "date": date.strftime("%Y-%m-%d"),
+                    "net_value": round(convert_string_to_number(valuation["Index Value in%"]), 6),
+                    "gross_value": round(convert_string_to_number(valuation["Index gross in%"]), 6),
+                    "calculated": False,
+                }
+            )
+
+    csv_file.close()
+    return {"data": data}

wbportfolio/import_export/parsers/refinitiv/adjustment.py

@@ -0,0 +1,24 @@
+import numpy as np
+import pandas as pd
+from wbfdm.import_export.parsers.refinitiv.utils import _clean_and_return_dict
+
+DEFAULT_MAPPING = {
+    "AX": "factor",
+    "Dates": "date",
+    "Instrument": "instrument",
+}
+
+
+def parse(import_source):
+    df = pd.read_json(import_source.file, orient="records")
+    df = df.replace([np.inf, -np.inf, np.nan], None)
+    df = df.rename(columns=DEFAULT_MAPPING).dropna(how="all", axis=1)
+    df = df.dropna(how="all", subset=df.columns.difference(["instrument"]))
+    df["date"] = pd.to_datetime(df["date"], utc=True, unit="ms")
+    df.date = df.date.dt.strftime("%Y-%m-%d")
+    df = df.dropna(how="any")
+    data = list()
+    if not df.empty:
+        df = df.groupby(["instrument", "date"]).first().reset_index()
+        data = _clean_and_return_dict(df)
+    return {"data": data}

wbportfolio/import_export/parsers/sg_lux/custodian_positions.py

@@ -0,0 +1,70 @@
+from typing import TYPE_CHECKING
+
+import pandas as pd
+from pandas.tseries.offsets import BDay
+from schwifty import IBAN
+from wbportfolio.models.portfolio import Portfolio
+
+if TYPE_CHECKING:
+    from wbcore.contrib.io.models import ImportSource
+
+# Bank specific Information for Societe Generale Luxembourg
+BANK_COUNTRY_CODE = "LU"
+BANK_CODE = "060"
+
+
+def get_underlying_instrument(row: pd.Series) -> dict[str, str]:
+    """Get the underlying instrument from the row"""
+    return {
+        "instrument_type": "equity",
+        "isin": str(row["isin"]),
+        "name": str(row["name"]),
+    }
+
+
+def get_portfolio_id(row: pd.Series) -> int:
+    """Get the portfolio id from the bank account number
+
+    Raises: Portfolio.DoesNotExist: We raise an error intentionally if the portfolio does not exist to make the import fail
+    """
+    iban = str(IBAN.generate(BANK_COUNTRY_CODE, bank_code=BANK_CODE, account_code=str(row["account_number"])))
+    return Portfolio.objects.get(bank_accounts__iban=iban).id
+
+
+def parse(import_source: "ImportSource") -> dict:
+    """Parse the custodian positions file into a dictionary"""
+
+    # Get df from csv and rename columns and group by account number, isin, and date to sum the shares per date, account, and isin
+    df = pd.read_csv(import_source.file.open(), encoding="latin1").rename(  # type: ignore
+        columns={
+            "Account number": "account_number",
+            "ISIN code": "isin",
+            "Quantity": "initial_shares",
+            "Position date": "date",
+            "Security name": "name",
+        }
+    )
+
+    df = pd.DataFrame(
+        df[["account_number", "isin", "initial_shares", "date", "name"]]
+        .groupby(["account_number", "isin", "date", "name"])
+        .sum()
+    )
+
+    # add weight per account number
+    df["weighting"] = df.groupby(["account_number", "date"])["initial_shares"].transform(lambda x: x / x.sum())
+
+    # reset index to remove the multi index from the groupby
+    df = df.reset_index()
+
+    # parse datetime string to date string and set to 1 day earlier
+    df["date"] = pd.to_datetime(df["date"], format="%m/%d/%Y %I:%M:%S %p") - BDay(1)
+    df["date"] = df["date"].dt.strftime("%Y-%m-%d")
+
+    df["underlying_instrument"] = df.apply(get_underlying_instrument, axis=1)
+    df["portfolio"] = df.apply(get_portfolio_id, axis=1)
+    df["estimated"] = True
+
+    # remove name column
+    df = df.drop(columns=["name", "account_number"])
+    return {"data": df.to_dict("records")}

wbportfolio/import_export/parsers/sg_lux/customer_trade.py

@@ -0,0 +1,75 @@
+from datetime import date
+from io import BytesIO
+
+import msoffcrypto
+import numpy as np
+import pandas as pd
+from wbportfolio.models import Product, Trade
+
+
+def get_portfolio(x):
+    product = Product.objects.get(id=x)
+    portfolio = product.primary_portfolio
+    return portfolio.id
+
+
+def parse(import_source):
+    if credential := import_source.source.get_valid_credential(date.today()):
+        password = credential.password
+        buffer = BytesIO()
+
+        encrypted_file = msoffcrypto.OfficeFile(import_source.file)
+        encrypted_file.load_key(password=password)
+        encrypted_file.decrypt(buffer)
+
+        buffer.seek(0)
+
+        df = pd.read_excel(buffer.read(), usecols=[3, 4, 7, 10, 15, 16, 17, 18, 20, 21], engine="openpyxl")
+
+        # Filter out all non transaction rows and remove RECORD_DESC col
+        df = df[df["RECORD_DESC"].str.strip() == "TRANSACTION"]
+        del df["RECORD_DESC"]
+
+        # Convert timestamps to json conform date strings
+        df["TRANS_DATE"] = df["TRANS_DATE"].apply(lambda x: x.date().strftime("%Y-%m-%d"))
+        df["SETTL_DATE"] = df["SETTL_DATE"].apply(lambda x: x.date().strftime("%Y-%m-%d"))
+
+        # Replace all nan values with empty str
+        df[["REGISTER_FIRSTNAME", "CUST_REF"]] = df[["REGISTER_FIRSTNAME", "CUST_REF"]].replace(np.nan, "", regex=True)
+
+        # Merge REGISTER_FIRSTNAME and CUST_REF and then remove both cols
+        df["note"] = df["REGISTER_FIRSTNAME"] + df["CUST_REF"]
+        del df["REGISTER_FIRSTNAME"]
+        del df["CUST_REF"]
+
+        # Create Product Mapping and apply to df
+        product_mapping = {
+            product["isin"]: product["id"]
+            for product in Product.objects.filter(isin__in=df["ISIN"].unique()).values("id", "isin")
+        }
+        df["ISIN"] = df["ISIN"].apply(lambda x: product_mapping[x])
+
+        # Rename Columns
+        df.columns = [
+            "bank",
+            "underlying_instrument",
+            "transaction_date",
+            "value_date",
+            "external_id",
+            "price",
+            "shares",
+            "comment",
+        ]
+        df["transaction_subtype"] = df.shares.apply(
+            lambda x: Trade.Type.REDEMPTION if x < 0 else Trade.Type.SUBSCRIPTION
+        )
+        df["portfolio"] = df["underlying_instrument"].apply(lambda x: get_portfolio(x))
+        df["underlying_instrument"] = df["underlying_instrument"].apply(
+            lambda x: {"id": x, "instrument_type": "product"}
+        )
+
+        # Convert df to list of dicts
+        data = list(df.T.to_dict().values())
+
+        return {"data": data}
+    return {"data": list()}

wbportfolio/import_export/parsers/sg_lux/customer_trade_pending_slk.py

@@ -0,0 +1,140 @@
+import csv
+import math
+from io import StringIO
+
+import numpy as np
+import pandas as pd
+from wbfdm.models import InstrumentPrice
+from wbportfolio.models import Product, Register, Trade
+from xlrd import xldate_as_datetime
+
+from .sylk import SYLK
+from .utils import assemble_transaction_reference, get_portfolio_id
+
+
+def convert_string_to_number(string):
+    try:
+        return float(string.replace(" ", "").replace(",", ""))
+    except ValueError:
+        return 0.0
+
+
+def remove_not_needed_columns(df: pd.DataFrame):
+    del df["NORDER"]
+    del df["NORDER_EXTERN"]
+    del df["REGISTER_ID1"]
+    del df["ISIN1"]
+    del df["AMOUNT"]
+    del df["QUANTITY"]
+    del df["AMOUNT_EST_EUR"]
+    del df["CODE_OPERATION"]
+    del df["TRADE_DATE"]
+    del df["VALUE_DATE"]
+    del df["REGISTER_DEAL_NAME"]
+    del df["REGISTER_ID2"]
+
+
+def convert_dates(df: pd.DataFrame):
+    df["trade_date"] = df["TRADE_DATE"].apply(lambda x: xldate_as_datetime(x, datemode=0).date())
+    df["trade_date"] = df["trade_date"].apply(lambda x: x.strftime("%Y-%m-%d"))
+    df["value_date"] = df["VALUE_DATE"].apply(lambda x: xldate_as_datetime(x, datemode=0).date())
+    df["value_date"] = df["value_date"].apply(lambda x: x.strftime("%Y-%m-%d"))
+
+
+def map_products_by_isin(df: pd.DataFrame):
+    product_mapping = {
+        product["isin"]: product["id"]
+        for product in Product.objects.filter(isin__in=df["ISIN1"].unique()).values("id", "isin")
+    }
+    df["underlying_instrument"] = df["ISIN1"].apply(lambda x: product_mapping[x])
+    df["portfolio"] = df["underlying_instrument"].apply(lambda x: get_portfolio_id(x))
+
+
+def map_registers_by_references(df: pd.DataFrame):
+    register_mapping = {
+        register["register_reference"]: register["id"]
+        for register in Register.objects.filter(register_reference__in=df["REGISTER_ID1"].unique()).values(
+            "id", "register_reference"
+        )
+    }
+    df["register"] = df["REGISTER_ID1"].apply(lambda x: register_mapping[str(x)])
+
+
+def get_price(x):
+    try:
+        estimated_price = float(
+            InstrumentPrice.objects.filter(
+                instrument=x["underlying_instrument"], calculated=False, date__lte=x["trade_date"]
+            )
+            .latest("date")
+            .net_value
+        )
+    except InstrumentPrice.DoesNotExist:
+        try:
+            estimated_price = Product.objects.get(id=x["underlying_instrument"]).issue_price
+        except Product.DoesNotExist:
+            estimated_price = 100
+    return estimated_price
+
+
+def get_shares(x):
+    multiplier = 1 if x["CODE_OPERATION"] == 1 else -1
+    if x["QUANTITY"] and not math.isnan(x["QUANTITY"]):
+        return round(x["QUANTITY"] * multiplier, 4)
+
+    return round((x["AMOUNT"] * multiplier) / x["price"], 4)
+
+
+def parse(import_source):
+    data = list()
+
+    sylk_handler = SYLK()
+    for line in [_line.decode("cp1252") for _line in import_source.file.open("rb").readlines()]:
+        sylk_handler.parseline(line)
+
+    buffer = StringIO()
+    csvwriter = csv.writer(buffer, quotechar="'", delimiter=";", lineterminator="\n", quoting=csv.QUOTE_ALL)
+    for line in sylk_handler.stream_rows():
+        csvwriter.writerow(line)
+
+    buffer.seek(0)
+    content = buffer.read().replace('""', "")
+    df = pd.read_csv(StringIO(content), sep=";", quotechar="'", usecols=[0, 4, 5, 6, 7, 12, 13, 15, 16, 17, 18, 22])
+    if not df.empty:
+        df["pending"] = True
+
+        df.loc[df["CODE_OPERATION"] == 6, "pending"] = False
+        transfers = df.loc[df["CODE_OPERATION"] == 6, :].copy()
+        transfers["CODE_OPERATION"] = 2
+        transfers["QUANTITY"] = -transfers["QUANTITY"]
+        transfers["TRANSFER_REGISTER"] = transfers["REGISTER_ID1"].astype("int").astype("str")
+        transfers["REGISTER_ID1"] = transfers["REGISTER_ID2"].astype("int").astype("str")
+        transfers["REGISTER_DEAL_NAME"] = transfers["REGISTER_ID1"].apply(
+            lambda x: Register.objects.get(register_reference=x).register_name_1
+        )
+
+        df = pd.concat([df, transfers], axis=0)
+
+        if "TRANSFER_REGISTER" in df:
+            df["TRANSFER_REGISTER"] = df["TRANSFER_REGISTER"].replace(np.nan, "", regex=True)
+
+        convert_dates(df)
+        df["NORDER_EXTERN"] = df["NORDER_EXTERN"].replace(np.nan, "", regex=True)
+        map_products_by_isin(df)
+        df["price"] = df.apply(get_price, axis=1)
+        df["shares"] = df.apply(get_shares, axis=1)
+        df["transaction_subtype"] = df.shares.apply(
+            lambda x: Trade.Type.REDEMPTION.value if x < 0 else Trade.Type.SUBSCRIPTION.value
+        )
+
+        df["bank"] = df["REGISTER_DEAL_NAME"]
+        df["external_identifier2"] = df["NORDER"]
+        df["register__register_reference"] = df["REGISTER_ID1"]
+        df["external_id"] = df.apply(assemble_transaction_reference, axis=1)
+
+        if "TRANSFER_REGISTER" in df:
+            del df["TRANSFER_REGISTER"]
+        remove_not_needed_columns(df)
+        # Convert df to list of dicts
+        data = df.rename(columns={"trade_date": "transaction_date"}).to_dict("records")
+    return {"data": data}