wbportfolio 1.49.5__py2.py3-none-any.whl → 1.49.6__py2.py3-none-any.whl

wbportfolio/models/asset.py

@@ -511,7 +511,6 @@ class AssetPosition(ImportMixin, models.Model):
                 self.initial_shares = new_weighting * self.get_portfolio_total_asset_value()
             else:
                 self.initial_shares = (new_weighting / self.weighting) * self.initial_shares
-        self.save()
 
     def get_portfolio_total_asset_value(self) -> Decimal:
         return self.portfolio.get_total_asset_value(self.date)

wbportfolio/models/transactions/trade_proposals.py

@@ -80,8 +80,6 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         if not self.trade_date and self.portfolio.assets.exists():
             self.trade_date = (self.portfolio.assets.latest("date").date + BDay(1)).date()
         super().save(*args, **kwargs)
-        if self.status == TradeProposal.Status.APPROVED:
-            self.portfolio.change_at_date(self.trade_date)
 
     @property
     def checked_object(self):
@@ -272,35 +270,43 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
 
     def replay(self):
         last_trade_proposal = self
+        last_trade_proposal_created = False
         while last_trade_proposal and last_trade_proposal.status == TradeProposal.Status.APPROVED:
-            logger.info(f"Replaying trade proposal {last_trade_proposal}")
-            last_trade_proposal.portfolio.assets.filter(
-                date=last_trade_proposal.trade_date
-            ).delete()  # we delete the existing position and we reapply the trade proposal
-            if last_trade_proposal.status == TradeProposal.Status.APPROVED:
-                logger.info("Reverting trade proposal ...")
-                last_trade_proposal.revert()
-            if last_trade_proposal.status == TradeProposal.Status.DRAFT:
-                if self.rebalancing_model:  # if there is no position (for any reason) or we the trade proposal has a rebalancer model attached (trades are computed based on an aglo), we reapply this trade proposal
-                    logger.info(f"Resetting trades from rebalancer model {self.rebalancing_model} ...")
-                    with suppress(
-                        ValidationError
-                    ):  # we silent any validation error while setting proposal, because if this happens, we assume the current trade proposal state if valid and we continue to batch compute
-                        self.reset_trades()
-                logger.info("Submitting trade proposal ...")
-                last_trade_proposal.submit()
-            if last_trade_proposal.status == TradeProposal.Status.SUBMIT:
-                logger.info("Approving trade proposal ...")
-                last_trade_proposal.approve(replay=False)
-            last_trade_proposal.save()
+            if not last_trade_proposal_created:
+                logger.info(f"Replaying trade proposal {last_trade_proposal}")
+                last_trade_proposal.portfolio.assets.filter(
+                    date=last_trade_proposal.trade_date
+                ).delete()  # we delete the existing position and we reapply the trade proposal
+                if last_trade_proposal.status == TradeProposal.Status.APPROVED:
+                    logger.info("Reverting trade proposal ...")
+                    last_trade_proposal.revert()
+                if last_trade_proposal.status == TradeProposal.Status.DRAFT:
+                    if self.rebalancing_model:  # if there is no position (for any reason) or we the trade proposal has a rebalancer model attached (trades are computed based on an aglo), we reapply this trade proposal
+                        logger.info(f"Resetting trades from rebalancer model {self.rebalancing_model} ...")
+                        with suppress(
+                            ValidationError
+                        ):  # we silent any validation error while setting proposal, because if this happens, we assume the current trade proposal state if valid and we continue to batch compute
+                            self.reset_trades()
+                    logger.info("Submitting trade proposal ...")
+                    last_trade_proposal.submit()
+                if last_trade_proposal.status == TradeProposal.Status.SUBMIT:
+                    logger.info("Approving trade proposal ...")
+                    last_trade_proposal.approve(replay=False)
+                last_trade_proposal.save()
             next_trade_proposal = last_trade_proposal.next_trade_proposal
