wbportfolio 1.55.9__py2.py3-none-any.whl → 1.56.0__py2.py3-none-any.whl

wbportfolio/import_export/parsers/ubs/valuation.py

@@ -11,7 +11,8 @@ from wbportfolio.import_export.utils import get_file_extension
 def file_name_parse(file_name):
     isin = re.findall("([A-Z]{2}[A-Z0-9]{9}[0-9]{1})", file_name)
 
-    assert len(isin) == 1, "Not exactly 1 isin found in the filename"
+    if len(isin) != 1:
+        raise ValueError("Not exactly 1 isin found in the filename")
 
     return {
         "isin": isin[0],

wbportfolio/import_export/utils.py

@@ -24,7 +24,9 @@ def convert_string_to_number(string):
         return 0.0
 
 
-def parse_date(date, formats=[]):
+def parse_date(date, formats: list | None = None):
+    if formats is None:
+        formats = []
     if isinstance(date, int) or isinstance(date, float):
         return xldate_as_datetime(int(date), 0).date()
     if isinstance(date, str):

wbportfolio/metric/backends/base.py

@@ -4,7 +4,7 @@ import numpy as np
 import pandas as pd
 from django.db.models import QuerySet
 from wbfdm.contrib.metric.backends.base import AbstractBackend, Metric
-from wbfdm.contrib.metric.exceptions import MetricInvalidParameterException
+from wbfdm.contrib.metric.exceptions import MetricInvalidParameterError
 
 from wbportfolio.models import AssetPosition, Portfolio
 
@@ -62,7 +62,7 @@ class PortfolioMetricBaseBackend(AbstractBackend[Portfolio]):
         try:
             return qs.latest("date").date
         except AssetPosition.DoesNotExist:
-            raise MetricInvalidParameterException()
+            raise MetricInvalidParameterError() from None
 
     def get_queryset(self) -> QuerySet[Portfolio]:
         product_portfolios = super().get_queryset().filter_active_and_tracked()

wbportfolio/migrations/0090_dividendtransaction_price_fx_portfolio_and_more.py

@@ -0,0 +1,44 @@
+# Generated by Django 5.0.12 on 2025-09-18 08:48
+
+import django.db.models.expressions
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('wbportfolio', '0089_orderproposal_min_weighting'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='dividendtransaction',
+            name='price_fx_portfolio',
+            field=models.GeneratedField(db_persist=True, expression=django.db.models.expressions.CombinedExpression(models.F('currency_fx_rate'), '*', models.F('price')), output_field=models.DecimalField(decimal_places=4, max_digits=20)),
+        ),
+        migrations.AddField(
+            model_name='dividendtransaction',
+            name='price_gross_fx_portfolio',
+            field=models.GeneratedField(db_persist=True, expression=django.db.models.expressions.CombinedExpression(models.F('currency_fx_rate'), '*', models.F('price_gross')), output_field=models.DecimalField(decimal_places=4, max_digits=20)),
+        ),
+        migrations.AddField(
+            model_name='order',
+            name='price_fx_portfolio',
+            field=models.GeneratedField(db_persist=True, expression=django.db.models.expressions.CombinedExpression(models.F('currency_fx_rate'), '*', models.F('price')), output_field=models.DecimalField(decimal_places=4, max_digits=20)),
+        ),
+        migrations.AddField(
+            model_name='order',
+            name='price_gross_fx_portfolio',
+            field=models.GeneratedField(db_persist=True, expression=django.db.models.expressions.CombinedExpression(models.F('currency_fx_rate'), '*', models.F('price_gross')), output_field=models.DecimalField(decimal_places=4, max_digits=20)),
+        ),
+        migrations.AddField(
+            model_name='trade',
+            name='price_fx_portfolio',
+            field=models.GeneratedField(db_persist=True, expression=django.db.models.expressions.CombinedExpression(models.F('currency_fx_rate'), '*', models.F('price')), output_field=models.DecimalField(decimal_places=4, max_digits=20)),
+        ),
+        migrations.AddField(
+            model_name='trade',
+            name='price_gross_fx_portfolio',
+            field=models.GeneratedField(db_persist=True, expression=django.db.models.expressions.CombinedExpression(models.F('currency_fx_rate'), '*', models.F('price_gross')), output_field=models.DecimalField(decimal_places=4, max_digits=20)),
+        ),
+    ]

wbportfolio/models/asset.py

