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

wbportfolio/order_routing/adapters/ubs.py

@@ -0,0 +1,195 @@
+import logging
+from datetime import datetime
+
+from django.conf import settings
+from requests import HTTPError
+
+from wbportfolio.api_clients.ubs import UBSNeoAPIClient
+from wbportfolio.pms.typing import Order
+
+from .. import ExecutionInstruction, ExecutionStatus, RoutingException
+from . import BaseCustodianAdapter
+
+logger = logging.getLogger("oms")
+
+
+ASSET_CLASS_MAP = {
+    Order.AssetType.EQUITY: "EQUITY",
+    Order.AssetType.AMERICAN_DEPOSITORY_RECEIPT: "EQUITY",
+}  # API can support BOND, FUTURE, OPTION, and DYNAMIC_STRATEGY
+ASSET_CLASS_MAP_INV = {
+    v: k for k, v in ASSET_CLASS_MAP.items()
+}  # API can support BOND, FUTURE, OPTION, and DYNAMIC_STRATEGY
+
+STATUS_MAP = {
+    "Amend Pending": ExecutionStatus.PENDING,
+    "Cancel Pending": ExecutionStatus.PENDING,
+    "Cancelled": ExecutionStatus.CANCELLED,
+    "Complete": ExecutionStatus.COMPLETED,
+    "Complete (Order Cancelled)": ExecutionStatus.COMPLETED,
+    "Complete (Partial Fill)": ExecutionStatus.COMPLETED,
+    "In Draft": ExecutionStatus.IN_DRAFT,
+    "Pending Approval": ExecutionStatus.PENDING,
+    "Pending Execution": ExecutionStatus.PENDING,
+    "Rebalance Cancelled": ExecutionStatus.CANCELLED,
+    "Rebalance Cancelled (Executing partially)": ExecutionStatus.CANCELLED,
+    "Rejected": ExecutionStatus.REJECTED,
+    "Rejection Acknowledged": ExecutionStatus.PENDING,
+    "Waiting for Response": ExecutionStatus.PENDING,
+}
+EXECUTION_INSTRUCTION_MAP = {
+    ExecutionInstruction.MARKET_ON_CLOSE: "MARKET_ON_CLOSE",
+    ExecutionInstruction.GUARANTEED_MARKET_ON_CLOSE: "GUARANTEED_MARKET_ON_CLOSE",
+    ExecutionInstruction.GUARANTEED_MARKET_ON_OPEN: "GUARANTEED_MARKET_ON_OPEN",
+    ExecutionInstruction.GPW_MARKET_ON_CLOSE: "GPW_MARKET_ON_CLOSE",
+    ExecutionInstruction.MARKET_ON_OPEN: "MARKET_ON_OPEN",
+    ExecutionInstruction.IN_LINE_WITH_VOLUME: "IN_LINE_WITH_VOLUME",
+    ExecutionInstruction.LIMIT_ORDER: "LIMIT_ORDER",
+    ExecutionInstruction.VWAP: "VWAP",
+    ExecutionInstruction.TWAP: "TWAP",
+}
+EXECUTION_INSTRUCTION_MAP_INV = {v: k for k, v in EXECUTION_INSTRUCTION_MAP.items()}
+
+
+class CustodianAdapter(BaseCustodianAdapter):
+    client: UBSNeoAPIClient
+
+    def __init__(self, *args, raise_exception: bool = False, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.raise_exception = raise_exception
+
+    def _handle_response(self, res):
+        logger.info(res["message"])
+        if errors := res.get("errors"):
+            logger.warning(errors)
+            if self.raise_exception:
+                raise RoutingException(errors)
+
+    def _serialize_execution_instruction(
+        self, execution_instruction: ExecutionInstruction, execution_parameters: dict
+    ):
+        repr = EXECUTION_INSTRUCTION_MAP[execution_instruction]
+        if execution_parameters:
+            if execution_instruction == ExecutionInstruction.IN_LINE_WITH_VOLUME:
+                repr += f':{execution_parameters["percent"]:.0f%}'
+            elif execution_instruction == ExecutionInstruction.LIMIT_ORDER:
+                repr += f':{execution_parameters["price"]:.1f}'
+                if good_for_date := execution_parameters.get("good_for_date"):
+                    repr += f",{good_for_date}"
+            elif (
+                execution_instruction == ExecutionInstruction.VWAP
+                or execution_instruction == ExecutionInstruction.TWAP
+            ):
+                repr += f':{execution_parameters["period"]},{execution_parameters["time"]}'
+        return repr
+
+    def serialize_orders(self, orders: list[Order]) -> list[dict[str, str]]:
+        items = []
+        for order in orders:
+            if order.refinitiv_identifier_code:
+                identifier_type, identifier = "RIC", order.refinitiv_identifier_code
+            elif order.bloomberg_ticker:
+                identifier_type, identifier = "BBTICKER", order.bloomberg_ticker
+            else:
+                identifier_type, identifier = "SEDOL", order.sedol
+            item = {
+                "assetClass": ASSET_CLASS_MAP[order.asset_class],
+                "identifierType": identifier_type,
+                "identifier": identifier,
+                "executionInstruction": self._serialize_execution_instruction(
+                    order.execution_instruction, order.execution_instruction_parameters
+                ),
+                "userElementId": str(order.id),
+                "tradeDate": order.trade_date.strftime("%Y-%m-%d"),
+            }
+            if order.shares:
+                item["sharesToTrade"] = str(order.shares)
+            else:
+                item["targetWeight"] = str(order.target_weight * 100)
+            items.append(item)
+        return items
+
+    def deserialize_items(self, items: list[dict[str, str]]):
+        orders = []
+        for item in items:
+            orders.append(
+                Order(
+                    id=item.get("userElementId"),
+                    asset_class=ASSET_CLASS_MAP_INV[item.get("assetClass")],
+                    refinitiv_identifier_code=item.get(
+                        "ric", item["identifier"] if item.get("identifierType") == "RIC" else None
+                    ),
+                    bloomberg_ticker=item["identifier"] if item.get("identifierType") == "BBTICKER" else None,
+                    sedol=item["identifier"] if item.get("identifierType") == "SEDOL" else None,
+                    trade_date=datetime.strptime(item.get("tradeDate"), "%Y-%m-%d"),
+                    target_weight=float(item["targetWeight"]) / 100 if "targetWeight" in item else None,
+                    shares=float(item["sharesToTrade"]) if "sharesToTrade" in item else None,
+                    execution_instruction=EXECUTION_INSTRUCTION_MAP_INV[item["executionInstruction"]],
+                )
+            )
+        return orders
+
+    def authenticate(self) -> bool:
+        """
+        Authenticate or renew tokens with the custodian API.
+        Raises an exception if authentication fails.
+        """
+        self.client = UBSNeoAPIClient(settings.UBS_NEO_API_TOKEN)
+        return True
+
+    def is_valid(self) -> bool:
+        """
+        Check whether the given isin is valid and can be rebalanced
+        """
+
+        try:
+            status_res = self.client.get_rebalance_service_status()
+
+            isin_res = self.client.get_rebalance_status_for_isin(self.isin)
+            self._handle_response(status_res)
+            self._handle_response(isin_res)
+            return (
+                status_res["status"] == UBSNeoAPIClient.SUCCESS_VALUE
+                and isin_res["status"] == UBSNeoAPIClient.SUCCESS_VALUE
+            )
+        except (HTTPError, KeyError) as e:
+            logger.warning(f"Couldn't validate adapter: {str(e)}")
+            return False
+
+    def submit_rebalancing(
+        self, items: list[dict[str, str]], as_draft: bool = True
+    ) -> tuple[list[dict[str, str]], str]:
+        """
+        Submit a rebalance order for the certificate.
+        """
+        if not as_draft:
+            res = self.client.submit_rebalance(self.isin, items)
+        else:
+            res = self.client.save_draft(self.isin, items)
+        self._handle_response(res)
+        return res["rebalanceItems"], res["message"]
+
+    def cancel_current_rebalancing(self) -> bool:
+        """
+        Cancel an existing rebalance order identified by ISIN.
+        """
+        try:
+            res = self.client.cancel_rebalance(self.isin)
+            self._handle_response(res)
+            return res["status"] == UBSNeoAPIClient.SUCCESS_VALUE
+        except (HTTPError, KeyError):
+            return False
+
+    def get_rebalance_status(self) -> tuple[ExecutionStatus, str]:
+        res = self.client.get_rebalance_status_for_isin(self.isin)
+        self._handle_response(res)
+        status = res.get("rebalanceStatus", "")
+        return STATUS_MAP.get(status, ExecutionStatus.UNKNOWN), status
+
+    def get_current_rebalancing(self) -> list[dict[str, str]]:
+        """
+        Fetch the current rebalance request details for a certificate.
+        """
+        res = self.client.get_current_rebalance_request(self.isin)
+        self._handle_response(res)
+        return res["rebalanceItems"]

wbportfolio/order_routing/router.py

@@ -0,0 +1,33 @@
+from django.conf import settings
+
+from wbportfolio.order_routing import ExecutionStatus
+from wbportfolio.order_routing.adapters import BaseCustodianAdapter
+from wbportfolio.pms.typing import Order
+
+
+class Router:
+    def __init__(self, adapter: BaseCustodianAdapter):
+        self.adapter = adapter
+
+    @property
+    def submit_as_draft(self):
+        return getattr(settings, "DEBUG", True) or getattr(settings, "ORDER_ROUTING_AS_DRAFT", True)
+
+    def submit_rebalancing(self, orders: list[Order]) -> tuple[list[Order], tuple[str, str]]:
+        """
+        Submit a rebalance order for the certificate.
+        """
+        items = self.adapter.serialize_orders(orders)
+        confirmed_items, msg = self.adapter.submit_rebalancing(items, as_draft=self.submit_as_draft)
+        status = ExecutionStatus.IN_DRAFT if self.submit_as_draft else ExecutionStatus.PENDING
+        return self.adapter.deserialize_items(confirmed_items), (status, msg)
+
+    def get_rebalance_status(self) -> tuple[ExecutionStatus, str]:
+        return self.adapter.get_rebalance_status()
+
+    def cancel_rebalancing(self) -> bool:
+        return self.adapter.cancel_current_rebalancing()
+
+    def get_current_rebalancing_request(self) -> list[Order]:
+        items = self.adapter.get_current_rebalancing()
+        return self.adapter.deserialize_items(items)

wbportfolio/order_routing/tests/test_router.py

@@ -0,0 +1,110 @@
+from unittest.mock import MagicMock, PropertyMock, patch
+
+import pytest
+from django.conf import settings
+
+from wbportfolio.order_routing import ExecutionStatus
+from wbportfolio.order_routing.router import Router
+from wbportfolio.pms.typing import Order
+
+
+@pytest.fixture
+def mock_adapter():
+    adapter = MagicMock()
+    return adapter
+
+
+@pytest.fixture
+def router(mock_adapter):
+    return Router(adapter=mock_adapter)
+
+
+def test_submit_as_draft_from_settings(monkeypatch, router):
+    # Test default True if settings attribute missing
+    monkeypatch.setattr(settings, "ORDER_ROUTING_AS_DRAFT", True)
+    monkeypatch.setattr(settings, "DEBUG", False)
+    assert router.submit_as_draft is True
+
+    monkeypatch.setattr(settings, "ORDER_ROUTING_AS_DRAFT", False)
+    monkeypatch.setattr(settings, "DEBUG", True)
+    assert router.submit_as_draft is True
+
+    monkeypatch.setattr(settings, "ORDER_ROUTING_AS_DRAFT", True)
+    monkeypatch.setattr(settings, "DEBUG", True)
+    assert router.submit_as_draft is True
+
+    monkeypatch.setattr(settings, "ORDER_ROUTING_AS_DRAFT", False)
+    monkeypatch.setattr(settings, "DEBUG", False)
+    assert router.submit_as_draft is False
+
+
+@patch.object(Router, "submit_as_draft", new_callable=PropertyMock)
+def test_submit_rebalancing_calls_adapter_as_draft(mock_property, router, mock_adapter):
+    mock_property.return_value = True
+    orders = [MagicMock(spec=Order), MagicMock(spec=Order)]
+    serialized_orders = ["serialized_order1", "serialized_order2"]  # simplified serialized orders as items
+    confirmed_items = ["confirmed_order1", "confirmed_order2"]  # simplified deserialized orders from items
+    msg = "Success message"
+
+    mock_adapter.serialize_orders.return_value = serialized_orders
+    mock_adapter.submit_rebalancing.return_value = (confirmed_items, msg)
+    mock_adapter.deserialize_items.return_value = orders
+
+    result_orders, (status, message) = router.submit_rebalancing(orders)
+    assert result_orders == orders
+    assert status == ExecutionStatus.IN_DRAFT
+    assert message == msg
+    mock_adapter.serialize_orders.assert_called_once_with(orders)
+    mock_adapter.submit_rebalancing.assert_called_once_with(serialized_orders, as_draft=True)
+    mock_adapter.deserialize_items.assert_called_once_with(confirmed_items)
+
+
+@patch.object(Router, "submit_as_draft", new_callable=PropertyMock)
+def test_submit_rebalancing_calls_adapter(mock_property, router, mock_adapter):
+    mock_property.return_value = False
+    orders = [MagicMock(spec=Order), MagicMock(spec=Order)]
+    serialized_orders = ["serialized_order1", "serialized_order2"]  # simplified serialized orders as items
+    confirmed_items = ["confirmed_order1", "confirmed_order2"]  # simplified deserialized orders from items
+    msg = "Success message"
+
+    mock_adapter.serialize_orders.return_value = serialized_orders
+    mock_adapter.submit_rebalancing.return_value = (confirmed_items, msg)
+    mock_adapter.deserialize_items.return_value = orders
+
+    result_orders, (status, message) = router.submit_rebalancing(orders)
+    assert result_orders == orders
+    assert status == ExecutionStatus.PENDING
+    assert message == msg
+    mock_adapter.serialize_orders.assert_called_once_with(orders)
+    mock_adapter.submit_rebalancing.assert_called_once_with(serialized_orders, as_draft=False)
+    mock_adapter.deserialize_items.assert_called_once_with(confirmed_items)
+
+
+def test_get_rebalance_status_returns_adapter_status(router, mock_adapter):
+    expected_status = ExecutionStatus.PENDING
+    expected_msg = "Status message"
+    mock_adapter.get_rebalance_status.return_value = (expected_status, expected_msg)
+
+    status, msg = router.get_rebalance_status()
+    assert status == expected_status
+    assert msg == expected_msg
+    mock_adapter.get_rebalance_status.assert_called_once()
+
+
+def test_cancel_rebalancing_returns_adapter_result(router, mock_adapter):
+    mock_adapter.cancel_current_rebalancing.return_value = True
+    result = router.cancel_rebalancing()
+    assert result is True
+    mock_adapter.cancel_current_rebalancing.assert_called_once()
+
+
+def test_get_current_rebalancing_request_returns_deserialized(router, mock_adapter):
+    serialized_orders = ["order1", "order2"]
+    deserialized_orders = [MagicMock(spec=Order), MagicMock(spec=Order)]
+    mock_adapter.get_current_rebalancing.return_value = serialized_orders
+    mock_adapter.deserialize_items.return_value = deserialized_orders
+
+    result = router.get_current_rebalancing_request()
+    assert result == deserialized_orders
+    mock_adapter.get_current_rebalancing.assert_called_once()
+    mock_adapter.deserialize_items.assert_called_once_with(serialized_orders)

wbportfolio/permissions.py

@@ -1,3 +1,5 @@
+from rest_framework.permissions import IsAuthenticated
+
 from wbportfolio.models import PortfolioRole
 
 
@@ -11,3 +13,8 @@ def is_portfolio_manager(request):
 
 def is_analyst(request):
     return PortfolioRole.is_analyst(request.user.profile)
+
+
+class IsPortfolioManager(IsAuthenticated):
+    def has_permission(self, request, view):
+        return is_portfolio_manager(request)

wbportfolio/pms/analytics/portfolio.py

@@ -2,6 +2,8 @@ import numpy as np
 import pandas as pd
 from skfolio import Portfolio as BasePortfolio
 
+from .utils import fix_quantization_error
+
 
 class Portfolio(BasePortfolio):
     @property
@@ -16,21 +18,27 @@ class Portfolio(BasePortfolio):
         )
         return df
 