+
             next_trade_date = (
                 next_trade_proposal.trade_date - timedelta(days=1) if next_trade_proposal else date.today()
             )
             overriding_trade_proposal = last_trade_proposal.portfolio.batch_portfolio(
                 last_trade_proposal.trade_date, next_trade_date
             )
-            last_trade_proposal = overriding_trade_proposal or next_trade_proposal
+            if overriding_trade_proposal:
+                last_trade_proposal_created = True
+                last_trade_proposal = overriding_trade_proposal
+            else:
+                last_trade_proposal_created = False
+                last_trade_proposal = next_trade_proposal
 
     def get_estimated_shares(self, weight: Decimal, underlying_quote: Instrument) -> Decimal:
         """
@@ -398,11 +404,14 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         },
     )
     def submit(self, by=None, description=None, **kwargs):
-        self.trades.update(comment="", status=Trade.Status.DRAFT)
         self.reset_trades(target_portfolio=self._build_dto().convert_to_portfolio())
+        trades = []
         for trade in self.trades.all():
-            trade.submit()
-            trade.save()
+            trade.status = Trade.Status.SUBMIT
+            trade.comment = ""
+            trades.append(trade)
+
+        Trade.objects.bulk_update(trades, ["status", "comment"])
 
         # If we estimate cash on this trade proposal, we make sure to create the corresponding cash component
         cash_target_cash_weight, cash_target_cash_shares = self.get_estimated_target_cash(self.portfolio.currency)
@@ -475,11 +484,16 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
         # We validate trade which will create or update the initial asset positions
         if not self.portfolio.can_be_rebalanced:
             raise ValueError("Non-Rebalanceable portfolio cannot be traded manually.")
-        self.trades.update(status=Trade.Status.SUBMIT)
-        self.portfolio.assets.filter(date=self.trade_date).delete()  # we delete position to avoid having leftovers
+        trades = []
+        assets = []
         for trade in self.trades.all():
-            trade.execute()
-            trade.save()
+            with suppress(ValueError):
+                assets.append(trade.to_asset())
+            trade.status = Trade.Status.EXECUTED
+            trades.append(trade)
+
+        Trade.objects.bulk_update(trades, ["status"])
+        self.portfolio.bulk_create_positions(assets, evaluate_rebalancer=False)
         if replay and self.portfolio.is_manageable:
             replay_as_task.delay(self.id)
 
@@ -584,10 +598,22 @@ class TradeProposal(CloneMixin, RiskCheckMixin, WBModel):
     def revert(self, **kwargs):
         with suppress(KeyError):
             del self.__dict__["validated_trading_service"]
-        for trade in self.trades.filter(status=Trade.Status.EXECUTED):
-            trade.revert()
-            trade.save()
-        # replay_as_task.delay(self.id)
+        trades = []
+        assets = []
+        for trade in self.trades.all():
+            trade.status = Trade.Status.DRAFT
+            trades.append(trade)
+            with suppress(AssetPosition.DoesNotExist):
+                asset = AssetPosition.unannotated_objects.get(
+                    underlying_quote=trade.underlying_instrument,
+                    portfolio=trade.portfolio,
+                    date=trade.transaction_date,
+                    is_estimated=False,
+                )
+                asset.set_weighting(asset.weighting - trade.weighting)
+                assets.append(asset)
+        Trade.objects.bulk_update(trades, ["status"])
+        self.portfolio.bulk_create_positions(assets, evaluate_rebalancer=False)
 
     def can_revert(self):
         errors = dict()

wbportfolio/models/transactions/trades.py

@@ -299,25 +299,47 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
             )
         },
     )
+    def to_asset(self) -> AssetPosition:
+        last_underlying_quote_price = self.last_underlying_quote_price
+        if not last_underlying_quote_price:
+            raise ValueError("No price found")
+        asset = AssetPosition(
+            underlying_quote=self.underlying_instrument,
+            portfolio_created=None,
+            portfolio=self.portfolio,
+            date=self.transaction_date,
+            initial_currency_fx_rate=self.currency_fx_rate,
+            weighting=self._target_weight,
+            initial_price=self.last_underlying_quote_price.net_value,
+            initial_shares=None,
+            underlying_quote_price=self.last_underlying_quote_price,
+            asset_valuation_date=self.transaction_date,
+            currency=self.currency,
+            is_estimated=False,
+        )
+        asset.set_weighting(self._target_weight)
+        asset.pre_save()
+        return asset
+
     def execute(self, **kwargs):
-        if self.last_underlying_quote_price:
-            asset, created = AssetPosition.unannotated_objects.update_or_create(
-                underlying_quote=self.underlying_instrument,
-                portfolio_created=None,
-                portfolio=self.portfolio,
-                date=self.transaction_date,
+        with suppress(ValueError):
+            asset = self.to_asset()
+            AssetPosition.unannotated_objects.update_or_create(
+                underlying_quote=asset.underlying_quote,
+                portfolio_created=asset.portfolio_created,
+                portfolio=asset.portfolio,
+                date=asset.date,
                 defaults={
-                    "initial_currency_fx_rate": self.currency_fx_rate,
-                    "weighting": self._target_weight,
-                    "initial_price": self.last_underlying_quote_price.net_value,
-                    "initial_shares": None,
-                    "underlying_quote_price": self.last_underlying_quote_price,
-                    "asset_valuation_date": self.transaction_date,
-                    "currency": self.currency,
-                    "is_estimated": False,
+                    "initial_currency_fx_rate": asset.initial_currency_fx_rate,
+                    "initial_price": asset.initial_price,
+                    "initial_shares": asset.initial_shares,
+                    "underlying_quote_price": asset.underlying_quote_price,
+                    "asset_valuation_date": asset.asset_valuation_date,
+                    "currency": asset.currency,
+                    "is_estimated": asset.is_estimated,
+                    "weighting": asset.weighting,
                 },
             )
-            asset.set_weighting(self._target_weight)
 
     def can_execute(self):
         if not self.last_underlying_quote_price:
@@ -402,6 +424,7 @@ class Trade(ShareMixin, Transaction, OrderedModel, WBModel):
                 is_estimated=False,
             )
             asset.set_weighting(asset.weighting - self.weighting)
+            asset.save()
 
     @property
     def product(self):

wbportfolio/rebalancing/models/composite.py

@@ -1,6 +1,7 @@
 from decimal import Decimal
 
 from django.core.exceptions import ObjectDoesNotExist
+from wbfdm.models import InstrumentPrice
 
 from wbportfolio.models import Trade
 from wbportfolio.pms.typing import Portfolio, Position
@@ -20,7 +21,7 @@ class CompositeRebalancing(AbstractRebalancingModel):
         """
         try:
             latest_trade_proposal = self.portfolio.trade_proposals.filter(
-                status="APPROVED", trade_date__lte=self.trade_date
+                status="APPROVED", trade_date__lt=self.trade_date
             ).latest("trade_date")
             return {
                 v["underlying_instrument"]: v["target_weight"]
@@ -33,7 +34,10 @@ class CompositeRebalancing(AbstractRebalancingModel):
             return dict()
 
     def is_valid(self) -> bool:
-        return len(self.base_assets.keys()) > 0
+        return (
+            len(self.base_assets.keys()) > 0
+            and InstrumentPrice.objects.filter(date=self.trade_date, instrument__in=self.base_assets.keys()).exists()
+        )
 
     def get_target_portfolio(self) -> Portfolio:
         positions = []

wbportfolio/rebalancing/models/equally_weighted.py

@@ -1,5 +1,7 @@
 from decimal import Decimal
 
+from wbfdm.models import InstrumentPrice
+
 from wbportfolio.pms.typing import Portfolio
 from wbportfolio.rebalancing.base import AbstractRebalancingModel
 from wbportfolio.rebalancing.decorators import register
@@ -7,8 +9,17 @@ from wbportfolio.rebalancing.decorators import register
 
 @register("Equally Weighted Rebalancing")
 class EquallyWeightedRebalancing(AbstractRebalancingModel):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.assets = self.portfolio.assets.filter(date=self.last_effective_date)
+
     def is_valid(self) -> bool:
-        return self.portfolio.assets.filter(date=self.last_effective_date).exists()
+        return (
+            self.assets.exists()
+            and InstrumentPrice.objects.filter(
+                date=self.trade_date, instrument__in=self.assets.values("underlying_quote")
+            ).exists()
+        )
 
     def get_target_portfolio(self) -> Portfolio:
         positions = []

wbportfolio/rebalancing/models/model_portfolio.py

@@ -1,3 +1,5 @@
+from wbfdm.models import InstrumentPrice
+
 from wbportfolio.pms.typing import Portfolio
 from wbportfolio.rebalancing.base import AbstractRebalancingModel
 from wbportfolio.rebalancing.decorators import register
@@ -18,11 +20,15 @@ class ModelPortfolioRebalancing(AbstractRebalancingModel):
             return model_portfolio_rel.dependency_portfolio
 
     def is_valid(self) -> bool:
-        return (
-            self.model_portfolio.assets.filter(date=self.last_effective_date).exists()
-            if self.model_portfolio
-            else False
-        )
+        if model_portfolio := self.model_portfolio:
+            assets = model_portfolio.get_positions(self.last_effective_date)
+            return (
+                assets.exists()
+                and InstrumentPrice.objects.filter(
+                    date=self.trade_date, instrument__in=assets.values("underlying_quote")
+                ).exists()
+            )
+        return False
 
     def get_target_portfolio(self) -> Portfolio:
         positions = []

wbportfolio/tests/models/transactions/test_rebalancing.py

@@ -11,11 +11,15 @@ from wbportfolio.models import AssetPosition, TradeProposal
 
 @pytest.mark.django_db
 class TestRebalancingModel:
-    def test_get_target_portfolio(self, rebalancing_model, portfolio, weekday, asset_position_factory):
+    def test_get_target_portfolio(
+        self, rebalancing_model, portfolio, weekday, asset_position_factory, instrument_price_factory
+    ):
+        trade_date = (weekday + BDay(1)).date()
         with pytest.raises(ValidationError):  # trigger value error because rebalancing not valid (no position yet)
-            rebalancing_model.get_target_portfolio(portfolio, (weekday + BDay(1)).date(), weekday)
+            rebalancing_model.get_target_portfolio(portfolio, trade_date, weekday)
         a1 = asset_position_factory(weighting=0.7, portfolio=portfolio, date=weekday)
         a2 = asset_position_factory(weighting=0.3, portfolio=portfolio, date=weekday)
+        instrument_price_factory.create(instrument=a1.underlying_quote, date=trade_date)
         target_portfolio = rebalancing_model.get_target_portfolio(portfolio, (weekday + BDay(1)).date(), weekday)
         target_positions = target_portfolio.positions_map
         assert target_positions[a1.underlying_instrument.id].weighting == 0.5

wbportfolio/tests/rebalancing/test_models.py

@@ -16,9 +16,11 @@ class TestEquallyWeightedRebalancing:
 
         return EquallyWeightedRebalancing(portfolio, (weekday + BDay(1)).date(), weekday)
 
-    def test_is_valid(self, portfolio, weekday, model, asset_position_factory):
+    def test_is_valid(self, portfolio, weekday, model, asset_position_factory, instrument_price_factory):
         assert not model.is_valid()
-        asset_position_factory.create(portfolio=model.portfolio, date=model.last_effective_date)
+        a = asset_position_factory.create(portfolio=model.portfolio, date=model.last_effective_date)
+        assert not model.is_valid()
+        instrument_price_factory.create(instrument=a.underlying_quote, date=model.trade_date)
         assert model.is_valid()
 
     def test_get_target_portfolio(self, portfolio, weekday, model, asset_position_factory):
@@ -38,7 +40,7 @@ class TestModelPortfolioRebalancing:
 
         return ModelPortfolioRebalancing(portfolio, (weekday + BDay(1)).date(), weekday)
 
-    def test_is_valid(self, portfolio, weekday, model, asset_position_factory):
+    def test_is_valid(self, portfolio, weekday, model, asset_position_factory, instrument_price_factory):
         assert not model.is_valid()
         asset_position_factory.create(portfolio=model.portfolio, date=model.last_effective_date)
         assert not model.is_valid()
@@ -48,7 +50,9 @@ class TestModelPortfolioRebalancing:
             dependency_portfolio=model_portfolio,
             type=PortfolioPortfolioThroughModel.Type.MODEL,
         )
