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

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

@@ -675,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()
@@ -1193,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/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/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/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/tests/models/test_portfolios.py

@@ -924,13 +924,13 @@ class TestPortfolioModel(PortfolioTestMixin):
 
         analytic_portfolio = portfolio.get_analytic_portfolio(weekday)
         assert analytic_portfolio.weights.tolist() == [float(a1.weighting), float(a2.weighting)]
-        expected_X = pd.DataFrame(
+        expected_x = pd.DataFrame(
             [[float(p11.net_value / p10.net_value - Decimal(1)), float(p21.net_value / p20.net_value - Decimal(1))]],
             columns=[i1.id, i2.id],
             index=[(weekday + BDay(1)).date()],
         )
-        expected_X.index = pd.to_datetime(expected_X.index)
-        pd.testing.assert_frame_equal(analytic_portfolio.X, expected_X, check_names=False, check_freq=False)
+        expected_x.index = pd.to_datetime(expected_x.index)
+        pd.testing.assert_frame_equal(analytic_portfolio.X, expected_x, check_names=False, check_freq=False)
 
     def test_get_total_asset_value(self, weekday, portfolio, asset_position_factory):
         a1 = asset_position_factory.create(date=weekday, portfolio=portfolio)
@@ -1010,7 +1010,7 @@ class TestPortfolioModel(PortfolioTestMixin):
         assert len(res) == 1
         assert a.date == weekday
         assert a.underlying_quote == instrument
-        assert a.underlying_quote_price == None
+        assert a.underlying_quote_price is None
         assert a.initial_price == p.net_value
         assert a.weighting == pytest.approx(weights[instrument.id], abs=Decimal(10e-6))
         assert a.currency_fx_rate_portfolio_to_usd == fx_portfolio
@@ -1053,7 +1053,7 @@ class TestPortfolioModel(PortfolioTestMixin):
         assert next(gen)[0] == middle_date, "Drifting weight with a non automatic rebalancer stops the iteration"
         try:
             next(gen)
-            assert False, "the next iteration should stop and return the rebalancing"
+            raise AssertionError("the next iteration should stop and return the rebalancing")
         except StopIteration as e:
             rebalancing_order_proposal = e.value
             assert rebalancing_order_proposal.trade_date == rebalancing_date

wbportfolio/tests/models/test_splits.py

@@ -14,10 +14,6 @@ fake = Faker()
 
 @pytest.mark.django_db
 class TestAdjustmentModel:
-    @pytest.fixture()
-    def applied_adjustment(self):
-        return AdjustmentFactory.create(status=Adjustment.Status.APPLIED)
-
     @pytest.fixture()
     def old_adjustment(self):
         return AdjustmentFactory.create(status=Adjustment.Status.PENDING, date=fake.past_date())
@@ -205,7 +201,7 @@ class TestAdjustmentModel:
         post_adjustment_on_prices(adjustment.id)
         a1.refresh_from_db()
         adjustment.refresh_from_db()
-        a1.applied_adjustment == adjustment
+        assert a1.applied_adjustment == adjustment
         assert adjustment.status == Adjustment.Status.APPLIED
 
     @patch("wbportfolio.models.adjustments.send_notification")
@@ -230,5 +226,4 @@ class TestAdjustmentModel:
         mock_check_fct.return_value = False
         post_adjustment_on_prices(adjustment.id)
         adjustment.refresh_from_db()
-        mock_delay_fct.call_args[0] == user_porftolio_manager.id
         assert adjustment.status == Adjustment.Status.PENDING

wbportfolio/tests/viewsets/test_products.py

@@ -23,6 +23,7 @@ class TestProductModelViewSet:
             portfolio_factory.create_batch(4, invested_timespan=DateRange(date.min, date.max))
             + portfolio_factory.create_batch(2, invested_timespan=DateRange(date.min, date.max)),
             product_factory.create_batch(6),
+            strict=False,
         ):
             InstrumentPortfolioThroughModel.objects.update_or_create(
                 instrument=product, defaults={"portfolio": portfolio}

wbportfolio/viewsets/charts/assets.py

@@ -101,7 +101,9 @@ class AbstractDistributionMixin(UserPortfolioRequestPermissionMixin):
             columns = {}
             level_representations = self.classification_group.get_levels_representation()
             for key, label in zip(
-                reversed(self.classification_group.get_fields_names(sep="_")), reversed(level_representations[1:])
+                reversed(self.classification_group.get_fields_names(sep="_")),
+                reversed(level_representations[1:]),
+                strict=False,
             ):
                 columns[key] = label
             columns["label"] = "Classification"
@@ -169,8 +171,8 @@ class AbstractDistributionMixin(UserPortfolioRequestPermissionMixin):
                 dict(Classification.objects.filter(id__in=df["classification"].dropna()).values_list("id", "name"))
             )
         elif self.group_by == AssetPositionGroupBy.CASH:
