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

wbportfolio/models/portfolio_relationship.py

@@ -61,6 +61,9 @@ class InstrumentPortfolioThroughModel(models.Model):
             models.UniqueConstraint(fields=["instrument", "portfolio"], name="unique_portfolio_relationship"),
         ]
 
+    def __str__(self) -> str:
+        return f"{self.instrument} - {self.portfolio}"
+
     @classmethod
     def get_portfolio(cls, instrument):
         with suppress(InstrumentPortfolioThroughModel.DoesNotExist):
@@ -99,6 +102,9 @@ class PortfolioInstrumentPreferredClassificationThroughModel(models.Model):
         related_name="preferred_classification_group_throughs",
     )
 
+    def __str__(self) -> str:
+        return f"{self.portfolio} - {self.instrument}: ({self.classification})"
+
     def save(self, *args, **kwargs) -> None:
         if not self.classification_group and self.classification:
             self.classification_group = self.classification.group

wbportfolio/models/products.py

@@ -4,6 +4,7 @@ from decimal import Decimal
 
 from celery import shared_task
 from django.contrib import admin
+from django.contrib.contenttypes.fields import GenericRelation
 from django.contrib.postgres.constraints import ExclusionConstraint
 from django.contrib.postgres.fields import DateRangeField, RangeOperators
 from django.db import models
@@ -33,6 +34,7 @@ from wbcore.utils.enum import ChoiceEnum
 from wbcrm.models.accounts import Account
 from wbfdm.models.instruments.instrument_prices import InstrumentPrice
 from wbfdm.models.instruments.instruments import InstrumentManager, InstrumentType
+from wbreport.models import Report
 
 from wbportfolio.models.portfolio_relationship import InstrumentPortfolioThroughModel
 
@@ -188,6 +190,9 @@ class FeeProductPercentage(models.Model):
             ),
         ]
 
+    def __str__(self) -> str:
+        return f"{self.product.name} ({self.type})"
+
     @property
     def net_percent(self) -> Decimal:
         return self.percent
@@ -198,6 +203,8 @@ class FeeProductPercentage(models.Model):
 
 
 class Product(PMSInstrumentAbstractModel):
+    reports = GenericRelation(Report)
+
     share_price = models.PositiveIntegerField(
         default=100,
         verbose_name="Share Price",
@@ -344,6 +351,11 @@ class Product(PMSInstrumentAbstractModel):
 
         self.is_managed = True
 
+    def save(self, *args, **kwargs):
+        super().save(*args, **kwargs)
+        if self.delisted_date and self.delisted_date <= date.today():
+            self.reports.update(is_active=False)
+
     def get_title(self):
         if self.parent:
             return f"{self.parent.name} ({self.name})"

wbportfolio/models/{transactions/rebalancing.py → rebalancing.py}

@@ -14,8 +14,8 @@ from wbcore.utils.importlib import import_from_dotted_path
 from wbcore.utils.models import ComplexToStringMixin
 from wbcore.utils.rrules import convert_rrulestr_to_dict, humanize_rrule
 
+from wbportfolio.models.orders.order_proposals import OrderProposal
 from wbportfolio.models.portfolio import Portfolio
-from wbportfolio.models.transactions.trade_proposals import TradeProposal
 from wbportfolio.pms.typing import Portfolio as PortfolioDTO
 from wbportfolio.rebalancing.base import AbstractRebalancingModel
 
@@ -43,9 +43,16 @@ class RebalancingModel(models.Model):
         return import_from_dotted_path(self.class_path)
 
     def get_target_portfolio(
-        self, portfolio: Portfolio, trade_date: date, last_effective_date: date, **kwargs
+        self,
+        portfolio: Portfolio,
+        trade_date: date,
+        last_effective_date: date,
+        effective_portfolio: PortfolioDTO | None = None,
+        **kwargs,
     ) -> PortfolioDTO:
-        model = self.model_class(portfolio, trade_date, last_effective_date, **kwargs)
+        model = self.model_class(
+            portfolio, trade_date, last_effective_date, effective_portfolio=effective_portfolio, **kwargs
+        )
         if not model.is_valid():
             raise ValidationError(model.validation_errors)
         return model.get_target_portfolio()
@@ -71,8 +78,8 @@ class Rebalancer(ComplexToStringMixin, models.Model):
         RebalancingModel, on_delete=models.PROTECT, related_name="rebalancers", verbose_name="Rebalancing Model"
     )
     parameters = models.JSONField(default=dict, verbose_name="Parameters", blank=True)
