wbportfolio 1.52.0__py2.py3-none-any.whl → 1.59.4__py2.py3-none-any.whl

wbportfolio/import_export/handlers/asset_position.py

@@ -1,6 +1,6 @@
 from collections import defaultdict
 from contextlib import suppress
-from datetime import datetime
+from datetime import datetime, timedelta
 from decimal import Decimal
 from itertools import chain
 from typing import Any, Dict, List, Optional
@@ -9,7 +9,8 @@ from django.core.exceptions import ObjectDoesNotExist
 from django.db import models
 from wbcore.contrib.authentication.authentication import User
 from wbcore.contrib.currency.import_export.handlers import CurrencyImportHandler
-from wbcore.contrib.io.exceptions import DeserializationError
+from wbcore.contrib.currency.models import Currency
+from wbcore.contrib.io.exceptions import DeserializationError, SkipImportError
 from wbcore.contrib.io.imports import ImportExportHandler
 from wbcore.contrib.notifications.dispatch import send_notification
 from wbfdm.import_export.handlers.instrument import InstrumentImportHandler
@@ -30,16 +31,24 @@ class AssetPositionImportHandler(ImportExportHandler):
         self.instrument_price_handler = InstrumentPriceImportHandler(self.import_source)
         self.currency_handler = CurrencyImportHandler(self.import_source)
 
-    def _deserialize(self, data: Dict[str, Any]):
+    def _deserialize(self, data: Dict[str, Any]):  # noqa: C901
         from wbportfolio.models import Portfolio
 
         portfolio_data = data.pop("portfolio", None)
         underlying_quote_data = data.pop("underlying_quote", data.pop("underlying_instrument", None))
         if "currency" in data:
-            data["currency"] = self.currency_handler.process_object(
-                data["currency"], read_only=True, raise_exception=False
-            )[0]
+            currency = self.currency_handler.process_object(data["currency"], read_only=True, raise_exception=False)[0]
+            # we do not support GBX in our instrument table
+            if currency.key == "GBX":
+                currency = Currency.objects.get(key="GBP")
+                if "initial_price" in data:
+                    data["initial_price"] /= 1000
+            data["currency"] = currency
         data["date"] = datetime.strptime(data["date"], "%Y-%m-%d").date()
+
+        # ensure that the position falls into a weekday
+        if data["date"].weekday() == 5:
+            data["date"] -= timedelta(days=1)
         if data.get("asset_valuation_date", None):
             data["asset_valuation_date"] = datetime.strptime(data["asset_valuation_date"], "%Y-%m-%d").date()
         else:
@@ -73,16 +82,19 @@ class AssetPositionImportHandler(ImportExportHandler):
                     data["initial_price"] = data["underlying_quote"].get_price(
                         data["date"], price_date_timedelta=self.MAX_PRICE_DATE_TIMEDELTA
                     )
-                except ValueError:
-                    raise DeserializationError("Price not provided but can not be found automatically")
+                except ValueError as e:
+                    raise DeserializationError("Price not provided but can not be found automatically") from e
 
         # number type deserialization and sanitization
         # ensure the provided Decimal field are of type Decimal
         decimal_fields = ["initial_currency_fx_rate", "initial_price", "initial_shares", "weighting"]
         for field in decimal_fields:
-            if not (value := data.get(field, None)) is None:
+            if (value := data.get(field, None)) is not None:
                 data[field] = Decimal(value)
 
+        if data["weighting"] == 0:
+            raise SkipImportError("exclude position whose weight is 0")
+
     def _process_raw_data(self, data: Dict[str, Any]):
         if prices := data.get("prices", None):
             self.import_source.log += "Instrument Prices found: Importing"
@@ -146,7 +158,7 @@ class AssetPositionImportHandler(ImportExportHandler):
             for position in leftovers_positions:
                 position.delete()
             for val_date in sorted(dates):
-                trigger_portfolio_change_as_task.delay(portfolio.id, val_date, recompute_weighting=True)
+                trigger_portfolio_change_as_task.delay(portfolio.id, val_date, fix_quantization=True)
 
             # check if portfolio as custodian
             latest_date = max(dates)

