wbportfolio 2.2.1__py2.py3-none-any.whl

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}

wbportfolio/import_export/parsers/sg_lux/customer_trade_slk.py

@@ -0,0 +1,80 @@
+import csv
+from io import StringIO
+
+import numpy as np
+import pandas as pd
+from wbportfolio.models import Product, Trade
+from xlrd import xldate_as_datetime
+
+from .sylk import SYLK
+from .utils import get_portfolio_id
+
+
+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=[1, 3, 4, 7, 10, 15, 16, 17, 18, 20, 21])
+    if not df.empty:
+        # 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: xldate_as_datetime(x, datemode=0).date())
+        df["trans_date"] = df["trans_date"].apply(lambda x: x.strftime("%Y-%m-%d"))
+        df["settl_date"] = df["settl_date"].apply(lambda x: xldate_as_datetime(x, datemode=0).date())
+        df["settl_date"] = df["settl_date"].apply(lambda x: x.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"]
+
+        # 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])
+
+        del df["cust_ref"]
+
+        # Rename Columns
+
+        df.columns = [
+            "register__register_reference",
+            "bank",
+            "underlying_instrument",
+            "transaction_date",
+            "value_date",
+            "external_id",
+            "price",
+            "shares",
+            "comment",
+        ]
+        df["transaction_subtype"] = df.shares.apply(
+            lambda x: Trade.Type.REDEMPTION.value if x < 0 else Trade.Type.SUBSCRIPTION.value
+        )
+        df["portfolio"] = df["underlying_instrument"].apply(lambda x: get_portfolio_id(x))
+        df["underlying_instrument"] = df["underlying_instrument"].apply(
+            lambda x: {"id": x, "instrument_type": "product"}
+        )
+        df["pending"] = False
+        # Convert df to list of dicts
+        data = df.to_dict("records")
+
+    return {
+        "data": data,
+    }

wbportfolio/import_export/parsers/sg_lux/customer_trade_without_pw.py

@@ -0,0 +1,57 @@
+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):
+    data = list()
+
+    df = pd.read_excel(import_source.file.open(), 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}

wbportfolio/import_export/parsers/sg_lux/equity.py

@@ -0,0 +1,137 @@
+import datetime
+import re
+from contextlib import suppress
+
+import numpy as np
+import pandas as pd
+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"
+
+    return {
+        "isin": isin[0],
+        "valuation_date": datetime.datetime.strptime(dates[0], "%Y-%m-%d").date(),
+        "generation_date": datetime.datetime.strptime(dates[1], "%Y-%m-%d").date(),
+    }
+
+
+def get_exchange(row):
+    if str(row["Asset type code"]) == "VMOB" and row["Bloom Ticker"]:
+        with suppress(ValueError):
+            [_, exchange] = str(row["Bloom Ticker"]).replace(" Equity", "").replace(" EQUITY", "").split(" ")
+            return {"bbg_exchange_codes": exchange}
+    return None
+
+
+def get_underlying_instrument(row):
+    if str(row["Asset type code"]) == "VMOB":
+        data = {
+            "instrument_type": "equity",
+            "currency__key": row["currency__key"],
+            "isin": row["Asset Code"] or row["Security code"],
+            "name": row["Asset description"],
+        }
+        if bloomberg_ticker := row.get("Bloom Ticker", None):
+            tickers = str(bloomberg_ticker).replace(" Equity", "").replace(" EQUITY", "").split(" ")
+            if len(tickers) > 0:
+                data["ticker"] = tickers[0]
+            if len(tickers) > 1:
+                data["exchange"] = {"bbg_exchange_codes": tickers[1]}
+        return data
+    return None
+
+
+def parse(import_source):
+    # Load file into a CSV DictReader and convert the encoding to latin1 due to hyphonation
+    csv_file = import_source.file.open()
+    # csv_file = codecs.iterdecode(csv_file, "latin1")
+
+    cols = [0, 2, 4, 6, 7, 8, 10, 13, 27, 28, 64, 67]
+
+    df = pd.read_csv(csv_file, encoding="latin1", usecols=cols)
+    df = df.replace([np.inf, -np.inf, np.nan], None)
+    columns_map = {
+        "Code": "portfolio",
+        "underlying_instrument": "underlying_instrument",
+        "exchange__bbg_exchange_codes": "exchange__bbg_exchange_codes",
+        "NAV Date": "date",
+        "Quantity / Amount": "initial_shares",
+        "Price": "initial_price",
+        "Ccy": "currency__key",
+        "FX Rate": "initial_currency_fx_rate",
+        "asset_valuation_date": "asset_valuation_date",
+    }
+    df = df.rename(columns=columns_map)
+    # Substitute the Code for the ProductGroup ID
+    product_group_mapping = {
+        product_group.identifier: product_group.id
+        for product_group in ProductGroup.objects.filter(identifier__in=df["portfolio"].unique())
+    }
+
+    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)
+
+    cash_mask = df["Accounting category"].isin(["T111"])
+    cash = (
+        df.loc[
+            cash_mask,
+            ["currency__key", "initial_currency_fx_rate", "portfolio", "date", "initial_price", "initial_shares"],
+        ]
+        .groupby(["currency__key", "initial_currency_fx_rate", "portfolio", "date", "initial_price"])
+        .sum()
+        .reset_index()
+    ).copy()
+    cash["underlying_instrument"] = cash["currency__key"].apply(
+        lambda x: {"currency__key": x, "instrument_type": "cash"}
+    )
+
+    # 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"],
+        ]
+        .groupby(["currency__key", "initial_currency_fx_rate", "portfolio", "date", "initial_price"])
+        .sum()
+        .reset_index()
+    ).copy()
+    cash_equivalents["underlying_instrument"] = cash_equivalents["currency__key"].apply(
+        lambda x: {"currency__key": x, "instrument_type": "cash_equivalent"}
+    )
+
+    # 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_instrument"] = equities.apply(lambda x: get_underlying_instrument(x), axis=1)
+        equities["exchange"] = equities.apply(lambda x: get_exchange(x), axis=1)
+        del equities["Accounting category"]
+        del equities["Asset type code"]
+        del equities["Bloom Ticker"]
+        del equities["Asset description"]
+    df = pd.concat([cash, equities, cash_equivalents])
+
+    df["asset_valuation_date"] = df["date"]
+    # Rename the columns
+
+    df = df.drop(df.columns.difference(columns_map.values()), axis=1)
+
+    df["is_estimated"] = False
+    df = df.replace([np.inf, -np.inf, np.nan], None)
+    df = df[df["underlying_instrument"].notnull()]
+
+    df["weighting"] = df.initial_currency_fx_rate * df.initial_price * df.initial_shares
+    portfolio_weights = df.groupby("portfolio")["weighting"].sum()
+    df["weighting"] = df.apply(lambda x: x["weighting"] / portfolio_weights.loc[x["portfolio"]], axis=1)
+    df["portfolio"] = df["portfolio"].apply(
+        lambda x: {"id": product_group_mapping[str(x)], "instrument_type": "product_group"}
+    )
+    csv_file.close()
+    return {"data": df.to_dict("records")}

