wbportfolio 1.45.0__py2.py3-none-any.whl → 1.46.0__py2.py3-none-any.whl

wbportfolio/import_export/parsers/jpmorgan/customer_trade.py

@@ -24,6 +24,10 @@ def file_name_parse(file_name):
 
 
 def parse(import_source):
+    bank_exclusion_list = [
+        excluded_bank.strip().lower()
+        for excluded_bank in import_source.source.import_parameters.get("bank_exclusion_list", [])
+    ]
     # Load files into a CSV DictReader
     df = pd.read_csv(import_source.file, encoding="latin1", delimiter=",")
     df = df.replace([np.inf, -np.inf, np.nan], None)
@@ -42,18 +46,22 @@ def parse(import_source):
         # Check whether it is a buy or a sell and convert the value correspondely
         shares = shares if nominal_data["Side"] == "S" else shares * -1
         portfolio = product.primary_portfolio
-        data.append(
-            {
-                "underlying_instrument": {"id": product.id, "instrument_type": "product"},
-                "transaction_date": nominal_data["Trade Date"].strftime("%Y-%m-%d"),
-                "shares": shares,
-                "portfolio": portfolio.id,
-                # 'currency': product.currency.key,
-                "transaction_subtype": Trade.Type.REDEMPTION if shares < 0 else Trade.Type.SUBSCRIPTION,
-                "bank": nominal_data["CounterParty Name"],
-                "price": convert_string_to_number(nominal_data["Price"]),
-            }
-        )
+        bank = nominal_data["CounterParty Name"]
+        if (
+            len(bank_exclusion_list) == 0 or bank.strip().lower() not in bank_exclusion_list
+        ):  # we do basic string comparison to exclude appropriate banks. We might want to include regex if bank data is inconsistent
+            data.append(
+                {
+                    "underlying_instrument": {"id": product.id, "instrument_type": "product"},
+                    "transaction_date": nominal_data["Trade Date"].strftime("%Y-%m-%d"),
+                    "shares": shares,
+                    "portfolio": portfolio.id,
+                    # 'currency': product.currency.key,
+                    "transaction_subtype": Trade.Type.REDEMPTION if shares < 0 else Trade.Type.SUBSCRIPTION,
+                    "bank": bank,
+                    "price": convert_string_to_number(nominal_data["Price"]),
+                }
+            )
     import_data = {"data": data}
     if "isin" in parts:
         product = Product.objects.get(isin=parts["isin"])

wbportfolio/import_export/parsers/vontobel/valuation_api.py

@@ -2,6 +2,8 @@ import json
 from contextlib import suppress
 from datetime import datetime
 
+from wbportfolio.models import Product
+
 
 def parse(import_source):
     data = []
@@ -9,12 +11,13 @@ def parse(import_source):
         series_data = json.loads(import_source.file.read())["payload"]["series"]
         for series in series_data:
             isin = series["item"]["priceIdentifier"]
-            for point in series["points"]:
-                data.append(
-                    {
-                        "instrument": {"isin": isin},
-                        "date": datetime.fromtimestamp(int(point["timestamp"]) / 1000).strftime("%Y-%m-%d"),
-                        "net_value": point["close"],
-                    }
-                )
+            if Product.objects.filter(isin=isin).exists():  # ensure the timeseries contain data for products we handle
+                for point in series["points"]:
+                    data.append(
+                        {
+                            "instrument": {"isin": isin},
+                            "date": datetime.fromtimestamp(int(point["timestamp"]) / 1000).strftime("%Y-%m-%d"),
+                            "net_value": point["close"],
+                        }
+                    )
     return {"data": data}

wbportfolio/models/graphs/portfolio.py

@@ -15,6 +15,7 @@ from .utils import networkx_graph_to_plotly
 class PortfolioGraph:
     def __init__(self, portfolio: Portfolio, val_date: date, **graph_kwargs):
         self.graph = pydot.Dot("Portfolio Tree", strict=True, **graph_kwargs)
+        self.base_portfolio = portfolio
         self.discovered_portfolios = set()
         self.val_date = val_date
         self._extend_portfolio_graph(portfolio)
@@ -31,13 +32,17 @@ class PortfolioGraph:
                     pydot.Node(
                         str(parent_portfolio.id),
                         label=self._convert_to_multilines(str(parent_portfolio)),
-                        shape="circle",
-                        orientation="45",
-                        style="solid",
+                        **self._get_node_kwargs(parent_portfolio),
                     )
                 )
+                self.graph.del_edge((str(portfolio.id), str(parent_portfolio.id)))
                 self.graph.add_edge(
-                    pydot.Edge(str(portfolio.id), str(parent_portfolio.id), label=f"{weighting:.2%}", style="dashed")
+                    pydot.Edge(
+                        str(portfolio.id),
+                        str(parent_portfolio.id),
+                        label=f"Invest in ({weighting:.2%})",
+                        style="dashed",
+                    )
                 )
                 # composition_edges.append((str(portfolio.id), str(parent_portfolio.id)))
                 self._extend_parent_portfolios_to_graph(parent_portfolio)
@@ -49,28 +54,42 @@ class PortfolioGraph:
                 pydot.Node(
                     str(child_portfolio.id),
                     label=self._convert_to_multilines(str(child_portfolio)),
-                    shape="circle",
-                    orientation="45",
-                    style="solid",
+                    **self._get_node_kwargs(child_portfolio),
                 )
             )
-            # self.graph.add_edge(pydot.Edge(str(child_portfolio.id), str(portfolio.id), label="child", style="dashed"))
+            # we add this edge only if the opposite relationship is not already added
+            graph_edge = pydot.Edge(str(child_portfolio.id), str(portfolio.id), label="implements", style="dashed")
+            if (graph_edge.get_source(), graph_edge.get_destination()) not in self.graph.obj_dict["edges"]:
+                self.graph.add_edge(graph_edge)
             # composition_edges.append((str(child_portfolio.id), str(portfolio.id)))
             self._extend_child_portfolios_to_graph(child_portfolio)
 
+    def _get_node_kwargs(self, portfolio):
+        node_args = {
+            "shape": "circle",
+            "orientation": "45",
+        }
+        if portfolio == self.base_portfolio:
+            node_args.update({"style": "filled", "fillcolor": "lightgrey"})
+        else:
+            node_args.update(
+                {
+                    "style": "solid",
+                }
+            )
+        return node_args
+
     def _extend_portfolio_graph(self, portfolio):
         self.graph.add_node(
             pydot.Node(
                 str(portfolio.id),
                 label=self._convert_to_multilines(str(portfolio)),
-                shape="circle",
-                orientation="45",
-                style="solid",
+                **self._get_node_kwargs(portfolio),
             )
         )
 
-        self._extend_parent_portfolios_to_graph(portfolio)
         self._extend_child_portfolios_to_graph(portfolio)
+        self._extend_parent_portfolios_to_graph(portfolio)
 
         # composition_edges = []
         # if composition_edges:
