wbportfolio 1.45.0__tar.gz → 1.46.0__tar.gz

{wbportfolio-1.45.0 → wbportfolio-1.46.0}/PKG-INFO

@@ -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 → wbportfolio-1.46.0}/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-1.46.0/wbportfolio/import_export/parsers/vontobel/valuation_api.py

@@ -0,0 +1,23 @@
+import json
+from contextlib import suppress
+from datetime import datetime
+
+from wbportfolio.models import Product
+
+
+def parse(import_source):
+    data = []
+    with suppress(KeyError):
+        series_data = json.loads(import_source.file.read())["payload"]["series"]
+        for series in series_data:
+            isin = series["item"]["priceIdentifier"]
+            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-1.45.0 → wbportfolio-1.46.0}/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-1.45.0 → wbportfolio-1.46.0}/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-1.45.0 → wbportfolio-1.46.0}/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-1.45.0 → wbportfolio-1.46.0}/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-1.45.0 → wbportfolio-1.46.0}/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-1.45.0 → wbportfolio-1.46.0}/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-1.45.0 → wbportfolio-1.46.0}/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-1.45.0 → wbportfolio-1.46.0}/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-1.46.0/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-1.45.0 → wbportfolio-1.46.0}/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-1.45.0 → wbportfolio-1.46.0}/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-1.45.0 → wbportfolio-1.46.0}/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-1.45.0 → wbportfolio-1.46.0}/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-1.45.0 → wbportfolio-1.46.0}/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-1.45.0 → wbportfolio-1.46.0}/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):