wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/import_export/handlers/dividend.py

@@ -0,0 +1,80 @@
+import math
+from datetime import datetime
+from decimal import Decimal
+from typing import Any, Dict
+
+from django.db import models
+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.import_export.handlers.instrument import InstrumentImportHandler
+
+
+class DividendImportHandler(ImportExportHandler):
+    MODEL_APP_LABEL = "wbportfolio.DividendTransaction"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.instrument_handler = InstrumentImportHandler(self.import_source)
+        self.currency_handler = CurrencyImportHandler(self.import_source)
+
+    def _deserialize(self, data):
+        data["transaction_date"] = datetime.strptime(data["transaction_date"], "%Y-%m-%d").date()
+        data["value_date"] = datetime.strptime(data["value_date"], "%Y-%m-%d").date()
+        from wbportfolio.models import Portfolio
+
+        data["portfolio"] = Portfolio.objects.get(id=data["portfolio"])
+        instrument = self.instrument_handler.process_object(
+            data["underlying_instrument"], only_security=False, read_only=True
+        )[0]
+        if not instrument:
+            raise DeserializationError("Can't process this data: underlying instrument not found")
+        data["underlying_instrument"] = instrument
+        if "currency" not in data:
+            data["currency"] = data["portfolio"].currency
+        else:
+            data["currency"] = self.currency_handler.process_object(data["currency"], read_only=True)[0]
+
+        for field in self.model._meta.get_fields():
+            if not (value := data.get(field.name, None)) is None and isinstance(field, models.DecimalField):
+                q = 1 / (math.pow(10, 4))
+                data[field.name] = Decimal(value).quantize(Decimal(str(q)))
+
+    def _get_instance(self, data, history=None, **kwargs):
+        self.import_source.log += "\nGet DividendTransaction Instance."
+        self.import_source.log += f"\nParameter: Portfolio={data['portfolio']} Underlying={data['underlying_instrument']} Date={data['transaction_date']}"
+        dividends = history if history is not None else self.model.objects
+
+        dividends = dividends.filter(
+            portfolio=data["portfolio"],
+            transaction_date=data["transaction_date"],
+            value_date=data["value_date"],
+            underlying_instrument=data["underlying_instrument"],
+            price_gross=data["price_gross"],
+        )
+        if dividends.count() == 1:
+            self.import_source.log += "\nDividendTransaction Instance Found." ""
+            return dividends.first()
+
+    def _create_instance(self, data, **kwargs):
+        self.import_source.log += "\nCreate DividendTransaction."
+        return self.model.objects.create(**data, import_source=self.import_source)
+
+    def _get_history(self: models.Model, history: Dict[str, Any]) -> models.QuerySet:
+        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)
+            return dividends
+
+    def _post_processing_history(self: models.Model, history: models.QuerySet):
+        self.import_source.log += "===================="
+        self.import_source.log += (
+            "It was a historical import and the following DividendTransaction have to be deleted:"
+        )
+        for dividend in history.order_by("transaction_date"):
+            self.import_source.log += (
+                f"\n{dividend.transaction_date:%d.%m.%Y}: {dividend.shares} {dividend.price} ==> Deleted"
+            )
+            dividend.delete()

wbportfolio/import_export/handlers/fees.py

