wbportfolio 1.44.5__py2.py3-none-any.whl → 1.45.1__py2.py3-none-any.whl

wbportfolio/models/asset.py

@@ -1,3 +1,4 @@
+from contextlib import suppress
 from datetime import date
 from decimal import Decimal
 
@@ -30,6 +31,7 @@ from wbcore.utils.enum import ChoiceEnum
 from wbfdm.models import Classification, ClassificationGroup, Instrument
 from wbfdm.models.instruments.instrument_prices import InstrumentPrice
 from wbfdm.signals import add_instrument_to_investable_universe
+
 from wbportfolio.import_export.handlers.asset_position import AssetPositionImportHandler
 from wbportfolio.models.portfolio_relationship import (
     InstrumentPortfolioThroughModel,
@@ -97,31 +99,31 @@ class DefaultAssetPositionManager(models.Manager):
                 F("applied_adjustment__cumulative_factor") * F("applied_adjustment__factor"), Decimal(1.0)
             ),
             shares=F("initial_shares") / F("adjusting_factor"),
-            price=Coalesce(F("underlying_instrument_price__net_value"), F("initial_price")),
+            price=Coalesce(F("underlying_quote_price__net_value"), F("initial_price")),
             market_capitalization=ExpressionWrapper(
                 Coalesce(
-                    F("underlying_instrument_price__market_capitalization_consolidated"),
-                    F("underlying_instrument_price__market_capitalization"),
+                    F("underlying_quote_price__market_capitalization_consolidated"),
+                    F("underlying_quote_price__market_capitalization"),
                 ),
                 output_field=models.DecimalField(),
             ),
-            beta=ExpressionWrapper(F("underlying_instrument_price__beta"), output_field=models.DecimalField()),
+            beta=ExpressionWrapper(F("underlying_quote_price__beta"), output_field=models.DecimalField()),
             correlation=ExpressionWrapper(
-                F("underlying_instrument_price__correlation"), output_field=models.DecimalField()
+                F("underlying_quote_price__correlation"), output_field=models.DecimalField()
             ),
             sharpe_ratio=ExpressionWrapper(
-                F("underlying_instrument_price__sharpe_ratio"), output_field=models.DecimalField()
+                F("underlying_quote_price__sharpe_ratio"), output_field=models.DecimalField()
             ),
             volume=Coalesce(
-                ExpressionWrapper(F("underlying_instrument_price__volume"), output_field=models.DecimalField()),
+                ExpressionWrapper(F("underlying_quote_price__volume"), output_field=models.DecimalField()),
                 Decimal(0),
             ),
             volume_50d=Coalesce(
-                ExpressionWrapper(F("underlying_instrument_price__volume_50d"), output_field=models.DecimalField()),
+                ExpressionWrapper(F("underlying_quote_price__volume_50d"), output_field=models.DecimalField()),
                 Decimal(0),
             ),
             volume_200d=Coalesce(
-                ExpressionWrapper(F("underlying_instrument_price__volume_200d"), output_field=models.DecimalField()),
+                ExpressionWrapper(F("underlying_quote_price__volume_200d"), output_field=models.DecimalField()),
                 Decimal(0),
             ),
             currency_fx_rate_instrument_to_usd_rate=Case(
@@ -162,17 +164,6 @@ class DefaultAssetPositionManager(models.Manager):
                 default=Value(False),
                 output_field=models.BooleanField(),
             ),
-            underlying_security=Case(  # Annotate the parent security if exists
-                When(underlying_instrument__parent__isnull=False, then=F("underlying_instrument__parent")),
-                default=F("underlying_instrument"),
-            ),
-            underlying_security_instrument_type_key=Case(  # Annotate the parent security if exists
-                When(
-                    underlying_instrument__parent__isnull=False,
-                    then=F("underlying_instrument__parent__instrument_type__key"),
-                ),
-                default=F("underlying_instrument__instrument_type__key"),
-            ),
         )
 
 
