wbportfolio 1.46.9__py2.py3-none-any.whl → 1.46.10__py2.py3-none-any.whl

wbportfolio/models/asset.py

@@ -1,6 +1,6 @@
 from contextlib import suppress
 from datetime import date
-from decimal import Decimal
+from decimal import Decimal, InvalidOperation
 
 from django.contrib import admin
 from django.db import models
@@ -393,7 +393,9 @@ class AssetPosition(ImportMixin, models.Model):
     analytical_objects = AnalyticalAssetPositionManager()
     unannotated_objects = models.Manager()
 
-    def pre_save(self, create_underlying_quote_price_if_missing: bool = False):
+    def pre_save(
+        self, create_underlying_quote_price_if_missing: bool = False, infer_underlying_quote_price: bool = True
+    ):
         if not self.asset_valuation_date:
             self.asset_valuation_date = self.date
 
@@ -417,10 +419,10 @@ class AssetPosition(ImportMixin, models.Model):
 
         if not getattr(self, "currency", None):
             self.currency = self.underlying_quote.currency
-        if not self.underlying_quote_price:
+        if not self.underlying_quote_price and infer_underlying_quote_price:
             try:
                 # We get only the instrument price (and don't create it) because we don't want to create product instrument price on asset position propagation
-                # Instead, we deciced to opt for a post_save based system that will assign the missing position price when a price is created
+                # Instead, we decided to opt for a post_save based system that will assign the missing position price when a price is created
                 self.underlying_quote_price = InstrumentPrice.objects.get(
                     calculated=False, instrument=self.underlying_quote, date=self.asset_valuation_date
                 )
@@ -468,9 +470,12 @@ class AssetPosition(ImportMixin, models.Model):
         if self.initial_currency_fx_rate is None:
             self.initial_currency_fx_rate = Decimal(1.0)
             if self.currency_fx_rate_portfolio_to_usd and self.currency_fx_rate_instrument_to_usd:
-                self.initial_currency_fx_rate = (
-                    self.currency_fx_rate_portfolio_to_usd.value / self.currency_fx_rate_instrument_to_usd.value
-                )
+                try:
+                    self.initial_currency_fx_rate = (
+                        self.currency_fx_rate_portfolio_to_usd.value / self.currency_fx_rate_instrument_to_usd.value
+                    )
+                except InvalidOperation:
+                    self.initial_currency_fx_rate = Decimal(0.0)
 
     def save(self, *args, create_underlying_quote_price_if_missing: bool = False, **kwargs):
         self.pre_save(create_underlying_quote_price_if_missing=create_underlying_quote_price_if_missing)

wbportfolio/models/mixins/instruments.py

@@ -65,7 +65,9 @@ class PMSInstrument(Instrument):
         try:
             return InstrumentPrice.objects.filter_only_valid_prices().get(instrument=self, date=val_date)
         except InstrumentPrice.DoesNotExist:
-            if not self.inception_date or not self.prices.filter(date__lte=val_date).exists():
+            if (not self.inception_date or self.inception_date == val_date) and not self.prices.filter(
+                date__lte=val_date
+            ).exists():
                 return InstrumentPrice.objects.get_or_create(
                     instrument=self, date=val_date, defaults={"calculated": False, "net_value": self.issue_price}
                 )[0]

wbportfolio/models/portfolio.py

@@ -1,4 +1,5 @@
 import logging
+from collections import defaultdict
 from contextlib import suppress
 from datetime import date, timedelta
 from decimal import Decimal
