wbportfolio 1.45.0__tar.gz → 1.45.1__tar.gz

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

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

wbportfolio-1.45.1/wbportfolio/import_export/parsers/vontobel/valuation_api.py

@@ -0,0 +1,23 @@
+import json
+from contextlib import suppress
+from datetime import datetime
+
+from wbportfolio.models import Product
+
+
+def parse(import_source):
+    data = []
+    with suppress(KeyError):
+        series_data = json.loads(import_source.file.read())["payload"]["series"]
+        for series in series_data:
+            isin = series["item"]["priceIdentifier"]
+            if Product.objects.filter(isin=isin).exists():  # ensure the timeseries contain data for products we handle
+                for point in series["points"]:
+                    data.append(
+                        {
+                            "instrument": {"isin": isin},
+                            "date": datetime.fromtimestamp(int(point["timestamp"]) / 1000).strftime("%Y-%m-%d"),
+                            "net_value": point["close"],
+                        }
+                    )
+    return {"data": data}

{wbportfolio-1.45.0 → wbportfolio-1.45.1}/wbportfolio/models/graphs/portfolio.py

@@ -15,6 +15,7 @@ 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)
@@ -31,13 +32,17 @@ class PortfolioGraph:
                     pydot.Node(
                         str(parent_portfolio.id),
                         label=self._convert_to_multilines(str(parent_portfolio)),
-                        shape="circle",
-                        orientation="45",
-                        style="solid",
+                        **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"{weighting:.2%}", style="dashed")
+                    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)
@@ -49,28 +54,42 @@ class PortfolioGraph:
                 pydot.Node(
                     str(child_portfolio.id),
                     label=self._convert_to_multilines(str(child_portfolio)),
-                    shape="circle",
-                    orientation="45",
-                    style="solid",
+                    **self._get_node_kwargs(child_portfolio),
                 )
             )
-            # self.graph.add_edge(pydot.Edge(str(child_portfolio.id), str(portfolio.id), label="child", style="dashed"))
+            # 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)),
-                shape="circle",
-                orientation="45",
-                style="solid",
+                **self._get_node_kwargs(portfolio),
             )
         )
 
-        self._extend_parent_portfolios_to_graph(portfolio)
         self._extend_child_portfolios_to_graph(portfolio)
+        self._extend_parent_portfolios_to_graph(portfolio)
 
         # composition_edges = []
         # if composition_edges:
@@ -87,37 +106,35 @@ class PortfolioGraph:
                 pydot.Node(
                     str(rel.portfolio.id),
                     label=self._convert_to_multilines(str(rel.portfolio)),
-                    shape="square",
-                    orientation="45",
-                    style="solid",
+                    **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)),
-                    shape="square",
-                    orientation="45",
-                    style="solid",
+                    **self._get_node_kwargs(rel.dependency_portfolio),
                 )
             )
             label = PortfolioPortfolioThroughModel.Type[rel.type].label
             if rel.dependency_portfolio.is_composition:
                 label += " (Composition)"
-            self.graph.add_edge(
-                pydot.Edge(
-                    str(rel.dependency_portfolio.id),
-                    str(rel.portfolio.id),
-                    label=label,
-                    style="bold",
-                )
-            )
+
             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:

{wbportfolio-1.45.0 → wbportfolio-1.45.1}/wbportfolio/risk_management/backends/ucits_portfolio.py

@@ -46,19 +46,25 @@ class RuleBackend(ActivePortfolioRelationshipMixin, backend.AbstractRuleBackend)
     def _process_dto(self, portfolio: PortfolioDTO, **kwargs) -> Generator[backend.IncidentResult, None, None]:
         if not (df := self._filter_df(pd.DataFrame(portfolio.to_df()).astype({"weighting": float}))).empty:
             df = df[["underlying_instrument", "weighting"]].groupby("underlying_instrument").sum()
-            total_weight_threshold_1_2 = df.loc[df["weighting"] < self.threshold_2, "weighting"].sum()
+            total_weight_threshold_1_2 = df["weighting"].sum()
             highest_incident_type = RiskIncidentType.objects.order_by("-severity_order").first()
+
             for id, row in df.to_dict("index").items():
                 if (row["weighting"] > self.threshold_2) or (total_weight_threshold_1_2 > self.threshold_3):
                     instrument = Instrument.objects.get(id=id)
+                    breached_value = f"""
+                    Sum >= {self.threshold_1:.2%}: {total_weight_threshold_1_2:+.2%}
+                    """
+                    if row["weighting"] > self.threshold_2:
+                        breached_value += f"<br>Instrument >= {self.threshold_2:.2%}: {instrument.name_repr}"
                     yield backend.IncidentResult(
                         breached_object=instrument,
                         breached_object_repr=str(instrument),
-                        breached_value=f'∑[0%, {self.threshold_2:.2%}]:  {row["weighting"]:+.2%} | ∑[{self.threshold_1:.2%}, {self.threshold_2:.2%}]: {total_weight_threshold_1_2:+.2%}',
+                        breached_value=breached_value,
                         report_details={
-                            "Breach Thresholds": f"{self.threshold_1}|{self.threshold_2}|{self.threshold_3}",
-                            "Weighting": f"{row['weighting']:.3f}",
-                            f"Sum of positions whose weight are between {self.threshold_1:.2%} and {self.threshold_2:.2%}": f"{total_weight_threshold_1_2:.3f}",
+                            "Breach Thresholds": f"{self.threshold_1:.2%}|{self.threshold_2:.2%}|{self.threshold_3:.2%}",
+                            "Weighting": f"{row['weighting']:+.2%}",
+                            f"Sum of positions > {self.threshold_1:.2%}": f"{total_weight_threshold_1_2:+.2%}",
                         },
                         severity=highest_incident_type,
                     )