@@ -191,7 +182,7 @@ class AnalyticalAssetPositionManager(DefaultAssetPositionManager):
             previous_price_usd=Subquery(
                 qs_default.filter(
                     date=OuterRef("last_portfolio_date"),
-                    underlying_instrument=OuterRef("underlying_instrument"),
+                    underlying_quote=OuterRef("underlying_quote"),
                     portfolio=OuterRef("portfolio"),
                 )
                 .order_by("-date")
@@ -373,14 +364,22 @@ class AssetPosition(ImportMixin, models.Model):
 
     underlying_instrument = models.ForeignKey(
         to="wbfdm.Instrument",
-        related_name="assets",
-        limit_choices_to=models.Q(children__isnull=True),
+        related_name="instrument_assets",
         on_delete=models.PROTECT,
         verbose_name="Underlying Instrument",
         help_text="The instrument that is this asset.",
     )
 
-    underlying_instrument_price = models.ForeignKey(
+    underlying_quote = models.ForeignKey(
+        to="wbfdm.Instrument",
+        related_name="assets",
+        limit_choices_to=models.Q(children__isnull=True),
+        on_delete=models.PROTECT,
+        verbose_name="Underlying Quote",
+        help_text="The quote that is this asset.",
+    )
+
+    underlying_quote_price = models.ForeignKey(
         to="wbfdm.InstrumentPrice",
         related_name="assets",
         on_delete=models.SET_NULL,
@@ -394,42 +393,58 @@ class AssetPosition(ImportMixin, models.Model):
     analytical_objects = AnalyticalAssetPositionManager()
     unannotated_objects = models.Manager()
 
-    def save(self, *args, create_underlying_instrument_price_if_missing: bool = False, **kwargs):
-        if not getattr(self, "currency", None):
-            self.currency = self.underlying_instrument.currency
+    def pre_save(self, create_underlying_quote_price_if_missing: bool = False):
         if not self.asset_valuation_date:
             self.asset_valuation_date = self.date
 
-        if not self.underlying_instrument_price:
+        if (
+            (not hasattr(self, "underlying_instrument") or not self.underlying_instrument)
+            and hasattr(self, "underlying_quote")
+            and self.underlying_quote
+        ):
+            self.underlying_instrument = (
+                self.underlying_quote.parent if self.underlying_quote.parent else self.underlying_quote
+            )
+        elif (
+            hasattr(self, "underlying_instrument")
+            and self.underlying_instrument
+            and (not hasattr(self, "underlying_quote") or not self.underlying_quote)
+        ):
+            try:
+                self.underlying_quote = self.underlying_instrument.children.get(is_primary=True)
+            except:
+                self.underlying_quote = self.underlying_instrument
+
+        if not getattr(self, "currency", None):
+            self.currency = self.underlying_quote.currency
+        if not self.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
-                self.underlying_instrument_price = InstrumentPrice.objects.get(
-                    calculated=False, instrument=self.underlying_instrument, date=self.asset_valuation_date
+                self.underlying_quote_price = InstrumentPrice.objects.get(
+                    calculated=False, instrument=self.underlying_quote, date=self.asset_valuation_date
                 )
             except InstrumentPrice.DoesNotExist:
                 # if we create instrument price automatically, we need to ensure that the position is not estimated and not from a fake portfolio (e.g. JPM morgan root portfolio)
-                if create_underlying_instrument_price_if_missing and not self.is_estimated:
+                if create_underlying_quote_price_if_missing and not self.is_estimated:
                     net_value = self.initial_price
-                    # in case the position currency and the linked underlying_instrument currency don't correspond, we convert the rate accordingly
-                    if self.currency != self.underlying_instrument.currency:
-                        net_value *= self.currency.convert(
-                            self.asset_valuation_date, self.underlying_instrument.currency
-                        )
-                    self.underlying_instrument_price = InstrumentPrice(
+                    # in case the position currency and the linked underlying_quote currency don't correspond, we convert the rate accordingly
+                    if self.currency != self.underlying_quote.currency:
+                        net_value *= self.currency.convert(self.asset_valuation_date, self.underlying_quote.currency)
+                    self.underlying_quote_price = InstrumentPrice.objects.create(
                         calculated=False,
-                        instrument=self.underlying_instrument,
+                        instrument=self.underlying_quote,
                         date=self.asset_valuation_date,
                         net_value=net_value,
                         import_source=self.import_source,  # we set the import source to know where this price is coming from
                     )
-                    self.underlying_instrument_price.fill_market_capitalization()
-                    self.underlying_instrument_price.save()
+                    self.underlying_quote_price.fill_market_capitalization()
+                    self.underlying_quote_price.save()
                 else:  # sometime, the asset valuation date does not correspond to a valid market date. In that case, we get the latest valid instrument price for that product
-                    self.underlying_instrument_price = (
+                    self.underlying_quote_price = (
                         InstrumentPrice.objects.filter(
                             calculated=False,
-                            instrument=self.underlying_instrument,
+                            instrument=self.underlying_quote,
                             date__lte=self.asset_valuation_date,
                         )
                         .order_by("date")
@@ -437,14 +452,28 @@ class AssetPosition(ImportMixin, models.Model):
                     )
 
         if not self.currency_fx_rate_instrument_to_usd or (self.currency_fx_rate_instrument_to_usd.date != self.date):
-            rates = CurrencyFXRates.objects.filter(date__lte=self.date, currency=self.underlying_instrument.currency)
-            if rates.exists():
-                self.currency_fx_rate_instrument_to_usd = rates.latest("date")
+            with suppress(CurrencyFXRates.DoesNotExist):
+                self.currency_fx_rate_instrument_to_usd = CurrencyFXRates.objects.get(
+                    date=self.date, currency=self.underlying_quote.currency
+                )
 
         if not self.currency_fx_rate_portfolio_to_usd or (self.currency_fx_rate_portfolio_to_usd.date != self.date):
-            rates = CurrencyFXRates.objects.filter(date__lte=self.date, currency=self.portfolio.currency)
-            if rates.exists():
-                self.currency_fx_rate_portfolio_to_usd = rates.latest("date")
+            with suppress(CurrencyFXRates.DoesNotExist):
+                self.currency_fx_rate_portfolio_to_usd = CurrencyFXRates.objects.get(
+                    date=self.date, currency=self.portfolio.currency
+                )
+
+        if not self.initial_price and self.underlying_quote_price:
+            self.initial_price = self.underlying_quote_price.net_value
+        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
+                )
+
+    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)
         super().save(*args, **kwargs)
 
     class Meta:
@@ -460,29 +489,27 @@ class AssetPosition(ImportMixin, models.Model):
                 name="%(app_label)s_%(class)s_weekday_constraint",
             ),
             models.UniqueConstraint(
-                fields=["portfolio", "date", "underlying_instrument", "portfolio_created"],
+                fields=["portfolio", "date", "underlying_quote", "portfolio_created"],
                 name="unique_asset_position",
                 nulls_distinct=False,
             ),
         ]
 
     def __str__(self):
-        return f"{self.initial_price} - {self.initial_shares} ({self.date}) ({str(self.underlying_instrument)})"
+        return f"{self.initial_price} - {self.initial_shares} ({self.date}) ({str(self.underlying_quote)})"
 
     def set_weighting(self, new_weighting: Decimal):
         # Use this method to set the new weighting and ensure that the relative shares are updated accordingly
         self.weighting = new_weighting
         if self.initial_shares is not None:
             if self.weighting == 0 or self.initial_shares == 0:
-                self.initial_shares = new_weighting * self.get_total_value_portfolio()
+                self.initial_shares = new_weighting * self.get_portfolio_total_asset_value()
             else:
                 self.initial_shares = (new_weighting / self.weighting) * self.initial_shares
         self.save()
 
-    def get_total_value_portfolio(self) -> Decimal:
-        return self.portfolio.assets.filter(date=self.date).aggregate(s=Sum("total_value_fx_portfolio"))[
-            "s"
-        ] or Decimal(0.0)
+    def get_portfolio_total_asset_value(self) -> Decimal:
+        return self.portfolio.get_total_asset_value(self.date)
 
     def _build_dto(self, new_weight: Decimal = None) -> PositionDTO:
         """
@@ -491,23 +518,23 @@ class AssetPosition(ImportMixin, models.Model):
             DTO position object
         """
         return PositionDTO(
-            underlying_instrument=self.underlying_instrument.id,
+            underlying_instrument=self.underlying_quote.id,
             weighting=self.weighting if new_weight is None else new_weight,
             shares=self._shares,
             date=self.date,
             asset_valuation_date=self.asset_valuation_date,
-            instrument_type=self.underlying_instrument.security_instrument_type.id,
-            currency=self.underlying_instrument.currency.id,
-            country=self.underlying_instrument.country.id if self.underlying_instrument.country else None,
-            is_cash=self.underlying_instrument.is_cash,
+            instrument_type=self.underlying_quote.instrument_type.id,
+            currency=self.underlying_quote.currency.id,
+            country=self.underlying_quote.country.id if self.underlying_quote.country else None,
+            is_cash=self.underlying_quote.is_cash,
             primary_classification=(
-                self.underlying_instrument.primary_classification.id
-                if self.underlying_instrument.primary_classification
+                self.underlying_quote.primary_classification.id
+                if self.underlying_quote.primary_classification
                 else None
             ),
             favorite_classification=(
-                self.underlying_instrument.favorite_classification.id
-                if self.underlying_instrument.favorite_classification
+                self.underlying_quote.favorite_classification.id
+                if self.underlying_quote.favorite_classification
                 else None
             ),
             market_capitalization_usd=self._market_capitalization_usd,
@@ -538,21 +565,17 @@ class AssetPosition(ImportMixin, models.Model):
     @cached_property
     @admin.display(description="Market Capitalization")
     def _market_capitalization(self) -> float:
-        return (
-            self.underlying_instrument_price.market_capitalization_consolidated
-            if self.underlying_instrument_price
-            else None
-        )
+        return self.underlying_quote_price.market_capitalization_consolidated if self.underlying_quote_price else None
 
     @cached_property
     @admin.display(description="Volume 50d")
     def _volume_50d(self) -> float:
-        return self.underlying_instrument_price.volume_50d if self.underlying_instrument_price else None
+        return self.underlying_quote_price.volume_50d if self.underlying_quote_price else None
 
     @cached_property
     @admin.display(description="Price (Instrument)")
     def _price(self) -> Decimal:
-        return self.underlying_instrument_price.net_value if self.underlying_instrument_price else self.initial_price
+        return self.underlying_quote_price.net_value if self.underlying_quote_price else self.initial_price
 
     @cached_property
     @admin.display(description="FX rate")
@@ -575,14 +598,17 @@ class AssetPosition(ImportMixin, models.Model):
             return self._price * self._shares
         return Decimal(0)
 
+    @cached_property
+    def fx_usd(self) -> Decimal:
+        if self.currency_fx_rate_instrument_to_usd:
+            return self.currency_fx_rate_instrument_to_usd.value
+        return Decimal(1.0)
+
     @cached_property
     @admin.display(description="Total Value (USD)")
     def _total_value_fx_usd(self) -> Decimal:
-        fx_rate = (
-            self.currency_fx_rate_instrument_to_usd.value if self.currency_fx_rate_instrument_to_usd else Decimal(1.0)
-        )
         if self._shares is not None:
-            return self._price * self._shares * fx_rate
+            return self._price * self._shares * self.fx_usd
         return Decimal(0)
 
     @cached_property
@@ -609,23 +635,15 @@ class AssetPosition(ImportMixin, models.Model):
     @cached_property
     @admin.display(description="Market Capitalization (USD)")
     def _market_capitalization_usd(self) -> float:
-        if self._market_capitalization is not None and self.currency_fx_rate_instrument_to_usd.value is not None:
-            return self._market_capitalization / float(self.currency_fx_rate_instrument_to_usd.value)
+        if self._market_capitalization is not None:
+            return self._market_capitalization * float(self.fx_usd)
         return 0.0
 
     @cached_property
     @admin.display(description="Volume (USD)")
     def _volume_usd(self) -> float:
-        if (
-            self._price_fx_portfolio is not None
-            and self.currency_fx_rate_instrument_to_usd.value is not None
-            and self._volume_50d is not None
-        ):
-            return (
-                float(self._price_fx_portfolio)
-                * float(self.currency_fx_rate_instrument_to_usd.value)
-                * self._volume_50d
-            )
+        if self._price_fx_portfolio is not None and self._volume_50d is not None:
+            return float(self._price_fx_portfolio) * float(self.fx_usd) * self._volume_50d
         return 0.0
 
     @classmethod
@@ -667,8 +685,8 @@ class AssetPosition(ImportMixin, models.Model):
             qs.annotate(
                 underlying_security_instrument_type_name_repr=Case(  # Annotate the parent security if exists
                     When(
-                        underlying_instrument__parent__isnull=False,
-                        then=F("underlying_instrument__parent__instrument_type__name_repr"),
+                        underlying_instrument__isnull=False,
+                        then=F("underlying_instrument__instrument_type__name_repr"),
                     ),
                     default=F("underlying_instrument__instrument_type__name_repr"),
                 ),
@@ -824,7 +842,7 @@ class AssetPosition(ImportMixin, models.Model):
         )
         return (
             Instrument.annotated_objects.filter(is_investable_universe=True)
-            .annotate(has_position=Exists(asset_positions.filter(underlying_instrument=OuterRef("id"))))
+            .annotate(has_position=Exists(asset_positions.filter(underlying_quote=OuterRef("id"))))
             .filter(has_position=True)
         )
 
@@ -834,12 +852,9 @@ def post_instrument_price_creation(sender, instance, created, raw, **kwargs):
     if not raw and created and not instance.calculated:
         AssetPosition.objects.filter(
             Q(asset_valuation_date=instance.date)
-            & Q(underlying_instrument=instance.instrument)
-            & (
-                Q(underlying_instrument_price__isnull=True)
-                | ~Q(asset_valuation_date=F("underlying_instrument_price__date"))
-            )
-        ).update(underlying_instrument_price=instance)
+            & Q(underlying_quote=instance.instrument)
+            & (Q(underlying_quote_price__isnull=True) | ~Q(asset_valuation_date=F("underlying_quote_price__date")))
+        ).update(underlying_quote_price=instance)
 
 
 @receiver(pre_merge, sender="wbfdm.Instrument")
@@ -851,7 +866,11 @@ def pre_merge_instrument(sender: models.Model, merged_object: Instrument, main_o
         new_price=InstrumentPrice.objects.filter(
             instrument=main_object, date=OuterRef("date"), calculated=False
         ).values("id")[:1]
-    ).update(underlying_instrument=main_object, underlying_instrument_price=F("new_price"))
+    ).update(
+        underlying_quote=main_object,
+        underlying_instrument=main_object.parent if main_object.parent else main_object,
+        underlying_quote_price=F("new_price"),
+    )
 
 
 @receiver(add_instrument_to_investable_universe, sender="wbfdm.Instrument")
@@ -863,7 +882,7 @@ def add_instrument_to_investable_universe(sender: models.Model, **kwargs) -> lis
         (
             Instrument.objects.annotate(
                 assets_exists=Exists(
-                    AssetPosition.objects.filter(portfolio__is_tracked=True, underlying_instrument=OuterRef("pk"))
+                    AssetPosition.objects.filter(portfolio__is_tracked=True, underlying_quote=OuterRef("pk"))
                 )
             ).filter(Q(assets_exists=True) | Q(portfolios__isnull=False))
         )

wbportfolio/models/graphs/portfolio.py

@@ -0,0 +1,161 @@
+import re
+import textwrap
+from datetime import date
+
+import networkx as nx
+import plotly.graph_objects as go
+import pydot
+from django.db.models import Q
+
+from wbportfolio.models import Portfolio, PortfolioPortfolioThroughModel
+
+from .utils import networkx_graph_to_plotly
+
+
+class PortfolioGraph:
+    def __init__(self, portfolio: Portfolio, val_date: date, **graph_kwargs):
+        self.graph = pydot.Dot("Portfolio Tree", strict=True, **graph_kwargs)
+        self.base_portfolio = portfolio
+        self.discovered_portfolios = set()
+        self.val_date = val_date
+        self._extend_portfolio_graph(portfolio)
+
+    @classmethod
+    def _convert_to_multilines(cls, name: str) -> str:
+        lines = textwrap.wrap(name, 30)
+        return "\n ".join(lines)
+
+    def _extend_parent_portfolios_to_graph(self, portfolio):
+        for parent_portfolio, weighting in portfolio.get_parent_portfolios(self.val_date):
+            if parent_portfolio.assets.filter(date=self.val_date).exists():
+                self.graph.add_node(
+                    pydot.Node(
+                        str(parent_portfolio.id),
+                        label=self._convert_to_multilines(str(parent_portfolio)),
+                        **self._get_node_kwargs(parent_portfolio),
+                    )
+                )
+                self.graph.del_edge((str(portfolio.id), str(parent_portfolio.id)))
+                self.graph.add_edge(
+                    pydot.Edge(
+                        str(portfolio.id),
+                        str(parent_portfolio.id),
+                        label=f"Invest in ({weighting:.2%})",
+                        style="dashed",
+                    )
+                )
+                # composition_edges.append((str(portfolio.id), str(parent_portfolio.id)))
+                self._extend_parent_portfolios_to_graph(parent_portfolio)
+                self._extend_portfolio_graph(parent_portfolio)
+
+    def _extend_child_portfolios_to_graph(self, portfolio):
+        for child_portfolio in portfolio.get_child_portfolios(self.val_date):
+            self.graph.add_node(
+                pydot.Node(
+                    str(child_portfolio.id),
+                    label=self._convert_to_multilines(str(child_portfolio)),
+                    **self._get_node_kwargs(child_portfolio),
+                )
+            )
+            # we add this edge only if the opposite relationship is not already added
+            graph_edge = pydot.Edge(str(child_portfolio.id), str(portfolio.id), label="implements", style="dashed")
+            if (graph_edge.get_source(), graph_edge.get_destination()) not in self.graph.obj_dict["edges"]:
+                self.graph.add_edge(graph_edge)
+            # composition_edges.append((str(child_portfolio.id), str(portfolio.id)))
+            self._extend_child_portfolios_to_graph(child_portfolio)
+
+    def _get_node_kwargs(self, portfolio):
+        node_args = {
+            "shape": "circle",
+            "orientation": "45",
+        }
+        if portfolio == self.base_portfolio:
+            node_args.update({"style": "filled", "fillcolor": "lightgrey"})
+        else:
+            node_args.update(
+                {
+                    "style": "solid",
+                }
+            )
+        return node_args
+
+    def _extend_portfolio_graph(self, portfolio):
+        self.graph.add_node(
+            pydot.Node(
+                str(portfolio.id),
+                label=self._convert_to_multilines(str(portfolio)),
+                **self._get_node_kwargs(portfolio),
+            )
+        )
+
+        self._extend_child_portfolios_to_graph(portfolio)
+        self._extend_parent_portfolios_to_graph(portfolio)
+
+        # composition_edges = []
+        # if composition_edges:
+        #     with self.graph.subgraph(label=f'composition_{portfolio.id}') as a:
+        #         a.edges(composition_edges)
+        #         a.attr(color='blue')
+        #         a.attr(label='Portfolio Composition')
+        self.discovered_portfolios.add(portfolio)
+
+        for rel in PortfolioPortfolioThroughModel.objects.filter(
+            Q(portfolio=portfolio) | Q(dependency_portfolio=portfolio)
+        ):
+            self.graph.add_node(
+                pydot.Node(
+                    str(rel.portfolio.id),
+                    label=self._convert_to_multilines(str(rel.portfolio)),
+                    **self._get_node_kwargs(rel.portfolio),
+                )
+            )
+            self.graph.add_node(
+                pydot.Node(
+                    str(rel.dependency_portfolio.id),
+                    label=self._convert_to_multilines(str(rel.dependency_portfolio)),
+                    **self._get_node_kwargs(rel.dependency_portfolio),
+                )
+            )
+            label = PortfolioPortfolioThroughModel.Type[rel.type].label
+            if rel.dependency_portfolio.is_composition:
+                label += " (Composition)"
+
+            if rel.portfolio.is_lookthrough and rel.type == PortfolioPortfolioThroughModel.Type.PRIMARY:
+                self.graph.add_edge(
+                    pydot.Edge(
+                        str(rel.portfolio.id), str(rel.dependency_portfolio.id), label="Look-Through", style="dotted"
+                    )
+                )
+            else:
+                self.graph.add_edge(
+                    pydot.Edge(
+                        str(rel.portfolio.id),
+                        str(rel.dependency_portfolio.id),
+                        label=label,
+                        style="bold",
+                    )
+                )
+            if rel.dependency_portfolio not in self.discovered_portfolios:
+                self._extend_portfolio_graph(rel.dependency_portfolio)
+            if rel.portfolio not in self.discovered_portfolios:
+                self._extend_portfolio_graph(rel.portfolio)
+
+    def to_string(self) -> str:
+        return self.graph.to_string()
+
+    def to_networkx(self) -> nx.Graph:
+        return nx.drawing.nx_pydot.from_pydot(self.graph)
+
+    def to_plotly(self, **kwargs) -> go.Figure:
+        node_labels = {
+            node.get_name(): node.obj_dict["attributes"].get("label", node.get_name())
+            for node in self.graph.get_node_list()
+        }
+        return networkx_graph_to_plotly(self.to_networkx(), labels=node_labels, **kwargs)
+
+    def to_svg(self) -> str:
+        svg = self.graph.create_svg().decode("utf-8")
+        svg_matches = re.findall(r"<svg\b[^<]*(?:(?!<\/svg>)<[^<]*)*<\/svg>", svg, flags=re.DOTALL)
+        if svg_matches:
+            return svg_matches[0]
+        return svg

wbportfolio/models/graphs/utils.py

@@ -0,0 +1,83 @@
+import networkx as nx
+import plotly.graph_objects as go
+from networkx.drawing.nx_agraph import graphviz_layout
+
+
+def reformat_graph_layout(G, layout):
+    """
+    this method provide positions based on layout algorithm
+    :param G:
+    :param layout:
+    :return:
+    """
+    if layout == "graphviz":
+        positions = graphviz_layout(G)
+    elif layout == "spring":
+        positions = nx.fruchterman_reingold_layout(G, k=0.5, iterations=1000)
+    elif layout == "spectral":
+        positions = nx.spectral_layout(G, scale=0.1)
+    elif layout == "random":
+        positions = nx.random_layout(G)
+    else:
+        raise Exception("please specify the layout from graphviz, spring, spectral or random")
+
+    return positions
+
+
+def networkx_graph_to_plotly(
+    G: nx.Graph,
+    labels: dict[str, str] | None = None,
+    node_size: int = 10,
+    edge_weight: int = 1,
+    edge_color: str = "black",
+    layout: str = "graphviz",
+    title: str = "",
+) -> go.Figure:
+    """
+    Visualize a NetworkX graph using Plotly.
+    """
+    positions = reformat_graph_layout(G, layout)
+    if not labels:
+        labels = {}
+    # Initialize edge traces
+    edge_traces = []
+    for edge in G.edges():
+        x0, y0 = positions[edge[0]]
+        x1, y1 = positions[edge[1]]
+
+        edge_trace = go.Scatter(
+            x=[x0, x1], y=[y0, y1], line=dict(width=edge_weight, color=edge_color), hoverinfo="none", mode="lines"
+        )
+        edge_traces.append(edge_trace)
+
+    # Initialize node trace
+    node_x, node_y, node_colors, node_labels = [], [], [], []
+    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_trace = go.Scatter(
+        x=node_x,
+        y=node_y,
+        text=node_labels,
+        mode="markers+text",
+        textfont=dict(family="Calibri (Body)", size=15, color="grey"),
+        marker=dict(
+            size=node_size,
+            color=node_colors,
+        ),
+    )
+
+    # Assemble the figure
+    fig = go.Figure(
+        data=edge_traces + [node_trace],
+        layout=go.Layout(
+            showlegend=False,
+            template="plotly_white",
+            margin=dict(l=50, r=50, t=0, b=40),
+        ),
+    )
+    return fig