@@ -26,6 +27,7 @@ from django.db.models import (
 from django.db.models.signals import post_save
 from django.dispatch import receiver
 from django.utils import timezone
+from django.utils.functional import cached_property
 from pandas._libs.tslibs.offsets import BDay
 from psycopg.types.range import DateRange
 from skfolio.preprocessing import prices_to_returns
@@ -54,6 +56,63 @@ from . import ProductGroup
 logger = logging.getLogger("pms")
 
 
+class PositionDictConverter:
+    """Utility class to load a dictionary of dictionary (dictionary of instrument_id and float per date) into a iterable of assetposition"""
+
+    def __init__(self, portfolio, prices: pd.DataFrame, infer_underlying_quote_price=False):
+        self.portfolio = portfolio
+        self.instruments = {}
+        self.fx_rates = defaultdict(dict)
+        self.prices = prices
+        self.infer_underlying_quote_price = infer_underlying_quote_price
+
+    def _get_instrument(self, instrument_id: int) -> Instrument:
+        try:
+            return self.instruments[instrument_id]
+        except KeyError:
+            instrument = Instrument.objects.get(id=instrument_id)
+            self.instruments[instrument_id] = instrument
+            return instrument
+
+    def _get_fx_rate(self, val_date: date, currency) -> CurrencyFXRates:
+        try:
+            return self.fx_rates[currency][val_date]
+        except KeyError:
+            fx_rate = CurrencyFXRates.objects.get_or_create(
+                currency=currency, date=val_date, defaults={"value": Decimal(0)}
+            )[0]  # we create a fx rate anyway to not fail the position. The fx rate expect to be there later on
+            self.fx_rates[currency][val_date] = fx_rate
+            return fx_rate
+
+    def dict_to_model(self, val_date: date, instrument_id: int, weighting: float) -> AssetPosition:
+        underlying_quote = self._get_instrument(instrument_id)
+        currency_fx_rate_portfolio_to_usd = self._get_fx_rate(val_date, self.portfolio.currency)
+        currency_fx_rate_instrument_to_usd = self._get_fx_rate(val_date, underlying_quote.currency)
+        position = AssetPosition(
+            underlying_quote=underlying_quote,
+            weighting=weighting,
+            date=val_date,
+            asset_valuation_date=val_date,
+            is_estimated=True,
+            portfolio=self.portfolio,
+            currency=underlying_quote.currency,
+            initial_price=self.prices.loc[pd.Timestamp(val_date), instrument_id],
+            currency_fx_rate_portfolio_to_usd=currency_fx_rate_portfolio_to_usd,
+            currency_fx_rate_instrument_to_usd=currency_fx_rate_instrument_to_usd,
+            initial_currency_fx_rate=None,
+            underlying_quote_price=None,
+            underlying_instrument=None,
+        )
+        position.pre_save(
+            infer_underlying_quote_price=self.infer_underlying_quote_price
+        )  # inferring underlying quote price is potentially very slow for big dataset of positions, it's not very needed for model portfolio so we disable it
+        return position
+
+    def convert(self, positions: dict[date, dict[int, float]]) -> Iterable[AssetPosition]:
+        for val_date, weights in positions.items():
+            yield from map(lambda row: self.dict_to_model(val_date, row[0], row[1]), weights.items())
+
+
 class DefaultPortfolioQueryset(QuerySet):
     def filter_invested_at_date(self, val_date: date) -> QuerySet:
         """
@@ -253,11 +312,12 @@ class Portfolio(DeleteToDisableMixin, WBModel):
     def imported_assets(self):
         return self.assets.filter(is_estimated=False)
 
-    @property
+    @cached_property
     def pms_instruments(self):
-        yield from Product.objects.filter(portfolios=self)
-        yield from ProductGroup.objects.filter(portfolios=self)
-        yield from Index.objects.filter(portfolios=self)
+        instruments = [i for i in Product.objects.filter(portfolios=self)]
+        instruments.extend([i for i in ProductGroup.objects.filter(portfolios=self)])
+        instruments.extend([i for i in Index.objects.filter(portfolios=self)])
+        return instruments
 
     @property
     def can_be_rebalanced(self):
@@ -298,31 +358,28 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             )
         )
 
-    def get_analytic_portfolio(self, val_date: date, with_previous_weights: bool = False) -> AnalyticPortfolio:
+    def get_analytic_portfolio(self, val_date: date, **kwargs) -> tuple[AnalyticPortfolio, pd.DataFrame]:
         """
         Return the analytic portfolio associated with this portfolio at the given date
 
         the analytic portfolio inherit from SKFolio Portfolio and can be used to access all this library methods
         Args:
             val_date: the date to calculate the portfolio for
-            with_previous_weights: If true, excludes the previous weights into the analytic portfolio (might be necessary for some metrics)
 
         Returns:
             The instantiated analytic portfolio
         """
         weights = self.get_weights(val_date)
         instrument_ids = weights.keys()
-        previous_weights = None
-        if with_previous_weights:
-            if previous_date := self.get_latest_asset_position_date(val_date - timedelta(days=1)):
-                previous_weights = self.get_weights(previous_date)
-                instrument_ids = previous_weights.keys()
-        returns = self.get_returns(instrument_ids, (val_date - BDay(3)).date(), val_date)[0]
+        return_date = (val_date + BDay(1)).date()
+        returns, prices = self.get_returns(instrument_ids, (val_date - BDay(2)).date(), return_date, **kwargs)
         returns = returns.fillna(0)  # not sure this is what we want
-        return AnalyticPortfolio(
-            X=returns,
-            weights=weights,
-            previous_weights=previous_weights,
+        return (
+            AnalyticPortfolio(
+                X=returns,
+                weights=weights,
+            ),
+            prices,
         )
 
     def is_invested_at_date(self, val_date: date) -> bool:
@@ -567,10 +624,11 @@ class Portfolio(DeleteToDisableMixin, WBModel):
 
     def get_child_portfolios(self, val_date: date) -> set["Portfolio"]:
         child_portfolios = set()
-        if pms_instruments := list(self.pms_instruments):
+        instrument_rel = InstrumentPortfolioThroughModel.objects.filter(portfolio=self)
+        if instrument_rel.exists():
             for parent_portfolio in Portfolio.objects.filter(
                 id__in=AssetPosition.unannotated_objects.filter(
-                    date=val_date, underlying_quote__in=pms_instruments
+                    date=val_date, underlying_quote__in=instrument_rel.values("instrument")
                 ).values("portfolio")
             ):
                 child_portfolios.add(parent_portfolio)
@@ -592,24 +650,29 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         evaluate_rebalancer: bool = True,
     ):
         logger.info(f"change at date for {self} at {val_date}")
-        qs = self.assets.filter(date=val_date).filter(
-            Q(total_value_fx_portfolio__isnull=False) | Q(weighting__isnull=False)
-        )
 
-        # We normalize weight across the portfolio for a given date
-        if (self.is_lookthrough or self.is_manageable or force_recompute_weighting) and qs.exists():
-            total_weighting = qs.aggregate(s=Sum("weighting"))["s"]
-            # We check if this actually necessary
-            # (i.e. if the weight is already summed to 100%, it is already normalized)
-            if not total_weighting or not isclose(total_weighting, Decimal(1.0), abs_tol=0.001) or recompute_weighting:
-                total_value = qs.aggregate(s=Sum("total_value_fx_portfolio"))["s"]
-                # TODO we change this because postgres doesn't support join statement in update (and total_value_fx_portfolio is a joined annoted field)
-                for asset in qs:
-                    if total_value:
-                        asset.weighting = asset._total_value_fx_portfolio / total_value
-                    elif total_weighting:
-                        asset.weighting = asset.weighting / total_weighting
-                    asset.save()
+        if recompute_weighting:
+            # We normalize weight across the portfolio for a given date
+            qs = self.assets.filter(date=val_date).filter(
+                Q(total_value_fx_portfolio__isnull=False) | Q(weighting__isnull=False)
+            )
+            if (self.is_lookthrough or self.is_manageable or force_recompute_weighting) and qs.exists():
+                total_weighting = qs.aggregate(s=Sum("weighting"))["s"]
+                # We check if this actually necessary
+                # (i.e. if the weight is already summed to 100%, it is already normalized)
+                if (
+                    not total_weighting
+                    or not isclose(total_weighting, Decimal(1.0), abs_tol=0.001)
+                    or force_recompute_weighting
+                ):
+                    total_value = qs.aggregate(s=Sum("total_value_fx_portfolio"))["s"]
+                    # TODO we change this because postgres doesn't support join statement in update (and total_value_fx_portfolio is a joined annoted field)
+                    for asset in qs:
+                        if total_value:
+                            asset.weighting = asset._total_value_fx_portfolio / total_value
+                        elif total_weighting:
+                            asset.weighting = asset.weighting / total_weighting
+                        asset.save()
 
         # We check if there is an instrument attached to the portfolio with calculated NAV and price computation method
         self.estimate_net_asset_values(val_date)
@@ -641,17 +704,21 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             dependent_portfolio.handle_controlling_portfolio_change_at_date(val_date)
 
     def evaluate_rebalancing(self, val_date: date):
-        # if the portfolio has an automatic rebalancer and the next business day is suitable with the rebalancer, we create a trade proposal automatically
-        next_business_date = (val_date + BDay(1)).date()
-
         if hasattr(self, "automatic_rebalancer"):
-            logger.info(f"Evaluate Rebalancing for {self} at {next_business_date}")
+            # if the portfolio has an automatic rebalancer and the next business day is suitable with the rebalancer, we create a trade proposal automatically
+            next_business_date = (val_date + BDay(1)).date()
+            if self.automatic_rebalancer.is_valid(val_date):  # we evaluate the rebalancer in t0 and t+1
+                logger.info(f"Evaluate Rebalancing for {self} at {val_date}")
+                self.automatic_rebalancer.evaluate_rebalancing(val_date)
             if self.automatic_rebalancer.is_valid(next_business_date):
+                logger.info(f"Evaluate Rebalancing for {self} at {next_business_date}")
                 self.automatic_rebalancer.evaluate_rebalancing(next_business_date)
 
     def estimate_net_asset_values(self, val_date: date):
         for instrument in self.pms_instruments:
-            if net_asset_value_computation_method_path := instrument.net_asset_value_computation_method_path:
+            if instrument.is_active_at_date(val_date) and (
+                net_asset_value_computation_method_path := instrument.net_asset_value_computation_method_path
+            ):
                 logger.info(f"Estimate NAV of {val_date:%Y-%m-%d} for instrument {instrument}")
                 net_asset_value_computation_method = import_from_dotted_path(net_asset_value_computation_method_path)
                 estimated_net_asset_value = net_asset_value_computation_method(val_date, instrument)
@@ -671,76 +738,32 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                         instrument.update_last_valuation_date()
                 instrument.update_last_valuation_date()
 
-    def get_estimated_portfolio_from_weights(
-        self, val_date: date, weights: dict[int, float], prices: dict[int, Decimal] | None = None
-    ) -> Iterable[AssetPosition]:
-        """
-        Given weights and the corresponding instrument price, instantiate asset positions (as AssetPosition object)
-
-        Args:
-            val_date: The positions valuation date
-            weights: The positions weights as dictionary (Instrument IDS as key and weights as values)
-            prices: The prices associated with each position
-
-        Returns:
-            Yield AssetPosition objects.
-        """
-        if prices is None:
-            prices = dict()
-        try:
-            currency_fx_rate_portfolio_to_usd = CurrencyFXRates.objects.get(date=val_date, currency=self.currency)
-        except CurrencyFXRates.DoesNotExist:
-            currency_fx_rate_portfolio_to_usd = None
-        for underlying_quote_id, next_weight in weights.items():
-            underlying_quote = Instrument.objects.get(id=underlying_quote_id)
-            position = AssetPosition(
-                underlying_quote=underlying_quote,
-                weighting=next_weight,
-                date=val_date,
-                asset_valuation_date=val_date,
-                is_estimated=True,
-                portfolio=self,
-                currency=underlying_quote.currency,
-                currency_fx_rate_portfolio_to_usd=currency_fx_rate_portfolio_to_usd,
-                initial_price=prices.get(underlying_quote_id, None),
-                initial_currency_fx_rate=None,
-                currency_fx_rate_instrument_to_usd=None,
-                underlying_quote_price=None,
-                underlying_instrument=None,
-            )
-            position.pre_save()
-            yield position
-
     def batch_portfolio(self, start_date: date, end_date: date):
         """
         Create the cumulative portfolios between the two given dates and stop at the first rebalancing (if any)
 
         Returns: The trade proposal generated by the rebalancing, if any (otherwise None)
         """
-        analytic_portfolio = self.get_analytic_portfolio(start_date)
         rebalancer = getattr(self, "automatic_rebalancer", None)
-        initial_assets = analytic_portfolio.assets
-        positions = []
+
+        weights = self.get_weights(start_date)  # initial weights
+        positions = dict()
         next_trade_proposal = None
         rebalancing_date = None
         logger.info(f"compute next weights in batch for {self} from {start_date:%Y-%m-%d} to {end_date:%Y-%m-%d}")
-        returns, prices = self.get_returns(initial_assets, (start_date - BDay(3)).date(), end_date, ffill_returns=True)
+        returns, prices = self.get_returns(weights.keys(), (start_date - BDay(3)).date(), end_date, ffill_returns=True)
         for to_date_ts in pd.date_range(start_date + timedelta(days=1), end_date, freq="B"):
             to_date = to_date_ts.date()
             logger.info(f"Processing {to_date:%Y-%m-%d}")
             if rebalancer and rebalancer.is_valid(to_date):
                 rebalancing_date = to_date
                 break
-            # with suppress(IndexError):
             last_returns = returns.loc[[to_date_ts], :]
-            next_weights = analytic_portfolio.get_next_weights(last_returns.iloc[-1, :].T)
-            positions.extend(
-                self.get_estimated_portfolio_from_weights(
-                    to_date, next_weights, prices.loc[to_date_ts, :].dropna().to_dict()
-                )
-            )
-            analytic_portfolio = AnalyticPortfolio(X=last_returns, weights=next_weights)
+            analytic_portfolio = AnalyticPortfolio(weights=weights, X=last_returns)
+            positions[to_date] = analytic_portfolio.get_next_weights()
 
+        positions_generator = PositionDictConverter(self, prices)
+        positions = list(positions_generator.convert(positions))
         self.bulk_create_positions(positions, delete_leftovers=True, compute_metrics=False, evaluate_rebalancer=False)
         if rebalancing_date:
             next_trade_proposal = rebalancer.evaluate_rebalancing(rebalancing_date)
@@ -774,18 +797,13 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             self.is_tracked and not self.is_lookthrough and not is_target_portfolio_imported and from_is_active
         ):  # we cannot propagate a new portfolio for untracked, or look-through or already imported or inactive portfolios
             logger.info(f"computing next weight for {self} from {from_date:%Y-%m-%d} to {to_date:%Y-%m-%d}")
-            analytic_portfolio = self.get_analytic_portfolio(from_date)
-            returns, prices = self.get_returns(analytic_portfolio.assets, (from_date - BDay(3)).date(), to_date)
-            if not returns.empty:
-                weights = analytic_portfolio.get_next_weights(returns.iloc[-1, :].T)
-                positions = list(
-                    map(
-                        lambda a: _parse_position(a),
-                        self.get_estimated_portfolio_from_weights(
-                            to_date, weights, prices.iloc[-1, :].T.dropna().to_dict()
-                        ),
-                    )
-                )
+            analytic_portfolio, to_prices = self.get_analytic_portfolio(from_date)
+            if not to_prices.empty:
+                weights = analytic_portfolio.get_next_weights()
+                positions_generator = PositionDictConverter(
+                    self, to_prices, infer_underlying_quote_price=True
+                ).convert({to_date: weights})
+                positions = list(map(lambda a: _parse_position(a), positions_generator))
                 self.bulk_create_positions(positions, delete_leftovers=True, compute_metrics=True)
 
     def get_lookthrough_positions(
@@ -932,8 +950,11 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             for position in positions:
                 position.portfolio = self
                 update_dates.add(position.date)
-            self.assets.filter(date__in=update_dates, is_estimated=True).delete()
-            leftover_positions = self.assets.filter(date__in=update_dates).all()
+            # self.assets.filter(date__in=update_dates, is_estimated=True).delete()
+            leftover_positions_ids = list(
+                self.assets.filter(date__in=update_dates).values_list("id", flat=True)
+            )  # we need to get the ids otherwise the queryset is reevaluated later
+            logger.info(f"bulk saving {len(positions)} positions ({len(leftover_positions_ids)} leftovers) ...")
             objs = AssetPosition.unannotated_objects.bulk_create(
                 positions,
                 update_fields=[
@@ -951,11 +972,13 @@ class Portfolio(DeleteToDisableMixin, WBModel):
                 ],
                 unique_fields=["portfolio", "date", "underlying_quote", "portfolio_created"],
                 update_conflicts=True,
+                batch_size=10000,
             )
             if delete_leftovers:
-                for leftover_position in leftover_positions:
-                    if leftover_position not in objs:  # this works because __eq__ of a django model use the id field
-                        leftover_position.delete()
+                objs_ids = list(map(lambda x: x.id, objs))
+                leftover_positions_ids = list(filter(lambda i: i not in objs_ids, leftover_positions_ids))
+                logger.info(f"deleting {len(leftover_positions_ids)} leftover positions..")
+                AssetPosition.objects.filter(id__in=leftover_positions_ids).delete()
             for update_date in sorted(update_dates):
                 self.change_at_date(update_date, **kwargs)
 
@@ -972,7 +995,12 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         return self.assets.filter(Q(date=val_date) & ~Q(initial_shares=F("initial_shares_at_custodian"))).exists()
 
     def get_returns(
-        self, instruments: Iterable, from_date: date, to_date: date, ffill_returns: bool = True
+        self,
+        instruments: Iterable,
+        from_date: date,
+        to_date: date,
+        ffill_returns: bool = True,
+        convert_to_portfolio_currency: bool = True,
     ) -> tuple[pd.DataFrame, pd.DataFrame]:
         """
         Utility methods to get instrument returns for a given date range
@@ -988,8 +1016,10 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         prices = InstrumentPrice.objects.filter(
             instrument__in=instruments, date__gte=from_date, date__lte=to_date
         ).annotate(
-            # fx_rate=CurrencyFXRates.get_fx_rates_subquery_for_two_currencies("date", "instrument__currency", self.currency),
-            price_fx_portfolio=F("net_value")  # * F("net_value")
+            fx_rate=CurrencyFXRates.get_fx_rates_subquery_for_two_currencies(
+                "date", "instrument__currency", self.currency
+            ),
+            price_fx_portfolio=F("net_value") * F("fx_rate") if convert_to_portfolio_currency else F("net_value"),
         )
         prices_df = (
             pd.DataFrame(
@@ -1190,9 +1220,9 @@ def default_estimate_net_value(val_date: date, instrument: Instrument) -> float
     if (
         previous_date := portfolio.get_latest_asset_position_date(val_date - BDay(1), with_estimated=True)
     ) and portfolio.assets.filter(date=val_date).exists():
-        analytic_portfolio = portfolio.get_analytic_portfolio(val_date, with_previous_weights=True)
         with suppress(IndexError):
             if last_price := instrument.get_latest_price(previous_date):
+                analytic_portfolio, _ = portfolio.get_analytic_portfolio(previous_date)
                 return analytic_portfolio.get_estimate_net_value(float(last_price.net_value))
 
 

wbportfolio/models/transactions/rebalancing.py

@@ -99,11 +99,16 @@ class Rebalancer(ComplexToStringMixin, models.Model):
         return pivot_date
 
     def is_valid(self, trade_date: date) -> bool:
-        for valid_datetime in self.get_rrule(trade_date):
-            valid_date = self._get_next_valid_date(valid_datetime.date())
-            if valid_date == trade_date:
+        if TradeProposal.objects.filter(
+            portfolio=self.portfolio, status=TradeProposal.Status.APPROVED, trade_date=trade_date
+        ).exists():  # if a already approved trade proposal exists, we do not allow a re-evaluatioon of the rebalancing (only possible if "replayed")
+            return False
+        for initial_valid_datetime in self.get_rrule(trade_date):
+            initial_valid_date = initial_valid_datetime.date()
+            alternative_valid_date = self._get_next_valid_date(initial_valid_date)
+            if trade_date in [alternative_valid_date, initial_valid_date]:
                 return True
-            if valid_date > trade_date:
+            if alternative_valid_date > trade_date:
                 break
         return False
 

wbportfolio/models/transactions/trade_proposals.py

@@ -79,6 +79,8 @@ class TradeProposal(RiskCheckMixin, WBModel):
         if not self.rebalancing_model and (rebalancer := getattr(self.portfolio, "automatic_rebalancer", None)):
             self.rebalancing_model = rebalancer.rebalancing_model
         super().save(*args, **kwargs)
+        if self.status == TradeProposal.Status.APPROVED:
+            self.portfolio.change_at_date(self.trade_date)
 
     def _get_checked_object_field_name(self) -> str:
         """
@@ -234,7 +236,6 @@ class TradeProposal(RiskCheckMixin, WBModel):
         )
         service.normalize()
         service.is_valid()
-
         for trade_dto in service.validated_trades:
             instrument = Instrument.objects.get(id=trade_dto.underlying_instrument)
             currency_fx_rate = instrument.currency.convert(
@@ -378,8 +379,6 @@ class TradeProposal(RiskCheckMixin, WBModel):
         for trade in self.trades.all():
             trade.execute()
             trade.save()
-        self.portfolio.change_at_date(self.trade_date)
-        # replay_as_task.delay(self.id)
 
     def can_approve(self):
         errors = dict()

wbportfolio/pms/analytics/portfolio.py

@@ -16,16 +16,14 @@ class Portfolio(BasePortfolio):
         )
         return df
 
-    def get_next_weights(self, returns: pd.Series) -> dict[int, float]:
+    def get_next_weights(self) -> dict[int, float]:
         """
-        Given the next returns, compute the next weights of this portfolio
-
-        Args:
-            returns: The returns for the next day as a pandas series
+        Given the next returns, compute the drifted weights of this portfolio
 
         Returns:
             A dictionary of weights (instrument ids as keys and weights as values)
         """
+        returns = self.X.iloc[-1, :].T
         weights = self.all_weights_per_observation.iloc[-1, :].T
         if weights.sum() != 0:
             weights /= weights.sum()
@@ -35,7 +33,5 @@ class Portfolio(BasePortfolio):
         return contribution.dropna().to_dict()
 
     def get_estimate_net_value(self, previous_net_asset_value: float) -> float:
-        if self.previous_weights is None:
-            raise ValueError("No previous weights available")
-        expected_returns = self.previous_weights @ self.X.iloc[-1, :].T
+        expected_returns = self.weights @ self.X.iloc[-1, :].T
         return previous_net_asset_value * (1.0 + expected_returns)

wbportfolio/pms/trading/handler.py

@@ -97,7 +97,7 @@ class TradingService:
             effective_shares = 0
             instrument_type = currency = None
             if effective_pos := effective_portfolio.positions_map.get(instrument, None):
-                effective_weight = target_weight = effective_pos.weighting
+                effective_weight = effective_pos.weighting
                 effective_shares = effective_pos.shares
                 instrument_type, currency = effective_pos.instrument_type, effective_pos.currency
             if target_pos := target_portfolio.positions_map.get(instrument, None):

wbportfolio/rebalancing/models/market_capitalization_weighted.py

@@ -1,5 +1,6 @@
 from decimal import Decimal
 
+import numpy as np
 import pandas as pd
 from django.db.models import Q, QuerySet
 from wbfdm.enums import MarketData
@@ -26,7 +27,7 @@ class MarketCapitalizationRebalancing(AbstractRebalancingModel):
         self.market_cap_df = pd.DataFrame(
             instruments.dl.market_data(
                 values=[MarketData.MARKET_CAPITALIZATION],
-                exact_date=self.last_effective_date,
+                exact_date=self.trade_date,
                 target_currency=self.TARGET_CURRENCY,
             )
         )
@@ -80,9 +81,7 @@ class MarketCapitalizationRebalancing(AbstractRebalancingModel):
 
         if not instrument_ids:
             instrument_ids = list(
-                self.portfolio.assets.filter(date=self.last_effective_date).values_list(
-                    "underlying_instrument", flat=True
-                )
+                self.portfolio.assets.filter(date=self.trade_date).values_list("underlying_instrument", flat=True)
             )
 
         return Instrument.objects.filter(id__in=instrument_ids).filter(
@@ -107,14 +106,16 @@ class MarketCapitalizationRebalancing(AbstractRebalancingModel):
 
     def get_target_portfolio(self) -> Portfolio:
         positions = []
-        market_cap_df = self.market_cap_df.dropna()
-        total_market_cap = market_cap_df.sum()
-
-        for underlying_instrument, market_cap in market_cap_df.to_dict().items():
+        total_market_cap = self.market_cap_df.dropna().sum()
+        for underlying_instrument, market_cap in self.market_cap_df.to_dict().items():
+            if np.isnan(market_cap):
+                weighting = Decimal(0)
+            else:
+                weighting = Decimal(market_cap / total_market_cap)
             positions.append(
                 Position(
                     underlying_instrument=underlying_instrument,
-                    weighting=Decimal(market_cap / total_market_cap),
+                    weighting=weighting,
                     date=self.trade_date,
                 )
             )

wbportfolio/tests/models/test_portfolios.py

@@ -21,7 +21,7 @@ from wbportfolio.models import (
     Trade,
 )
 
-from ...models.portfolio import update_portfolio_after_investable_universe
+from ...models.portfolio import PositionDictConverter, update_portfolio_after_investable_universe
 from .utils import PortfolioTestMixin
 
 fake = Faker()
@@ -259,7 +259,7 @@ class TestPortfolioModel(PortfolioTestMixin):
     ):
         asset_position_factory.create_batch(10, portfolio=portfolio, date=weekday)
 
-        portfolio.change_at_date(weekday, compute_metrics=True)
+        portfolio.change_at_date(weekday, compute_metrics=True, recompute_weighting=True)
 
         # test that change at date normalize the weighting
         total_value = AssetPosition.objects.aggregate(s=Sum("total_value_fx_portfolio"))["s"]
@@ -905,10 +905,10 @@ class TestPortfolioModel(PortfolioTestMixin):
     ):
         i1 = instrument_factory.create()
         i2 = instrument_factory.create()
-        p10 = instrument_price_factory.create(instrument=i1, date=(weekday - BDay(1)).date())
-        p11 = instrument_price_factory.create(instrument=i1, date=weekday)
-        p20 = instrument_price_factory.create(instrument=i2, date=(weekday - BDay(1)).date())
-        p21 = instrument_price_factory.create(instrument=i2, date=weekday)
+        p10 = instrument_price_factory.create(instrument=i1, date=weekday)
+        p11 = instrument_price_factory.create(instrument=i1, date=(weekday + BDay(1)).date())
+        p20 = instrument_price_factory.create(instrument=i2, date=weekday)
+        p21 = instrument_price_factory.create(instrument=i2, date=(weekday + BDay(1)).date())
 
         a1 = asset_position_factory.create(date=weekday, portfolio=portfolio, underlying_instrument=i1)
         a1.refresh_from_db()
@@ -917,12 +917,12 @@ class TestPortfolioModel(PortfolioTestMixin):
         )
         a2.refresh_from_db()
 
-        analytic_portfolio = portfolio.get_analytic_portfolio(weekday)
+        analytic_portfolio, _ = portfolio.get_analytic_portfolio(weekday, convert_to_portfolio_currency=False)
         assert analytic_portfolio.weights.tolist() == [float(a1.weighting), float(a2.weighting)]
         expected_X = pd.DataFrame(
             [[float(p11.net_value / p10.net_value - Decimal(1)), float(p21.net_value / p20.net_value - Decimal(1))]],
             columns=[i1.id, i2.id],
-            index=[weekday],
+            index=[(weekday + BDay(1)).date()],
         )
         expected_X.index = pd.to_datetime(expected_X.index)
         pd.testing.assert_frame_equal(analytic_portfolio.X, expected_X, check_names=False, check_freq=False)
@@ -997,14 +997,15 @@ class TestPortfolioModel(PortfolioTestMixin):
         fx_instrument = currency_fx_rates_factory.create(currency=instrument.currency, date=weekday)
 
         weights = {instrument.id: random.random()}
-        prices = {}
-
-        res = list(portfolio.get_estimated_portfolio_from_weights(weekday, weights, prices))
+        prices = pd.DataFrame([{instrument.id: p.net_value, "date": weekday}]).set_index("date")
+        prices.index = pd.to_datetime(prices.index)
+        converter = PositionDictConverter(portfolio, prices)
+        res = list(converter.convert({weekday: weights}))
         a = res[0]
         assert len(res) == 1
         assert a.date == weekday
         assert a.underlying_quote == instrument
-        assert a.underlying_quote_price == p
+        assert a.underlying_quote_price == None
         assert a.initial_price == p.net_value
         assert a.weighting == weights[instrument.id]
         assert a.currency_fx_rate_portfolio_to_usd == fx_portfolio
@@ -1129,7 +1130,9 @@ class TestPortfolioModel(PortfolioTestMixin):
         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)
+        returns, _ = portfolio.get_returns(
+            [i1.id, i2.id], from_date=v1, to_date=v3, convert_to_portfolio_currency=False
+        )
 
         expected_returns = pd.DataFrame(
             [[i12.net_value / i11.net_value - 1], [i13.net_value / i12.net_value - 1]],

wbportfolio/tests/pms/test_analytics.py

@@ -13,7 +13,7 @@ def test_get_next_weights():
     weights = [w0, w1, w2]
     returns = [r0, r1, r2]
     portfolio = Portfolio(X=pd.DataFrame([returns]), weights=pd.Series(weights))
-    next_weights = portfolio.get_next_weights(pd.Series(returns))
+    next_weights = portfolio.get_next_weights()
 
     assert next_weights[0] == w0 * (r0 + 1) / (w0 * (r0 + 1) + w1 * (r1 + 1) + w2 * (r2 + 1))
     assert next_weights[1] == w1 * (r1 + 1) / (w0 * (r0 + 1) + w1 * (r1 + 1) + w2 * (r2 + 1))
@@ -29,7 +29,7 @@ def test_get_estimate_net_value():
     r2 = -0.23
     weights = [w0, w1, w2]
     returns = [r0, r1, r2]
-    portfolio = Portfolio(X=pd.DataFrame([returns]), weights=pd.Series(weights), previous_weights=pd.Series(weights))
+    portfolio = Portfolio(X=pd.DataFrame([returns]), weights=pd.Series(weights))
     current_price = 100
     net_asset_value = portfolio.get_estimate_net_value(current_price)
     return net_asset_value == current_price * (1.0 + w0 * r0 + w1 * r1 + w2 * r2)

wbportfolio/tests/rebalancing/test_models.py

@@ -138,8 +138,8 @@ class TestMarketCapitalizationRebalancing:
 
         i1 = instrument_factory()
         i2 = instrument_factory()
-        instrument_price_factory.create(instrument=i1, date=last_effective_date)
-        instrument_price_factory.create(instrument=i2, date=last_effective_date)
+        instrument_price_factory.create(instrument=i1, date=weekday)
+        instrument_price_factory.create(instrument=i2, date=weekday)
         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):
@@ -151,8 +151,8 @@ class TestMarketCapitalizationRebalancing:
     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.last_effective_date).market_capitalization
-        mkt21 = InstrumentPrice.objects.get(instrument_id=i2, date=model.last_effective_date).market_capitalization
+        mkt12 = InstrumentPrice.objects.get(instrument_id=i1, date=weekday).market_capitalization
+        mkt21 = InstrumentPrice.objects.get(instrument_id=i2, date=weekday).market_capitalization
 
         target_portfolio = model.get_target_portfolio()
         target_positions = target_portfolio.positions_map

{wbportfolio-1.46.9.dist-info → wbportfolio-1.46.10.dist-info}/METADATA

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

{wbportfolio-1.46.9.dist-info → wbportfolio-1.46.10.dist-info}/RECORD

@@ -243,10 +243,10 @@ wbportfolio/migrations/0074_alter_rebalancer_frequency_and_more.py,sha256=o01rBj
 wbportfolio/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/models/__init__.py,sha256=PDLJry5w1zE4N4arQh20_uFi2v7gy9QyavJ_rfGE21Q,882
 wbportfolio/models/adjustments.py,sha256=osXWkJZOiansPWYPyHtl7Z121zDWi7u1YMtrBQtbHVo,10272
-wbportfolio/models/asset.py,sha256=V-fSAF1bsfj_Td3VfdKyhCgcwB_xPS6vTI90Dh5iDx8,37502
+wbportfolio/models/asset.py,sha256=TEOsSlbog6Yw0PZiMxjnCccp6ApXAAJNd3BIx_wU7D8,37749
 wbportfolio/models/custodians.py,sha256=owTiS2Vm5CRKzh9M_P9GOVg-s-ndQ9UvRmw3yZP7cw0,3815
 wbportfolio/models/indexes.py,sha256=iLYF2gzNzX4GLj_Nh3fybUcAQ1TslnT0wgQ6mN164QI,728
-wbportfolio/models/portfolio.py,sha256=r_qTDNTeUu9QiJ6g_g1rIp5yOuUOwinqadJtykb9KE8,55501
+wbportfolio/models/portfolio.py,sha256=d4cWfv_mJpqvdYLYW-DFoT5wDHjCGf7UO_0QsM5NoME,57187
 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
@@ -261,7 +261,7 @@ wbportfolio/models/graphs/portfolio.py,sha256=NwkehWvTcyTYrKO5ku3eNNaYLuBwuLdSbT
 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
-wbportfolio/models/mixins/instruments.py,sha256=IucFwxbSxyqLwDbaMYg_vKh1BPwGqo1VERpj0U-nS0Q,6728
+wbportfolio/models/mixins/instruments.py,sha256=SgBreTpa_X3uyCWo7t8B0VaTtl49IjmBMe4Pab6TjAM,6796
 wbportfolio/models/mixins/liquidity_stress_test.py,sha256=whkzjtbOyl_ncNyaQBORb_Z_rDgcvfdTYPgqPolu7dA,58865
 wbportfolio/models/reconciliations/__init__.py,sha256=MXH5fZIPGDRBgJkO6wVu_NLRs8fkP1im7G6d-h36lQY,127
 wbportfolio/models/reconciliations/account_reconciliation_lines.py,sha256=QP6M7hMcyFbuXBa55Y-azui6Dl_WgbzMntEqWzQkbfM,7394
@@ -272,24 +272,24 @@ 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=vEYdYhog9jiPw_xQd_XQunNzcpHZ8Zk18kQhsN4HuhA,6596
-wbportfolio/models/transactions/trade_proposals.py,sha256=gsvgEI5yqmFb_bCN4FsgfyQqslMXLQlzTe3G7odwTCA,21366
+wbportfolio/models/transactions/rebalancing.py,sha256=3p5r6m68_7AD783hYAlDZCnUz1TOLVa9mvF5zConTMo,7036
+wbportfolio/models/transactions/trade_proposals.py,sha256=6U0BFGPrX9aOOam4xFbo8asbjzkUUh0SWMeedTXX4Lk,21386
 wbportfolio/models/transactions/trades.py,sha256=gbXvxiyh8bvg6ldyd8qBwRPv4t0Tf5cbZXBnZXPIomc,27861
 wbportfolio/models/transactions/transactions.py,sha256=4THsE4xqdigZAwWKYfTNRLPJlkmAmsgE70Ribp9Lnrk,7127
 wbportfolio/pms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/pms/typing.py,sha256=WKP5tYyYt7DbMo25VM99V4IAM9oDSIPZyR3yXCzeZEA,5920
 wbportfolio/pms/analytics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wbportfolio/pms/analytics/portfolio.py,sha256=93hcHEuBOPi534El2HVCIyjs9MBQMX7dIZ97JIpNV1c,1535
+wbportfolio/pms/analytics/portfolio.py,sha256=vE0KA6Z037bUdmBTkYuBqXElt80nuYObNzY_kWvxEZY,1360
 wbportfolio/pms/statistics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wbportfolio/pms/trading/__init__.py,sha256=R_yLKc54sCak8A1cW0O1Aszrcv5KV8mC_3h17Hr20e4,36
-wbportfolio/pms/trading/handler.py,sha256=Xpgo719S0jE1wUTTyGFpYccPEIg9GXghWEAdYawJbrk,7165
+wbportfolio/pms/trading/handler.py,sha256=9RDRQFcnk55t69KSFYZxZDFOvd942-J4St-zJ7e8zlY,7149
 wbportfolio/rebalancing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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=XAjJqLRNsV-MuBKrat3THEfAWs6PXQNSO0g8k8MtBXo,1157
 wbportfolio/rebalancing/models/equally_weighted.py,sha256=U29MOHJMQMIg7Y7W_8t5K3nXjaznzt4ArIxQSiv0Xok,863
-wbportfolio/rebalancing/models/market_capitalization_weighted.py,sha256=myb7j_aJns5dfuUXzL4cPSK8R8X540h0INiXB6z-aV4,4867
+wbportfolio/rebalancing/models/market_capitalization_weighted.py,sha256=LvzV7a8fNbpsRahysvKbE6oNSQccWpnnne-rlDj3uzU,4928
 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
@@ -371,7 +371,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=YF1SRS-REJFQhbtxs1LfIUs91jmHpI7pXBE70pW4W7E,51735
+wbportfolio/tests/models/test_portfolios.py,sha256=_LtxyTIZqQUB_sJ4DpdE1BNkoSssGeYPgjGaOYciW2E,52059
 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,9 +383,9 @@ wbportfolio/tests/models/transactions/test_fees.py,sha256=1gp_h_CCC4Z_cWHUgrZCjG
 wbportfolio/tests/models/transactions/test_rebalancing.py,sha256=H1UbxPm-oa00-JJXbBxNutdTKvXXJmuATTab2XsXp44,3900
 wbportfolio/tests/models/transactions/test_trades.py,sha256=z0CCZjB648ECDSEdwmzqCdIe7h4UWVJQ8qKR42Xu0TQ,9008
 wbportfolio/tests/pms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wbportfolio/tests/pms/test_analytics.py,sha256=FrvVsV_uUiTgmRUfsaB-_sGzY30CqknbOY2DvmwR_70,1141
+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=wdlCfc6YxVT0oLxr45Q-LPKy4LjGbylkdxcfZozS0Fk,7565
+wbportfolio/tests/rebalancing/test_models.py,sha256=mhhuIWPZF2SQHzVdotp90eIrfmnMGQNu5YTGcMDjlIY,7505
 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
@@ -517,7 +517,7 @@ wbportfolio/viewsets/transactions/rebalancing.py,sha256=6rIrdK0rtKL1afJ-tYfAGdQV
 wbportfolio/viewsets/transactions/trade_proposals.py,sha256=gXdJJ00D6UavZfBczvZQb5cYPQlU6-xOg_-TnMBzEO0,4742
 wbportfolio/viewsets/transactions/trades.py,sha256=mo5b1wFm0twvGVp-CYnzpGLYMqPcHN8GjH4G_WwFFwc,16237
 wbportfolio/viewsets/transactions/transactions.py,sha256=ixDp-nsNA8t_A06rBCT19hOMJHy0iRmdz1XKdV1OwAs,4450
-wbportfolio-1.46.9.dist-info/METADATA,sha256=8tU84AIx2o33fnK6DQgvVs_OXm8g54lAacgMDS3Ep38,734
-wbportfolio-1.46.9.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
-wbportfolio-1.46.9.dist-info/licenses/LICENSE,sha256=jvfVH0SY8_YMHlsJHKe_OajiscQDz4lpTlqT6x24sVw,172
-wbportfolio-1.46.9.dist-info/RECORD,,
+wbportfolio-1.46.10.dist-info/METADATA,sha256=ROqtFk4aUYi22kAtL59XSN67K2FQ_81K07XqnNfugRE,735
+wbportfolio-1.46.10.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
+wbportfolio-1.46.10.dist-info/licenses/LICENSE,sha256=jvfVH0SY8_YMHlsJHKe_OajiscQDz4lpTlqT6x24sVw,172
+wbportfolio-1.46.10.dist-info/RECORD,,