wbportfolio 1.54.22__py2.py3-none-any.whl → 1.55.0__py2.py3-none-any.whl

wbportfolio/order_routing/adapters/ubs.py

@@ -0,0 +1,161 @@
+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 ExecutionStatus, RoutingException
+from . import BaseCustodianAdapter
+
+ASSET_CLASS_MAP = {Order.AssetType.EQUITY: "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.PENDING,
+    "Complete": ExecutionStatus.PENDING,
+    "Complete (Order Cancelled)": ExecutionStatus.PENDING,
+    "Complete (Partial Fill)": ExecutionStatus.PENDING,
+    "In Draft": ExecutionStatus.PENDING,
+    "Pending Approval": ExecutionStatus.PENDING,
+    "Pending Execution": ExecutionStatus.PENDING,
+    "Rebalance Cancelled": ExecutionStatus.PENDING,
+    "Rebalance Cancelled (Executing partially)": ExecutionStatus.PENDING,
+    "Rejected": ExecutionStatus.PENDING,
+    "Rejection Acknowledged": ExecutionStatus.PENDING,
+    "Waiting for Response": ExecutionStatus.PENDING,
+}
+logger = logging.getLogger("oms")
+
+
+def _serialize_orders(orders: list[Order], default_execution_instruction=None) -> 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": order.execution_instruction
+            if order.execution_instruction
+            else default_execution_instruction,
+            "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)
+        items.append(item)
+    return items
+
+
+def _deserialize_items(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"]) if "targetWeight" in item else None,
+                shares=float(item["sharesToTrade"]) if "sharesToTrade" in item else None,
+                execution_instruction=item.get("executionInstruction"),
+            )
+        )
+    return orders
+
+
+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 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 get_rebalance_status(self) -> tuple[ExecutionStatus, str]:
+        res = self.client.get_rebalance_status_for_isin(self.isin)
+        self._handle_response(res)
+        status = res["rebalanceStatus"]
+        return STATUS_MAP.get(status, ExecutionStatus.UNKNOWN), status
+
+    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, orders: list[Order], as_draft: bool = True) -> tuple[list[Order], str]:
+        """
+        Submit a rebalance order for the certificate.
+        """
+        items = _serialize_orders(orders, default_execution_instruction="MARKET_ON_CLOSE")
+        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 _deserialize_items(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_current_rebalancing(self) -> list[Order]:
+        """
+        Fetch the current rebalance request details for a certificate.
+        """
+        res = self.client.get_current_rebalance_request(self.isin)
+        self._handle_response(res)
+        return _deserialize_items(res["rebalanceItems"])

wbportfolio/pms/trading/handler.py

@@ -87,7 +87,6 @@ class TradingService:
             total_target_weight
         )
         self._effective_portfolio = effective_portfolio
-        self._target_portfolio = target_portfolio
 
     @property
     def errors(self) -> list[str]:
@@ -146,12 +145,15 @@ class TradingService:
             previous_weight = target_weight = 0
             effective_shares = target_shares = 0
             daily_return = 0
+            is_cash = False
             if effective_pos := effective_portfolio.positions_map.get(instrument_id, None):
                 previous_weight = effective_pos.weighting
                 effective_shares = effective_pos.shares
                 daily_return = effective_pos.daily_return
+                is_cash = effective_pos.is_cash
             if target_pos := target_portfolio.positions_map.get(instrument_id, None):
                 target_weight = target_pos.weighting
+                is_cash = target_pos.is_cash
                 if target_pos.shares is not None:
                     target_shares = target_pos.shares
             trade = Trade(
@@ -167,6 +169,7 @@ class TradingService:
                 currency_fx_rate=Decimal(pos.currency_fx_rate),
                 daily_return=Decimal(daily_return),
                 portfolio_contribution=effective_portfolio.portfolio_contribution,
+                is_cash=is_cash,
             )
             trades.append(trade)
         return TradeBatch(trades)

wbportfolio/pms/typing.py

@@ -1,4 +1,6 @@
+import enum
 from dataclasses import asdict, dataclass, field, fields
+from datetime import date
 from datetime import date as date_lib
 from decimal import Decimal
 
@@ -13,7 +15,7 @@ class Valuation:
     outstanding_shares: Decimal = Decimal(0)
 
 