@@ -0,0 +1,58 @@
+from datetime import datetime
+
+from wbcore.contrib.currency.import_export.handlers import CurrencyImportHandler
+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"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.currency_handler = CurrencyImportHandler(self.import_source)
+
+    def _deserialize(self, data):
+        data["transaction_date"] = datetime.strptime(data["transaction_date"], "%Y-%m-%d").date()
+        data["fee_date"] = data["transaction_date"]
+        if value_date_str := data.get("value_date", None):
+            data["value_date"] = datetime.strptime(value_date_str, "%Y-%m-%d").date()
+        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
+
+        data["linked_product"] = Product.objects.get(id=data["linked_product"])
+        if "porfolio" in data:
+            data["portfolio"] = Portfolio.objects.get(id=data["portfolio"])
+        else:
+            data["portfolio"] = data["linked_product"].primary_portfolio
+        data["underlying_instrument"] = Cash.objects.filter(currency=data["portfolio"].currency).first()
+        if "currency" not in data:
+            data["currency"] = data["portfolio"].currency
+        else:
+            data["currency"] = self.currency_handler.process_object(data["currency"], read_only=True)[0]
+        data["currency_fx_rate"] = 1.0
+        data["total_value"] = data.get("total_value", data.get("total_value_gross", None))
+        data["total_value_gross"] = data.get("total_value_gross", data["total_value"])
+        data["calculated"] = data.get("calculated", False)
+
+    def _get_instance(self, data, history=None, **kwargs):
+        self.import_source.log += "\nGet Fees Instance."
+        self.import_source.log += f"\nParameter: Portfolio={data['portfolio']} Date={data['transaction_date']}"
+        fees = self.model.objects.filter(
+            linked_product=data["linked_product"],
+            fee_date=data["fee_date"],
+            transaction_subtype=data["transaction_subtype"],
+            calculated=data["calculated"],
+        )
+        if fees.exists():
+            if fees.count() > 1:
+                raise ValueError(f'Number of similar fees found > 1: {fees.values_list("id", flat=True)}')
+            self.import_source.log += "\nFees Instance Found." ""
+            return fees.first()
+
+    def _create_instance(self, data, **kwargs):
+        self.import_source.log += "\nCreate Fees."
+        return self.model.objects.create(**data, import_source=self.import_source)

wbportfolio/import_export/handlers/portfolio_cash_flow.py

@@ -0,0 +1,57 @@
+from contextlib import suppress
+from datetime import datetime
+from decimal import Decimal
+from typing import TYPE_CHECKING
+
+from django.contrib.auth import get_user_model
+from django.db.models import Q
+from wbcore.contrib.io.imports import ImportExportHandler
+from wbcore.contrib.notifications.dispatch import send_notification
+from wbportfolio.models import Portfolio
+
+if TYPE_CHECKING:
+    from wbportfolio.models.portfolio_cash_flow import DailyPortfolioCashFlow
+
+
+class DailyPortfolioCashFlowImportHandler(ImportExportHandler):
+    MODEL_APP_LABEL = "wbportfolio.DailyPortfolioCashFlow"
+
+    def _deserialize(self, data):
+        data["value_date"] = datetime.strptime(data["value_date"], "%Y-%m-%d").date()
+        data["portfolio"] = Portfolio.objects.get(id=data["portfolio"])
+        if "cash" in data:
+            data["cash"] = Decimal(data["cash"])
+
+        if "total_assets" in data:
+            data["total_assets"] = Decimal(data["total_assets"])
+
+        if "cash_flow_forecast" in data:
+            data["cash_flow_forecast"] = Decimal(data["cash_flow_forecast"])
+
+    def _get_instance(self, data, history=None, **kwargs):
+        self.import_source.log += "\nGet Daily Portfolio Cash Flow Instance."
+        self.import_source.log += f"\nParameter: Portfolio={data['portfolio']} Value Date={data['value_date']}"
+
+        with suppress(self.model.DoesNotExist):
+            return self.model.objects.get(portfolio=data["portfolio"], value_date=data["value_date"])
+
+    def _post_processing_created_object(self, _object: "DailyPortfolioCashFlow"):
+        if not _object.portfolio.daily_cashflows.filter(value_date__gt=_object.value_date).exists():
+            if _object.proposed_rebalancing != Decimal(0):
+                color = "red" if _object.proposed_rebalancing < 0 else "green"
+                for user in (
+                    get_user_model()
+                    .objects.filter(
+                        Q(user_permissions__codename="view_dailyportfoliocashflow")
+                        | Q(groups__permissions__codename="view_dailyportfoliocashflow")
+                    )
+                    .distinct()
+                ):
+                    send_notification(
+                        code="wbportfolio.dailyportfoliocashflow.notify_rebalance",
+                        title=f"Proposed Rebalancing in the portfolio: {_object.portfolio}",
+                        body=f"The workbench proposes to rebalance the portfolio {_object.portfolio} by <span style='color:{color}'>{_object.proposed_rebalancing:+,.2f}</span>",
+                        user=user,
+                        reverse_name="wbportfolio:portfoliocashflow-detail",
+                        reverse_args=[_object.pk],
+                    )