{wbportfolio-1.45.0 → wbportfolio-1.45.1}/wbportfolio/risk_management/tests/test_ucits_portfolio.py

@@ -19,7 +19,7 @@ class TestUcitsRuleModel(PortfolioTestMixin):
         #  Check No single asset can represent more than 10% of the fund's assets;
         asset_position_factory.create(date=weekday, weighting=0.05, portfolio=portfolio)
         asset_position_factory.create(date=weekday, weighting=0.05, portfolio=portfolio)
-        a3 = asset_position_factory.create(date=weekday, weighting=0.90, portfolio=portfolio)
+        a3 = asset_position_factory.create(date=weekday, weighting=0.15, portfolio=portfolio)
 
         res = list(ucits_backend.check_rule())
         assert len(res) == 1

{wbportfolio-1.45.0 → wbportfolio-1.45.1}/wbportfolio/tests/models/test_portfolios.py

@@ -1114,3 +1114,28 @@ class TestPortfolioModel(PortfolioTestMixin):
         undependant_portfolio = portfolio_factory.create(name="undependant portfolio", id=4)
         res = list(Portfolio.objects.all().to_dependency_iterator(weekday))
         assert res == [index_portfolio, dependency_portfolio, dependant_portfolio, undependant_portfolio]
+
+    def test_get_returns(self, instrument_factory, instrument_price_factory, portfolio):
+        v1 = date(2025, 1, 1)
+        v2 = date(2025, 1, 2)
+        v3 = date(2025, 1, 3)
+
+        i1 = instrument_factory.create()
+        i2 = instrument_factory.create()
+
+        i11 = instrument_price_factory.create(date=v1, instrument=i1)
+        i12 = instrument_price_factory.create(date=v2, instrument=i1)
+        i13 = instrument_price_factory.create(date=v3, instrument=i1)
+        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)
+
+        expected_returns = pd.DataFrame(
+            [[i12.net_value / i11.net_value - 1], [i13.net_value / i12.net_value - 1]],
+            index=[v2, v3],
+            columns=[i1.id],
+            dtype="float64",
+        )
+        expected_returns.index = pd.to_datetime(expected_returns.index)
+        pd.testing.assert_frame_equal(returns, expected_returns, check_names=False, check_freq=False, atol=1e-6)

{wbportfolio-1.45.0 → wbportfolio-1.45.1}/wbportfolio/viewsets/configs/endpoints/assets.py

@@ -56,6 +56,8 @@ class AssetPositionProductGroupEndpointConfig(AssetPositionEndpointConfig):
 
 
 class CashPositionPortfolioEndpointConfig(AssetPositionEndpointConfig):
+    PK_FIELD = "portfolio"
+
     def get_list_endpoint(self, **kwargs):
         return reverse(
             "wbportfolio:productcashposition-list",
@@ -63,6 +65,16 @@ class CashPositionPortfolioEndpointConfig(AssetPositionEndpointConfig):
             request=self.request,
         )
 
+    def get_instance_endpoint(self, **kwargs):
+        return reverse(
+            "wbportfolio:portfolio-list",
+            args=[],
+            request=self.request,
+        )
+
+    def get_update_endpoint(self, **kwargs):
+        return None
+
 
 class ContributorPortfolioChartEndpointConfig(AssetPositionEndpointConfig):
     def get_list_endpoint(self, **kwargs):

{wbportfolio-1.45.0 → wbportfolio-1.45.1}/wbportfolio/viewsets/portfolios.py

@@ -181,7 +181,7 @@ class PortfolioTreeGraphChartViewSet(UserPortfolioRequestPermissionMixin, viewse
         return parse_date(self.request.GET["date"])
 
     def get_html(self, queryset) -> str:
-        portfolio_graph = PortfolioGraph(self.portfolio, self.val_date)
+        portfolio_graph = PortfolioGraph(self.portfolio, self.val_date, rankdir="LR", size="20,11")
         return portfolio_graph.to_svg()
 
 

wbportfolio-1.45.0/wbportfolio/import_export/parsers/vontobel/valuation_api.py

@@ -1,20 +0,0 @@
-import json
-from contextlib import suppress
-from datetime import datetime
-
-
-def parse(import_source):
-    data = []
-    with suppress(KeyError):
-        series_data = json.loads(import_source.file.read())["payload"]["series"]
-        for series in series_data:
-            isin = series["item"]["priceIdentifier"]
-            for point in series["points"]:
-                data.append(
-                    {
-                        "instrument": {"isin": isin},
-                        "date": datetime.fromtimestamp(int(point["timestamp"]) / 1000).strftime("%Y-%m-%d"),
-                        "net_value": point["close"],
-                    }
-                )
-    return {"data": data}