-    def get_next_weights(self) -> dict[int, float]:
+    def get_contributions(self) -> tuple[pd.Series, float]:
+        returns = self.X.iloc[-1, :].T
+        weights = self.all_weights_per_observation.iloc[-1, :].T
+        portfolio_returns = (weights * (returns + 1.0)).sum()
+        return returns, portfolio_returns
+
+    def get_next_weights(self, round_precision: int = 8) -> dict[int, float]:
         """
         Given the next returns, compute the drifted weights of this portfolio
-
+            round_precision: Round the weight to the given round number and ensure the total weight reflects this. Default to 8 decimals
         Returns:
             A dictionary of weights (instrument ids as keys and weights as values)
         """
-        returns = self.X.iloc[-1, :].T
+        returns, portfolio_returns = self.get_contributions()
         weights = self.all_weights_per_observation.iloc[-1, :].T
-        if weights.sum() != 0:
-            weights /= weights.sum()
-        contribution = weights * (returns + 1.0)
-        if contribution.sum() != 0:
-            contribution /= contribution.sum()
-        return contribution.dropna().to_dict()
+        next_weights = weights * (returns + 1.0) / portfolio_returns
+        next_weights = next_weights.dropna()
+        next_weights = next_weights / next_weights.sum()
+        if round_precision and not next_weights.empty:
+            next_weights = fix_quantization_error(next_weights, round_precision)
+        return {i: round(w, round_precision) for i, w in next_weights.items()}  # handle float precision manually
 
     def get_estimate_net_value(self, previous_net_asset_value: float) -> float:
         expected_returns = self.weights @ self.X.iloc[-1, :].T