wbportfolio/import_export/handlers/register.py

@@ -0,0 +1,43 @@
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+from django.db import models
+from wbcore.contrib.geography.models import Geography
+from wbcore.contrib.io.imports import ImportExportHandler
+
+
+class RegisterImportHandler(ImportExportHandler):
+    MODEL_APP_LABEL = "wbportfolio.Register"
+
+    def _deserialize(self, data: Dict[str, Any]):
+        if "opened" in data:
+            data["opened"] = datetime.strptime(data["opened"], "%Y-%m-%d").date()
+        if residence_id := data.get("residence"):
+            data["residence"] = Geography.countries.get(id=residence_id)
+        if citizenship_id := data.get("citizenship"):
+            data["citizenship"] = Geography.countries.get(id=citizenship_id)
+        if outlet_country_id := data.get("outlet_country"):
+            data["outlet_country"] = Geography.countries.get(id=outlet_country_id)
+        if custodian_country_id := data.get("custodian_country"):
+            data["custodian_country"] = Geography.countries.get(id=custodian_country_id)
+
+        outlet_city = data.pop("outlet_city", None)
+        if (outlet_country := data.get("outlet_country", None)) and outlet_city:
+            if res := outlet_country.lookup_descendants(outlet_city, level=Geography.Level.CITY.value):
+                data["outlet_city"] = res
+
+        custodian_city = data.pop("custodian_city", None)
+        if (custodian_country := data.get("custodian_country", None)) and custodian_city:
+            if res := custodian_country.lookup_descendants(custodian_city, level=Geography.Level.CITY.value):
+                data["custodian_city"] = res
+
+    def _get_instance(self, data: Dict[str, Any], history: Optional[models.QuerySet] = None, **kwargs) -> models.Model:
+        self.import_source.log += "Get Register Instance."
+        self.import_source.log += f"Parameter: Reference={data['register_reference']}"
+        if isinstance(data, int):
+            return self.model.objects.get(id=data)
+        return self.model.objects.filter(register_reference=data["register_reference"]).first()
+
+    def _create_instance(self, data: Dict[str, Any], **kwargs) -> models.Model:
+        self.import_source.log += "Create Register."
+        return self.model.objects.create(import_source=self.import_source, **data)

wbportfolio/import_export/handlers/trade.py

