wbportfolio 1.55.8__py2.py3-none-any.whl → 1.55.10rc0__py2.py3-none-any.whl

wbportfolio/migrations/0089_orderproposal_min_weighting.py

@@ -0,0 +1,71 @@
+# Generated by Django 5.0.12 on 2025-09-15 13:45
+
+import django.core.validators
+from decimal import Decimal
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('wbportfolio', '0088_orderproposal_total_effective_portfolio_contribution'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='orderproposal',
+            name='min_weighting',
+            field=models.DecimalField(decimal_places=8, default=Decimal('0'), help_text='The minimum weight allowed for this order proposal ', max_digits=9, verbose_name='Minimum Weight'),
+        ),
+        migrations.AddField(
+            model_name='portfolio',
+            name='default_order_proposal_min_order_value',
+            field=models.IntegerField(default=0, verbose_name='Default Order Proposal Minimum Order Value'),
+        ),
+        migrations.AddField(
+            model_name='portfolio',
+            name='default_order_proposal_min_weighting',
+            field=models.DecimalField(decimal_places=8, default=Decimal('0'), max_digits=9,
+                                      verbose_name='Default Order Proposal Minimum Weight'),
+        ),
+        migrations.AddField(
+            model_name='portfolio',
+            name='default_order_proposal_total_cash_weight',
+            field=models.DecimalField(decimal_places=4, default=Decimal('0'), max_digits=5,
+                                      verbose_name='Default Order Proposal Total Cash Weight'),
+        ),
+        migrations.AlterField(
+            model_name='orderproposal',
+            name='min_weighting',
+            field=models.DecimalField(decimal_places=8, default=Decimal('0'),
+                                      help_text='The minimum weight allowed for this order proposal ', max_digits=9,
+                                      validators=[django.core.validators.MinValueValidator(Decimal('0')),
+                                                  django.core.validators.MaxValueValidator(Decimal('1'))],
+                                      verbose_name='Minimum Weight'),
+        ),
+        migrations.AlterField(
+            model_name='orderproposal',
+            name='total_cash_weight',
+            field=models.DecimalField(decimal_places=4, default=Decimal('0'),
+                                      help_text='The desired percentage for the cash component. The remaining percentage (100% minus this value) will be allocated to total target weighting. Default is 0%.',
+                                      max_digits=5, validators=[django.core.validators.MinValueValidator(Decimal('0')),
+                                                                django.core.validators.MaxValueValidator(Decimal('1'))],
+                                      verbose_name='Total Cash Weight'),
+        ),
+        migrations.AlterField(
+            model_name='portfolio',
+            name='default_order_proposal_min_weighting',
+            field=models.DecimalField(decimal_places=8, default=Decimal('0'), max_digits=9,
+                                      validators=[django.core.validators.MinValueValidator(Decimal('0')),
+                                                  django.core.validators.MaxValueValidator(Decimal('1'))],
+                                      verbose_name='Default Order Proposal Minimum Weight'),
+        ),
+        migrations.AlterField(
+            model_name='portfolio',
+            name='default_order_proposal_total_cash_weight',
+            field=models.DecimalField(decimal_places=4, default=Decimal('0'), max_digits=5,
+                                      validators=[django.core.validators.MinValueValidator(Decimal('0')),
+                                                  django.core.validators.MaxValueValidator(Decimal('1'))],
+                                      verbose_name='Default Order Proposal Total Cash Weight'),
+        ),
+    ]

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,
@@ -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/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/orders/order_proposals.py

@@ -7,6 +7,7 @@ from typing import Any, TypeVar
 
 from celery import shared_task
 from django.core.exceptions import ValidationError