wbportfolio/import_export/handlers/dividend.py

@@ -19,7 +19,7 @@ class DividendImportHandler(ImportExportHandler):
         self.currency_handler = CurrencyImportHandler(self.import_source)
 
     def _deserialize(self, data):
-        data["transaction_date"] = datetime.strptime(data["transaction_date"], "%Y-%m-%d").date()
+        data["ex_date"] = datetime.strptime(data["ex_date"], "%Y-%m-%d").date()
         data["value_date"] = datetime.strptime(data["value_date"], "%Y-%m-%d").date()
         from wbportfolio.models import Portfolio
 
@@ -36,18 +36,18 @@ class DividendImportHandler(ImportExportHandler):
             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):
+            if (value := data.get(field.name, None)) is not 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']}"
+        self.import_source.log += f"\nParameter: Portfolio={data['portfolio']} Underlying={data['underlying_instrument']} Date={data['ex_date']}"
         dividends = history if history is not None else self.model.objects
 
         dividends = dividends.filter(
             portfolio=data["portfolio"],
-            transaction_date=data["transaction_date"],
+            ex_date=data["ex_date"],
             value_date=data["value_date"],
             underlying_instrument=data["underlying_instrument"],
             price_gross=data["price_gross"],
@@ -63,10 +63,10 @@ class DividendImportHandler(ImportExportHandler):
     def _get_history(self: models.Model, history: Dict[str, Any]) -> models.QuerySet:
         from wbportfolio.models import Product
 
-        val_date = datetime.strptime(history["transaction_date"], "%Y-%m-%d")
+        val_date = datetime.strptime(history["value_date"], "%Y-%m-%d")
         try:
             product = Product.objects.get(**history.get("product", {}))
-            dividends = self.model.objects.filter(transaction_date__lte=val_date, portfolio=product.primary_portfolio)
+            dividends = self.model.objects.filter(ex_date__lte=val_date, portfolio=product.primary_portfolio)
             if underlying_instrument_data := history.get("underlying_instrument"):
                 if isinstance(underlying_instrument_data, dict):
                     dividends = dividends.filter(
@@ -83,8 +83,8 @@ class DividendImportHandler(ImportExportHandler):
         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"):
+        for dividend in history.order_by("value_date"):
             self.import_source.log += (
-                f"\n{dividend.transaction_date:%d.%m.%Y}: {dividend.shares} {dividend.price} ==> Deleted"
+                f"\n{dividend.value_date:%d.%m.%Y}: {dividend.shares} {dividend.price} ==> Deleted"
             )
             dividend.delete()

wbportfolio/import_export/handlers/fees.py

@@ -3,7 +3,6 @@ from datetime import datetime
 from wbcore.contrib.currency.import_export.handlers import CurrencyImportHandler
 from wbcore.contrib.io.exceptions import DeserializationError
 from wbcore.contrib.io.imports import ImportExportHandler
-from wbfdm.models.instruments import Cash
 
 
 class FeesImportHandler(ImportExportHandler):
@@ -14,31 +13,22 @@ class FeesImportHandler(ImportExportHandler):
         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, Product
+        data["fee_date"] = datetime.strptime(
+            data.get("fee_date", data.pop("transaction_date", None)), "%Y-%m-%d"
+        ).date()
+        from wbportfolio.models import Product
 
         try:
-            linked_product_data = data.pop("linked_product", None)
-            if isinstance(linked_product_data, dict):
-                data["linked_product"] = Product.objects.get(**linked_product_data)
+            product_data = data.pop("product", None)
+            if isinstance(product_data, dict):
+                data["product"] = Product.objects.get(**product_data)
             else:
-                data["linked_product"] = Product.objects.get(id=linked_product_data)
-        except Product.DoesNotExist:
-            raise DeserializationError("There is no valid linked product for in this row.")
+                data["product"] = Product.objects.get(id=product_data)
+        except Product.DoesNotExist as e:
+            raise DeserializationError("There is no valid linked product for in this row.") from e
 
-        if "porfolio" in data:
-            data["portfolio"] = Portfolio.all_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
+            data["currency"] = data["product"].currency
         else:
             data["currency"] = self.currency_handler.process_object(data["currency"], read_only=True)[0]
         data["currency_fx_rate"] = 1.0
@@ -48,9 +38,9 @@ class FeesImportHandler(ImportExportHandler):
 
     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']}"
+        self.import_source.log += f"\nParameter: Product={data['product']} Date={data['fee_date']}"
         fees = self.model.objects.filter(
-            linked_product=data["linked_product"],
+            product=data["product"],
             fee_date=data["fee_date"],
             transaction_subtype=data["transaction_subtype"],
             calculated=data["calculated"],

wbportfolio/import_export/handlers/orders.py

@@ -0,0 +1,71 @@
+from decimal import Decimal
+from typing import Any, Dict
+
+from django.db import models
+from wbcore.contrib.io.exceptions import DeserializationError
+from wbcore.contrib.io.imports import ImportExportHandler, ImportState
+from wbcore.contrib.io.utils import nest_row
+from wbfdm.import_export.handlers.instrument import InstrumentImportHandler
+
+from wbportfolio.pms.typing import Portfolio, Position
+
+
+class OrderImportHandler(ImportExportHandler):
+    MODEL_APP_LABEL: str = "wbportfolio.Order"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.instrument_handler = InstrumentImportHandler(self.import_source)
+        self.order_proposal = None
+
+    def process_object(
+        self,
+        data: Dict[str, Any],
+        **kwargs,
+    ):
+        from wbportfolio.models import OrderProposal
+
+        data = nest_row(data)
+        underlying_instrument = self.instrument_handler.process_object(
+            data["underlying_instrument"], only_security=False, read_only=True
+        )[0]
+        self.order_proposal = OrderProposal.objects.get(id=data.pop("order_proposal_id"))
+        weighting = data.get("target_weight", data.get("weighting"))
+        shares = data.get("target_shares", data.get("shares", 0))
+        if weighting is None:
+            raise DeserializationError("We couldn't figure out the target weight column")
+        position_dto = Position(
+            underlying_instrument=underlying_instrument.id,
+            instrument_type=underlying_instrument.instrument_type.id,
+            weighting=Decimal(weighting),
+            shares=Decimal(shares),
+            currency=underlying_instrument.currency,
+            date=self.order_proposal.trade_date,
+            is_cash=underlying_instrument.is_cash,
+        )
+        return position_dto, ImportState.CREATED
+
+    def _get_history(self, history: Dict[str, Any]) -> models.QuerySet:
+        from wbportfolio.models.orders.order_proposals import OrderProposal
+
+        if order_proposal_id := history.get("order_proposal_id"):
+            # if a order proposal is provided, we delete the existing history first as otherwise, it would mess with the target weight computation
+            order_proposal = OrderProposal.objects.get(id=order_proposal_id)
+            order_proposal.orders.all().delete()
+        return self.model.objects.none()
+
+    def _post_processing_objects(self, positions: list[Position], *args, **kwargs):
+        total_weight = sum(map(lambda p: p.weighting, positions))
+        if cash_weight := Decimal("1") - total_weight:
+            cash_component = self.order_proposal.cash_component
+            positions.append(
+                Position(
+                    underlying_instrument=cash_component.id,
+                    instrument_type=cash_component.instrument_type.id,
+                    weighting=cash_weight,
+                    currency=cash_component.currency,
+                    date=self.order_proposal.trade_date,
+                    is_cash=cash_component.is_cash,
+                )
+            )
+        self.order_proposal.reset_orders(target_portfolio=Portfolio(positions))

wbportfolio/import_export/handlers/trade.py

@@ -25,7 +25,6 @@ class TradeImportHandler(ImportExportHandler):
         self.instrument_handler = InstrumentImportHandler(self.import_source)
         self.register_handler = RegisterImportHandler(self.import_source)
         self.currency_handler = CurrencyImportHandler(self.import_source)
-        self.trade_proposals = set()
 
     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):
@@ -35,67 +34,59 @@ class TradeImportHandler(ImportExportHandler):
         return super()._data_changed(_object, change_data, initial_data, **kwargs)
 
     def _deserialize(self, data: Dict[str, Any]):
-        from wbportfolio.models import Product, TradeProposal
+        from wbportfolio.models import Product
 
         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]
 
-        if trade_proposal_id := data.pop("trade_proposal_id", None):
-            trade_proposal = TradeProposal.objects.get(id=trade_proposal_id)
-            self.trade_proposals.add(trade_proposal)
-            data["value_date"] = trade_proposal.last_effective_date
-            data["transaction_date"] = trade_proposal.trade_date
-            data["trade_proposal"] = trade_proposal
-            data["portfolio"] = trade_proposal.portfolio
-            data["status"] = "DRAFT"
-        else:
-            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()
-            data["portfolio"] = Portfolio._get_or_create_portfolio(
-                self.instrument_handler, data.get("portfolio", data["underlying_instrument"])
-            )
+        if external_id_alternative := data.get("external_id_alternative", None):
+            data["external_id_alternative"] = str(external_id_alternative)
+        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()
+        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 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]
+        if register_data := data.get("register", None):
+            data["register"] = self.register_handler.process_object(register_data)[0]
 