@@ -0,0 +1,191 @@
+import math
+from datetime import datetime
+from decimal import Decimal
+from typing import Any, Dict, Optional
+
+from django.db import models
+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.import_export.handlers.instrument import InstrumentImportHandler
+from wbfdm.models import InstrumentType
+from wbportfolio.models.portfolio import Portfolio
+from wbportfolio.models.products import update_outstanding_shares_as_task
+from wbportfolio.utils import string_matching
+
+from .register import RegisterImportHandler
+
+
+class TradeImportHandler(ImportExportHandler):
+    MODEL_APP_LABEL: str = "wbportfolio.Trade"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.instrument_handler = InstrumentImportHandler(self.import_source)
+        self.register_handler = RegisterImportHandler(self.import_source)
+        self.currency_handler = CurrencyImportHandler(self.import_source)
+
+    def _data_changed(self, _object, change_data: Dict[str, Any], initial_data: Dict[str, Any], **kwargs):
+        if (new_register := change_data.get("register")) and (current_register := _object.register):
+            # we remplace the register only if the new one gives us more information
+            if new_register.register_reference == current_register.global_register_reference:
+                del change_data["register"]
+        return super()._data_changed(_object, change_data, initial_data, **kwargs)
+
+    def _deserialize(self, data: Dict[str, Any]):
+        if external_identifier2 := data.get("external_identifier2", None):
+            data["external_identifier2"] = str(external_identifier2)
+        if transaction_date_str := data.get("transaction_date", None):
+            data["transaction_date"] = datetime.strptime(transaction_date_str, "%Y-%m-%d").date()
+        if value_date_str := data.get("value_date", None):
+            data["value_date"] = datetime.strptime(value_date_str, "%Y-%m-%d").date()
+        if book_date_str := data.get("book_date", None):
+            data["book_date"] = datetime.strptime(book_date_str, "%Y-%m-%d").date()
+        if underlying_instrument := data.get("underlying_instrument", None):
+            data["underlying_instrument"] = self.instrument_handler.process_object(
+                underlying_instrument, only_security=False, read_only=True
+            )[0]
+        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]
+
+        if register_data := data.get("register", None):
+            data["register"] = self.register_handler.process_object(register_data)[0]
+
+        for field in self.model._meta.get_fields():
+            if not (value := data.get(field.name, None)) is None and isinstance(field, models.DecimalField):
+                q = 1 / (math.pow(10, 4))
+                data[field.name] = Decimal(value).quantize(Decimal(str(q)))
+
+        if "total_value" in data:
+            data["total_value"] = data["price"] * data["shares"]
+        if "total_value_fx_portfolio" in data:
+            data["total_value_fx_portfolio"] = data["price"] * data["shares"] * data["currency_fx_rate"]
+        data["marked_for_deletion"] = data.get("marked_for_deletion", False)
+
+    def _create_instance(self, data: Dict[str, Any], **kwargs) -> models.Model:
+        if "transaction_date" not in data:  # we might get only book date and not transaction date
+            data["transaction_date"] = data["book_date"]
+
+        return self.model.objects.create(**data, import_source=self.import_source)
+
+    def _get_instance(self, data: Dict[str, Any], history: Optional[models.QuerySet] = None, **kwargs) -> models.Model:
+        self.import_source.log += "\nGet Trade Instance."
+
+        if transaction_date := data.get("transaction_date"):
+            dates_lookup = {"transaction_date": transaction_date}
+        elif book_date := data.get("book_date"):
+            dates_lookup = {"book_date": book_date}
+        else:
+            raise DeserializationError("date lookup is missing from data")
+        self.import_source.log += f"\nParameter: Product={data['underlying_instrument']} Trade-Date={transaction_date} Shares={data['shares']}"
+
+        if history.exists():
+            queryset = history
+        else:
+            queryset = self.model.objects.filter(marked_for_deletion=False)
+
+        queryset = queryset.filter(
+            models.Q(underlying_instrument=data["underlying_instrument"])
+            & models.Q(**dates_lookup)
+            & models.Q(shares=data["shares"])
+        )
+
+        if _id := data.get("id", None):
+            self.import_source.log += f"ID {_id} provided -> Load CustomerTrade"
+            return self.model.objects.get(id=_id)
+        # We need to check for external identifiers
+        if external_id := data.get("external_id"):
+            self.import_source.log += f"\nExternal Identifier used: {external_id}"
+            queryset = queryset.filter(external_id=external_id)
+            if queryset.count() == 1:
+                self.import_source.log += f"External ID {external_id} provided -> Load CustomerTrade"
+                return queryset.first()
+
+        if portfolio := data.get("portfolio", None):
+            queryset = queryset.filter(portfolio=portfolio)
+        if queryset.exists():
+            if bank := data["bank"]:
+                self.import_source.log += (
+                    f"\n{queryset.count()} Trades found. The bank will tried to be matched against {bank}"
+                )
+                if queryset.filter(bank=bank).count() >= 1:  # exact match
+                    queryset = queryset.filter(bank=bank)
+                else:
+                    best_result = string_matching(bank, queryset.values_list("bank", flat=True))
+                    if best_result[1] >= 80:
+                        possible_trades = queryset.filter(bank=best_result[0])
+                        if possible_trades.count() > 1 and possible_trades.filter(claims__isnull=False).exists():
+                            possible_trades = possible_trades.filter(claims__isnull=False)
+                        if (
+                            possible_trades.count() >= 1
+                        ):  # If count is greater than 1, we get exact match so we return either trades
+                            queryset = possible_trades
+            if (queryset.count() > 1) and (price := data.get("price", None)):
+                if queryset.filter(price=price).count() == 1:
+                    queryset = queryset.filter(price=price)
+            if queryset.exists():
+                # We try to filter by price as well
+                trade = queryset.first()
+                if queryset.count() == 1:
+                    self.import_source.log += f"\nOne Trade found: {trade}"
+                if queryset.count() > 1:
+                    self.import_source.log += f"\nMultiple similar Trades found (returning first trade): {trade}"
+                return trade
+        self.import_source.log += "\nNo trade was successfully matched."
+
+    def _get_history(self, history: Dict[str, Any]) -> models.QuerySet:
+        trades = self.model.objects.filter(
+            exclude_from_history=False,
+            pending=False,
+            transaction_subtype__in=[
+                self.model.Type.SUBSCRIPTION,
+                self.model.Type.REDEMPTION,
+            ],  # we cannot exclude marked for deleted trade because otherwise they are never consider in the history
+        )
+        if transaction_date := history.get("transaction_date"):
+            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"])
+        elif "underlying_instruments" in history:
+            trades = trades.filter(underlying_instrument__id__in=history["underlying_instruments"])
+        else:
+            raise ValueError("We cannot estimate history without at least the underlying instrument")
+        return trades
+
+    def _post_processing_objects(
+        self,
+        created_objs: list[models.Model],
+        modified_objs: list[models.Model],
+        unmodified_objs: list[models.Model],
+    ):
+        for instrument in set(
+            map(lambda x: x.underlying_instrument, filter(lambda t: t.is_customer_trade, created_objs + modified_objs))
+        ):
+            if instrument.instrument_type.key == "product":
+                update_outstanding_shares_as_task.delay(instrument.id)
+
+    def _post_processing_updated_object(self, _object):
+        if _object.marked_for_deletion:
+            _object.marked_for_deletion = False
+            _object.save()
+            self.import_source.log += "\nMarked for deletion reverted"
+        if _object.underlying_instrument.instrument_type == InstrumentType.PRODUCT:
+            _object.link_to_internal_trade()
+
+    def _post_processing_created_object(self, _object):
+        self._post_processing_updated_object(_object)
+
+    def _post_processing_history(self, history: models.QuerySet):
+        self.import_source.log += "===================="
+        self.import_source.log += "It was a historical import and the following Trades have to be deleted:"
+        for trade in history.order_by("transaction_date"):
+            self.import_source.log += (
+                f"{trade.transaction_date:%d.%m.%Y}: {trade.shares} {trade.bank} ==> Marked for deletion"
+            )
+            trade.marked_for_deletion = True
+            trade.save()