+from django.core.validators import MaxValueValidator, MinValueValidator
 from django.db import DatabaseError, models
 from django.db.models import (
     F,
@@ -96,12 +97,22 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
     min_order_value = models.IntegerField(
         default=0, verbose_name="Minimum Order Value", help_text="Minimum Order Value in the Portfolio currency"
     )
+    min_weighting = models.DecimalField(
+        max_digits=9,
+        decimal_places=Order.ORDER_WEIGHTING_PRECISION,
+        default=Decimal(0),
+        help_text="The minimum weight allowed for this order proposal ",
+        verbose_name="Minimum Weight",
+        validators=[MinValueValidator(Decimal("0")), MaxValueValidator(Decimal("1"))],
+    )
+
     total_cash_weight = models.DecimalField(
         default=Decimal("0"),
         decimal_places=4,
         max_digits=5,
         verbose_name="Total Cash Weight",
         help_text="The desired percentage for the cash component. The remaining percentage (100% minus this value) will be allocated to total target weighting. Default is 0%.",
+        validators=[MinValueValidator(Decimal("0")), MaxValueValidator(Decimal("1"))],
     )
     total_effective_portfolio_contribution = models.DecimalField(
         default=Decimal("1"),
@@ -136,6 +147,13 @@ class OrderProposal(CloneMixin, RiskCheckMixin, WBModel):
         ]
 
     def save(self, *args, **kwargs):
+        # if the order proposal is created, we default these fields with the portfolio default value for automatic value assignement
+        if not self.id and not self.min_order_value:
+            self.min_order_value = self.portfolio.default_order_proposal_min_order_value
+        if not self.id and not self.min_weighting:
+            self.min_weighting = self.portfolio.default_order_proposal_min_weighting
+        if not self.id and not self.total_cash_weight:
+            self.total_cash_weight = self.portfolio.default_order_proposal_total_cash_weight
         # if a order proposal is created before the existing earliest order proposal, we automatically shift the linked instruments inception date to allow automatic NAV computation since the new inception date
         if not self.portfolio.order_proposals.filter(trade_date__lt=self.trade_date).exists():
             # we need to set the inception date as the first order proposal trade date (and thus, the first position date). We expect a NAV at 100 then
@@ -657,7 +675,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()
@@ -1175,7 +1193,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

@@ -87,6 +87,12 @@ class Order(TransactionMixin, ImportMixin, OrderedModel, models.Model):
                 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})"

wbportfolio/models/portfolio.py

@@ -9,6 +9,7 @@ import pandas as pd
 from celery import shared_task
 from django.contrib.postgres.fields import DateRangeField
 from django.core.exceptions import ObjectDoesNotExist
+from django.core.validators import MaxValueValidator, MinValueValidator
 from django.db import models
 from django.db.models import Exists, F, OuterRef, Q, QuerySet, Sum
 from django.db.models.signals import post_save
@@ -71,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)
@@ -84,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)
@@ -233,6 +234,25 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         blank=True,
     )
 
+    # OMS default parameters. Used to seed order proposal default value upon creation
+    default_order_proposal_min_order_value = models.IntegerField(
+        default=0, verbose_name="Default Order Proposal Minimum Order Value"
+    )
+    default_order_proposal_min_weighting = models.DecimalField(
+        max_digits=9,
+        decimal_places=8,
+        default=Decimal(0),
+        verbose_name="Default Order Proposal Minimum Weight",
+        validators=[MinValueValidator(Decimal("0")), MaxValueValidator(Decimal("1"))],
+    )
+    default_order_proposal_total_cash_weight = models.DecimalField(
+        default=Decimal("0"),
+        decimal_places=4,
+        max_digits=5,
+        verbose_name="Default Order Proposal Total Cash Weight",
+        validators=[MinValueValidator(Decimal("0")), MaxValueValidator(Decimal("1"))],
+    )
+
     objects = DefaultPortfolioManager()
     tracked_objects = ActiveTrackedPortfolioManager()
 
@@ -929,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
@@ -962,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/pms/typing.py

@@ -269,7 +269,7 @@ class TradeBatch:
 
     def convert_to_portfolio(self, use_effective: bool = False, *extra_positions):
         positions = []