-            df.loc[df["id"] == True, "label"] = "Cash"
-            df.loc[df["id"] == False, "label"] = "Non-Cash"
+            df.loc[df["id"], "label"] = "Cash"
+            df.loc[~df["id"], "label"] = "Non-Cash"
         elif self.group_by == AssetPositionGroupBy.COUNTRY:
             df["label"] = df["id"].map(dict(Geography.objects.filter(id__in=df["id"]).values_list("id", "name")))
         elif self.group_by == AssetPositionGroupBy.CURRENCY:
@@ -307,7 +309,7 @@ class ContributorPortfolioChartView(UserPortfolioRequestPermissionMixin, viewset
 
             text_forex = df_forex.contribution_forex.apply(lambda x: f"{x:,.2%}")
             text_equity = contribution_equity.apply(lambda x: f"{x:,.2%}")
-            setattr(self, "nb_rows", df.shape[0])
+            self.nb_rows = df.shape[0]
             fig.add_trace(
                 go.Bar(
                     y=df.instrument_id,

wbportfolio/viewsets/configs/buttons/mixins.py

@@ -7,7 +7,7 @@ from wbfdm.models.instruments import Instrument
 
 class InstrumentButtonMixin:
     @classmethod
-    def add_instrument_request_button(self, request=None, view=None, pk=None, **kwargs):
+    def add_instrument_request_button(cls, request=None, view=None, pk=None, **kwargs):
         buttons = [
             bt.WidgetButton(key="assets", label="Implemented Portfolios (Assets)"),
             # bt.WidgetButton(
@@ -44,7 +44,7 @@ class InstrumentButtonMixin:
         )
 
     @classmethod
-    def add_transactions_request_button(self, request=None, view=None, pk=None, **kwargs):
+    def add_transactions_request_button(cls, request=None, view=None, pk=None, **kwargs):
         return bt.DropDownButton(
             label="Transactions",
             icon=WBIcon.UNFOLD.icon,

wbportfolio/viewsets/configs/display/reconciliations.py

@@ -49,14 +49,14 @@ class AccountReconciliationLineDisplayViewConfig(DisplayViewConfig):
         ]
         editable = [dp.FormattingRule(style={"fontWeight": "bold"})]
         equal = [dp.FormattingRule(condition=("==", False, "is_equal"), style={"backgroundColor": "orange"})]
-        borderLeft = [
+        border_left = [
             dp.FormattingRule(
                 style={
                     "borderLeft": "1px solid #bdc3c7",
                 }
             )
         ]
-        borderRight = [
+        border_right = [
             dp.FormattingRule(
                 style={
                     "borderRight": "1px solid #bdc3c7",
@@ -111,7 +111,7 @@ class AccountReconciliationLineDisplayViewConfig(DisplayViewConfig):
                             key="shares_external",
                             label="Shares",
                             width=90,
-                            formatting_rules=[*equal, *editable, *borderLeft],
+                            formatting_rules=[*equal, *editable, *border_left],
                         ),
                         dp.Field(
                             key="nominal_value_external",
@@ -128,7 +128,7 @@ class AccountReconciliationLineDisplayViewConfig(DisplayViewConfig):
                             key="assets_under_management_external",
                             label="AuM",
                             width=120,
-                            formatting_rules=[*equal, *borderRight],
+                            formatting_rules=[*equal, *border_right],
                         ),
                     ],
                 ),

{wbportfolio-1.55.9.dist-info → wbportfolio-1.55.10rc0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wbportfolio
-Version: 1.55.9
+Version: 1.55.10rc0
 Author-email: Christopher Wittlinger <c.wittlinger@stainly.com>
 License-File: LICENSE
 Requires-Dist: cryptography==3.4.*