wbportfolio/import_export/parsers/default_mapping.py

@@ -0,0 +1,30 @@
+import numpy as np
+import pandas as pd
+
+
+def parse(import_source):
+    data = []
+    if (
+        (data_backend := import_source.source.data_backend)
+        and (backend_class := data_backend.backend_class)
+        and (default_mapping := getattr(backend_class, "DEFAULT_MAPPING"))
+    ):
+        df = pd.read_json(import_source.file, orient="records")
+        if not df.empty:
+            if date_label := getattr(backend_class, "DATE_LABEL", None):
+                df[date_label] = pd.to_datetime(df[date_label])
+                df = df.sort_values(by=date_label, ascending=True)
+                if reindex_method := getattr(backend_class, "REINDEX_METHOD", None):
+                    df = df.set_index(date_label)
+                    timeline = pd.date_range(start=df.index.min(), end=df.index.max(), freq="B")
+                    df = df.reindex(timeline, method=reindex_method)
+                    df = df.reset_index(names=date_label)
+                df[date_label] = df[date_label].dt.strftime("%Y-%m-%d")
+        df = df.replace([np.inf, -np.inf, np.nan], None).rename(columns=default_mapping)
+        df = df.drop(columns=df.columns.difference([*default_mapping.values()]))
+
+        if none_nullable_fields := getattr(backend_class, "NONE_NULLABLE_FIELDS", None):
+            df = df.dropna(subset=none_nullable_fields, how="any")
+
+        data = df.to_dict("records")
+    return {"data": data}