-            data["marked_for_deletion"] = data.get("marked_for_deletion", False)
+        data["marked_for_deletion"] = data.get("marked_for_deletion", False)
         if underlying_instrument := data.get("underlying_instrument"):
             if nominal := data.pop("nominal", None):
                 try:
                     product = Product.objects.get(id=underlying_instrument.id)
                     data["shares"] = nominal / product.share_price
-                except Product.DoesNotExist:
+                except Product.DoesNotExist as e:
                     raise DeserializationError(
                         "We cannot compute the number of shares from the nominal value as we cannot find the product share price."
-                    )
+                    ) from e
         else:
             raise DeserializationError("We couldn't find a valid underlying instrument this row.")
 
         for field in self.model._meta.get_fields():
-            if not (value := data.get(field.name, None)) is None and isinstance(field, models.DecimalField):
+            if (value := data.get(field.name, None)) is not None and isinstance(field, models.DecimalField):
                 q = (
                     1 / (math.pow(10, 4))
                 )  # we need that convertion mechanism otherwise there is floating point approximation error while casting to decimal and get_instance does not work as expected
                 data[field.name] = Decimal(value).quantize(Decimal(str(q)))
+        if (target_weight := data.pop("target_weight", None)) is not None:
+            data["_target_weight"] = target_weight
 
     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:
+    def _get_instance(self, data: Dict[str, Any], history: Optional[models.QuerySet] = None, **kwargs) -> models.Model:  # noqa: C901
         self.import_source.log += "\nGet Trade Instance."
         if transaction_date := data.get("transaction_date"):
             dates_lookup = {"transaction_date": transaction_date}
@@ -108,25 +99,23 @@ class TradeImportHandler(ImportExportHandler):
         if history.exists():
             queryset = history
         else:
-            queryset = self.model.objects.filter(marked_for_deletion=False)
+            queryset = self.model.objects.filter(marked_for_deletion=False).exclude(id__in=self.processed_ids)
 
         queryset = queryset.filter(
             models.Q(underlying_instrument=data["underlying_instrument"]) & models.Q(**dates_lookup)
         )
         if "shares" in data:
             queryset = queryset.filter(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:
+            external_id_queryset = queryset.filter(external_id=external_id)
+            if external_id_queryset.count() == 1:
                 self.import_source.log += f"External ID {external_id} provided -> Load CustomerTrade"
-                return queryset.first()
-
+                return external_id_queryset.first()
         if portfolio := data.get("portfolio", None):
             queryset = queryset.filter(portfolio=portfolio)
         if queryset.exists():
@@ -152,6 +141,7 @@ class TradeImportHandler(ImportExportHandler):
             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:
@@ -160,35 +150,30 @@ class TradeImportHandler(ImportExportHandler):
         self.import_source.log += "\nNo trade was successfully matched."
 
     def _get_history(self, history: Dict[str, Any]) -> models.QuerySet:
-        if trade_proposal_id := history.get("trade_proposal_id"):
-            # if a trade proposal is provided, we delete the existing history first as otherwise, it would mess with the target weight computation
-            self.model.objects.filter(trade_proposal_id=trade_proposal_id).delete()
-            trades = self.model.objects.none()
-        else:
-            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_data := history.get("underlying_instrument"):
-                if isinstance(underlying_instrument_data, dict):
-                    trades = trades.filter(
-                        **{f"underlying_instrument__{k}": v for k, v in underlying_instrument_data.items()}
-                    )
-                else:
-                    trades = trades.filter(underlying_instrument__id=underlying_instrument_data)
-
-            elif "underlying_instruments" in history:
-                trades = trades.filter(underlying_instrument__id__in=history["underlying_instruments"])
+        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_data := history.get("underlying_instrument"):
+            if isinstance(underlying_instrument_data, dict):
+                trades = trades.filter(
+                    **{f"underlying_instrument__{k}": v for k, v in underlying_instrument_data.items()}
+                )
             else:
-                raise ValueError("We cannot estimate history without at least the underlying instrument")
+                trades = trades.filter(underlying_instrument__id=underlying_instrument_data)
+
+        elif "underlying_instruments" in history:
+            trades = trades.filter(underlying_instrument__id__in=history["underlying_instruments"])
+        else:
+            raise ValueError("We cannot estimate history without at least the underlying instrument")
         return trades
 
     def _post_processing_objects(
@@ -203,12 +188,6 @@ class TradeImportHandler(ImportExportHandler):
             if instrument.instrument_type.key == "product":
                 update_outstanding_shares_as_task.delay(instrument.id)
 
-        # if the trade import relates to a trade proposal, we reset the TP after the import to ensure it contains the deleted positions (often forgotten by user)
-        for changed_trade_proposal in self.trade_proposals:
-            changed_trade_proposal.reset_trades(
-                target_portfolio=changed_trade_proposal._build_dto().convert_to_portfolio()
-            )
-
     def _post_processing_updated_object(self, _object):
         if _object.marked_for_deletion:
             _object.marked_for_deletion = False
@@ -227,8 +206,5 @@ class TradeImportHandler(ImportExportHandler):
             self.import_source.log += (
                 f"{trade.transaction_date:%d.%m.%Y}: {trade.shares} {trade.bank} ==> Marked for deletion"
             )
-            if trade.trade_proposal:
-                trade.delete()
-            else:
-                trade.marked_for_deletion = True
-                trade.save()
+            trade.marked_for_deletion = True
+            trade.save()

wbportfolio/import_export/parsers/default_mapping.py

@@ -7,7 +7,7 @@ def parse(import_source):
     if (
         (data_backend := import_source.source.data_backend)
         and (backend_class := data_backend.backend_class)
-        and (default_mapping := getattr(backend_class, "DEFAULT_MAPPING"))
+        and (default_mapping := backend_class.DEFAULT_MAPPING)
     ):
         df = pd.read_json(import_source.file, orient="records")
         if not df.empty:

wbportfolio/import_export/parsers/jpmorgan/customer_trade.py

@@ -11,8 +11,8 @@ from wbportfolio.models import Product, Trade
 def file_name_parse(file_name):
     dates = re.findall("([0-9]{8})", file_name)
 
-    assert len(dates) > 0
-
+    if len(dates) <= 0:
+        raise ValueError("No dates found in the filename")
     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)

wbportfolio/import_export/parsers/jpmorgan/fees.py

@@ -14,8 +14,8 @@ 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"
-
+    if len(dates) != 1:
+        raise ValueError("Not exactly 1 date found in the filename")
     return {"valuation_date": datetime.datetime.strptime(dates[0], "%Y%m%d").date()}
 
 
@@ -34,8 +34,8 @@ def parse(import_source):
         isin = fee_data["ISIN"]
         fee_date = fee_data["Date"]
         base_data = {
-            "linked_product": {"isin": isin},
-            "transaction_date": fee_date.strftime("%Y-%m-%d"),
+            "product": {"isin": isin},
+            "fee_date": fee_date.strftime("%Y-%m-%d"),
             "calculated": False,
         }
         data.append(