wbportfolio/import_export/parsers/sg_lux/fees.py

@@ -0,0 +1,56 @@
+import codecs
+import csv
+import datetime
+import logging
+
+from wbportfolio.import_export.utils import convert_string_to_number
+from wbportfolio.models import Fees, Product
+
+logger = logging.getLogger("importers.parsers.sglux.fee")
+# Shares class mapping between ticker to identifier
+# {
+#     "ATNRFRP": "UNIT/RG",
+#     "ATNRFRC": "UNIT/RC",
+#     "ATNRFRE": "UNIT/R1",
+#     "ATNRFRU": "UNIT/R2",
+#     "ATNRFPP": "UNIT/PG",
+#     "ATNRFPC": "UNIT/PC",
+#     "ATNRFPE": "UNIT/P1",
+#     "ATNRFPU": "UNIT/P2",
+#     "ATNRFZU": "UNIT/H",
+#     "ATNRFAU": "UNIT/A",
+#     "ATNRFBU": "UNIT/B",
+#     "ATNRFFU": "UNIT/F"
+# }
+
+
+def parse(import_source):
+    fee_file = import_source.file.open()
+    fee_file = codecs.iterdecode(fee_file, "latin1")
+
+    # Read file into a CSV Dict Reader
+    fee_reader = csv.DictReader(fee_file, delimiter=",")
+
+    # Iterate through the CSV File and parse the data into a list
+    data = list()
+
+    for fee_data in fee_reader:
+        if (fee_description := fee_data["Fees description"]) and fee_description.startswith("Investment Manager fees"):
+            share_class = fee_data["Class"]  # .split("\\")[1][0]
+            product = Product.objects.get(
+                parent__identifier=fee_data["Code"], currency__key=fee_data["Local ccy"], identifier=share_class
+            )
+            date = datetime.datetime.strptime(fee_data["NAV Date"], "%Y/%m/%d")
+            data.append(
+                {
+                    "portfolio": product.primary_portfolio.id,
+                    "linked_product": product.id,
+                    "transaction_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),
+                }
+            )
+
+    fee_file.close()
+    return {"data": data}

wbportfolio/import_export/parsers/sg_lux/perf_fees.py

@@ -0,0 +1,51 @@
+import codecs
+import csv
+import datetime
+import logging
+import re
+
+from wbportfolio.import_export.utils import convert_string_to_number
+from wbportfolio.models import Fees, Product
+
+logger = logging.getLogger("importers.parsers.sglux.perf_fees")
+
+
+def parse(import_source):
+    fee_file = import_source.file.open()
+    fee_file = codecs.iterdecode(fee_file, "latin1")
+
+    # Read file into a CSV Dict Reader
+    # fee_reader = csv.DictReader(fee_file, delimiter=',')
+    fee_reader = csv.reader(fee_file)
+    isin = re.findall("([A-Z]{2}[A-Z0-9]{9}[0-9]{1})", import_source.file.name)[0]
+    product = Product.objects.get(isin=isin)
+
+    # Iterate through the CSV File and parse the data into a list
+    data = list()
+
+    for fee_data in fee_reader:
+        date = datetime.datetime.strptime(fee_data[0], "%m/%d/%Y")
+        data.append(
+            {
+                "portfolio": product.primary_portfolio.id,
+                "linked_product": product.id,
+                "transaction_date": date.strftime("%Y-%m-%d"),
+                "calculated": False,
+                "transaction_subtype": Fees.Type.PERFORMANCE,
+                "total_value": round(convert_string_to_number(fee_data[1]), 6),
+            }
+        )
+        data.append(
+            {
+                "portfolio": product.primary_portfolio.id,
+                "linked_product": product.id,
+                "transaction_date": date.strftime("%Y-%m-%d"),
+                "calculated": False,
+                "transaction_subtype": Fees.Type.PERFORMANCE_CRYSTALIZED,
+                "total_value": round(convert_string_to_number(fee_data[2]), 6),
+            }
+        )
+
+    fee_file.close()
+
+    return {"data": data}