-@dataclass(frozen=True)
+@dataclass()
 class Position:
     underlying_instrument: int
     weighting: Decimal
@@ -38,6 +40,10 @@ class Position:
     volume_usd: float = None
     price: float = None
 
+    def __post_init__(self):
+        self.daily_return = round(self.daily_return, 16)
+        self.weighting = round(self.weighting, 8)
+
     def __add__(self, other):
         return Position(
             weighting=self.weighting + other.weighting,
@@ -58,6 +64,7 @@ class Portfolio:
 
     def __post_init__(self):
         positions_map = {}
+
         for pos in self.positions:
             if pos.underlying_instrument in positions_map:
                 positions_map[pos.underlying_instrument] += pos
@@ -67,7 +74,7 @@ class Portfolio:
 
     @property
     def total_weight(self):
-        return round(sum([pos.weighting for pos in self.positions]), 8)
+        return sum([pos.weighting for pos in self.positions])
 
     @property
     def total_shares(self):
@@ -75,7 +82,7 @@ class Portfolio:
 
     @property
     def portfolio_contribution(self) -> Decimal:
-        return sum(map(lambda pos: pos.weighting * (Decimal("1") + pos.daily_return), self.positions))
+        return round(sum(map(lambda pos: pos.weighting * (Decimal("1") + pos.daily_return), self.positions)), 16)
 
     def to_df(self):
         return pd.DataFrame([asdict(pos) for pos in self.positions])
@@ -91,6 +98,28 @@ class Portfolio:
 
 
 @dataclass(frozen=True)
+class Order:
+    class AssetType(enum.Enum):
+        EQUITY = "EQUITY"
+
+    id: int | str
+    trade_date: date
+    target_weight: float
+
+    # Instrument identifier
+    asset_class: AssetType
+    refinitiv_identifier_code: str | None = None
+    bloomberg_ticker: str | None = None
+    sedol: str | None = None
+
+    weighting: float | None = None
+    target_shares: float | None = None
+    shares: float | None = None
+    execution_instruction: str | None = None
+    comment: str = ""
+
+
+@dataclass()
 class Trade:
     underlying_instrument: int
     instrument_type: int
@@ -104,9 +133,19 @@ class Trade:
     target_shares: Decimal = Decimal("0")
     daily_return: Decimal = Decimal("0")
     portfolio_contribution: Decimal = Decimal("1")
+    quantization_error: Decimal = Decimal("0")
+
     id: int | None = None
     is_cash: bool = False
 
+    def __post_init__(self):
+        self.previous_weight = round(self.previous_weight, 8)
+        # ensure a trade target weight cannot be lower than 0
+        self.target_weight = round(self.target_weight, 8)
+        if self.target_weight < Decimal("1e-7"):
+            self.target_weight = Decimal("0")
+        self.daily_return = round(self.daily_return, 16)
+
     def __add__(self, other):
         return Trade(
             underlying_instrument=self.underlying_instrument,
@@ -137,12 +176,20 @@ class Trade:
         attrs.update(kwargs)
         return Trade(**attrs)
 
+    def set_quantization_error(self, quantization_error: Decimal):
+        self.quantization_error = quantization_error
+        self.target_weight += quantization_error
+
     @property
     def effective_weight(self) -> Decimal:
         return (
-            self.previous_weight * (round(self.daily_return, 16) + 1) / self.portfolio_contribution
-            if self.portfolio_contribution
-            else self.previous_weight
+            round(
+                self.previous_weight * (self.daily_return + 1) / self.portfolio_contribution
+                if self.portfolio_contribution
+                else self.previous_weight,
+                8,
+            )
+            + self.quantization_error
         )
 
     @property
@@ -184,6 +231,9 @@ class TradeBatch:
 
     def __post_init__(self):
         trade_map = {}
+        total_effective_weight = self.total_effective_weight
+        if total_effective_weight and (quant_error := Decimal("1") - self.total_effective_weight):
+            self.largest_effective_order.set_quantization_error(quant_error)
         for trade in self.trades:
             if trade.underlying_instrument in trade_map:
                 trade_map[trade.underlying_instrument] += trade
@@ -191,13 +241,17 @@ class TradeBatch:
                 trade_map[trade.underlying_instrument] = trade
         object.__setattr__(self, "trades_map", trade_map)
 
+    @property
+    def largest_effective_order(self) -> Trade:
+        return max(self.trades, key=lambda obj: obj.previous_weight)
+
     @property
     def total_target_weight(self) -> Decimal:
-        return round(sum([trade.target_weight for trade in self.trades], Decimal("0")), 8)
+        return sum([trade.target_weight for trade in self.trades], Decimal("0"))
 
     @property
     def total_effective_weight(self) -> Decimal:
-        return round(sum([trade.effective_weight for trade in self.trades], Decimal("0")), 8)
+        return sum([trade.effective_weight for trade in self.trades], Decimal("0"))
 
     @property
     def total_abs_delta_weight(self) -> Decimal:

wbportfolio/rebalancing/models/composite.py

@@ -20,7 +20,7 @@ class CompositeRebalancing(AbstractRebalancingModel):
         """
         try:
             latest_order_proposal = self.portfolio.order_proposals.filter(
-                status="APPROVED", trade_date__lt=self.trade_date
+                status="APPLIED", trade_date__lt=self.trade_date
             ).latest("trade_date")
             return {
                 v["underlying_instrument"]: v["target_weight"]

wbportfolio/rebalancing/models/equally_weighted.py

@@ -24,11 +24,11 @@ class EquallyWeightedRebalancing(AbstractRebalancingModel):
 
     def get_target_portfolio(self) -> Portfolio:
         positions = []
-        nb_assets = len(self.effective_portfolio.positions)
-        for position in self.effective_portfolio.positions:
+        assets = list(filter(lambda p: not p.is_cash, self.effective_portfolio.positions))
+        for position in assets:
             positions.append(
                 position.copy(
-                    weighting=Decimal(1 / nb_assets), date=self.trade_date, asset_valuation_date=self.trade_date
+                    weighting=Decimal(1 / len(assets)), date=self.trade_date, asset_valuation_date=self.trade_date
                 )
             )
         return Portfolio(positions)

wbportfolio/rebalancing/models/market_capitalization_weighted.py

@@ -22,7 +22,7 @@ from wbportfolio.rebalancing.decorators import register
 @register("Market Capitalization Rebalancing")
 class MarketCapitalizationRebalancing(AbstractRebalancingModel):
     TARGET_CURRENCY: str = "USD"
-    MIN_WEIGHT: float = 10e-5  # we allow only weight of minimum 0.01%
+    MIN_WEIGHT: float = 1e-5  # we allow only weight of minimum 0.01%
 
     def __init__(
         self,

wbportfolio/rebalancing/models/model_portfolio.py

@@ -1,5 +1,3 @@
-from wbfdm.models import InstrumentPrice
-
 from wbportfolio.pms.typing import Portfolio
 from wbportfolio.rebalancing.base import AbstractRebalancingModel
 from wbportfolio.rebalancing.decorators import register
@@ -9,6 +7,11 @@ from wbportfolio.rebalancing.decorators import register
 class ModelPortfolioRebalancing(AbstractRebalancingModel):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
+        self.value_date = (
+            self.trade_date
+            if self.model_portfolio.assets.filter(date=self.trade_date).exists()
+            else self.last_effective_date
+        )
 
     @property
     def model_portfolio_rel(self):
@@ -20,19 +23,15 @@ class ModelPortfolioRebalancing(AbstractRebalancingModel):
 
     @property
     def assets(self):
-        return self.model_portfolio.get_positions(self.last_effective_date) if self.model_portfolio else []
+        return self.model_portfolio.get_positions(self.value_date) if self.model_portfolio else []
 
     def is_valid(self) -> bool:
-        instruments = list(map(lambda o: o.underlying_quote, self.assets))
-        return (
-            len(self.assets) > 0
-            and InstrumentPrice.objects.filter(date=self.trade_date, instrument__in=instruments).exists()
-        )
+        return len(self.assets) > 0
 
     def get_target_portfolio(self) -> Portfolio:
         positions = []
         for asset in self.assets:
-            asset.date = self.trade_date
-            asset.asset_valuation_date = self.trade_date
+            asset.date = self.value_date
+            asset.asset_valuation_date = self.value_date
             positions.append(asset._build_dto())
         return Portfolio(positions=tuple(positions))

wbportfolio/serializers/orders/order_proposals.py

@@ -1,10 +1,9 @@
-from decimal import Decimal
-
 from django.contrib.messages import warning
 from django.core.exceptions import ValidationError
 from rest_framework.reverse import reverse
 from wbcore import serializers as wb_serializers
-from wbcore.serializers import DefaultFromView
+from wbcore.contrib.directory.serializers import PersonRepresentationSerializer
+from wbcore.serializers import CharField, DefaultFromView
 
 from wbportfolio.models import OrderProposal, Portfolio, RebalancingModel
 
@@ -20,31 +19,28 @@ class OrderProposalRepresentationSerializer(wb_serializers.RepresentationSeriali
 
 
 class OrderProposalModelSerializer(wb_serializers.ModelSerializer):
+    _portfolio = PortfolioRepresentationSerializer(source="portfolio")
     rebalancing_model = wb_serializers.PrimaryKeyRelatedField(queryset=RebalancingModel.objects.all(), required=False)
     _rebalancing_model = RebalancingModelRepresentationSerializer(source="rebalancing_model")
     target_portfolio = wb_serializers.PrimaryKeyRelatedField(
         queryset=Portfolio.objects.all(), write_only=True, required=False
     )
     _target_portfolio = PortfolioRepresentationSerializer(source="target_portfolio")
-    total_cash_weight = wb_serializers.DecimalField(
-        default=0,
-        decimal_places=4,
-        max_digits=5,
-        write_only=True,
-        required=False,
-        precision=4,
-        percent=True,
-        label="Target Cash",
-        help_text="Enter the desired percentage for the cash component. The remaining percentage (100% minus this value) will be allocated to total target weighting. Default is 0%.",
-    )
-
     trade_date = wb_serializers.DateField(
         read_only=lambda view: not view.new_mode, default=DefaultFromView("default_trade_date")
     )
+    _creator = PersonRepresentationSerializer(source="creator")
+    _approver = PersonRepresentationSerializer(source="approver")
+    execution_status_repr = wb_serializers.SerializerMethodField(label="Status", field_class=CharField, read_only=True)
+
+    def get_execution_status_repr(self, obj):
+        repr = obj.execution_status
+        if obj.execution_status_detail:
+            repr += f" (Custodian: {obj.execution_status_detail})"
+        return repr
 
     def create(self, validated_data):
         target_portfolio = validated_data.pop("target_portfolio", None)
-        total_cash_weight = validated_data.pop("total_cash_weight", Decimal("0.0"))
         rebalancing_model = validated_data.get("rebalancing_model", None)
         if request := self.context.get("request"):
             validated_data["creator"] = request.user.profile
@@ -59,9 +55,7 @@ class OrderProposalModelSerializer(wb_serializers.ModelSerializer):
             )
 
         try:
-            obj.reset_orders(
-                target_portfolio=target_portfolio_dto, total_target_weight=Decimal("1.0") - total_cash_weight
-            )
+            obj.reset_orders(target_portfolio=target_portfolio_dto)
         except ValidationError as e:
             if request := self.context.get("request"):
                 warning(request, str(e), extra_tags="auto_close=0")
@@ -70,7 +64,7 @@ class OrderProposalModelSerializer(wb_serializers.ModelSerializer):
     @wb_serializers.register_only_instance_resource()
     def additional_resources(self, instance, request, user, **kwargs):
         res = {}
-        if instance.status == OrderProposal.Status.APPROVED:
+        if instance.status == OrderProposal.Status.APPLIED:
             res["replay"] = reverse("wbportfolio:orderproposal-replay", args=[instance.id], request=request)
         if instance.status == OrderProposal.Status.DRAFT:
             res["reset"] = reverse("wbportfolio:orderproposal-reset", args=[instance.id], request=request)
@@ -86,18 +80,28 @@ class OrderProposalModelSerializer(wb_serializers.ModelSerializer):
     class Meta:
         model = OrderProposal
         only_fsm_transition_on_instance = True
+        percent_fields = ["total_cash_weight"]
         fields = (
             "id",
             "trade_date",
+            "portfolio",
+            "_portfolio",
             "total_cash_weight",
             "comment",
             "status",
             "min_order_value",
-            "portfolio",
             "_rebalancing_model",
             "rebalancing_model",
             "target_portfolio",
             "_target_portfolio",
+            "creator",
+            "approver",
+            "_creator",
+            "_approver",
+            "execution_status",
+            "execution_status_detail",
+            "execution_comment",
+            "execution_status_repr",
             "_additional_resources",
         )
 

wbportfolio/serializers/orders/orders.py

@@ -42,6 +42,7 @@ class OrderOrderProposalListModelSerializer(wb_serializers.ModelSerializer):
     underlying_instrument_ticker = wb_serializers.CharField(read_only=True)
     underlying_instrument_refinitiv_identifier_code = wb_serializers.CharField(read_only=True)
     underlying_instrument_instrument_type = wb_serializers.CharField(read_only=True)
+    underlying_instrument_exchange = wb_serializers.CharField(read_only=True)
 
     target_weight = wb_serializers.DecimalField(
         max_digits=Order.ORDER_WEIGHTING_PRECISION + 1,
@@ -83,8 +84,7 @@ class OrderOrderProposalListModelSerializer(wb_serializers.ModelSerializer):
         weighting = data.get("weighting", self.instance.weighting if self.instance else Decimal(0.0))
         if (target_weight := data.pop("target_weight", None)) is not None:
             weighting = target_weight - effective_weight
-        if (target_weight := data.pop("target_weight", None)) is not None:
-            weighting = target_weight - effective_weight
+            data["desired_target_weight"] = target_weight
         if weighting >= 0:
             data["order_type"] = "BUY"
         else:
@@ -124,6 +124,7 @@ class OrderOrderProposalListModelSerializer(wb_serializers.ModelSerializer):
             "underlying_instrument_ticker",
             "underlying_instrument_refinitiv_identifier_code",
             "underlying_instrument_instrument_type",
+            "underlying_instrument_exchange",
             "order_type",
             "comment",
             "effective_weight",
@@ -138,6 +139,8 @@ class OrderOrderProposalListModelSerializer(wb_serializers.ModelSerializer):
             "target_total_value_fx_portfolio",
             "portfolio_currency",
             "has_warnings",
+            "execution_confirmed",
+            "execution_comment",
         )
 
 

wbportfolio/serializers/positions.py

@@ -11,8 +11,8 @@ class AggregatedAssetPositionModelSerializer(wb_serializers.ModelSerializer):
     sum_total_value = wb_serializers.DecimalField(read_only=True, max_digits=16, decimal_places=4)
     weighting = wb_serializers.DecimalField(
         read_only=True,
-        max_digits=6,
-        decimal_places=4,
+        max_digits=9,
+        decimal_places=8,
         percent=True,
         decorators=[{"position": "right", "value": "%"}],
     )

wbportfolio/serializers/rebalancing.py

@@ -49,7 +49,7 @@ class RebalancerModelSerializer(wb_serializers.ModelSerializer):
             "computed_str",
             "_rebalancing_model",
             "rebalancing_model",
-            "approve_order_proposal_automatically",
+            "apply_order_proposal_automatically",
             "activation_date",
             "frequency",
             "frequency_repr",

wbportfolio/tests/conftest.py

@@ -70,7 +70,7 @@ from wbportfolio.factories import (
     RebalancerFactory,
     RebalancingModelFactory
 )
-
+from wbreport.factories import ReportFactory, ReportAssetFactory, ReportVersionFactory, ReportClassFactory, ReportCategoryFactory
 from wbcore.tests.conftest import *  # isort:skip
 
 register(AccountFactory)
@@ -147,7 +147,11 @@ register(DailyPortfolioCashFlowFactory)
 
 register(AccountReconciliationFactory)
 register(AccountReconciliationLineFactory)
-
+register(ReportFactory)
+register(ReportAssetFactory)
+register(ReportVersionFactory)
+register(ReportClassFactory)
+register(ReportCategoryFactory)
 
 pre_migrate.connect(app_pre_migration, sender=apps.get_app_config("wbportfolio"))
 from .signals import *  # noqa: F401