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

wbportfolio/models/transactions/transactions.py

@@ -1,105 +1,94 @@
 from decimal import Decimal
 
-from django.apps import apps
 from django.db import models
-from django.dispatch import receiver
-from wbcore.contrib.io.mixins import ImportMixin
-from wbcore.signals import pre_merge
-from wbfdm.models.instruments.instruments import Instrument
-from wbfdm.signals import add_instrument_to_investable_universe
 
 
-class ShareMixin(models.Model):
-    shares = models.DecimalField(
-        max_digits=15,
-        decimal_places=4,
-        default=Decimal("0.0"),
-        help_text="The number of shares that were traded.",
-        verbose_name="Shares",
+class TransactionMixin(models.Model):
+    value_date = models.DateField(
+        verbose_name="Value Date",
+        help_text="The date that this transaction was valuated/paid.",
+    )
+    portfolio = models.ForeignKey(
+        "wbportfolio.Portfolio", related_name="%(class)ss", on_delete=models.PROTECT, verbose_name="Portfolio"
+    )
+    underlying_instrument = models.ForeignKey(
+        to="wbfdm.Instrument",
+        related_name="%(class)ss",
+        limit_choices_to=models.Q(children__isnull=True),
+        on_delete=models.PROTECT,
+        verbose_name="Underlying Instrument",
+        help_text="The instrument that is this transaction.",
+    )
+    currency = models.ForeignKey(
+        "currency.Currency",
+        related_name="%(class)ss",
+        on_delete=models.PROTECT,
+        verbose_name="Currency",
+    )
+    currency_fx_rate = models.DecimalField(
+        max_digits=14, decimal_places=8, default=Decimal(1.0), verbose_name="FOREX rate"
     )
     price = models.DecimalField(
         max_digits=16,
         decimal_places=4,
-        default=Decimal(
-            "0.0"
-        ),  # we shouldn't default to anything but we have trade with price=None. Needs to be handled carefully
         help_text="The price per share.",
         verbose_name="Price",
     )
-
     price_gross = models.DecimalField(
         max_digits=16,
         decimal_places=4,
         help_text="The gross price per share.",
         verbose_name="Gross Price",
     )
-
-    def save(
-        self,
-        *args,
-        factor: Decimal = Decimal("1.0"),
-        **kwargs,
-    ):
-        if self.price_gross is None:
-            self.price_gross = self.price
-
-        self.total_value = self.price * self.shares * factor
-        self.total_value_gross = self.price_gross * self.shares * factor
-        super().save(*args, **kwargs)
-
-    class Meta:
-        abstract = True
-
-
-class Transaction(ImportMixin, models.Model):
-    class Type(models.TextChoices):
-        # Standart Asset Types
-        TRADE = "Trade", "Trade"
-        DIVIDEND_TRANSACTION = "DividendTransaction", "Dividend Transaction"
-        EXPIRY = "Expiry", "Expiry"
-        FEES = "Fees", "Fees"
-
-    transaction_type = models.CharField(max_length=255, verbose_name="Type", choices=Type.choices, default=Type.TRADE)
-
-    portfolio = models.ForeignKey(
-        "wbportfolio.Portfolio", related_name="transactions", on_delete=models.PROTECT, verbose_name="Portfolio"
-    )
-
-    underlying_instrument = models.ForeignKey(
-        to="wbfdm.Instrument",
-        related_name="transactions",
-        limit_choices_to=models.Q(children__isnull=True),
-        on_delete=models.PROTECT,
-        verbose_name="Underlying Instrument",
-        help_text="The instrument that is this transaction.",
+    shares = models.DecimalField(
+        max_digits=15,
+        decimal_places=4,
+        default=Decimal("0.0"),
+        help_text="The number of shares held at record date, used to calculate the dividend",
+        verbose_name="Shares / Quantity",
     )
-
-    transaction_date = models.DateField(
-        verbose_name="Trade Date",
-        help_text="The date that this transaction was traded.",
+    fees = models.GeneratedField(
+        expression=models.F("price_gross") - models.F("price"),
+        output_field=models.DecimalField(
+            max_digits=20,
+            decimal_places=4,
+        ),
+        db_persist=True,
     )
-    book_date = models.DateField(
-        verbose_name="Trade Date",
-        help_text="The date that this transaction was booked.",
+    total_value_gross = models.GeneratedField(
+        expression=models.F("price_gross") * models.F("shares"),
+        output_field=models.DecimalField(
+            max_digits=20,
+            decimal_places=4,
+        ),
+        db_persist=True,
     )
-    value_date = models.DateField(
-        verbose_name="Value Date",
-        help_text="The date that this transaction was valuated.",
+    total_value = models.GeneratedField(
+        expression=models.F("price") * models.F("shares"),
+        output_field=models.DecimalField(
+            max_digits=20,
+            decimal_places=4,
+        ),
+        db_persist=True,
     )
-
-    currency = models.ForeignKey(
-        "currency.Currency",
-        related_name="transactions",
-        on_delete=models.PROTECT,
-        verbose_name="Currency",
+    price_fx_portfolio = models.GeneratedField(
+        expression=models.F("currency_fx_rate") * models.F("price"),
+        output_field=models.DecimalField(
+            max_digits=20,
+            decimal_places=4,
+        ),
+        db_persist=True,
     )
-    currency_fx_rate = models.DecimalField(
-        max_digits=14, decimal_places=8, default=Decimal(1.0), verbose_name="FOREX rate"
+    price_gross_fx_portfolio = models.GeneratedField(
+        expression=models.F("currency_fx_rate") * models.F("price_gross"),
+        output_field=models.DecimalField(
+            max_digits=20,
+            decimal_places=4,
+        ),
+        db_persist=True,
     )
-    total_value = models.DecimalField(max_digits=20, decimal_places=4, verbose_name="Total Value")
-    total_value_gross = models.DecimalField(max_digits=20, decimal_places=4, verbose_name="Total Value Gross")
     total_value_fx_portfolio = models.GeneratedField(
-        expression=models.F("currency_fx_rate") * models.F("total_value"),
+        expression=models.F("currency_fx_rate") * models.F("price") * models.F("shares"),
         output_field=models.DecimalField(
             max_digits=20,
             decimal_places=4,
@@ -107,99 +96,30 @@ class Transaction(ImportMixin, models.Model):
         db_persist=True,
     )
     total_value_gross_fx_portfolio = models.GeneratedField(
-        expression=models.F("currency_fx_rate") * models.F("total_value_gross"),
+        expression=models.F("currency_fx_rate") * models.F("price_gross") * models.F("shares"),
         output_field=models.DecimalField(
             max_digits=20,
             decimal_places=4,
         ),
         db_persist=True,
     )
-    external_id = models.CharField(
-        max_length=255,
-        null=True,
-        blank=True,
-        help_text="An external identifier that was supplied.",
-        verbose_name="External Identifier",
-    )
-    comment = models.TextField(default="", verbose_name="Comment", blank=True)
 
-    def save(self, *args, **kwargs):
-        if not self.value_date:
-            self.value_date = self.transaction_date
-        if not self.book_date:
-            self.book_date = self.transaction_date
+    comment = models.TextField(default="", verbose_name="Comment", blank=True)
+    created = models.DateTimeField(auto_now_add=True)
+    updated = models.DateTimeField(auto_now=True)
 
-        if not getattr(self, "currency", None) and self.underlying_instrument:
+    def pre_save(self):
+        if self.underlying_instrument:
             self.currency = self.underlying_instrument.currency
+
+        if self.price is not None and self.price_gross is None:
+            self.price_gross = self.price
+        elif self.price_gross is not None and self.price is None:
+            self.price = self.price_gross
         if self.currency_fx_rate is None:
             self.currency_fx_rate = self.underlying_instrument.currency.convert(
                 self.value_date, self.portfolio.currency, exact_lookup=True
             )
-        if not self.transaction_type:
-            self.transaction_type = self.__class__.__name__
-
-        if self.total_value_gross is None:
-            self.total_value_gross = self.total_value
-
-        super().save(*args, **kwargs)
-
-    def __str__(self):
-        return f"{self.total_value} - {self.transaction_date:%d.%m.%Y} : {str(self.underlying_instrument)} (in {str(self.portfolio)})"
-
-    def get_casted_model(self):
-        return apps.get_model(app_label="wbportfolio", model_name=self.transaction_type)
-
-    def get_casted_transaction(self) -> models.Model:
-        """
-        Cast the asset into its child representative
-        """
-        model = self.get_casted_model()
-        return model.objects.get(pk=self.pk)
 
     class Meta:
-        verbose_name = "Transaction"
-        verbose_name_plural = "Transactions"
-        indexes = [
-            models.Index(fields=["underlying_instrument", "transaction_date"]),
-            # models.Index(fields=["date", "underlying_instrument"]),
-        ]
-
-    objects = models.Manager()
-
-    @classmethod
-    def get_representation_value_key(cls):
-        return "id"
-
-    @classmethod
-    def get_representation_label_key(cls):
-        return "{{total_value}}{{transaction_date}}"
-
-    @classmethod
-    def get_endpoint_basename(cls):
-        return "wbportfolio:transaction"
-
-
-@receiver(pre_merge, sender="wbfdm.Instrument")
-def pre_merge_instrument(sender: models.Model, merged_object: "Instrument", main_object: "Instrument", **kwargs):
-    """
-    Simply reassign the transactions linked to the merged instrument to the main instrument
-    """
-    merged_object.transactions.update(underlying_instrument=main_object)
-
-
-@receiver(add_instrument_to_investable_universe, sender="wbfdm.Instrument")
-def add_instrument_to_investable_universe_from_transactions(sender: models.Model, **kwargs) -> list[int]:
-    """
-    register all instrument linked to assets as within the investible universe
-    """
-    return list(
-        (
-            Instrument.objects.annotate(
-                transaction_exists=models.Exists(
-                    Transaction.objects.filter(underlying_instrument=models.OuterRef("pk"))
-                )
-            ).filter(transaction_exists=True)
-        )
-        .distinct()
-        .values_list("id", flat=True)
-    )
+        abstract = True

wbportfolio/models/utils.py

@@ -1,6 +1,17 @@
+import logging
+from datetime import date
+from decimal import Decimal
+from typing import Iterator
+
+from celery import shared_task
+from django.db.models import F, QuerySet, Window
+from django.db.models.functions import RowNumber
+from tqdm import tqdm
 from wbfdm.models import Instrument
 
-from wbportfolio.models import Index, Product
+from wbportfolio.models import AssetPosition, Index, Order, OrderProposal, Portfolio, Product
+
+logger = logging.getLogger("pms")
 
 
 def get_casted_portfolio_instrument(instrument: Instrument) -> Product | Index | None:
@@ -11,3 +22,91 @@ def get_casted_portfolio_instrument(instrument: Instrument) -> Product | Index |
             return Index.objects.get(id=instrument.id)
         except Index.DoesNotExist:
             return None
+
+
+def get_adjusted_shares(old_shares: Decimal, old_price: Decimal, new_price: Decimal) -> Decimal:
+    return old_shares * (old_price / new_price)
+
+
+def adjust_assets(qs: Iterator[AssetPosition], underlying_quote: Instrument):
+    objs = []
+    logger.info("adjusting asset positions...")
+    for a in qs:
+        old_price: Decimal = a.initial_price
+        a.initial_price = a.underlying_instrument = a.underlying_quote_price = None
+        a.underlying_quote = underlying_quote
+        a.pre_save()
+        if a.initial_shares and a.initial_price and old_price != a.initial_price:
+            a.initial_shares = get_adjusted_shares(a.initial_shares, old_price, a.initial_price)
+        objs.append(a)
+    AssetPosition.objects.bulk_update(
+        objs,
+        ["underlying_quote", "underlying_quote_price", "underlying_instrument", "initial_price", "initial_shares"],
+        batch_size=1000,
+    )
+
+
+def adjust_orders(qs: Iterator[Order], underlying_quote: Instrument):
+    objs = []
+    logger.info("adjusting orders...")
+    for o in qs:
+        old_price: Decimal = o.price
+        o.underlying_instrument = underlying_quote
+        o.set_price()
+        if o.price and old_price != o.price and o.shares:
+            o.shares = get_adjusted_shares(o.shares, old_price, o.price)
+        objs.append(o)
+    Order.objects.bulk_update(objs, ["price", "shares", "underlying_instrument"], batch_size=1000)
+
+
+def adjust_quote(
+    old_quote: Instrument,
+    new_quote: Instrument,
+    adjust_after: date | None = None,
+    only_portfolios: QuerySet[Portfolio] | None = None,
+    debug: bool = False,
+):
+    if old_quote.currency != new_quote.currency:
+        raise ValueError("cannot safely switch quotes that are not of the same currency")
+    assets_to_change = AssetPosition.objects.filter(underlying_quote=old_quote)
+    orders_to_change = Order.objects.filter(underlying_instrument=old_quote)
+    new_quote.import_prices()
+    if adjust_after:
+        assets_to_change = assets_to_change.filter(date__gt=adjust_after)
+        orders_to_change = orders_to_change.filter(value_date__gt=adjust_after)
+    if only_portfolios is not None:
+        assets_to_change = assets_to_change.filter(portfolio__in=only_portfolios)
+        orders_to_change = orders_to_change.filter(order_proposal__portfolio__in=only_portfolios)
+    if debug:
+        assets_to_change = tqdm(assets_to_change, total=assets_to_change.count())
+        orders_to_change = tqdm(orders_to_change, total=orders_to_change.count())
+
+    # gather the list of order proposal to replay (if the quote led to missing position, we want to replay it to correct automatically the issue)
+    latest_orders = orders_to_change.annotate(
+        row_number=Window(
+            expression=RowNumber(), partition_by=[F("order_proposal__portfolio")], order_by=F("value_date").desc()
+        )
+    ).filter(row_number=1)
+    order_proposals_to_replay = OrderProposal.objects.filter(
+        portfolio__is_manageable=True, id__in=latest_orders.values("order_proposal")
+    )
+
+    # Adjust assets to the new quote
+    adjust_assets(assets_to_change, new_quote)
+
+    # Adjust orders to the new quote
+    adjust_orders(orders_to_change, new_quote)
+
+    # replay latest order proposal
+    for op in order_proposals_to_replay:
+        op.replay(reapply_order_proposal=True)
+
+
+@shared_task(queue="portfolio")
+def adjust_quote_as_task(
+    old_quote_id: int, new_quote_id: int, adjust_after: date | None = None, only_portfolio_ids: list[int] | None = None
+):
+    old_quote = Instrument.objects.get(id=old_quote_id)
+    new_quote = Instrument.objects.get(id=new_quote_id)
+    only_portfolios = Portfolio.objects.filter(id__in=only_portfolio_ids) if only_portfolio_ids else None
+    adjust_quote(old_quote, new_quote, adjust_after=adjust_after, only_portfolios=only_portfolios)

wbportfolio/order_routing/__init__.py

@@ -0,0 +1,35 @@
+from django.db.models import TextChoices
+
+class ExecutionStatus(TextChoices):
+    PENDING = "PENDING", "Pending"
+    IN_DRAFT = "IN_DRAFT", "In Draft"
+    COMPLETED = "COMPLETED", "Completed"
+    CANCELLED = "CANCELLED", "Cancelled"
+    REJECTED = "REJECTED", "Rejected"
+    FAILED = "FAILED", "Failed"
+    UNKNOWN = "UNKNOWN", "Unknown"
+
+
+
+class ExecutionInstruction(TextChoices):
+
+    MARKET_ON_CLOSE = "MARKET_ON_CLOSE", "Market On Close" # no parameter
+    GUARANTEED_MARKET_ON_CLOSE = "GUARANTEED_MARKET_ON_CLOSE", "Guaranteed Market On Close" # no parameter
+    GUARANTEED_MARKET_ON_OPEN  = "GUARANTEED_MARKET_ON_OPEN", "Guaranteed Market On Open" # no parameter
+    GPW_MARKET_ON_CLOSE = "GPW_MARKET_ON_CLOSE", "GPW Market On Close" # no parameter
+    MARKET_ON_OPEN = "MARKET_ON_OPEN", "Market On Open" # no parameter
+    IN_LINE_WITH_VOLUME = "IN_LINE_WITH_VOLUME", "In Line With Volume" # 1 parameter "Percentage"
+    LIMIT_ORDER = "LIMIT_ORDER", "Limit Order" # 2 parameters "limit and cutoff"
+    VWAP = "VWAP", "VWAP" # 2 parameters
+    TWAP = "TWAP", "TWAP" # 2 paramters
+
+
+
+class RoutingException(Exception):
+    def __init__(self, errors):
+        # messages: a list of strings
+        super().__init__()  # You can pass a summary to the base Exception
+        self.errors = errors
+
+    def __str__(self):
+        return str(self.errors)

wbportfolio/order_routing/adapters/__init__.py

@@ -0,0 +1,65 @@
+from abc import ABC, abstractmethod
+
+from wbportfolio.order_routing import ExecutionStatus
+from wbportfolio.pms.typing import Order
+
+class BaseCustodianAdapter(ABC):
+
+    def __init__(self, isin: str, **identifiers):
+        self.isin = isin
+
+    @property
+    def errors(self):
+        if not hasattr(self, '_errors'):
+            raise ValueError("is_valid needs to call before accessing errors")
+        return
+    @abstractmethod
+    def authenticate(self) -> bool:
+        """
+        Authenticate or renew tokens with the custodian API.
+        Raises an exception if authentication fails.
+        """
+        pass
+
+    @abstractmethod
+    def is_valid(self) -> bool:
+        """
+        Check whether the given isin is valid and can be rebalanced
+        """
+        pass
+
+    @abstractmethod
+    def serialize_orders(self, orders: list[Order]) -> list[dict[str, str]]:
+        pass
+
+    @abstractmethod
+    def deserialize_items(self, items: list[dict[str, str]]) -> list[Order]:
+        pass
+
+    @abstractmethod
+    def get_rebalance_status(self) -> tuple[ExecutionStatus, str]:
+        """
+        Return the rebalance status as a string (in the custodian format)
+        """
+        pass
+
+    @abstractmethod
+    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.
+        """
+        pass
+
+    @abstractmethod
+    def cancel_current_rebalancing(self) -> bool:
+        """
+        Cancel an existing rebalance order identified by ISIN.
+        """
+        pass
+
+    @abstractmethod
+    def get_current_rebalancing(self) -> list[dict[str, str]]:
+        """
+        Fetch the current rebalance request details for a certificate.
+        """
+        pass