wbportfolio/pms/analytics/utils.py

@@ -0,0 +1,9 @@
+import pandas as pd
+
+
+def fix_quantization_error(df: pd.Series, round_precision: int):
+    df = df.round(round_precision)
+    quantization_error = 1.0 - df.sum()
+    largest_weight = df.idxmax()
+    df.loc[largest_weight] = df.loc[largest_weight] + quantization_error
+    return df

wbportfolio/pms/trading/__init__.py

@@ -1 +0,0 @@
-from .handler import TradingService

wbportfolio/pms/trading/optimizer.py

@@ -0,0 +1,61 @@
+import math
+
+import cvxpy as cp
+import numpy as np
+
+from wbportfolio.pms.typing import TradeBatch
+
+
+class TradeShareOptimizer:
+    def __init__(self, batch: TradeBatch, portfolio_total_value: float):
+        self.batch = batch
+        self.portfolio_total_value = portfolio_total_value
+
+    def optimize(self, target_cash: float = 0.99):
+        try:
+            return self.optimize_trade_share(target_cash)
+        except ValueError:
+            return self.floor_trade_share()
+
+    def optimize_trade_share(self, target_cash: float = 0.01):
+        prices_fx_portfolio = np.array([trade.price_fx_portfolio for trade in self.batch.trades])
+        target_allocs = np.array([trade.target_weight for trade in self.batch.trades])
+
+        # Decision variable: number of shares (integers)
+        shares = cp.Variable(len(prices_fx_portfolio), integer=True)
+
+        # Calculate portfolio values
+        portfolio_values = cp.multiply(shares, prices_fx_portfolio)
+
+        # Target values based on allocations
+        target_values = self.portfolio_total_value * target_allocs
+
+        # Objective: minimize absolute deviation from target values
+        objective = cp.Minimize(cp.sum(cp.abs(portfolio_values - target_values)))
+
+        # Constraints
+        constraints = [
+            shares >= 0,  # No short selling
+            cp.sum(portfolio_values) <= self.portfolio_total_value,  # Don't exceed budget
+            cp.sum(portfolio_values) >= (1.0 - target_cash) * self.portfolio_total_value,  # Use at least 99% of budget
+        ]
+
+        # Solve
+        problem = cp.Problem(objective, constraints)
+        problem.solve(solver=cp.CBC)
+
+        if problem != "optimal":
+            raise ValueError(f"Optimization failed: {problem.status}")
+
+        shares_result = shares.value.astype(int)
+        return TradeBatch(
+            [
+                trade.normalize_target(target_shares=shares_result[index])
+                for index, trade in enumerate(self.batch.trades)
+            ]
+        )
+
+    def floor_trade_share(self):
+        return TradeBatch(
+            [trade.normalize_target(target_shares=math.floor(trade.target_shares)) for trade in self.batch.trades]
+        )