wbportfolio/import_export/parsers/jpmorgan/customer_trade.py

@@ -0,0 +1,63 @@
+import datetime
+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, Trade
+
+
+def file_name_parse(file_name):
+    dates = re.findall("([0-9]{8})", file_name)
+
+    assert len(dates) > 0
+
+    parts_dict = {"valuation_date": datetime.datetime.strptime(dates[0], "%Y%m%d").date()}
+
+    isin = re.findall("([A-Z]{2}[A-Z0-9]{9}[0-9]{1})", file_name)
+
+    if len(isin) > 0:
+        parts_dict["isin"] = isin[0]
+
+    return parts_dict
+
+
+def parse(import_source):
+    # Load files into a CSV DictReader
+    df = pd.read_csv(import_source.file, encoding="latin1", 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)
+    df["Trade Date"] = pd.to_datetime(df["Trade Date"], format="%Y%m%d")
+    # 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()
+    for nominal_data in df.to_dict("records"):
+        product = Product.objects.get(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
+        data.append(
+            {
+                "underlying_instrument": {"id": product.id, "instrument_type": "product"},
+                "transaction_date": nominal_data["Trade Date"].strftime("%Y-%m-%d"),
+                "shares": shares,
+                "portfolio": portfolio.id,
+                # 'currency': product.currency.key,
+                "transaction_subtype": Trade.Type.REDEMPTION if shares < 0 else Trade.Type.SUBSCRIPTION,
+                "bank": nominal_data["CounterParty Name"],
+                "price": convert_string_to_number(nominal_data["Price"]),
+            }
+        )
+    import_data = {"data": data}
+    if "isin" in parts:
+        product = Product.objects.get(isin=parts["isin"])
+        import_data["history"] = {
+            "underlying_instrument": product.id,
+            "transaction_date": valuation_date.strftime("%Y-%m-%d"),
+        }
+    return import_data

wbportfolio/import_export/parsers/jpmorgan/fees.py

@@ -0,0 +1,64 @@
+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 Fees, Product
+
+logger = logging.getLogger("importers.parsers.jpmorgan.fee")
+
+
+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):
+    df = pd.read_csv(import_source.file, encoding="utf-16", delimiter=",")
+    df["Date"] = pd.to_datetime(df["Date"])
+
+    columns_fees = df.columns.difference(["ISIN", "CCY"])
+    df[columns_fees] = df[columns_fees].where(pd.notnull(df[columns_fees]), 0)
+    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 fee_data in df.to_dict("records"):
+        product = Product.objects.get(isin=fee_data["ISIN"])
+        fee_date = fee_data["Date"]
+        base_data = {
+            "portfolio": product.primary_portfolio.id,
+            "linked_product": product.id,
+            "transaction_date": fee_date.strftime("%Y-%m-%d"),
+            "calculated": False,
+        }
+        data.append(
+            {
+                "transaction_subtype": Fees.Type.PERFORMANCE,
+                "total_value": round(convert_string_to_number(fee_data.get("Perf_Fee * Units", 0)), 4),
+                "total_value_gross": round(convert_string_to_number(fee_data.get("Perf_Fee * Units", 0)), 4),
+                **base_data,
+            }
+        )
+        data.append(
+            {
+                "transaction_subtype": Fees.Type.MANAGEMENT,
+                "total_value": round(convert_string_to_number(fee_data.get("Mgmt_Fee * Units", 0)), 4),
+                **base_data,
+            }
+        )
+        data.append(
+            {
+                "transaction_subtype": Fees.Type.ISSUER,
+                "total_value": round(convert_string_to_number(fee_data.get("JPM_Fee * Units", 0)), 4),
+                **base_data,
+            }
+        )
+
+    return {"data": data}