wbportfolio 1.52.0__py2.py3-none-any.whl → 1.59.4__py2.py3-none-any.whl

wbportfolio/models/builder.py

@@ -0,0 +1,323 @@
+import logging
+import math
+from collections import defaultdict
+from datetime import date
+from decimal import Decimal
+from typing import TYPE_CHECKING, Iterable
+
+import pandas as pd
+from celery import chain, group
+from django.contrib.contenttypes.models import ContentType
+from pandas._libs.tslibs.offsets import BDay
+from wbcore.contrib.currency.models import Currency, CurrencyFXRates
+from wbfdm.contrib.metric.tasks import compute_metrics_as_task
+from wbfdm.models import Instrument
+
+from wbportfolio.models.asset import AssetPosition
+from wbportfolio.pms.analytics.portfolio import Portfolio as AnalyticPortfolio
+
+if TYPE_CHECKING:
+    from wbportfolio.models import Portfolio
+logger = logging.getLogger("pms")
+
+
+MINIMUM_DECIMAL = 8
+MIN_STEP = Decimal("0.00000001")
+
+
+class AssetPositionBuilder:
+    """
+    Efficiently converts position data into AssetPosition models with batch operations
+    and proper dependency management.
+
+    Features:
+    - Bulk database fetching for performance
+    - Thread-safe operations
+    - Clear type hints
+    - Memory-efficient storage
+    """
+
+    _positions: dict[date, dict[tuple[int, int | None], "AssetPosition"]]
+
+    _fx_rates: dict[date, dict[Currency, CurrencyFXRates]]
+    _instruments: dict[int, Instrument]
+
+    def __init__(
+        self,
+        portfolio: "Portfolio",
+    ):
+        self.portfolio = portfolio
+        # Initialize data stores with type hints
+        self._instruments = {}
+        self._fx_rates = defaultdict(dict)
+        self.prices = defaultdict(dict)
+        self.returns = pd.DataFrame()
+        self._compute_metrics_tasks = set()
+        self._change_at_date_tasks = dict()
+        self._positions = defaultdict(dict)
+        self.excluded_positions = defaultdict(list)
+        self._change_at_date_kwargs = {}
+
+    def get_positions(self, fix_quantization: bool = True, **kwargs):
+        # return an iterable excluding the position with a null weight if the portfolio is manageable (otherwise, we assume the 0-weight position is valid)
+        for val_date, positions in self._positions.items():
+            excluded_positions = self.excluded_positions.get(val_date, [])
+            total_excluded_position_weight = (
+                sum(map(lambda o: o.weighting, excluded_positions)) if excluded_positions else Decimal("0")
+            )
+            quantization_weight_error = round(
+                Decimal("1") - total_excluded_position_weight - sum(map(lambda o: o.weighting, positions.values()))
+                if fix_quantization
+                else Decimal("0"),
+                MINIMUM_DECIMAL,
+            )
+            for position in sorted(positions.values(), key=lambda x: x.weighting, reverse=True):
+                if position.weighting:
+                    for k, v in kwargs.items():
+                        setattr(position, k, v)
+                    # if the total weight is not 100%, we add the quantization leftover to some random position (max 1e-8 per position, thus it is negligible)
+                    if quantization_weight_error:
+                        step = round(Decimal(math.copysign(MIN_STEP, quantization_weight_error)), MINIMUM_DECIMAL)
+                        position.weighting += step
+                        quantization_weight_error -= step
+                    yield position
+
+    def __bool__(self) -> bool:
+        return len(self._positions.keys()) > 0
+
+    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: Currency) -> CurrencyFXRates | None:
+        try:
+            return self._fx_rates[val_date][currency]
+        except KeyError:
+            if currency.key == "USD":
+                fx_rate = CurrencyFXRates.objects.get_or_create(
+                    currency=currency, date=val_date, defaults={"value": Decimal("1")}
+                )[0]
+            else:
+                try:
+                    fx_rate = CurrencyFXRates.objects.get(
+                        currency=currency, date=val_date
+                    )  # we create a fx rate anyway to not fail the position. The fx rate expect to be there later on
+                except CurrencyFXRates.DoesNotExist:
+                    fx_rate = CurrencyFXRates.objects.filter(currency=currency, date__lt=val_date).latest("date")
+            self._fx_rates[val_date][currency] = fx_rate
+            return fx_rate
+
+    def _get_price(self, val_date: date, instrument: Instrument) -> float | None:
+        try:
+            return self.prices[val_date][instrument.id]
+        except KeyError:
+            return None
+
+    def _dict_to_model(
+        self,
+        val_date: date,
+        instrument_id: int,
+        weighting: float,
+        **kwargs,
+    ) -> "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)
+        if underlying_quote.is_cash:
+            price = Decimal("1")
+        else:
+            price = self._get_price(val_date, underlying_quote)
+
+        parameters = dict(
+            underlying_quote=underlying_quote,
+            weighting=round(weighting, MINIMUM_DECIMAL),
+            date=val_date,
+            asset_valuation_date=val_date,
+            is_estimated=True,
+            portfolio=self.portfolio,
+            currency=underlying_quote.currency,
+            initial_price=price,
+            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,
+        )
+        parameters.update(kwargs)
+        position = AssetPosition(**parameters)
+        return position
+
+    def load_returns(self, instrument_ids: Iterable[int], from_date: date, to_date: date, use_dl: bool = True):
+        if self.returns.empty:
+            self.prices, self.returns = Instrument.objects.filter(id__in=instrument_ids).get_returns_df(
+                from_date=from_date, to_date=to_date, to_currency=self.portfolio.currency, use_dl=use_dl
+            )
+        else:
+            min_date = min(self.prices.keys())
+            max_date = max(self.prices.keys())
+            if from_date < min_date or to_date > max_date:
+                # we need to refetch everything as we are missing index
+                self.prices, self.returns = Instrument.objects.filter(
+                    id__in=set(instrument_ids).union(set(self.returns.columns))
+                ).get_returns_df(
+                    from_date=min(from_date, min_date),
+                    to_date=max(to_date, max_date),
+                    to_currency=self.portfolio.currency,
+                    use_dl=use_dl,
+                )
+            else:
+                instruments = set(instrument_ids) - set(self.returns.columns)
+                if instruments:
+                    new_prices, new_returns = Instrument.objects.filter(id__in=instruments).get_returns_df(
+                        from_date=min(from_date, min_date),
+                        to_date=max(to_date, max_date),
+                        to_currency=self.portfolio.currency,
+                        use_dl=use_dl,
+                    )
+                    self.returns = self.returns.join(new_returns, how="left").fillna(0)
+                    for d, p in new_prices.items():
+                        self.prices[d].update(p)
+
+    def add(
+        self,
+        positions: list["AssetPosition"] | tuple[date, dict[int, float]],
+        infer_underlying_quote_price: bool = False,
+    ):
+        """
+        Add multiple positions efficiently with batch processing
+
+        Args:
+            positions: Iterable of AssetPosition instances or dictionary of weight {instrument_id: weight} that needs to be converted into AssetPosition
+        """
+        if isinstance(positions, tuple):
+            val_date = positions[0]
+            positions = [(val_date, i, w) for i, w in positions[1].items()]  # unflatten data to make it iterable
+        for position in positions:
+            if not isinstance(position, AssetPosition):
+                position = self._dict_to_model(*position)
+            position.pre_save(
+                infer_underlying_quote_price=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
+            # Generate unique composite key
+            key = (
+                position.underlying_quote.id,
+                position.portfolio_created.id if position.portfolio_created else None,
+            )
+            # Merge duplicate positions
+            if existing_position := self._positions[position.date].get(key):
+                position.weighting += existing_position.weighting
+                if existing_position.initial_shares:
+                    position.initial_shares += existing_position.initial_shares
+            # ensure the position portfolio is the iterator portfolio (could be different when computing look-through for instance)
+            position.portfolio = self.portfolio
+            position.weighting = Decimal(
+                round(position.weighting, 8)
+            )  # set the weight as it will be saved in the db to handle quantization error accordingly
+            if position.initial_price is not None and position.initial_currency_fx_rate is not None:
+                self._positions[position.date][key] = position
+            else:
+                self.excluded_positions[position.date].append(position)
+                self._change_at_date_kwargs["fix_quantization"] = True
+        return self
+
+    def get_dates(self) -> list[date]:
+        """Get sorted list of unique dates"""
+        return list(sorted(self._positions.keys()))
+
+    def _get_portfolio(self, val_date: date) -> AnalyticPortfolio:
+        """Get weight structure with instrument IDs as keys"""
+        positions = self._positions[val_date]
+        next_returns = self.returns.loc[[(val_date + BDay(1)).date()], :]
+        weights = dict(map(lambda row: (row[1].underlying_quote.id, float(row[1].weighting)), positions.items()))
+        return AnalyticPortfolio(weights=weights, X=next_returns)
+
+    def bulk_create_positions(self, delete_leftovers: bool = False, force_save: bool = False, **kwargs):
+        positions = list(self.get_positions(**kwargs))
+        # we need to delete the existing estimated portfolio because otherwise we risk to have existing and not
+        # overlapping positions remaining (as they will not be updating by the bulk create). E.g. when someone
+        # change completely the trades of a portfolio model and drift it.
+        dates = self.get_dates()
+        self.portfolio.assets.filter(date__in=dates, is_estimated=True).delete()
+
+        if len(positions) > 0:
+            if self.portfolio.is_tracked or force_save:  # if the portfolio is not "tracked", we do no drift weights
+                leftover_positions_ids = list(
+                    self.portfolio.assets.filter(date__in=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=[
+                        "weighting",
+                        "initial_price",
+                        "initial_currency_fx_rate",
+                        "initial_shares",
+                        "currency_fx_rate_instrument_to_usd",
+                        "currency_fx_rate_portfolio_to_usd",
+                        "underlying_quote_price",
+                        "portfolio",
+                        "portfolio_created",
+                        "underlying_instrument",
+                    ],
+                    unique_fields=["portfolio", "date", "underlying_quote", "portfolio_created"],
+                    update_conflicts=True,
+                    batch_size=10000,
+                )
+                if delete_leftovers:
+                    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 val_date in self.get_dates():
+                if self.portfolio.is_tracked:
+                    try:
+                        changed_portfolio = self._get_portfolio(val_date)
+                    except KeyError:
+                        changed_portfolio = None
+                    self._change_at_date_tasks[val_date] = changed_portfolio
+                    self._compute_metrics_tasks.add(val_date)
+        self._positions = defaultdict(dict)
+
+    def clear(self):
+        self.excluded_positions = defaultdict(list)
+
+    def schedule_metric_computation(self):
+        if self._compute_metrics_tasks:
+            basket_id = self.portfolio.id
+            basket_content_type_id = ContentType.objects.get_by_natural_key("wbportfolio", "portfolio").id
+            group(
+                *[
+                    compute_metrics_as_task.si(d, basket_id=basket_id, basket_content_type_id=basket_content_type_id)
+                    for d in self._compute_metrics_tasks
+                ]
+            ).apply_async()
+            self._change_at_date_tasks = dict()
+
+    def schedule_change_at_dates(self, synchronous: bool = True, **task_kwargs):
+        from wbportfolio.models.portfolio import trigger_portfolio_change_as_task
+
+        change_at_date_kwargs = task_kwargs
+        change_at_date_kwargs.update(self._change_at_date_kwargs)
+        if self._change_at_date_tasks:
+            tasks = chain(
+                *[
+                    trigger_portfolio_change_as_task.si(
+                        self.portfolio.id,
+                        d,
+                        changed_portfolio=portfolio,
+                        evaluate_rebalancer=False,
+                        **change_at_date_kwargs,
+                    )
+                    for d, portfolio in self._change_at_date_tasks.items()
+                ]
+            )
+            if synchronous:
+                tasks.apply()
+            else:
+                tasks.apply_async()
+            self._change_at_date_tasks = dict()

wbportfolio/models/custodians.py

@@ -32,7 +32,7 @@ class Custodian(WBModel):
 
     @classmethod
     def get_by_mapping(cls, mapping: str, use_similarity=False, create_missing=True):
-        SIMILIRATY_SCORE = 0.7
+        similarity_score = 0.7
         lower_mapping = mapping.lower()
         try:
             return cls.objects.get(mapping__contains=[lower_mapping])
@@ -40,7 +40,7 @@ class Custodian(WBModel):
             if use_similarity:
                 similar_custodians = cls.objects.annotate(
                     similarity_score=TrigramSimilarity("name", lower_mapping)
-                ).filter(similarity_score__gt=SIMILIRATY_SCORE)
+                ).filter(similarity_score__gt=similarity_score)
                 if similar_custodians.count() == 1:
                     custodian = similar_custodians.first()
                     print(f"find similar custodian {lower_mapping} -> {custodian.name}")  # noqa: T201
@@ -50,7 +50,7 @@ class Custodian(WBModel):
                 else:
                     similar_companies = Company.objects.annotate(
                         similarity_score=TrigramSimilarity("name", lower_mapping)
-                    ).filter(similarity_score__gt=SIMILIRATY_SCORE)
+                    ).filter(similarity_score__gt=similarity_score)
                     if similar_companies.count() == 1:
                         print(  # noqa: T201
                             f"Find similar company {lower_mapping} -> {similar_companies.first().name}"

wbportfolio/models/exceptions.py

@@ -1,2 +1,2 @@
-class InvalidAnalyticPortfolio(Exception):
+class InvalidAnalyticPortfolioError(Exception):
     pass

wbportfolio/models/graphs/portfolio.py

@@ -120,7 +120,7 @@ class PortfolioGraph:
             if rel.dependency_portfolio.is_composition:
                 label += " (Composition)"
 
-            if rel.portfolio.is_lookthrough and rel.type == PortfolioPortfolioThroughModel.Type.PRIMARY:
+            if rel.portfolio.is_lookthrough and rel.type == PortfolioPortfolioThroughModel.Type.LOOK_THROUGH:
                 self.graph.add_edge(
                     pydot.Edge(
                         str(rel.portfolio.id), str(rel.dependency_portfolio.id), label="Look-Through", style="dotted"

wbportfolio/models/graphs/utils.py

@@ -3,21 +3,21 @@ import plotly.graph_objects as go
 from networkx.drawing.nx_agraph import graphviz_layout
 
 
-def reformat_graph_layout(G, layout):
+def reformat_graph_layout(g, layout):
     """
     this method provide positions based on layout algorithm
-    :param G:
+    :param g:
     :param layout:
     :return:
     """
     if layout == "graphviz":
-        positions = graphviz_layout(G)
+        positions = graphviz_layout(g)
     elif layout == "spring":
-        positions = nx.fruchterman_reingold_layout(G, k=0.5, iterations=1000)
+        positions = nx.fruchterman_reingold_layout(g, k=0.5, iterations=1000)
     elif layout == "spectral":
-        positions = nx.spectral_layout(G, scale=0.1)
+        positions = nx.spectral_layout(g, scale=0.1)
     elif layout == "random":
-        positions = nx.random_layout(G)
+        positions = nx.random_layout(g)
     else:
         raise Exception("please specify the layout from graphviz, spring, spectral or random")
 
@@ -25,7 +25,7 @@ def reformat_graph_layout(G, layout):
 
 
 def networkx_graph_to_plotly(
-    G: nx.Graph,
+    g: nx.Graph,
     labels: dict[str, str] | None = None,
     node_size: int = 10,
     edge_weight: int = 1,
@@ -36,12 +36,12 @@ def networkx_graph_to_plotly(
     """
     Visualize a NetworkX graph using Plotly.
     """
-    positions = reformat_graph_layout(G, layout)
+    positions = reformat_graph_layout(g, layout)
     if not labels:
         labels = {}
     # Initialize edge traces
     edge_traces = []
-    for edge in G.edges():
+    for edge in g.edges():
         x0, y0 = positions[edge[0]]
         x1, y1 = positions[edge[1]]
 
@@ -52,12 +52,12 @@ def networkx_graph_to_plotly(
 
     # Initialize node trace
     node_x, node_y, node_colors, node_labels = [], [], [], []
-    for node in G.nodes():
+    for node in g.nodes():
         x, y = positions[node]
         node_x.append(x)
         node_y.append(y)
         node_labels.append(labels.get(node, node))
-        node_colors.append(len(list(G.neighbors(node))))  # Color based on degree
+        node_colors.append(len(list(g.neighbors(node))))  # Color based on degree
 
     node_trace = go.Scatter(
         x=node_x,

wbportfolio/models/mixins/instruments.py

@@ -150,6 +150,13 @@ class PMSInstrumentAbstractModel(PMSInstrument):
         default="wbportfolio.models.portfolio.default_estimate_net_value",
         verbose_name="NAV Computation Method",
     )
+    order_routing_custodian_adapter = models.CharField(
+        blank=True,
+        null=True,
+        max_length=1024,
+        verbose_name="Order Routing Custodian Adapter",
+        help_text="The dotted path to the order routing custodian adapter",
+    )
     risk_scale = models.IntegerField(
         validators=[MinValueValidator(1), MaxValueValidator(7)],
         default=4,

wbportfolio/models/mixins/liquidity_stress_test.py

@@ -834,7 +834,7 @@ class LiquidityStressMixin:
 
     """ The main function for the liquidity stress tests """
 
-    def liquidity_stress_test(
+    def liquidity_stress_test(  # noqa: C901
         self,
         report_date: Optional[date] = None,
         weights_date: Optional[date] = None,
@@ -966,7 +966,7 @@ class LiquidityStressMixin:
 
         qs_trades = Trade.objects.filter(
             underlying_instrument__in=product_ids,
-            transaction_subtype__in=["SUBSCRIPTION", "REDEMPTION"],
+            type__in=["SUBSCRIPTION", "REDEMPTION"],
             transaction_date__lte=report_date,
         ).order_by("transaction_date")
         if not qs_trades.exists():
@@ -974,7 +974,7 @@ class LiquidityStressMixin:
 
         trades_fields = [
             "transaction_date",
-            "transaction_subtype",
+            "type",
             "underlying_instrument",
             "underlying_instrument__currency",
             "total_value",
@@ -999,7 +999,7 @@ class LiquidityStressMixin:
 
         # df_trades.transaction_date = pd.to_datetime(df_trades["transaction_date"])  # to use df.rolling
         # Gross Redemption
-        df_gross_redemption = df_trades.where(df_trades.transaction_subtype == "REDEMPTION")
+        df_gross_redemption = df_trades.where(df_trades.type == "REDEMPTION")
         df_gross_redemption = df_gross_redemption.groupby("date").total_value_usd.sum()
         df_gross_redemption.name = "gross_redemption"
         df_gross_redemption = df_aum.join(df_gross_redemption)

wbportfolio/models/orders/__init__.py

@@ -0,0 +1,2 @@
+from .orders import Order
+from .order_proposals import OrderProposal