@@ -87,37 +106,35 @@ class PortfolioGraph:
                 pydot.Node(
                     str(rel.portfolio.id),
                     label=self._convert_to_multilines(str(rel.portfolio)),
-                    shape="square",
-                    orientation="45",
-                    style="solid",
+                    **self._get_node_kwargs(rel.portfolio),
                 )
             )
             self.graph.add_node(
                 pydot.Node(
                     str(rel.dependency_portfolio.id),
                     label=self._convert_to_multilines(str(rel.dependency_portfolio)),
-                    shape="square",
-                    orientation="45",
-                    style="solid",
+                    **self._get_node_kwargs(rel.dependency_portfolio),
                 )
             )
             label = PortfolioPortfolioThroughModel.Type[rel.type].label
             if rel.dependency_portfolio.is_composition:
                 label += " (Composition)"
-            self.graph.add_edge(
-                pydot.Edge(
-                    str(rel.dependency_portfolio.id),
-                    str(rel.portfolio.id),
-                    label=label,
-                    style="bold",
-                )
-            )
+
             if rel.portfolio.is_lookthrough and rel.type == PortfolioPortfolioThroughModel.Type.PRIMARY:
                 self.graph.add_edge(
                     pydot.Edge(
                         str(rel.portfolio.id), str(rel.dependency_portfolio.id), label="Look-Through", style="dotted"
                     )
                 )
+            else:
+                self.graph.add_edge(
+                    pydot.Edge(
+                        str(rel.portfolio.id),
+                        str(rel.dependency_portfolio.id),
+                        label=label,
+                        style="bold",
+                    )
+                )
             if rel.dependency_portfolio not in self.discovered_portfolios:
                 self._extend_portfolio_graph(rel.dependency_portfolio)
             if rel.portfolio not in self.discovered_portfolios:

wbportfolio/models/portfolio.py

@@ -802,7 +802,11 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             adjusted_currency_fx_rate,
             adjusted_is_estimated,
             portfolio_created=None,
+            path=None,
         ):
+            if not path:
+                path = []
+            path.append(parent_portfolio)
             for position in parent_portfolio.assets.filter(date=sync_date):
                 position.id = None
                 position.weighting = adjusted_weighting * position.weighting
@@ -811,7 +815,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                     position.weighting == 1.0
                 )
                 position.portfolio_created = portfolio_created
-                position.parent_portfolio = parent_portfolio
+                setattr(position, "path", path)
                 position.initial_shares = None
                 if portfolio_total_asset_value:
                     position.initial_shares = (position.weighting * portfolio_total_asset_value) / (
@@ -826,8 +830,9 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                         position.currency_fx_rate,
                         position.is_estimated,
                         portfolio_created=child_portfolio,
+                        path=path.copy(),
                     )
-                elif position.weighting:  # we do not yield postion with weight 0 because of issue with certain multi-thematic portfolios which contain duplicates
+                elif position.weighting:  # we do not yield position with weight 0 because of issue with certain multi-thematic portfolios which contain duplicates
                     yield position
 
         yield from _crawl_portfolio(self, Decimal(1.0), Decimal(1.0), False)

wbportfolio/models/transactions/rebalancing.py

@@ -8,6 +8,7 @@ from django.dispatch import receiver
 from django.utils.functional import cached_property
 from django.utils.module_loading import autodiscover_modules
 from django.utils.translation import gettext_lazy as _
+from pandas._libs.tslibs.offsets import BDay
 from wbcore.utils.importlib import import_from_dotted_path
 from wbcore.utils.models import ComplexToStringMixin
 from wbcore.utils.rrules import convert_rrulestr_to_dict, humanize_rrule
@@ -41,10 +42,10 @@ class RebalancingModel(models.Model):
     def get_target_portfolio(
         self, portfolio: Portfolio, trade_date: date, last_effective_date: date, **kwargs
     ) -> PortfolioDTO:
-        model = self.model_class(portfolio, trade_date, last_effective_date)
+        model = self.model_class(portfolio, trade_date, last_effective_date, **kwargs)
         if not model.is_valid():
             raise ValidationError("Rebalacing cannot applied for these parameters")
-        return model.get_target_portfolio(**kwargs)
+        return model.get_target_portfolio()
 
     @classmethod
     def get_representation_endpoint(cls) -> str:
@@ -86,9 +87,22 @@ class Rebalancer(ComplexToStringMixin, models.Model):
                 self.activation_date = date.today()
         super().save(*args, **kwargs)
 
+    def _get_next_valid_date(self, valid_date: date) -> date:
+        pivot_date = valid_date
+        while TradeProposal.objects.filter(
+            portfolio=self.portfolio, status=TradeProposal.Status.FAILED, trade_date=pivot_date
+        ).exists():
+            pivot_date += BDay(1)
+        return pivot_date
+
     def is_valid(self, trade_date: date) -> bool:
-        valid_dates = [_d.date() for _d in self.get_rrule(trade_date)]
-        return trade_date in valid_dates
+        for valid_datetime in self.get_rrule(trade_date):
+            valid_date = self._get_next_valid_date(valid_datetime.date())
+            if valid_date == trade_date:
+                return True
+            if valid_date > trade_date:
+                break
+        return False
 
     def evaluate_rebalancing(self, trade_date: date):
         trade_proposal, _ = TradeProposal.objects.get_or_create(
@@ -101,17 +115,18 @@ class Rebalancer(ComplexToStringMixin, models.Model):
         )
         if trade_proposal.rebalancing_model == self.rebalancing_model:
             trade_proposal.status = TradeProposal.Status.DRAFT
-            target_portfolio = self.rebalancing_model.get_target_portfolio(
-                self.portfolio, trade_date, trade_proposal.last_effective_date, **self.parameters
-            )
             try:
+                target_portfolio = self.rebalancing_model.get_target_portfolio(
+                    self.portfolio, trade_date, trade_proposal.last_effective_date, **self.parameters
+                )
                 trade_proposal.reset_trades(target_portfolio)
                 trade_proposal.submit()
+                if self.approve_trade_proposal_automatically and self.portfolio.can_be_rebalanced:
+                    trade_proposal.approve()
             except ValidationError:
-                pass  # Do something
+                # If we encountered a validation error, we set the trade proposal as failed
+                trade_proposal.status = TradeProposal.Status.FAILED
 
-            if self.approve_trade_proposal_automatically and self.portfolio.can_be_rebalanced:
-                trade_proposal.approve()
             trade_proposal.save()
 
         return trade_proposal

wbportfolio/models/transactions/trade_proposals.py

@@ -38,6 +38,7 @@ class TradeProposal(RiskCheckMixin, WBModel):
         SUBMIT = "SUBMIT", "Submit"
         APPROVED = "APPROVED", "Approved"
         DENIED = "DENIED", "Denied"
+        FAILED = "FAILED", "Failed"
 
     comment = models.TextField(default="", verbose_name="Trade Comment", blank=True)
     status = FSMField(default=Status.DRAFT, choices=Status.choices, verbose_name="Status")