-    approve_trade_proposal_automatically = models.BooleanField(
-        default=False, verbose_name="Apply Trade Proposal Automatically"
+    apply_order_proposal_automatically = models.BooleanField(
+        default=False, verbose_name="Apply Order Proposal Automatically"
     )
     activation_date = models.DateField(verbose_name="Activation Date")
     frequency = models.CharField(
@@ -82,6 +89,9 @@ class Rebalancer(ComplexToStringMixin, models.Model):
         help_text=_("The Evaluation Frequency in RRULE format"),
     )
 
+    def __str__(self) -> str:
+        return f"{self.portfolio.name} ({self.rebalancing_model})"
+
     def save(self, *args, **kwargs):
         if not self.activation_date:
             try:
@@ -92,19 +102,19 @@ class Rebalancer(ComplexToStringMixin, models.Model):
 
     def _get_next_valid_date(self, valid_date: date) -> date:
         pivot_date = valid_date
-        while TradeProposal.objects.filter(
-            portfolio=self.portfolio, status=TradeProposal.Status.FAILED, trade_date=pivot_date
+        while OrderProposal.objects.filter(
+            portfolio=self.portfolio, status=OrderProposal.Status.FAILED, trade_date=pivot_date
         ).exists():
             pivot_date = (pivot_date + BDay(1)).date()
         return pivot_date
 
     def is_valid(self, trade_date: date) -> bool:
-        if TradeProposal.objects.filter(
+        if OrderProposal.objects.filter(
             portfolio=self.portfolio,
-            status=TradeProposal.Status.APPROVED,
+            status=OrderProposal.Status.CONFIRMED,
             trade_date=trade_date,
             rebalancing_model__isnull=True,
-        ).exists():  # if a already approved trade proposal exists, we do not allow a re-evaluatioon of the rebalancing (only possible if "replayed")
+        ).exists():  # if a already applied order proposal exists, we do not allow a re-evaluatioon of the rebalancing (only possible if "replayed")
             return False
         for initial_valid_datetime in self.get_rrule(trade_date):
             initial_valid_date = initial_valid_datetime.date()
@@ -115,8 +125,8 @@ class Rebalancer(ComplexToStringMixin, models.Model):
                 break
         return False
 
-    def evaluate_rebalancing(self, trade_date: date):
-        trade_proposal, _ = TradeProposal.objects.get_or_create(
+    def evaluate_rebalancing(self, trade_date: date, effective_portfolio=None):
+        order_proposal, _ = OrderProposal.objects.get_or_create(
             trade_date=trade_date,
             portfolio=self.portfolio,
             defaults={
@@ -124,27 +134,30 @@ class Rebalancer(ComplexToStringMixin, models.Model):
                 "rebalancing_model": self.rebalancing_model,
             },
         )
-
-        if trade_proposal.rebalancing_model == self.rebalancing_model:
-            trade_proposal.status = TradeProposal.Status.DRAFT
+        order_proposal.portfolio = self.portfolio
+        if order_proposal.rebalancing_model == self.rebalancing_model:
             try:
                 logger.info(
                     f"Getting target portfolio ({self.portfolio}) for rebalancing model {self.rebalancing_model} for trade date {trade_date:%Y-%m-%d}"
                 )
                 target_portfolio = self.rebalancing_model.get_target_portfolio(
-                    self.portfolio, trade_date, trade_proposal.last_effective_date, **self.parameters
+                    self.portfolio,
+                    order_proposal.trade_date,
+                    order_proposal.value_date,
+                    effective_portfolio=effective_portfolio,
+                    **self.parameters,
                 )
-                trade_proposal.reset_trades(target_portfolio)
-                trade_proposal.submit()
-                if self.approve_trade_proposal_automatically and self.portfolio.can_be_rebalanced:
-                    trade_proposal.approve(replay=False)
-            except ValidationError:
-                # If we encountered a validation error, we set the trade proposal as failed
-                trade_proposal.status = TradeProposal.Status.FAILED
-
-            trade_proposal.save()
-
-        return trade_proposal
+                order_proposal.apply_workflow(
+                    apply_automatically=self.apply_order_proposal_automatically,
+                    target_portfolio=target_portfolio,
+                    effective_portfolio=effective_portfolio,
+                )
+            except ValidationError as e:
+                logger.warning(f"Validation error while approving the orders: {e}")
+                # If we encountered a validation error, we set the order proposal as failed
+                order_proposal.status = OrderProposal.Status.FAILED
+            order_proposal.save()
+        return order_proposal
 
     @property
     def rrule(self):

wbportfolio/models/roles.py

@@ -52,16 +52,10 @@ class PortfolioRole(models.Model):
         return f"{self.role_type} {self.person.computed_str}"
 
     def save(self, *args, **kwargs):
-        assert (
-            self.role_type in [self.RoleType.MANAGER, self.RoleType.RISK_MANAGER] and not self.instrument
-        ) or self.role_type in [
-            self.RoleType.PORTFOLIO_MANAGER,
-            self.RoleType.ANALYST,
-        ], self.default_error_messages["manager"].format(model="instrument")
-
-        assert (self.start and self.end and self.start < self.end) or (
-            not self.start or not self.end
-        ), self.default_error_messages["start_end"]
+        if self.role_type in [self.RoleType.MANAGER, self.RoleType.RISK_MANAGER] and self.instrument:
+            raise ValueError(self.default_error_messages["manager"].format(model="instrument"))
+        if self.start and self.end and self.start > self.end:
+            raise ValueError(self.default_error_messages["start_end"])
 
         super().save(*args, **kwargs)
 

wbportfolio/models/transactions/__init__.py

@@ -1,8 +1,4 @@
 from .claim import Claim
 from .dividends import DividendTransaction
-from .expiry import Expiry
 from .fees import FeeCalculation, Fees
-from .trade_proposals import TradeProposal
-from .rebalancing import RebalancingModel, Rebalancer
 from .trades import Trade
-from .transactions import Transaction

wbportfolio/models/transactions/claim.py

@@ -259,9 +259,10 @@ class Claim(ReferenceIDMixin, WBModel):
         return f"{self.reference_id} {self.product.name} ({self.bank} - {self.shares:,} shares - {self.date}) "
 
     def save(self, *args, auto_match: bool = True, **kwargs):
-        assert (
-            self.shares is not None or self.nominal_amount is not None
-        ), f"Either shares or nominal amount have to be provided. Shares={self.shares}, Nominal={self.nominal_amount}"
+        if self.shares is None and self.nominal_amount is None:
+            raise ValueError(
+                f"Either shares or nominal amount have to be provided. Shares={self.shares}, Nominal={self.nominal_amount}"
+            )
         if self.product:
             if self.shares is not None:
                 self.nominal_amount = self.shares * self.product.share_price
@@ -447,7 +448,7 @@ class Claim(ReferenceIDMixin, WBModel):
         return self.can_approve()
 
     def auto_match(self) -> Trade | None:
-        SHARES_EPSILON = 1  # share
+        shares_epsilon = 1  # share
         auto_match_trade = None
         # Obvious filtering
         trades = Trade.valid_customer_trade_objects.filter(
@@ -458,7 +459,7 @@ class Claim(ReferenceIDMixin, WBModel):
             trades = trades.filter(underlying_instrument=self.product)
         # Find trades by shares (or remaining to be claimed)
         trades = trades.filter(
-            Q(diff_shares__lte=self.shares + SHARES_EPSILON) & Q(diff_shares__gte=self.shares - SHARES_EPSILON)
+            Q(diff_shares__lte=self.shares + shares_epsilon) & Q(diff_shares__gte=self.shares - shares_epsilon)
         )
         if trades.count() == 1:
             auto_match_trade = trades.first()
@@ -477,7 +478,7 @@ class Claim(ReferenceIDMixin, WBModel):
         # Find trades by external_id
         if not auto_match_trade and self.external_id and trades.count() > 1:
             trades = trades.filter(
-                Q(external_id__icontains=self.external_id) | Q(external_identifier2__icontains=self.external_id)
+                Q(external_id__icontains=self.external_id) | Q(external_id_alternative__icontains=self.external_id)
             )
             if trades.count() == 1:
                 auto_match_trade = trades.first()

wbportfolio/models/transactions/dividends.py

@@ -1,15 +1,52 @@
-from decimal import Decimal
-
 from django.db import models
+from wbcore.contrib.io.mixins import ImportMixin
 
 from wbportfolio.import_export.handlers.dividend import DividendImportHandler
 
-from .transactions import ShareMixin, Transaction
+from .transactions import TransactionMixin
 
 
-class DividendTransaction(Transaction, ShareMixin, models.Model):
+class DividendTransaction(TransactionMixin, ImportMixin, models.Model):
     import_export_handler_class = DividendImportHandler
+
+    class DistributionMethod(models.TextChoices):
+        PAYMENT = "Payment", "Payment"
+        REINVESTMENT = "Reinvestment", "Reinvestment"
+
+    ex_date = models.DateField(
+        verbose_name="Ex-Dividend Date",
+        help_text="The date on which the stock starts trading without the dividend",
+    )
+    record_date = models.DateField(
+        verbose_name="Record Date",
+        help_text="The date on which the holder must own the shares to be eligible for the dividend",
+    )
+    distribution_method = models.CharField(
+        max_length=255, verbose_name="Type", choices=DistributionMethod.choices, default=DistributionMethod.PAYMENT
+    )
     retrocession = models.FloatField(default=1)
+    price = models.DecimalField(
+        max_digits=15,
+        decimal_places=4,
+        help_text="The amount paid per share",
+        verbose_name="DPS",
+    )
+    total_value_gross = models.GeneratedField(
+        expression=models.F("price") * models.F("shares") * models.F("retrocession"),
+        output_field=models.DecimalField(
+            max_digits=20,
+            decimal_places=4,
+        ),
+        db_persist=True,
+    )
 
     def save(self, *args, **kwargs):
-        super().save(*args, factor=Decimal(self.retrocession), **kwargs)
+        self.pre_save()
+        if not self.record_date and self.ex_date:
+            self.record_date = self.ex_date
+        elif self.record_date and not self.ex_date:
+            self.ex_date = self.record_date
+        super().save(*args, **kwargs)
+
+    def __str__(self):
+        return f"{self.total_value} - {self.value_date:%d.%m.%Y} : {str(self.underlying_instrument)} (in {str(self.portfolio)})"

wbportfolio/models/transactions/fees.py

@@ -1,17 +1,17 @@
 import importlib
 from contextlib import suppress
+from decimal import Decimal
 
 from celery import shared_task
 from django.db import models
 from django.db.models import Exists, OuterRef, Q, QuerySet
 from django.dispatch import receiver
+from wbcore.contrib.io.mixins import ImportMixin
 from wbfdm.models.instruments.instrument_prices import InstrumentPrice
 
 from wbportfolio.import_export.handlers.fees import FeesImportHandler
 from wbportfolio.models.products import Product
 
-from .transactions import Transaction
-
 
 class ValidFeesQueryset(QuerySet):
     def filter_only_valid_fees(self) -> QuerySet:
@@ -22,7 +22,7 @@ class ValidFeesQueryset(QuerySet):
             real_fees_exists=Exists(
                 self.filter(
                     transaction_subtype=OuterRef("transaction_subtype"),
-                    linked_product=OuterRef("linked_product"),
+                    product=OuterRef("product"),
                     fee_date=OuterRef("fee_date"),
                     calculated=False,
                 )
@@ -43,7 +43,7 @@ class ValidFeesManager(DefaultFeesManager):
         return super().get_queryset().filter_only_valid_fees()
 
 
-class Fees(Transaction):
+class Fees(ImportMixin, models.Model):
     import_export_handler_class = FeesImportHandler
 
     class Type(models.TextChoices):
@@ -57,31 +57,61 @@ class Fees(Transaction):
     transaction_subtype = models.CharField(
         max_length=255, verbose_name="Fees Type", choices=Type.choices, default=Type.MANAGEMENT
     )
-
-    fee_date = models.DateField()  # needed for indexing
+    fee_date = models.DateField(
+        verbose_name="Fees Date",
+        help_text="The date that this fee was paid.",
+    )  # needed for indexing
+    product = models.ForeignKey(
+        "wbportfolio.Product",
+        related_name="fees",
+        on_delete=models.PROTECT,
+        verbose_name="Product",
+    )
+    currency = models.ForeignKey(
+        "currency.Currency",
+        related_name="fees",
+        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"
+    )
+    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"),
+        output_field=models.DecimalField(
+            max_digits=20,
+            decimal_places=4,
+        ),
+        db_persist=True,
+    )
+    total_value_gross_fx_portfolio = models.GeneratedField(
+        expression=models.F("currency_fx_rate") * models.F("total_value_gross"),
+        output_field=models.DecimalField(
+            max_digits=20,
+            decimal_places=4,
+        ),
+        db_persist=True,
+    )
     calculated = models.BooleanField(
         default=True,
         help_text="A marker whether the fees were calculated or supplied.",
         verbose_name="Is calculated",
     )
-
-    linked_product = models.ForeignKey(
-        "wbportfolio.Product",
-        related_name="transactionfees",
-        on_delete=models.PROTECT,
-        verbose_name="Product",
-    )
+    created = models.DateTimeField(auto_now_add=True)
+    updated = models.DateTimeField(auto_now=True)
 
     class Meta:
         verbose_name = "Fees"
         verbose_name_plural = "Fees"
         indexes = [
-            models.Index(fields=["linked_product"]),
-            models.Index(fields=["transaction_subtype", "linked_product", "fee_date", "calculated"]),
+            models.Index(fields=["product"]),
+            models.Index(fields=["transaction_subtype", "product", "fee_date", "calculated"]),
         ]
         constraints = [
             models.UniqueConstraint(
-                fields=["linked_product", "fee_date", "transaction_subtype", "calculated"], name="unique_fees"
+                fields=["product", "fee_date", "transaction_subtype", "calculated"], name="unique_fees"
             ),
         ]
 
@@ -89,11 +119,14 @@ class Fees(Transaction):
     valid_objects = ValidFeesManager()
 
     def save(self, *args, **kwargs):
-        self.fee_date = self.transaction_date
+        if self.total_value_gross is None and self.total_value is not None:
+            self.total_value_gross = self.total_value
+        elif self.total_value is None and self.total_value_gross is not None:
+            self.total_value = self.total_value_gross
         super().save(*args, **kwargs)
 
     def __str__(self):
-        return f"{self.transaction_date:%d.%m.%Y} - {self.Type[self.transaction_subtype]}: {self.portfolio.name}"
+        return f"{self.fee_date:%d.%m.%Y} - {self.Type[self.transaction_subtype]}: {self.product.name}"
 
     @classmethod
     def get_endpoint_basename(cls):
@@ -111,8 +144,8 @@ class FeeCalculation(models.Model):
             calculation_module = importlib.import_module(import_path)
             for new_fees in calculation_module.fees_calculation(price.id):
                 Fees.objects.update_or_create(
-                    linked_product=new_fees.pop("linked_product"),
-                    transaction_date=new_fees.pop("transaction_date"),
+                    product=new_fees.pop("product"),
+                    fee_date=new_fees.pop("fee_date"),
                     transaction_subtype=new_fees.pop("transaction_subtype"),
                     calculated=True,
                     defaults=new_fees,
@@ -145,10 +178,10 @@ def update_or_create_fees_post(sender, instance, created, raw, **kwargs):
 #         .filter(
 #             transaction_date=instance.transaction_date,
 #             transaction_subtype=instance.transaction_subtype,
-#             linked_product=instance.linked_product,
+#             product=instance.product,
 #         )
 #         .exists()
 #     ):
 #         raise ValueError(
-#             f"A fees object already exists with date, type and product = {instance.transaction_date}, {instance.transaction_subtype}, {instance.linked_product}"
+#             f"A fees object already exists with date, type and product = {instance.transaction_date}, {instance.type}, {instance.product}"
 #         )