wbportfolio 1.45.1__tar.gz → 1.46.1__tar.gz

{wbportfolio-1.45.1 → wbportfolio-1.46.1}/PKG-INFO

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

{wbportfolio-1.45.1 → wbportfolio-1.46.1}/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.45.1 → wbportfolio-1.46.1}/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.1 → wbportfolio-1.46.1}/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.1 → wbportfolio-1.46.1}/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.1 → wbportfolio-1.46.1}/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.1 → wbportfolio-1.46.1}/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.1 → wbportfolio-1.46.1}/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.1 → wbportfolio-1.46.1}/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.1/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.1 → wbportfolio-1.46.1}/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.1 → wbportfolio-1.46.1}/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.1 → wbportfolio-1.46.1}/wbportfolio/viewsets/portfolios.py

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