wbportfolio/rebalancing/base.py

@@ -4,7 +4,7 @@ from wbportfolio.pms.typing import Portfolio as PortfolioDTO
 
 
 class AbstractRebalancingModel:
-    def __init__(self, portfolio, trade_date: date, last_effective_date: date):
+    def __init__(self, portfolio, trade_date: date, last_effective_date: date, **kwargs):
         self.portfolio = portfolio
         self.trade_date = trade_date
         self.last_effective_date = last_effective_date
@@ -12,5 +12,5 @@ class AbstractRebalancingModel:
     def is_valid(self) -> bool:
         return True
 
-    def get_target_portfolio(self, **kwargs) -> PortfolioDTO:
+    def get_target_portfolio(self) -> PortfolioDTO:
         raise NotImplementedError()

wbportfolio/rebalancing/models/__init__.py

@@ -1,3 +1,4 @@
 from .composite import CompositeRebalancing
 from .model_portfolio import ModelPortfolioRebalancing
 from .equally_weighted import EquallyWeightedRebalancing
+from .market_capitalization_weighted import MarketCapitalizationRebalancing

wbportfolio/rebalancing/models/composite.py

@@ -22,7 +22,7 @@ class CompositeRebalancing(AbstractRebalancingModel):
     def is_valid(self) -> bool:
         return len(self.base_assets.keys()) > 0
 
-    def get_target_portfolio(self, **kwargs) -> Portfolio:
+    def get_target_portfolio(self) -> Portfolio:
         positions = []
         for underlying_instrument, weighting in self.base_assets.items():
             positions.append(

wbportfolio/rebalancing/models/equally_weighted.py

@@ -10,7 +10,7 @@ class EquallyWeightedRebalancing(AbstractRebalancingModel):
     def is_valid(self) -> bool:
         return self.portfolio.assets.filter(date=self.last_effective_date).exists()
 
-    def get_target_portfolio(self, **kwargs) -> Portfolio:
+    def get_target_portfolio(self) -> Portfolio:
         positions = []
         assets = self.portfolio.assets.filter(date=self.last_effective_date)
         nb_assets = assets.count()

wbportfolio/rebalancing/models/market_capitalization_weighted.py

@@ -0,0 +1,85 @@
+from decimal import Decimal
+
+import pandas as pd
+from django.db.models import Q, QuerySet
+from wbfdm.enums import MarketData
+from wbfdm.models import Classification, Instrument, InstrumentClassificationThroughModel
+
+from wbportfolio.pms.typing import Portfolio, Position
+from wbportfolio.rebalancing.base import AbstractRebalancingModel
+from wbportfolio.rebalancing.decorators import register
+
+
+@register("Market Capitalization Rebalancing")
+class MarketCapitalizationRebalancing(AbstractRebalancingModel):
+    TARGET_CURRENCY: str = "USD"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        instruments = self._get_instruments(**kwargs)
+        self.market_cap_df = pd.Series()
+        df = pd.DataFrame(
+            instruments.dl.market_data(
+                values=[MarketData.MARKET_CAPITALIZATION],
+                from_date=self.last_effective_date,
+                to_date=self.trade_date,
+                target_currency=self.TARGET_CURRENCY,
+            )
+        )
+        try:
+            df = df[["valuation_date", "market_capitalization", "instrument_id"]].pivot_table(
+                index="valuation_date", columns="instrument_id", values="market_capitalization"
+            )
+            df = df.ffill()
+            self.market_cap_df = df.iloc[-1, :].transpose()
+        except (IndexError, KeyError):
+            self.market_cap_df = pd.Series()
+
+    def _get_instruments(
+        self, classification_ids: list[int] | None = None, instrument_ids: list[int] | None = None, **kwargs
+    ) -> QuerySet[Instrument]:
+        """
+        Use the provided kwargs to return a list of instruments as universe.
+        - If classifications are given, we returns all the instrument linked to these classifications
+        - Or directly from a static list of instrument ids
+        - fallback to the last effective portfolio underlying instruments list
+        """
+        if classification_ids:
+            classifications = set()
+            for classification in Classification.objects.filter(id__in=classification_ids):
+                for children in classification.get_descendants(include_self=True):
+                    classifications.add(children)
+            instrument_ids = list(
+                InstrumentClassificationThroughModel.objects.filter(classification__in=classifications).values_list(
+                    "id", flat=True
+                )
+            )
+        elif not instrument_ids:
+            instrument_ids = list(
+                self.portfolio.assets.filter(date=self.last_effective_date).values_list(
+                    "underlying_instrument", flat=True
+                )
+            )
+        return Instrument.objects.filter(id__in=instrument_ids).filter(
+            Q(delisted_date__isnull=True) | Q(delisted_date__gt=self.trade_date)
+        )
+
+    def is_valid(self) -> bool:
+        return (
+            not self.market_cap_df.empty and not self.market_cap_df.isnull().any()
+        )  # if we are missing any market cap for not-delisted instrument, we consider the rebalancing not valid
+
+    def get_target_portfolio(self) -> Portfolio:
+        positions = []
+        market_cap_df = self.market_cap_df
+        total_market_cap = market_cap_df.sum()
+
+        for underlying_instrument, market_cap in market_cap_df.to_dict().items():
+            positions.append(
+                Position(
+                    underlying_instrument=underlying_instrument,
+                    weighting=Decimal(market_cap / total_market_cap),
+                    date=self.trade_date,
+                )
+            )
+        return Portfolio(positions=tuple(positions))

wbportfolio/rebalancing/models/model_portfolio.py

@@ -24,7 +24,7 @@ class ModelPortfolioRebalancing(AbstractRebalancingModel):
             else False
         )
 
-    def get_target_portfolio(self, **kwargs) -> Portfolio:
+    def get_target_portfolio(self) -> Portfolio:
         positions = []
         assets = self.model_portfolio.get_positions(self.last_effective_date)
 

wbportfolio/risk_management/backends/ucits_portfolio.py

@@ -46,19 +46,25 @@ class RuleBackend(ActivePortfolioRelationshipMixin, backend.AbstractRuleBackend)
     def _process_dto(self, portfolio: PortfolioDTO, **kwargs) -> Generator[backend.IncidentResult, None, None]:
         if not (df := self._filter_df(pd.DataFrame(portfolio.to_df()).astype({"weighting": float}))).empty:
             df = df[["underlying_instrument", "weighting"]].groupby("underlying_instrument").sum()
-            total_weight_threshold_1_2 = df.loc[df["weighting"] < self.threshold_2, "weighting"].sum()
+            total_weight_threshold_1_2 = df["weighting"].sum()
             highest_incident_type = RiskIncidentType.objects.order_by("-severity_order").first()
+
             for id, row in df.to_dict("index").items():
                 if (row["weighting"] > self.threshold_2) or (total_weight_threshold_1_2 > self.threshold_3):
                     instrument = Instrument.objects.get(id=id)