-        for instrument, trade in self.trades_map.items():
+        for trade in self.trades_map.values():
             positions.append(
                 Position(
                     underlying_instrument=trade.underlying_instrument,

wbportfolio/rebalancing/models/market_capitalization_weighted.py

@@ -108,11 +108,7 @@ class MarketCapitalizationRebalancing(AbstractRebalancingModel):
                 return df.any()
             else:
                 if missing_exchanges.exists():
-                    setattr(
-                        self,
-                        "_validation_errors",
-                        f"Couldn't find any market capitalization for exchanges {', '.join([str(e) for e in missing_exchanges])}",
-                    )
+                    self._validation_errors = f"Couldn't find any market capitalization for exchanges {', '.join([str(e) for e in missing_exchanges])}"
                 return df.all()
         return False
 

wbportfolio/risk_management/backends/controversy_portfolio.py

@@ -44,7 +44,7 @@ class RuleBackend(ActivePortfolioRelationshipMixin):
         return RuleBackendSerializer
 
     def _process_dto(self, portfolio: PortfolioDTO, **kwargs) -> Generator[backend.IncidentResult, None, None]:
-        for instrument_id, weight in portfolio.positions_map.items():
+        for instrument_id in portfolio.positions_map.keys():
             instrument = Instrument.objects.get(id=instrument_id)
             if (
                 controversies := Controversy.objects.filter(

wbportfolio/risk_management/backends/instrument_list_portfolio.py

@@ -64,7 +64,7 @@ class RuleBackend(ActivePortfolioRelationshipMixin):
         return RuleBackendSerializer
 
     def _process_dto(self, portfolio: PortfolioDTO, **kwargs) -> Generator[backend.IncidentResult, None, None]:
-        for instrument_id, weight in portfolio.positions_map.items():
+        for instrument_id in portfolio.positions_map.keys():
             instrument = Instrument.objects.get(id=instrument_id)
             relationships = self.instruments_relationship.filter(instrument=instrument, validated=True)
 

wbportfolio/risk_management/tests/test_stop_loss_instrument.py

@@ -92,7 +92,7 @@ class TestStopLossInstrumentRuleModel(PortfolioTestMixin):
             date=weekday, net_value=500, calculated=False, instrument=benchmark
         )
         RelatedInstrumentThroughModel.objects.create(instrument=product, related_instrument=benchmark, is_primary=True)
-        setattr(stop_loss_instrument_backend, "dynamic_benchmark_type", "PRIMARY_BENCHMARK")
+        stop_loss_instrument_backend.dynamic_benchmark_type = "PRIMARY_BENCHMARK"
 
         res = list(stop_loss_instrument_backend.check_rule())
         assert len(res) == 0
@@ -105,7 +105,7 @@ class TestStopLossInstrumentRuleModel(PortfolioTestMixin):
         assert len(res) == 1
         assert res[0].breached_object.id == product.id
 
-        setattr(stop_loss_instrument_backend, "static_benchmark", benchmark)
+        stop_loss_instrument_backend.static_benchmark = benchmark
         res = list(stop_loss_instrument_backend.check_rule())
         assert len(res) == 1
         assert res[0].breached_object.id == product.id

wbportfolio/risk_management/tests/test_stop_loss_portfolio.py

@@ -119,7 +119,7 @@ class TestStopLossPortfolioRuleModel(PortfolioTestMixin):
         res = list(stop_loss_portfolio_backend.check_rule())
         assert len(res) == 0
 
-        setattr(stop_loss_portfolio_backend, "static_benchmark", benchmark)
+        stop_loss_portfolio_backend.static_benchmark = benchmark
         res = list(stop_loss_portfolio_backend.check_rule())
         assert len(res) == 1
         assert res[0].breached_object.id == instrument.id

wbportfolio/serializers/orders/order_proposals.py

@@ -90,6 +90,7 @@ class OrderProposalModelSerializer(wb_serializers.ModelSerializer):
             "comment",
             "status",
             "min_order_value",
+            "min_weighting",
             "_rebalancing_model",
             "rebalancing_model",
             "target_portfolio",

wbportfolio/serializers/transactions/claim.py

@@ -49,8 +49,8 @@ class ClaimAPIModelSerializer(serializers.ModelSerializer):
             if "isin" in request.data:
                 try:
                     data["product"] = Product.objects.get(isin=request.data["isin"])
-                except Product.DoesNotExist:
-                    raise ValidationError({"isin": "A product with this ISIN does not exist."})
+                except Product.DoesNotExist as e:
+                    raise ValidationError({"isin": "A product with this ISIN does not exist."}) from e
         if trade := data.get("trade", None):
             if not trade.is_claimable:
                 raise ValidationError({"trade": "Only a claimable trade can be selected"})

wbportfolio/tasks.py

@@ -1,12 +1,12 @@
 from contextlib import suppress
 from datetime import date, timedelta
 
+from celery import shared_task
 from django.db.models import ProtectedError, Q
+from tqdm import tqdm
+from wbfdm.models import Controversy, Instrument
 
-from wbportfolio.models import Portfolio, Trade
-from wbportfolio.models.products import Product
-
-from .fdm.tasks import *  # noqa
+from wbportfolio.models import AssetPosition, Portfolio, Product, Trade
 
 
 @shared_task(queue="portfolio")
@@ -49,3 +49,41 @@ def update_preferred_classification_per_instrument_and_portfolio_as_task():
 # - propagate (or update) t-2 asset positions into t-1
 # - Synchronize wbportfolio at t-1
 # - Compute Instrument Price estimate at t-1
+
+
+@shared_task(queue="portfolio")
+def synchronize_portfolio_controversies():
+    active_portfolios = Portfolio.objects.filter_active_and_tracked()
+    qs = (
+        AssetPosition.objects.filter(portfolio__in=active_portfolios)
+        .values("underlying_instrument")
+        .distinct("underlying_instrument")
+    )
+    objs = {}
+    securities = Instrument.objects.filter(id__in=qs.values("underlying_instrument"))
+    securities_mapping = {security.id: security.get_root() for security in securities}
+    for controversy in securities.dl.esg_controversies():
+        instrument = securities_mapping[controversy["instrument_id"]]
+        obj = Controversy.dict_to_model(controversy, instrument)
+        objs[obj.external_id] = obj
+
+    Controversy.objects.bulk_create(
+        objs.values(),
+        update_fields=[
+            "instrument",
+            "headline",
+            "description",
+            "source",
+            "direct_involvement",
+            "company_response",
+            "review",
+            "initiated",
+            "flag",
+            "status",
+            "type",
+            "severity",
+        ],
+        unique_fields=["external_id"],
+        update_conflicts=True,
+        batch_size=10000,
+    )

wbportfolio/tests/models/orders/test_order_proposals.py

@@ -695,6 +695,38 @@ class TestOrderProposal:
         assert order.shares == Decimal(0)
         assert order.weighting == Decimal(0)
 
+    def test_order_submit_bellow_minimum_weighting(self, order_factory, order_proposal):
+        o1 = order_factory.create(order_proposal=order_proposal, price=Decimal(1), weighting=Decimal("0.8"))
+        o2 = order_factory.create(order_proposal=order_proposal, price=Decimal(1), weighting=Decimal("0.2"))
+        order_proposal.submit()
+        order_proposal.save()
+
+        o1.refresh_from_db()
+        o2.refresh_from_db()
+        assert o1.weighting == Decimal("0.8")
+        assert o2.weighting == Decimal("0.2")
+
+        order_proposal.min_weighting = Decimal("0.21")
+        order_proposal.backtodraft()
+        order_proposal.submit()
+        order_proposal.save()
+
+        o1.refresh_from_db()
+        o2.refresh_from_db()
+        assert o1.weighting == Decimal("0.8")
+        assert o2.weighting == Decimal("0")
+
+        order_proposal.approve()
+        order_proposal.apply()
+        order_proposal.save()
+
+        assert order_proposal.portfolio.assets.get(
+            date=order_proposal.trade_date, underlying_quote=o1.underlying_instrument
+        ).weighting == Decimal("0.8")
+        assert order_proposal.portfolio.assets.get(
+            date=order_proposal.trade_date, underlying_quote=order_proposal.cash_component
+        ).weighting == Decimal("0.2")
+
     def test_reset_order_use_desired_target_weight(self, order_proposal, order_factory):
         order1 = order_factory.create(
             order_proposal=order_proposal, weighting=Decimal("0.5"), desired_target_weight=Decimal("0.7")