@@ -5,6 +5,7 @@ from decimal import Decimal, InvalidOperation
 from typing import TYPE_CHECKING
 
 from django.contrib import admin
+from django.core.exceptions import ObjectDoesNotExist
 from django.db import models
 from django.db.models import (
     Case,
@@ -408,7 +409,7 @@ class AssetPosition(ImportMixin, models.Model):
     analytical_objects = AnalyticalAssetPositionManager()
     unannotated_objects = models.Manager()
 
-    def pre_save(
+    def pre_save(  # noqa: C901
         self, create_underlying_quote_price_if_missing: bool = False, infer_underlying_quote_price: bool = True
     ):
         if not self.asset_valuation_date:
@@ -429,7 +430,7 @@ class AssetPosition(ImportMixin, models.Model):
         ):
             try:
                 self.underlying_quote = self.underlying_instrument.children.get(is_primary=True)
-            except:
+            except ObjectDoesNotExist:
                 self.underlying_quote = self.underlying_instrument
 
         if not getattr(self, "currency", None):

wbportfolio/models/builder.py

@@ -225,7 +225,6 @@ class AssetPositionBuilder:
 
     def bulk_create_positions(self, delete_leftovers: bool = False, force_save: bool = False, **kwargs):
         positions = list(self.get_positions(**kwargs))
-
         # we need to delete the existing estimated portfolio because otherwise we risk to have existing and not
         # overlapping positions remaining (as they will not be updating by the bulk create). E.g. when someone
         # change completely the trades of a portfolio model and drift it.

wbportfolio/models/custodians.py

@@ -32,7 +32,7 @@ class Custodian(WBModel):
 
     @classmethod
     def get_by_mapping(cls, mapping: str, use_similarity=False, create_missing=True):
-        SIMILIRATY_SCORE = 0.7
+        similarity_score = 0.7
         lower_mapping = mapping.lower()
         try:
             return cls.objects.get(mapping__contains=[lower_mapping])
@@ -40,7 +40,7 @@ class Custodian(WBModel):
             if use_similarity:
                 similar_custodians = cls.objects.annotate(
                     similarity_score=TrigramSimilarity("name", lower_mapping)
-                ).filter(similarity_score__gt=SIMILIRATY_SCORE)
+                ).filter(similarity_score__gt=similarity_score)
                 if similar_custodians.count() == 1:
                     custodian = similar_custodians.first()
                     print(f"find similar custodian {lower_mapping} -> {custodian.name}")  # noqa: T201