+                    breached_value = f"""
+                    Sum >= {self.threshold_1:.2%}: {total_weight_threshold_1_2:+.2%}
+                    """
+                    if row["weighting"] > self.threshold_2:
+                        breached_value += f"<br>Instrument >= {self.threshold_2:.2%}: {instrument.name_repr}"
                     yield backend.IncidentResult(
                         breached_object=instrument,
                         breached_object_repr=str(instrument),
-                        breached_value=f'∑[0%, {self.threshold_2:.2%}]:  {row["weighting"]:+.2%} | ∑[{self.threshold_1:.2%}, {self.threshold_2:.2%}]: {total_weight_threshold_1_2:+.2%}',
+                        breached_value=breached_value,
                         report_details={
-                            "Breach Thresholds": f"{self.threshold_1}|{self.threshold_2}|{self.threshold_3}",
-                            "Weighting": f"{row['weighting']:.3f}",
-                            f"Sum of positions whose weight are between {self.threshold_1:.2%} and {self.threshold_2:.2%}": f"{total_weight_threshold_1_2:.3f}",
+                            "Breach Thresholds": f"{self.threshold_1:.2%}|{self.threshold_2:.2%}|{self.threshold_3:.2%}",
+                            "Weighting": f"{row['weighting']:+.2%}",
+                            f"Sum of positions > {self.threshold_1:.2%}": f"{total_weight_threshold_1_2:+.2%}",
                         },
                         severity=highest_incident_type,
                     )

wbportfolio/risk_management/tests/test_ucits_portfolio.py

@@ -19,7 +19,7 @@ class TestUcitsRuleModel(PortfolioTestMixin):
         #  Check No single asset can represent more than 10% of the fund's assets;
         asset_position_factory.create(date=weekday, weighting=0.05, portfolio=portfolio)
         asset_position_factory.create(date=weekday, weighting=0.05, portfolio=portfolio)
-        a3 = asset_position_factory.create(date=weekday, weighting=0.90, portfolio=portfolio)
+        a3 = asset_position_factory.create(date=weekday, weighting=0.15, portfolio=portfolio)
 
         res = list(ucits_backend.check_rule())
         assert len(res) == 1

wbportfolio/tests/models/test_portfolios.py

@@ -1114,3 +1114,28 @@ class TestPortfolioModel(PortfolioTestMixin):
         undependant_portfolio = portfolio_factory.create(name="undependant portfolio", id=4)
         res = list(Portfolio.objects.all().to_dependency_iterator(weekday))
         assert res == [index_portfolio, dependency_portfolio, dependant_portfolio, undependant_portfolio]
+
+    def test_get_returns(self, instrument_factory, instrument_price_factory, portfolio):
+        v1 = date(2025, 1, 1)
+        v2 = date(2025, 1, 2)
+        v3 = date(2025, 1, 3)
+
+        i1 = instrument_factory.create()
+        i2 = instrument_factory.create()
+
+        i11 = instrument_price_factory.create(date=v1, instrument=i1)
+        i12 = instrument_price_factory.create(date=v2, instrument=i1)
+        i13 = instrument_price_factory.create(date=v3, instrument=i1)
+        i11.refresh_from_db()
+        i12.refresh_from_db()
+        i13.refresh_from_db()
+        returns, _ = portfolio.get_returns([i1.id, i2.id], from_date=v1, to_date=v3)
+
+        expected_returns = pd.DataFrame(
+            [[i12.net_value / i11.net_value - 1], [i13.net_value / i12.net_value - 1]],
+            index=[v2, v3],
+            columns=[i1.id],
+            dtype="float64",
+        )
+        expected_returns.index = pd.to_datetime(expected_returns.index)
+        pd.testing.assert_frame_equal(returns, expected_returns, check_names=False, check_freq=False, atol=1e-6)

wbportfolio/tests/rebalancing/test_models.py

@@ -1,7 +1,9 @@
 from decimal import Decimal
 
+import numpy as np
 import pytest
 from pandas._libs.tslibs.offsets import BDay
+from wbfdm.models import InstrumentPrice
 
 from wbportfolio.factories import PortfolioFactory, TradeFactory, TradeProposalFactory
 from wbportfolio.models import PortfolioPortfolioThroughModel, Trade, TradeProposal
@@ -125,3 +127,35 @@ class TestCompositeRebalancing:
         target_positions = target_portfolio.positions_map
         assert target_positions[t1.underlying_instrument.id].weighting == Decimal("0.800000")
         assert target_positions[t2.underlying_instrument.id].weighting == Decimal("0.200000")
+
+
+@pytest.mark.django_db
+class TestMarketCapitalizationRebalancing:
+    @pytest.fixture()
+    def model(self, portfolio, weekday, instrument_factory, instrument_price_factory):
+        from wbportfolio.rebalancing.models import MarketCapitalizationRebalancing
+
+        last_effective_date = (weekday - BDay(1)).date()
+
+        i1 = instrument_factory()
+        i2 = instrument_factory()
+        instrument_price_factory.create(instrument=i1, date=last_effective_date)
+        instrument_price_factory.create(instrument=i1, date=weekday)
+        instrument_price_factory.create(instrument=i2, date=last_effective_date)  # weekday is ffill
+        return MarketCapitalizationRebalancing(portfolio, weekday, last_effective_date, instrument_ids=[i1.id, i2.id])
+
+    def test_is_valid(self, portfolio, weekday, model, instrument_factory, instrument_price_factory):
+        assert model.is_valid()
+        model.market_cap_df.iloc[0] = np.nan
+        assert not model.is_valid()
+
+    def test_get_target_portfolio(self, portfolio, weekday, model, asset_position_factory):
+        i1 = model.market_cap_df.index[0]
+        i2 = model.market_cap_df.index[1]
+        mkt12 = InstrumentPrice.objects.get(instrument_id=i1, date=model.trade_date).market_capitalization
+        mkt21 = InstrumentPrice.objects.get(instrument_id=i2, date=model.last_effective_date).market_capitalization
+
+        target_portfolio = model.get_target_portfolio()
+        target_positions = target_portfolio.positions_map
+        assert target_positions[i1].weighting == mkt12 / (mkt12 + mkt21)
+        assert target_positions[i2].weighting == mkt21 / (mkt12 + mkt21)

wbportfolio/viewsets/configs/endpoints/assets.py

@@ -56,6 +56,8 @@ class AssetPositionProductGroupEndpointConfig(AssetPositionEndpointConfig):
 
 
 class CashPositionPortfolioEndpointConfig(AssetPositionEndpointConfig):
+    PK_FIELD = "portfolio"
+
     def get_list_endpoint(self, **kwargs):
         return reverse(
             "wbportfolio:productcashposition-list",
@@ -63,6 +65,16 @@ class CashPositionPortfolioEndpointConfig(AssetPositionEndpointConfig):
             request=self.request,
         )
 
+    def get_instance_endpoint(self, **kwargs):
+        return reverse(
+            "wbportfolio:portfolio-list",
+            args=[],
+            request=self.request,
+        )
+
+    def get_update_endpoint(self, **kwargs):
+        return None
+
 
 class ContributorPortfolioChartEndpointConfig(AssetPositionEndpointConfig):
     def get_list_endpoint(self, **kwargs):

wbportfolio/viewsets/portfolios.py

@@ -181,7 +181,7 @@ class PortfolioTreeGraphChartViewSet(UserPortfolioRequestPermissionMixin, viewse
         return parse_date(self.request.GET["date"])
 
     def get_html(self, queryset) -> str:
-        portfolio_graph = PortfolioGraph(self.portfolio, self.val_date)
+        portfolio_graph = PortfolioGraph(self.portfolio, self.val_date, rankdir="LR", size="20,11")
         return portfolio_graph.to_svg()
 
 
@@ -196,7 +196,7 @@ class TopDownPortfolioCompositionPandasAPIView(UserPortfolioRequestPermissionMix
     pandas_fields = pf.PandasFields(
         fields=[
             pf.PKField(key="id", label="ID"),
-            pf.CharField(key="_group_key", label="Group Key"),
+            pf.IntegerField(key="_group_key", label="Group Key"),
             pf.IntegerField(key="parent_row_id", label="Parent Row"),
             pf.CharField(key="instrument", label="Instrument"),
             pf.FloatField(key="effective_weights", label="Effective Weights", precision=2, percent=True),
@@ -229,7 +229,7 @@ class TopDownPortfolioCompositionPandasAPIView(UserPortfolioRequestPermissionMix
 
         def _get_parent_instrument_id(portfolio):
             with suppress(AttributeError):
-                return portfolio.instruments.first().id
+                return str(portfolio.instruments.first().id)
 
         if (
             self.has_portfolio_access
@@ -237,85 +237,87 @@ class TopDownPortfolioCompositionPandasAPIView(UserPortfolioRequestPermissionMix
             and self.last_rebalancing_date
             and self.last_effective_date
         ):
-            tree_positions_effective_date_df = (
-                pd.DataFrame(
-                    map(
-                        lambda x: {
-                            "instrument": x.underlying_instrument.id,
-                            "parent_instrument": _get_parent_instrument_id(
-                                getattr(x, "parent_portfolio", "portfolio")
-                            ),
-                            "effective_weights": x.weighting,
-                        },
-                        self.composition_portfolio.get_positions(
-                            self.last_effective_date, with_intermediary_position=True
+            df = pd.DataFrame(
+                map(
+                    lambda x: {
+                        "instrument": str(x.underlying_instrument.id),
+                        "path": "-".join(
+                            map(
+                                lambda o: _get_parent_instrument_id(o),
+                                getattr(x, "path", [self.composition_portfolio]),
+                            )
                         ),
+                        "effective_weights": x.weighting,
+                    },
+                    self.composition_portfolio.get_positions(
+                        self.last_effective_date, with_intermediary_position=True
                     ),
-                    columns=["instrument", "parent_instrument", "effective_weights"],
-                )
-                .groupby(["parent_instrument", "instrument"])
-                .sum()
-            )
-            tree_positions_rebalancing_date_df = (
-                pd.DataFrame(
+                ),
+                columns=["instrument", "path", "effective_weights"],
+            ).set_index(["path", "instrument"])
+
+            if last_rebalancing_date := self.last_rebalancing_date:
+                tree_positions_rebalancing_date_df = pd.DataFrame(
                     map(
                         lambda x: {
-                            "instrument": x.underlying_instrument.id,
-                            "parent_instrument": _get_parent_instrument_id(
-                                getattr(x, "parent_portfolio", "portfolio")
+                            "instrument": str(x.underlying_instrument.id),
+                            "path": "-".join(
+                                map(
+                                    lambda o: _get_parent_instrument_id(o),
+                                    getattr(x, "path", [self.composition_portfolio]),
+                                )
                             ),
                             "rebalancing_weights": x.weighting,
                         },
                         self.composition_portfolio.get_positions(
-                            self.last_rebalancing_date, with_intermediary_position=True
+                            last_rebalancing_date, with_intermediary_position=True
                         ),
                     ),
-                    columns=["instrument", "parent_instrument", "rebalancing_weights"],
-                )
-                .groupby(["parent_instrument", "instrument"])
-                .sum()
-            )
+                    columns=["instrument", "path", "rebalancing_weights"],
+                ).set_index(["path", "instrument"])
 
+                df = pd.concat([df, tree_positions_rebalancing_date_df], axis=1)
+            df = df.reset_index()
             df = pd.concat(
-                [tree_positions_effective_date_df, tree_positions_rebalancing_date_df], axis=1
-            ).reset_index()
-
-            if not df["parent_instrument"].isnull().any():
-                df = pd.concat(
-                    [
-                        pd.DataFrame(
-                            [
-                                {
-                                    "instrument": self.portfolio.instruments.first().id,
-                                    "parent_instrument": None,
-                                    "effective_weights": 1.0,
-                                    "rebalancing_weights": 1.0,
-                                }
-                            ]
-                        ),
-                        df,
-                    ],
-                    ignore_index=True,
-                )
+                [
+                    pd.DataFrame(
+                        [
+                            {
+                                "instrument": str(self.portfolio.instruments.first().id),
+                                "path": "",
+                                "effective_weights": 1.0,
+                                "rebalancing_weights": 1.0,
+                            }
+                        ]
+                    ),
+                    df,
+                ],
+                ignore_index=True,
+            )
 
             df = df.reset_index(names="id")
 
-            def _get_parent_id(x):
-                dff = df.loc[df["instrument"] == x, "id"]
+            def _get_group_key(x):
+                return str(int(x)) if not df.loc[df["parent_row_id"] == x, :].empty else None
+
+            def _get_parent_row_id(path):
+                s = path.split("-")
+                instrument = s[-1]
+                parent_path = "-".join(s[:-1]) if len(s) > 1 else ""
+                dff = df.loc[(df["instrument"] == instrument) & (df["path"] == parent_path), "id"]
                 if not dff.empty:
                     return dff.iloc[0]
                 return None
 
-            def _get_group_key(x):
-                return str(int(x)) if not df.loc[df["parent_row_id"] == x, :].empty else None
-
-            df["parent_row_id"] = df["parent_instrument"].apply(lambda x: _get_parent_id(x))
+            df["parent_row_id"] = df["path"].apply(lambda x: _get_parent_row_id(x))
             df["_group_key"] = df["id"].apply(lambda x: _get_group_key(x))
-            df = df.drop(columns=["parent_instrument"])
+            df = df.drop(columns=["path"])
         return df
 
     def manipulate_dataframe(self, df):
-        df["instrument"] = df["instrument"].map(
-            dict(Instrument.objects.filter(id__in=df["instrument"]).values_list("id", "name_repr"))
+        df["instrument"] = (
+            df["instrument"]
+            .astype(int)
+            .map(dict(Instrument.objects.filter(id__in=df["instrument"]).values_list("id", "name_repr")))
         )
         return df

{wbportfolio-1.45.0.dist-info → wbportfolio-1.46.0.dist-info}/METADATA

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

{wbportfolio-1.45.0.dist-info → wbportfolio-1.46.0.dist-info}/RECORD

@@ -119,7 +119,7 @@ wbportfolio/import_export/handlers/trade.py,sha256=LydAyFtqHPNfCF6j1yY9Md0xWf6NM
 wbportfolio/import_export/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/import_export/parsers/default_mapping.py,sha256=KrO-X5CvQCeQoBYzFDxavoQGriyUSeI2QDx5ar_zo7A,1405
 wbportfolio/import_export/parsers/jpmorgan/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wbportfolio/import_export/parsers/jpmorgan/customer_trade.py,sha256=UXi71aP0BGtqJpkiemWlgt0Ez3Aj5JKgjDaRPAz9vj0,2380
+wbportfolio/import_export/parsers/jpmorgan/customer_trade.py,sha256=AMB7vXkhRctGBzgdCdWz0lrWVOIbmuqTjyotEJvTKYE,2859
 wbportfolio/import_export/parsers/jpmorgan/fees.py,sha256=l1eoU_QJZdE3rL2ql_s5qGUDfDqnOZKN5mrSV4qxEqs,2179
 wbportfolio/import_export/parsers/jpmorgan/strategy.py,sha256=OAIKv9NyKj8WiWLXsVIj7ujjfxBl5OLCNNXlx0oJIiE,4463
 wbportfolio/import_export/parsers/jpmorgan/valuation.py,sha256=-PGYjAjvHyW6muwPeA3HCFWtD-U7elzXThgrcOfQe58,1306
@@ -187,7 +187,7 @@ wbportfolio/import_export/parsers/vontobel/performance_fees.py,sha256=DlpP2Skih2
 wbportfolio/import_export/parsers/vontobel/trade.py,sha256=Eu5qR-cjnkA_jwtrJ78xoi9ealysjHDLXIKSandqDe0,1570
 wbportfolio/import_export/parsers/vontobel/utils.py,sha256=toleo4gRb4YFtiD8m2d7z1GGGdG-O3mpTMjOO9R_E1Q,516
 wbportfolio/import_export/parsers/vontobel/valuation.py,sha256=iav8_xYpTJchmTa7KOPmFr1gi9xxLwq3e-VcZ9MDiRk,1220
-wbportfolio/import_export/parsers/vontobel/valuation_api.py,sha256=4-PwFCPt9pmSBgHgBGF62uEaYTNZalc2P_5piJYjmvw,690
+wbportfolio/import_export/parsers/vontobel/valuation_api.py,sha256=WLkZ5z-WqhFraNorWlOhIpSx1pQ2fnjdsLHwSTA7O2o,882
 wbportfolio/import_export/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/import_export/resources/assets.py,sha256=zjgHlQWpud41jHrKdRyqGUt1KUJQm9Z7pt0uVh4qBWQ,2234
 wbportfolio/import_export/resources/trades.py,sha256=5HC0YrE1fnc_dOMfkOEj7vsICv1JN_OEZiGryg2GboY,1125
@@ -245,7 +245,7 @@ wbportfolio/models/adjustments.py,sha256=osXWkJZOiansPWYPyHtl7Z121zDWi7u1YMtrBQt
 wbportfolio/models/asset.py,sha256=V-fSAF1bsfj_Td3VfdKyhCgcwB_xPS6vTI90Dh5iDx8,37502
 wbportfolio/models/custodians.py,sha256=owTiS2Vm5CRKzh9M_P9GOVg-s-ndQ9UvRmw3yZP7cw0,3815
 wbportfolio/models/indexes.py,sha256=iLYF2gzNzX4GLj_Nh3fybUcAQ1TslnT0wgQ6mN164QI,728
-wbportfolio/models/portfolio.py,sha256=ao9S7qV_EmVCnWjSQ8hU3zIeMeyDdplHexEmpNbp98k,55313
+wbportfolio/models/portfolio.py,sha256=-B--vg_vGsZjHtUsW1hrkmg8LoGeyBO_ilcE6BEE3e0,55459
 wbportfolio/models/portfolio_cash_flow.py,sha256=2blPiXSw7dbhUVd-7LcxDBb4v0SheNOdvRK3MFYiChA,7273
 wbportfolio/models/portfolio_cash_targets.py,sha256=WmgG-etPisZsh2yaFQpz7EkpvAudKBEzqPsO715w52U,1498
 wbportfolio/models/portfolio_relationship.py,sha256=mMb18UMRWg9kx_9uIPkMktwORuXXLjKdgRPQQvB6fVE,5486
@@ -256,7 +256,7 @@ wbportfolio/models/registers.py,sha256=qA6T33t4gxFYnabQFBMd90WGIr6wxxirDLKDFqjOf
 wbportfolio/models/roles.py,sha256=34BwZleaPMHnUqDK1nHett45xaNNsUqSHY44844itW8,7387
 wbportfolio/models/utils.py,sha256=iBdMjRCvr6aOL0nLgfSCWUKe0h39h3IGmUbYo6l9t6w,394
 wbportfolio/models/graphs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wbportfolio/models/graphs/portfolio.py,sha256=yztomiujS_HwXAslc3WwkIA4DH3OTE8sk71kiIHOVWU,5814
+wbportfolio/models/graphs/portfolio.py,sha256=NwkehWvTcyTYrKO5ku3eNNaYLuBwuLdSbTEuugGuSIU,6541
 wbportfolio/models/graphs/utils.py,sha256=1AMpEE9mDuUZ82XgN2irxjCW1-LmziROhKevEBo0mJE,2347
 wbportfolio/models/llm/wbcrm/analyze_relationship.py,sha256=_y2Myc-M2hXQDkRGXvzsM0ZNC31dmxSHHz5BKMtymww,2106
 wbportfolio/models/mixins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -271,8 +271,8 @@ wbportfolio/models/transactions/claim.py,sha256=agdpGqxpO0FSzYDWV-Gv1tQY46k0LN9C
 wbportfolio/models/transactions/dividends.py,sha256=naL5xeDQfUBf5KyGt7y-tTcHL22nzZumT8DV6AaG8Bg,1064
 wbportfolio/models/transactions/expiry.py,sha256=vnNHdcC1hf2HP4rAbmoGgOfagBYKNFytqOwzOI0MlVI,144
 wbportfolio/models/transactions/fees.py,sha256=ffvqo8I4A0l5rLi00jJ6sGot0jmnkoxaNsbDzdPLwCg,5712
-wbportfolio/models/transactions/rebalancing.py,sha256=t-bQcFTfPTD-ciCNTKEtKW0r29RZ63PmeVJmBAKyj3Y,5719
-wbportfolio/models/transactions/trade_proposals.py,sha256=xekzZcY1i9jsguVTTMTeLRwEMJogNWxV4OvJTF3z7uI,20275
+wbportfolio/models/transactions/rebalancing.py,sha256=9EdElkaqPoH14FBSK9QOCLFzVpr4YFa3YrgCJV9XvaI,6396
+wbportfolio/models/transactions/trade_proposals.py,sha256=ZpMWOKXfWo85AW2cqp0X5aUGabGECB4W1bK4RaD5-QM,20311
 wbportfolio/models/transactions/trades.py,sha256=3HthfL0wgzPmwwXRVzA5yvm-UPiQco7HhN30ztsOjvI,27529
 wbportfolio/models/transactions/transactions.py,sha256=4THsE4xqdigZAwWKYfTNRLPJlkmAmsgE70Ribp9Lnrk,7127
 wbportfolio/pms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -283,12 +283,13 @@ wbportfolio/pms/statistics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJ
 wbportfolio/pms/trading/__init__.py,sha256=R_yLKc54sCak8A1cW0O1Aszrcv5KV8mC_3h17Hr20e4,36
 wbportfolio/pms/trading/handler.py,sha256=Xpgo719S0jE1wUTTyGFpYccPEIg9GXghWEAdYawJbrk,7165
 wbportfolio/rebalancing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wbportfolio/rebalancing/base.py,sha256=HttfNmOjclSw9Kfm283LmyHajjBJi4CTjv25EP9_JeQ,481
+wbportfolio/rebalancing/base.py,sha256=Z5IAG8zu6_RLkQE1AgIoROBUDXWza0myzKhKx_4ONwA,481
 wbportfolio/rebalancing/decorators.py,sha256=JhQ2vkcIuGBTGvNmpkQerdw2-vLq-RAb0KAPjOrETkw,515
-wbportfolio/rebalancing/models/__init__.py,sha256=AQHlyjyIdlBRSim6eCdWDf4-M-supY9VP-xkuyBWYnA,156
-wbportfolio/rebalancing/models/composite.py,sha256=H6AgpAAegW2H0pF2xbKVuAubUwbWsQU_L_4lLJBowiI,1167
-wbportfolio/rebalancing/models/equally_weighted.py,sha256=L_XFiVnik3HQjwA0F05FjASlQEXv_X5L8g_Rq0TvVaM,873
-wbportfolio/rebalancing/models/model_portfolio.py,sha256=bGkThc3t80XIvAEp9prstZHsdlt9tGUsLEenzH9XmKc,1243
+wbportfolio/rebalancing/models/__init__.py,sha256=AQjG7Tu5vlmhqncVoYOjpBKU2UIvgo9FuP2_jD2w-UI,232
+wbportfolio/rebalancing/models/composite.py,sha256=XAjJqLRNsV-MuBKrat3THEfAWs6PXQNSO0g8k8MtBXo,1157
+wbportfolio/rebalancing/models/equally_weighted.py,sha256=U29MOHJMQMIg7Y7W_8t5K3nXjaznzt4ArIxQSiv0Xok,863
+wbportfolio/rebalancing/models/market_capitalization_weighted.py,sha256=AYVoLg_bf7s7DSXVjBuIOltFpkySVmv2lrDD-pKBH9I,3643
+wbportfolio/rebalancing/models/model_portfolio.py,sha256=XQdvs03-0M9YUnL4DidwZC4E6k-ANCNcZ--T_aaOXTQ,1233
 wbportfolio/reports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/reports/monthly_position_report.py,sha256=e7BzjDd6eseUOwLwQJXKvWErQ58YnCsznHU2VtR6izM,2981
 wbportfolio/risk_management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -303,7 +304,7 @@ wbportfolio/risk_management/backends/mixins.py,sha256=anuOlop9gc9X8tywx7_wbH7fAJ
 wbportfolio/risk_management/backends/product_integrity.py,sha256=3BbQBYYzLdj2iuQb9QOIgPjWMz1FaPkvEJoNgxWVfz0,4598
 wbportfolio/risk_management/backends/stop_loss_instrument.py,sha256=qIzeV26TRdbgG8-Nsh5O0NPMrPmIXeaRdPR-EF_uaLo,1128
 wbportfolio/risk_management/backends/stop_loss_portfolio.py,sha256=yiDa3FkZKdrmHSf8p1XmT8RhJW6KyiMuypYpY39SiO8,1674
-wbportfolio/risk_management/backends/ucits_portfolio.py,sha256=tBj3HWHVu4fEwLQuVhQsO4tnpOQieSpwnjPMGzWgVNU,3366
+wbportfolio/risk_management/backends/ucits_portfolio.py,sha256=WAw2emAcwDBtYuYoieW0KqGST_CJ27UQuKY0B6jav_Q,3477
 wbportfolio/risk_management/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/risk_management/tests/conftest.py,sha256=ChVocx8SDmh13ixkRmnKe_MMudQAX0495o7nG4NDlsg,440
 wbportfolio/risk_management/tests/test_accounts.py,sha256=q9Z3hDw0Yw86VealdmUfiJBkzRcqDwfybteGxS0hAJA,3990
@@ -314,7 +315,7 @@ wbportfolio/risk_management/tests/test_liquidity_risk.py,sha256=UtzBrW7LeY0Z0ARX
 wbportfolio/risk_management/tests/test_product_integrity.py,sha256=wqJ4b5DO2BrEVQF4eVX2B9AvfrRMAyC_lppGrgKc_ug,1959
 wbportfolio/risk_management/tests/test_stop_loss_instrument.py,sha256=ZueuA9qQOv6JdKuRiPLGV3auOLRnoUCZzfqcQzGJGig,4197
 wbportfolio/risk_management/tests/test_stop_loss_portfolio.py,sha256=bFQqIUs1FZVn1SwiNkzt7hVrvT-qs3EcxOfI20xAjOM,4595
-wbportfolio/risk_management/tests/test_ucits_portfolio.py,sha256=7ZYVfIN0vdAcVUmu8RJtjKgzPHIwjHkPewzRrULybVY,1807
+wbportfolio/risk_management/tests/test_ucits_portfolio.py,sha256=UcZLhatl8iU9AhNNYv6OBs_cjILZKaws2nvUen6orkc,1807
 wbportfolio/serializers/__init__.py,sha256=w1nPxkapcnGngYwiU7BGSLfyhJ67_PQWVjuya7YSxX0,1795
 wbportfolio/serializers/adjustments.py,sha256=0yTPgDjGRyzSa-ecCklENKtLJXZhq1dryMI3nTRsQRo,783
 wbportfolio/serializers/assets.py,sha256=EHTPwicRbdklLHvKS0_Y7pNtw7YC5iW_AuecPoTfJnc,6477
@@ -369,7 +370,7 @@ wbportfolio/tests/models/test_merge.py,sha256=sdsjiZsmR6vsUKwTa5kkvL6QTeAZqtd_EP
 wbportfolio/tests/models/test_portfolio_cash_flow.py,sha256=X8dsXexsb1b0lBiuGzu40ps_Az_1UmmKT0eo1vbXH94,5792
 wbportfolio/tests/models/test_portfolio_cash_targets.py,sha256=q8QWAwt-kKRkLC0E05GyRhF_TTQXIi8bdHjXVU0fCV0,965
 wbportfolio/tests/models/test_portfolio_swing_pricings.py,sha256=kr2AOcQkyg2pX3ULjU-o9ye-NVpjMrrfoe-DVbYCbjs,1656
-wbportfolio/tests/models/test_portfolios.py,sha256=tfQCTmJBZvhzd1iC5B7NW8vi3IySrioWG6ZAHFk4_oA,50675
+wbportfolio/tests/models/test_portfolios.py,sha256=YF1SRS-REJFQhbtxs1LfIUs91jmHpI7pXBE70pW4W7E,51735
 wbportfolio/tests/models/test_product_groups.py,sha256=AcdxhurV-n_bBuUsfD1GqVtwLFcs7VI2CRrwzsIUWbU,3337
 wbportfolio/tests/models/test_products.py,sha256=5YYmQreFnaKLbWmrSib103wgLalqn8u01Fnh3A0XMz8,8217
 wbportfolio/tests/models/test_roles.py,sha256=4Cn7WyrA2ztJNeWLk5cy9kYo5XLWMbFSvo1O-9JYxeA,3323
@@ -383,7 +384,7 @@ wbportfolio/tests/models/transactions/test_trades.py,sha256=z0CCZjB648ECDSEdwmzq
 wbportfolio/tests/pms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/tests/pms/test_analytics.py,sha256=FrvVsV_uUiTgmRUfsaB-_sGzY30CqknbOY2DvmwR_70,1141
 wbportfolio/tests/rebalancing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wbportfolio/tests/rebalancing/test_models.py,sha256=I9yHsDge2MgULcSpdp2YtlqvUSsC1tLAgKUCUH2cVkc,5916
+wbportfolio/tests/rebalancing/test_models.py,sha256=Zph5NFWeIJVFxv06F6CBrJC0xPr3TB5ns0EdgzKdh8U,7610
 wbportfolio/tests/serializers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/tests/serializers/test_claims.py,sha256=vQrg73xQXRFEgvx3KI9ivFre_wpBFzdO0p0J13PkvdY,582
 wbportfolio/tests/viewsets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -403,7 +404,7 @@ wbportfolio/viewsets/portfolio_cash_flow.py,sha256=jkBfdZRQ3KsxGMJpltRjmdrZ2qEFJ
 wbportfolio/viewsets/portfolio_cash_targets.py,sha256=CvHlrDE8qnnnfRpTYnFu-Uu15MDbF5d5gTmEKth2S24,322
 wbportfolio/viewsets/portfolio_relationship.py,sha256=RGyvxd8NfFEs8YdqEvVD3VbrISvAO5UtCTlocSIuWQw,2109
 wbportfolio/viewsets/portfolio_swing_pricing.py,sha256=-57l3WLQZRslIV67OT0ucHE5JXTtTtLvd3t7MppdVn8,357
-wbportfolio/viewsets/portfolios.py,sha256=PZ9ZLZavQuFv6sMQzB1rCq0Ycj5Cc2Q0ddXDD-I9xRo,13014
+wbportfolio/viewsets/portfolios.py,sha256=ZQjlBUZYAM576V0kE8nfRdyCkOPhvt54yFz9drUZilE,13128
 wbportfolio/viewsets/positions.py,sha256=MDf_0x9La2qE6qjaIqBtfV5VC0RfJ1chZIim45Emk10,13198
 wbportfolio/viewsets/product_groups.py,sha256=YvmuXPPy98K1J_rz6YPsx9gNK-tCS2P-wc1uRYgfyo0,2399
 wbportfolio/viewsets/product_performance.py,sha256=dRfRgifjGS1RgZSu9uJRM0SmB7eLnNUkPuqARMO4gyo,28371
@@ -452,7 +453,7 @@ wbportfolio/viewsets/configs/display/trades.py,sha256=e61wLzTEDwewgctpztDa4Exvie
 wbportfolio/viewsets/configs/display/transactions.py,sha256=DOM3eV1DxBwX6Iiw3C2sJamWh6A_3ZSYC9447Jc3Wmo,2586
 wbportfolio/viewsets/configs/endpoints/__init__.py,sha256=E13AYY3CIW4CZtmqwBVMPDYA5zNyKJeRZtiXKtad68Y,2871
 wbportfolio/viewsets/configs/endpoints/adjustments.py,sha256=9CcnfNuFcxsZ8YvfUitSeyCvpLxY-jU-gIw3GG0mIp4,697
-wbportfolio/viewsets/configs/endpoints/assets.py,sha256=VfM9IwyYDLVcN-Hemj5IHx_5ylzhPzksqSEmOM94ys4,3618
+wbportfolio/viewsets/configs/endpoints/assets.py,sha256=fe_D-x3z4xzzAJ7ktvvvwGuoX51l8iTPdDNugagxHYc,3891
 wbportfolio/viewsets/configs/endpoints/claim.py,sha256=H7oUbatjyq6HiSrMzgSMV8KqzH_PNQ5XcwHuL1yX1aA,3650
 wbportfolio/viewsets/configs/endpoints/custodians.py,sha256=Ve7TxfvFnmvm9x0cx6taO502EVWJb23fdVT9yX3ME5o,194
 wbportfolio/viewsets/configs/endpoints/esg.py,sha256=9wGxw1fW8UQJtGd-cT9XWl5gfKN68SSft3wqmkUK4MQ,467
@@ -515,7 +516,7 @@ wbportfolio/viewsets/transactions/rebalancing.py,sha256=6rIrdK0rtKL1afJ-tYfAGdQV
 wbportfolio/viewsets/transactions/trade_proposals.py,sha256=fYTvvRk7k5xsBzbIgJvU4I4OrllF0VkhlrekD4GVgDk,4296
 wbportfolio/viewsets/transactions/trades.py,sha256=6iTIM5g7TUlRtiCjIG4EdYvyfaoB6K3UC2WRX9BD9Jg,15850
 wbportfolio/viewsets/transactions/transactions.py,sha256=ixDp-nsNA8t_A06rBCT19hOMJHy0iRmdz1XKdV1OwAs,4450
-wbportfolio-1.45.0.dist-info/METADATA,sha256=KiCMJmtZLiBOiNHnBttN66pzpw2q1_LZU31dGkbhH_0,734
-wbportfolio-1.45.0.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
-wbportfolio-1.45.0.dist-info/licenses/LICENSE,sha256=jvfVH0SY8_YMHlsJHKe_OajiscQDz4lpTlqT6x24sVw,172
-wbportfolio-1.45.0.dist-info/RECORD,,
+wbportfolio-1.46.0.dist-info/METADATA,sha256=bH78CovhJCtF2hEmjiCmmyo_CstuGHyjdNkqpRSaomk,734
+wbportfolio-1.46.0.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
+wbportfolio-1.46.0.dist-info/licenses/LICENSE,sha256=jvfVH0SY8_YMHlsJHKe_OajiscQDz4lpTlqT6x24sVw,172
+wbportfolio-1.46.0.dist-info/RECORD,,