-        asset_position_factory.create(portfolio=model.model_portfolio, date=model.last_effective_date)
+        a = asset_position_factory.create(portfolio=model.model_portfolio, date=model.last_effective_date)
+        assert not model.is_valid()
+        instrument_price_factory.create(instrument=a.underlying_quote, date=model.trade_date)
         assert model.is_valid()
 
     def test_get_target_portfolio(self, portfolio, weekday, model, asset_position_factory):
@@ -76,15 +80,15 @@ class TestCompositeRebalancing:
 
         return CompositeRebalancing(portfolio, (weekday + BDay(1)).date(), weekday)
 
-    def test_is_valid(self, portfolio, weekday, model, asset_position_factory):
+    def test_is_valid(self, portfolio, weekday, model, asset_position_factory, instrument_price_factory):
         assert not model.is_valid()
 
         trade_proposal = TradeProposalFactory.create(
-            portfolio=model.portfolio, trade_date=model.trade_date, status=TradeProposal.Status.APPROVED
+            portfolio=model.portfolio, trade_date=model.last_effective_date, status=TradeProposal.Status.APPROVED
         )
-        TradeFactory.create(
+        t1 = TradeFactory.create(
             portfolio=model.portfolio,
-            transaction_date=model.trade_date,
+            transaction_date=model.last_effective_date,
             transaction_subtype=Trade.Type.BUY,
             trade_proposal=trade_proposal,
             weighting=0.7,
@@ -92,23 +96,25 @@ class TestCompositeRebalancing:
         )
         TradeFactory.create(
             portfolio=model.portfolio,
-            transaction_date=model.trade_date,
+            transaction_date=model.last_effective_date,
             transaction_subtype=Trade.Type.BUY,
             trade_proposal=trade_proposal,
             weighting=0.3,
             status=Trade.Status.EXECUTED,
         )
+        assert not model.is_valid()
+        instrument_price_factory.create(instrument=t1.underlying_instrument, date=model.trade_date)
         assert model.is_valid()
 
     def test_get_target_portfolio(self, portfolio, weekday, model, asset_position_factory):
         trade_proposal = TradeProposalFactory.create(
-            portfolio=model.portfolio, trade_date=model.trade_date, status=TradeProposal.Status.APPROVED
+            portfolio=model.portfolio, trade_date=model.last_effective_date, status=TradeProposal.Status.APPROVED
         )
         asset_position_factory(portfolio=portfolio, date=model.last_effective_date)  # noise
         asset_position_factory(portfolio=portfolio, date=model.last_effective_date)  # noise
         t1 = TradeFactory.create(
             portfolio=model.portfolio,
-            transaction_date=model.trade_date,
+            transaction_date=model.last_effective_date,
             transaction_subtype=Trade.Type.BUY,
             trade_proposal=trade_proposal,
             weighting=0.8,
@@ -116,7 +122,7 @@ class TestCompositeRebalancing:
         )
         t2 = TradeFactory.create(
             portfolio=model.portfolio,
-            transaction_date=model.trade_date,
+            transaction_date=model.last_effective_date,
             transaction_subtype=Trade.Type.BUY,
             trade_proposal=trade_proposal,
             weighting=0.2,

wbportfolio/viewsets/configs/display/portfolios.py

@@ -205,13 +205,11 @@ class TopDownPortfolioCompositionPandasDisplayConfig(DisplayViewConfig):
             effective_column_label += f" ({self.view.last_effective_date:%Y-%m-%d})"
         return dp.ListDisplay(
             fields=[
-                dp.Field(key="instrument", label="Instrument"),
+                dp.Field(key="instrument", label="Instrument", pinned="left"),
                 dp.Field(key="rebalancing_weights", label=rebalancing_column_label),
                 dp.Field(key="effective_weights", label=effective_column_label),
             ],
             tree=True,
-            tree_group_pinned="left",
             tree_group_field="instrument",
-            tree_group_label="Instrument",
             tree_group_parent_pointer="parent_row_id",
         )

{wbportfolio-1.49.5.dist-info → wbportfolio-1.49.6.dist-info}/METADATA

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

{wbportfolio-1.49.5.dist-info → wbportfolio-1.49.6.dist-info}/RECORD

@@ -245,7 +245,7 @@ wbportfolio/migrations/0076_alter_dividendtransaction_price_and_more.py,sha256=4
 wbportfolio/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/models/__init__.py,sha256=IIS_PNRxyX2Dcvyk1bcQOUzFt0B9SPC0WlM88CXqj04,881
 wbportfolio/models/adjustments.py,sha256=osXWkJZOiansPWYPyHtl7Z121zDWi7u1YMtrBQtbHVo,10272
-wbportfolio/models/asset.py,sha256=yf4vBPfN1eZlWXG9SowQwr5-goG8rO1yYDitHDLZCBs,37758
+wbportfolio/models/asset.py,sha256=QftWva0GmlStpspcp33TOMZf2t_PTeEhwWdp6xUbQNU,37738
 wbportfolio/models/custodians.py,sha256=owTiS2Vm5CRKzh9M_P9GOVg-s-ndQ9UvRmw3yZP7cw0,3815
 wbportfolio/models/exceptions.py,sha256=3ix0tWUO-O6jpz8f07XIwycw2x3JFRoWzjwil8FVA2Q,52
 wbportfolio/models/indexes.py,sha256=iLYF2gzNzX4GLj_Nh3fybUcAQ1TslnT0wgQ6mN164QI,728
@@ -276,8 +276,8 @@ wbportfolio/models/transactions/dividends.py,sha256=92-jG8bZN9nU9oDubpu-UDH43Ri7
 wbportfolio/models/transactions/expiry.py,sha256=vnNHdcC1hf2HP4rAbmoGgOfagBYKNFytqOwzOI0MlVI,144
 wbportfolio/models/transactions/fees.py,sha256=ffvqo8I4A0l5rLi00jJ6sGot0jmnkoxaNsbDzdPLwCg,5712
 wbportfolio/models/transactions/rebalancing.py,sha256=nrBi6x6PssCtkLtOpV-2OoAHDUKnnYyrM6xH1PmnjSo,7240
-wbportfolio/models/transactions/trade_proposals.py,sha256=9ggUkwzDgMKa8cC8dNZ4IHlleiGpRN0WU-oXGDSiuaw,26730
-wbportfolio/models/transactions/trades.py,sha256=P9cSTEpZBsqKBvw25XY_RNctTiOBEzCvcuy0r8IkedE,28013
+wbportfolio/models/transactions/trade_proposals.py,sha256=qpjjQMK7G5sX7iiCnXBt07EH-ztxZz-l842yfYrBLQw,27764
+wbportfolio/models/transactions/trades.py,sha256=NA_hUpFKQ4H-w3B0gMZ5IFkZo6WJTH2S7GBUQC1jUpU,28922
 wbportfolio/models/transactions/transactions.py,sha256=fWoDf0TSV0L0gLUDOQpCRLzjMt1H4MUvUHGEaMsilCc,7027
 wbportfolio/pms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/pms/typing.py,sha256=b2pBWYt1E8ok-Kqm0lEFIakSnWJ6Ib57z-VX3C3gkQc,6081
@@ -290,10 +290,10 @@ wbportfolio/rebalancing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG
 wbportfolio/rebalancing/base.py,sha256=NwTGZtBm1f35gj5Jp6iTyyFvDT1GSIztN990cKBvYzQ,637
 wbportfolio/rebalancing/decorators.py,sha256=JhQ2vkcIuGBTGvNmpkQerdw2-vLq-RAb0KAPjOrETkw,515
 wbportfolio/rebalancing/models/__init__.py,sha256=AQjG7Tu5vlmhqncVoYOjpBKU2UIvgo9FuP2_jD2w-UI,232
-wbportfolio/rebalancing/models/composite.py,sha256=uyF1n3NAFprnAZ3Gl5pNJl0GajelqJspC2NufZ7Tf0s,1636
-wbportfolio/rebalancing/models/equally_weighted.py,sha256=U29MOHJMQMIg7Y7W_8t5K3nXjaznzt4ArIxQSiv0Xok,863
+wbportfolio/rebalancing/models/composite.py,sha256=XEgK3oMurrE_d_l5uN0stBKRrtvnKQzRWyXNXuBYfmc,1818
+wbportfolio/rebalancing/models/equally_weighted.py,sha256=FCpSKOs49ckNYVgoYIiHB0BqPT9OeCMuFoet4Ixbp-Y,1210
 wbportfolio/rebalancing/models/market_capitalization_weighted.py,sha256=6ZsR8iJg6l89CsxHqoxJSXlTaj8Pmb8_bFPrXhnxaRs,5295
-wbportfolio/rebalancing/models/model_portfolio.py,sha256=XQdvs03-0M9YUnL4DidwZC4E6k-ANCNcZ--T_aaOXTQ,1233
+wbportfolio/rebalancing/models/model_portfolio.py,sha256=DNg9vEDYDUwXTOnIpk26FQSPHC0qxkuvW2sJWX0VodQ,1489
 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
@@ -383,13 +383,13 @@ wbportfolio/tests/models/utils.py,sha256=ORNJq6NMo1Za22jGZXfTfKeNEnTRlfEt_8SJ6xL
 wbportfolio/tests/models/transactions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/tests/models/transactions/test_claim.py,sha256=NG3BKB-FVcIDgHSJHCjImxgMM3ISVUMl24xUPmEcPec,5570
 wbportfolio/tests/models/transactions/test_fees.py,sha256=1gp_h_CCC4Z_cWHUgrZCjGAxYuT2u8FZdw0krDpESiY,2801
-wbportfolio/tests/models/transactions/test_rebalancing.py,sha256=H1UbxPm-oa00-JJXbBxNutdTKvXXJmuATTab2XsXp44,3900
+wbportfolio/tests/models/transactions/test_rebalancing.py,sha256=fZ5tx6kByEGXD6nhapYdvk9HOjYlmjhU2w6KlQJ6QE4,4061
 wbportfolio/tests/models/transactions/test_trade_proposals.py,sha256=sqC8uT46Znb03ZwWxIJOaFNBENKunfA5U73xjWbdj80,17053
 wbportfolio/tests/models/transactions/test_trades.py,sha256=vqvOqUY_uXvBp8YOKR0Wq9ycA2oeeEBhO3dzV7sbXEU,9863
 wbportfolio/tests/pms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/tests/pms/test_analytics.py,sha256=fAuY1zcXibttFpBh2GhKVyzdYfi1kz_b7SPa9xZQXY0,1086
 wbportfolio/tests/rebalancing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wbportfolio/tests/rebalancing/test_models.py,sha256=qyZkNG1WF1lZdYwvjUElkkNey8b5ZMGSlWpzxujCuNg,7549
+wbportfolio/tests/rebalancing/test_models.py,sha256=_gT_7UtpOWceDwT7FbTUW6P6ZpCVLBpgXWM0goIljWc,8090
 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
@@ -444,7 +444,7 @@ wbportfolio/viewsets/configs/display/esg.py,sha256=W8uetCPN2TjHtU2kvQjKOmkq7uoaY
 wbportfolio/viewsets/configs/display/fees.py,sha256=_8HDJADh5bA5VMVPkhKObPmNNdPHWR8Oz23PEgd04F0,5834
 wbportfolio/viewsets/configs/display/portfolio_cash_flow.py,sha256=CS_UGhKZSXnX-0SZ0RXzbG1WMJm6NX3GUljwIa4RWBk,5025
 wbportfolio/viewsets/configs/display/portfolio_relationship.py,sha256=8DvsYWFCX29qj5wUf1wCtjlPwzKRd_E7JDuo_CopaJ0,1294
-wbportfolio/viewsets/configs/display/portfolios.py,sha256=HFUFYajD7l-7WhwsxEeBp8QvJ5ZZY03EA8Am-DQ6f6w,10726
+wbportfolio/viewsets/configs/display/portfolios.py,sha256=FDL0wucfqnyehrPg_vJqZ1JJ_1S37C_TAbON165-07w,10660
 wbportfolio/viewsets/configs/display/positions.py,sha256=yolWLxzGPIpSQSiVhVQChURqbomPt5kSjkYrmXT1Mik,3123
 wbportfolio/viewsets/configs/display/product_groups.py,sha256=PwI-A0_ofShT2pub9-C1HqreiqpHxKMHd51JYwEzvbM,2500
 wbportfolio/viewsets/configs/display/product_performance.py,sha256=6Mme48JBn_okwClR44dBK2OK26ejvdasDvBa5DI33_0,10070
@@ -521,7 +521,7 @@ wbportfolio/viewsets/transactions/rebalancing.py,sha256=6rIrdK0rtKL1afJ-tYfAGdQV
 wbportfolio/viewsets/transactions/trade_proposals.py,sha256=iQpC_Thbj56SmM05vPRsF1JZguGBDaTUH3I-_iCHCV0,5958
 wbportfolio/viewsets/transactions/trades.py,sha256=xeEzx7GP34aBNPlDmiUmT86labsbb8_f1U2RCN1Jatg,21494
 wbportfolio/viewsets/transactions/transactions.py,sha256=ixDp-nsNA8t_A06rBCT19hOMJHy0iRmdz1XKdV1OwAs,4450
-wbportfolio-1.49.5.dist-info/METADATA,sha256=5rVe6Q67fXJTmyNtQe8MP7cfiBkqOQ7z-sRlfgU5f-U,734
-wbportfolio-1.49.5.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
-wbportfolio-1.49.5.dist-info/licenses/LICENSE,sha256=jvfVH0SY8_YMHlsJHKe_OajiscQDz4lpTlqT6x24sVw,172
-wbportfolio-1.49.5.dist-info/RECORD,,
+wbportfolio-1.49.6.dist-info/METADATA,sha256=KMGYS4c7qMFyTTr5hrm23nCftQHaW2JSIRsfp0SetKA,734
+wbportfolio-1.49.6.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
+wbportfolio-1.49.6.dist-info/licenses/LICENSE,sha256=jvfVH0SY8_YMHlsJHKe_OajiscQDz4lpTlqT6x24sVw,172
+wbportfolio-1.49.6.dist-info/RECORD,,