@@ -50,7 +50,7 @@ class Custodian(WBModel):
                 else:
                     similar_companies = Company.objects.annotate(
                         similarity_score=TrigramSimilarity("name", lower_mapping)
-                    ).filter(similarity_score__gt=SIMILIRATY_SCORE)
+                    ).filter(similarity_score__gt=similarity_score)
                     if similar_companies.count() == 1:
                         print(  # noqa: T201
                             f"Find similar company {lower_mapping} -> {similar_companies.first().name}"

wbportfolio/models/exceptions.py

@@ -1,2 +1,2 @@
-class InvalidAnalyticPortfolio(Exception):
+class InvalidAnalyticPortfolioError(Exception):
     pass

wbportfolio/models/graphs/utils.py

@@ -3,21 +3,21 @@ import plotly.graph_objects as go
 from networkx.drawing.nx_agraph import graphviz_layout
 
 
-def reformat_graph_layout(G, layout):
+def reformat_graph_layout(g, layout):
     """
     this method provide positions based on layout algorithm
-    :param G:
+    :param g:
     :param layout:
     :return:
     """
     if layout == "graphviz":
-        positions = graphviz_layout(G)
+        positions = graphviz_layout(g)
     elif layout == "spring":
-        positions = nx.fruchterman_reingold_layout(G, k=0.5, iterations=1000)
+        positions = nx.fruchterman_reingold_layout(g, k=0.5, iterations=1000)
     elif layout == "spectral":
-        positions = nx.spectral_layout(G, scale=0.1)
+        positions = nx.spectral_layout(g, scale=0.1)
     elif layout == "random":
-        positions = nx.random_layout(G)
+        positions = nx.random_layout(g)
     else:
         raise Exception("please specify the layout from graphviz, spring, spectral or random")
 
@@ -25,7 +25,7 @@ def reformat_graph_layout(G, layout):
 
 
 def networkx_graph_to_plotly(
-    G: nx.Graph,
+    g: nx.Graph,
     labels: dict[str, str] | None = None,
     node_size: int = 10,
     edge_weight: int = 1,
@@ -36,12 +36,12 @@ def networkx_graph_to_plotly(
     """
     Visualize a NetworkX graph using Plotly.
     """
-    positions = reformat_graph_layout(G, layout)
+    positions = reformat_graph_layout(g, layout)
     if not labels:
         labels = {}
     # Initialize edge traces
     edge_traces = []
-    for edge in G.edges():
+    for edge in g.edges():
         x0, y0 = positions[edge[0]]
         x1, y1 = positions[edge[1]]
 
@@ -52,12 +52,12 @@ def networkx_graph_to_plotly(
 
     # Initialize node trace
     node_x, node_y, node_colors, node_labels = [], [], [], []
-    for node in G.nodes():
+    for node in g.nodes():
         x, y = positions[node]
         node_x.append(x)
         node_y.append(y)
         node_labels.append(labels.get(node, node))
-        node_colors.append(len(list(G.neighbors(node))))  # Color based on degree
+        node_colors.append(len(list(g.neighbors(node))))  # Color based on degree
 
     node_trace = go.Scatter(
         x=node_x,

wbportfolio/models/mixins/liquidity_stress_test.py

@@ -834,7 +834,7 @@ class LiquidityStressMixin:
 
     """ The main function for the liquidity stress tests """
 
-    def liquidity_stress_test(
+    def liquidity_stress_test(  # noqa: C901
         self,
         report_date: Optional[date] = None,
         weights_date: Optional[date] = None,

wbportfolio/models/orders/order_proposals.py

@@ -527,10 +527,11 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             total_target_weight=self.total_expected_target_weight,
         )
         leftovers_orders = self.orders.all()
+        portfolio_value = self.portfolio_total_asset_value
         for underlying_instrument_id, order_dto in service.trades_batch.trades_map.items():
             with suppress(Order.DoesNotExist):
                 order = self.orders.get(underlying_instrument_id=underlying_instrument_id)
-                order.weighting = round(order_dto.delta_weight, Order.ORDER_WEIGHTING_PRECISION)
+                order.set_weighting(round(order_dto.delta_weight, Order.ORDER_WEIGHTING_PRECISION), portfolio_value)
                 order.save()
                 leftovers_orders = leftovers_orders.exclude(id=order.id)
         leftovers_orders.delete()
@@ -539,11 +540,12 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
     def fix_quantization(self):
         if self.orders.exists():
             orders = self.get_orders()
+            portfolio_value = self.portfolio_total_asset_value
             t_weight = orders.aggregate(models.Sum("target_weight"))["target_weight__sum"] or Decimal("0.0")
             # we handle quantization error due to the decimal max digits. In that case, we take the biggest order (highest weight) and we remove the quantization error
             if quantize_error := (t_weight - self.total_expected_target_weight):
                 biggest_order = orders.exclude(underlying_instrument__is_cash=True).latest("target_weight")
-                biggest_order.weighting -= quantize_error
+                biggest_order.set_weighting(biggest_order.weighting - quantize_error, portfolio_value)
                 biggest_order.save()
 
     def _get_default_target_portfolio(self, use_desired_target_weight: bool = False, **kwargs) -> PortfolioDTO:
@@ -594,6 +596,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                 orders = service.trades_batch.trades_map.values()
 
             objs = []
+            portfolio_value = self.portfolio_total_asset_value
             for order_dto in orders:
                 instrument = Instrument.objects.get(id=order_dto.underlying_instrument)
                 currency_fx_rate = instrument.currency.convert(
@@ -604,7 +607,6 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                 daily_return = order_dto.daily_return
                 try:
                     order = self.orders.get(underlying_instrument=instrument)
-                    order.weighting = weighting
                     order.currency_fx_rate = currency_fx_rate
                     order.daily_return = daily_return
                 except Order.DoesNotExist:
@@ -616,11 +618,12 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                         daily_return=daily_return,
                         currency_fx_rate=currency_fx_rate,
                     )
+                order.pre_save()
+                order.set_weighting(weighting, portfolio_value)
                 order.desired_target_weight = order_dto.target_weight
                 order.order_type = Order.get_type(
                     weighting, round(order_dto.previous_weight, 8), round(order_dto.target_weight, 8)
                 )
-                order.pre_save()
                 # # if we cannot automatically find a price, we consider the stock is invalid and we sell it
                 # if not order.price and order.weighting > 0:
                 #     order.price = Decimal("0.0")
@@ -638,7 +641,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                     "price",
                     "price_gross",
                     "desired_target_weight",
-                    # "shares"
+                    "shares",
                 ],
                 unique_fields=["order_proposal", "underlying_instrument"],
                 update_conflicts=True,
@@ -675,7 +678,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
                 except (ValidationError, DatabaseError) as e:
                     self.status = OrderProposal.Status.FAILED
                     if not silent_exception:
-                        raise ValidationError(e)
+                        raise ValidationError(e) from e
                     return
             logger.info("Submitting order proposal ...")
             self.submit()
@@ -790,7 +793,6 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         price_fx_portfolio = quote_price * underlying_quote.currency.convert(
             self.trade_date, self.portfolio.currency, exact_lookup=False
         )
-
         # If the price is valid, calculate and return the estimated shares
         if price_fx_portfolio:
             return trade_total_value_fx_portfolio / price_fx_portfolio
@@ -888,6 +890,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
             order_warnings = order.submit(
                 by=by, description=description, portfolio_total_asset_value=self.portfolio_total_asset_value, **kwargs
             )
+
             if order_warnings:
                 orders_validation_warnings.extend(order_warnings)
             orders.append(order)
@@ -1193,7 +1196,7 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         return warning
 
     def can_cancelexecution(self):
-        if not self.execution_status in [ExecutionStatus.PENDING, ExecutionStatus.IN_DRAFT]:
+        if self.execution_status not in [ExecutionStatus.PENDING, ExecutionStatus.IN_DRAFT]:
             return {"execution_status": "Execution can only be cancelled if it is not already executed"}
 
     def update_execution_status(self):

wbportfolio/models/orders/orders.py

@@ -71,44 +71,25 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
     execution_confirmed = models.BooleanField(default=False, verbose_name="Execution Confirmed")
     execution_comment = models.TextField(default="", blank=True, verbose_name="Execution Comment")
 
-    def submit(self, by=None, description=None, portfolio_total_asset_value=None, **kwargs):
-        warnings = []
+    order_with_respect_to = "order_proposal"
 
-        # if shares is defined and the underlying instrument defines a round lot size different than 1 and exchange allows its application, we round the share accordingly
-        if self.order_proposal and not self.portfolio.only_weighting:
-            shares = self.order_proposal.get_round_lot_size(self.shares, self.underlying_instrument)
-            if shares != self.shares:
-                warnings.append(
-                    f"{self.underlying_instrument.computed_str} has a round lot size of  {self.underlying_instrument.round_lot_size}: shares were rounded from {self.shares} to {shares}"
-                )
-            shares = round(shares)  # ensure fractional shares are converted into integer
-            # we need to recompute the delta weight has we changed the number of shares
-            if shares != self.shares:
-                self.shares = shares
-                if portfolio_total_asset_value:
-                    self.weighting = self.shares * self.price * self.currency_fx_rate / portfolio_total_asset_value
-        if abs(self.weighting) < self.order_proposal.min_weighting:
-            warnings.append(
-                f"Weighting for order {self.underlying_instrument.computed_str} ({self.weighting}) is bellow the allowed Minimum Weighting ({self.order_proposal.min_weighting})"
-            )
-            self.shares = Decimal("0")
-            self.weighting = Decimal("0")
-        if self.shares and abs(self.total_value_fx_portfolio) < self.order_proposal.min_order_value:
-            warnings.append(
-                f"Total Value for order {self.underlying_instrument.computed_str} ({self.total_value_fx_portfolio}) is bellow the allowed Minimum Order Value ({self.order_proposal.min_order_value})"
-            )
-            self.shares = Decimal("0")
-            self.weighting = Decimal("0")
-        if not self.price:
-            warnings.append(f"No price for {self.underlying_instrument.computed_str}")
-        if (
-            not self.underlying_instrument.is_cash
-            and not self.underlying_instrument.is_cash_equivalent
-            and self._target_weight < -1e-8
-        ):  # any value below -1e8 will be considered zero
-            warnings.append(f"Negative target weight for {self.underlying_instrument.computed_str}")
-        self.desired_target_weight = self._target_weight
-        return warnings
+    class Meta(OrderedModel.Meta):
+        verbose_name = "Order"
+        verbose_name_plural = "Orders"
+        indexes = [
+            models.Index(fields=["order_proposal"]),
+            models.Index(fields=["underlying_instrument", "value_date"]),
+            models.Index(fields=["portfolio", "underlying_instrument", "value_date"]),
+            models.Index(fields=["order_proposal", "underlying_instrument"]),
+            # models.Index(fields=["date", "underlying_instrument"]),
+        ]
+        constraints = [
+            models.UniqueConstraint(
+                fields=["order_proposal", "underlying_instrument"],
+                name="unique_order",
+            ),
+        ]
+        # notification_email_template = "portfolio/email/trade_notification.html"
 
     @property
     def product(self):
@@ -176,25 +157,9 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
     def _target_shares(self) -> Decimal:
         return getattr(self, "target_shares", self._effective_shares + self.shares)
 
-    order_with_respect_to = "order_proposal"
-
-    class Meta(OrderedModel.Meta):
-        verbose_name = "Order"
-        verbose_name_plural = "Orders"
-        indexes = [
-            models.Index(fields=["order_proposal"]),
-            models.Index(fields=["underlying_instrument", "value_date"]),
-            models.Index(fields=["portfolio", "underlying_instrument", "value_date"]),
-            models.Index(fields=["order_proposal", "underlying_instrument"]),
-            # models.Index(fields=["date", "underlying_instrument"]),
-        ]
-        constraints = [
-            models.UniqueConstraint(
-                fields=["order_proposal", "underlying_instrument"],
-                name="unique_order",
-            ),
-        ]
-        # notification_email_template = "portfolio/email/trade_notification.html"
+    def __str__(self):
+        ticker = f"{self.underlying_instrument.ticker}:" if self.underlying_instrument.ticker else ""
+        return f"{ticker}{self.weighting}"
 
     def pre_save(self):
         self.portfolio = self.order_proposal.portfolio
@@ -240,15 +205,72 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
                 else:
                     return Order.Type.SELL
 
-    def set_type(self):
-        self.order_type = self.get_type(self.weighting, self._previous_weight, self._target_weight)
-
     def get_price(self) -> Decimal:
         try:
             return self.underlying_instrument.get_price(self.value_date)
         except ValueError:
             return Decimal("0")
 
-    def __str__(self):
-        ticker = f"{self.underlying_instrument.ticker}:" if self.underlying_instrument.ticker else ""
-        return f"{ticker}{self.weighting}"
+    def set_type(self):
+        self.order_type = self.get_type(self.weighting, self._previous_weight, self._target_weight)
+
+    def set_weighting(self, weighting: Decimal, portfolio_value: Decimal):
+        self.weighting = weighting
+        price_fx_portfolio = self.price * self.currency_fx_rate
+        if price_fx_portfolio and portfolio_value:
+            total_value = self.weighting * portfolio_value
+            self.shares = total_value / price_fx_portfolio
+        else:
+            self.shares = Decimal("0")
+
+    def set_shares(self, shares: Decimal, portfolio_value: Decimal):
+        if portfolio_value:
+            price_fx_portfolio = self.price * self.currency_fx_rate
+            self.shares = shares
+            total_value = shares * price_fx_portfolio
+            self.weighting = total_value / portfolio_value
+        else:
+            self.weighting = self.shares = Decimal("0")
+
+    def set_total_value_fx_portfolio(self, total_value_fx_portfolio: Decimal, portfolio_value: Decimal):
+        price_fx_portfolio = self.price * self.currency_fx_rate
+        if price_fx_portfolio and portfolio_value:
+            self.shares = total_value_fx_portfolio / price_fx_portfolio
+            self.weighting = total_value_fx_portfolio / portfolio_value
+        else:
+            self.weighting = self.shares = Decimal("0")
+
+    def submit(self, by=None, description=None, portfolio_total_asset_value=None, **kwargs):
+        warnings = []
+
+        # if shares is defined and the underlying instrument defines a round lot size different than 1 and exchange allows its application, we round the share accordingly
+        if self.order_proposal and not self.portfolio.only_weighting:
+            shares = self.order_proposal.get_round_lot_size(self.shares, self.underlying_instrument)
+            if shares != self.shares:
+                warnings.append(
+                    f"{self.underlying_instrument.computed_str} has a round lot size of  {self.underlying_instrument.round_lot_size}: shares were rounded from {self.shares} to {shares}"
+                )
+            shares = round(shares)  # ensure fractional shares are converted into integer
+            # we need to recompute the delta weight has we changed the number of shares
+            if shares != self.shares:
+                self.set_shares(shares, portfolio_total_asset_value)
+        if abs(self.weighting) < self.order_proposal.min_weighting:
+            warnings.append(
+                f"Weighting for order {self.underlying_instrument.computed_str} ({self.weighting}) is bellow the allowed Minimum Weighting ({self.order_proposal.min_weighting})"
+            )
+            self.set_weighting(Decimal("0"), portfolio_total_asset_value)
+        if self.shares and abs(self.total_value_fx_portfolio) < self.order_proposal.min_order_value:
+            warnings.append(
+                f"Total Value for order {self.underlying_instrument.computed_str} ({self.total_value_fx_portfolio}) is bellow the allowed Minimum Order Value ({self.order_proposal.min_order_value})"
+            )
+            self.set_weighting(Decimal("0"), portfolio_total_asset_value)
+        if not self.price:
+            warnings.append(f"No price for {self.underlying_instrument.computed_str}")
+        if (
+            not self.underlying_instrument.is_cash
+            and not self.underlying_instrument.is_cash_equivalent
+            and self._target_weight < -1e-8
+        ):  # any value below -1e8 will be considered zero
+            warnings.append(f"Negative target weight for {self.underlying_instrument.computed_str}")
+        self.desired_target_weight = self._target_weight
+        return warnings

wbportfolio/models/portfolio.py

@@ -72,7 +72,7 @@ class DefaultPortfolioQueryset(QuerySet):
         """
         A method to sort the given queryset to return undependable portfolio first. This is very useful if a routine needs to be applied sequentially on portfolios by order of dependence.
         """
-        MAX_ITERATIONS: int = (
+        max_iterations: int = (
             5  # in order to avoid circular dependency and infinite loop, we need to stop recursion at a max depth
         )
         remaining_portfolios = set(self)
@@ -85,7 +85,7 @@ class DefaultPortfolioQueryset(QuerySet):
             dependency_relationships = PortfolioPortfolioThroughModel.objects.filter(
                 portfolio=p, dependency_portfolio__in=remaining_portfolios
             )  # get dependency portfolios
-            if iterator_counter >= MAX_ITERATIONS or (
+            if iterator_counter >= max_iterations or (
                 not dependency_relationships.exists() and not bool(parent_portfolios)
             ):  # if not dependency portfolio or parent portfolio that remained, then we yield
                 remaining_portfolios.remove(p)
@@ -949,7 +949,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                 except IndexError:
                     position.portfolio_created = None
 
-                setattr(position, "path", path)
+                position.path = path
                 position.initial_shares = None
                 if portfolio_total_asset_value and (price_fx_portfolio := position.price * position.currency_fx_rate):
                     position.initial_shares = (position.weighting * portfolio_total_asset_value) / price_fx_portfolio
@@ -982,13 +982,13 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             )
         if not to_date:
             to_date = from_date
-        for from_date in pd.date_range(from_date, to_date, freq="B").date:
-            logger.info(f"Compute Look-Through for {self} at {from_date}")
+        for val_date in pd.date_range(from_date, to_date, freq="B").date:
+            logger.info(f"Compute Look-Through for {self} at {val_date}")
             portfolio_total_asset_value = (
-                self.primary_portfolio.get_total_asset_under_management(from_date) if not self.only_weighting else None
+                self.primary_portfolio.get_total_asset_under_management(val_date) if not self.only_weighting else None
             )
             self.builder.add(
-                list(self.primary_portfolio.get_lookthrough_positions(from_date, portfolio_total_asset_value)),
+                list(self.primary_portfolio.get_lookthrough_positions(val_date, portfolio_total_asset_value)),
                 infer_underlying_quote_price=True,
             )
         self.builder.bulk_create_positions(delete_leftovers=True)

wbportfolio/models/portfolio_relationship.py

@@ -61,6 +61,9 @@ class InstrumentPortfolioThroughModel(models.Model):
             models.UniqueConstraint(fields=["instrument", "portfolio"], name="unique_portfolio_relationship"),
         ]
 
+    def __str__(self) -> str:
+        return f"{self.instrument} - {self.portfolio}"
+
     @classmethod
     def get_portfolio(cls, instrument):
         with suppress(InstrumentPortfolioThroughModel.DoesNotExist):
@@ -99,6 +102,9 @@ class PortfolioInstrumentPreferredClassificationThroughModel(models.Model):
         related_name="preferred_classification_group_throughs",
     )
 
+    def __str__(self) -> str:
+        return f"{self.portfolio} - {self.instrument}: ({self.classification})"
+
     def save(self, *args, **kwargs) -> None:
         if not self.classification_group and self.classification:
             self.classification_group = self.classification.group

wbportfolio/models/products.py

@@ -190,6 +190,9 @@ class FeeProductPercentage(models.Model):
             ),
         ]
 
+    def __str__(self) -> str:
+        return f"{self.product.name} ({self.type})"
+
     @property
     def net_percent(self) -> Decimal:
         return self.percent

wbportfolio/models/rebalancing.py

@@ -89,6 +89,9 @@ class Rebalancer(ComplexToStringMixin, models.Model):
         help_text=_("The Evaluation Frequency in RRULE format"),
     )
 
+    def __str__(self) -> str:
+        return f"{self.portfolio.name} ({self.rebalancing_model})"
+
     def save(self, *args, **kwargs):
         if not self.activation_date:
             try:

wbportfolio/models/roles.py

@@ -52,16 +52,10 @@ class PortfolioRole(models.Model):
         return f"{self.role_type} {self.person.computed_str}"
 
     def save(self, *args, **kwargs):
-        assert (
-            self.role_type in [self.RoleType.MANAGER, self.RoleType.RISK_MANAGER] and not self.instrument
-        ) or self.role_type in [
-            self.RoleType.PORTFOLIO_MANAGER,
-            self.RoleType.ANALYST,
-        ], self.default_error_messages["manager"].format(model="instrument")
-
-        assert (self.start and self.end and self.start < self.end) or (
-            not self.start or not self.end
-        ), self.default_error_messages["start_end"]
+        if self.role_type in [self.RoleType.MANAGER, self.RoleType.RISK_MANAGER] and self.instrument:
+            raise ValueError(self.default_error_messages["manager"].format(model="instrument"))
+        if self.start and self.end and self.start > self.end:
+            raise ValueError(self.default_error_messages["start_end"])
 
         super().save(*args, **kwargs)
 

wbportfolio/models/transactions/claim.py

@@ -259,9 +259,10 @@ class Claim(ReferenceIDMixin, WBModel):
         return f"{self.reference_id} {self.product.name} ({self.bank} - {self.shares:,} shares - {self.date}) "
 
     def save(self, *args, auto_match: bool = True, **kwargs):
-        assert (
-            self.shares is not None or self.nominal_amount is not None
-        ), f"Either shares or nominal amount have to be provided. Shares={self.shares}, Nominal={self.nominal_amount}"
+        if self.shares is None and self.nominal_amount is None:
+            raise ValueError(
+                f"Either shares or nominal amount have to be provided. Shares={self.shares}, Nominal={self.nominal_amount}"
+            )
         if self.product:
             if self.shares is not None:
                 self.nominal_amount = self.shares * self.product.share_price
@@ -447,7 +448,7 @@ class Claim(ReferenceIDMixin, WBModel):
         return self.can_approve()
 
     def auto_match(self) -> Trade | None:
-        SHARES_EPSILON = 1  # share
+        shares_epsilon = 1  # share
         auto_match_trade = None
         # Obvious filtering
         trades = Trade.valid_customer_trade_objects.filter(
@@ -458,7 +459,7 @@ class Claim(ReferenceIDMixin, WBModel):
             trades = trades.filter(underlying_instrument=self.product)
         # Find trades by shares (or remaining to be claimed)
         trades = trades.filter(
-            Q(diff_shares__lte=self.shares + SHARES_EPSILON) & Q(diff_shares__gte=self.shares - SHARES_EPSILON)
+            Q(diff_shares__lte=self.shares + shares_epsilon) & Q(diff_shares__gte=self.shares - shares_epsilon)
         )
         if trades.count() == 1:
             auto_match_trade = trades.first()

wbportfolio/models/transactions/dividends.py

@@ -41,6 +41,7 @@ class DividendTransaction(TransactionMixin, ImportMixin, models.Model):
     )
 
     def save(self, *args, **kwargs):
+        self.pre_save()
         if not self.record_date and self.ex_date:
             self.record_date = self.ex_date
         elif self.record_date and not self.ex_date: