wbportfolio 1.43.1__py2.py3-none-any.whl

wbportfolio/models/portfolio_cash_flow.py

@@ -0,0 +1,167 @@
+from contextlib import suppress
+from decimal import Decimal
+
+from django.db import models
+from wbcore.contrib.io.mixins import ImportMixin
+from wbcore.models import WBModel
+from wbportfolio.import_export.handlers.portfolio_cash_flow import (
+    DailyPortfolioCashFlowImportHandler,
+)
+from wbportfolio.models.portfolio_cash_targets import PortfolioCashTarget
+from wbportfolio.models.portfolio_swing_pricings import PortfolioSwingPricing
+
+
+class DailyPortfolioCashFlow(ImportMixin, WBModel):
+    import_export_handler_class = DailyPortfolioCashFlowImportHandler
+    pending = models.BooleanField(default=False)
+
+    portfolio = models.ForeignKey(
+        to="wbportfolio.Portfolio",
+        related_name="daily_cashflows",
+        on_delete=models.CASCADE,
+    )
+    value_date = models.DateField()
+
+    cash = models.DecimalField(max_digits=19, decimal_places=4, blank=True)
+    cash_flow_forecast = models.DecimalField(max_digits=19, decimal_places=4, default=Decimal(0), blank=True)
+    total_assets = models.DecimalField(max_digits=19, decimal_places=4, blank=True)
+
+    min_target_cash_pct = models.DecimalField(max_digits=4, decimal_places=4, default=Decimal(0), blank=True)
+    target_cash_pct = models.DecimalField(max_digits=4, decimal_places=4, default=Decimal(0), blank=True)
+    max_target_cash_pct = models.DecimalField(max_digits=4, decimal_places=4, default=Decimal(0), blank=True)
+
+    swing_pricing = models.ForeignKey(
+        to="wbportfolio.PortfolioSwingPricing",
+        related_name="cash_flow",
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+    )
+
+    estimated_total_assets = models.DecimalField(max_digits=19, decimal_places=4, blank=True)
+    cash_flow_asset_ratio = models.DecimalField(max_digits=5, decimal_places=4, blank=True)
+    true_cash = models.DecimalField(max_digits=19, decimal_places=4, blank=True)
+    cash_pct = models.DecimalField(max_digits=5, decimal_places=4, blank=True)
+    true_cash_pct = models.DecimalField(max_digits=5, decimal_places=4, blank=True)
+    target_cash = models.DecimalField(max_digits=19, decimal_places=4, blank=True)
+    excess_cash = models.DecimalField(max_digits=19, decimal_places=4, blank=True)
+    proposed_rebalancing = models.DecimalField(max_digits=19, decimal_places=4, blank=True, default=Decimal(0))
+    rebalancing = models.DecimalField(max_digits=19, decimal_places=4, blank=True, default=Decimal(0))
+
+    comment = models.TextField(default="", blank=True)
+
+    def save(self, *args, **kwargs):
+        # convert to decimal in case we get floats
+        if isinstance(self.cash_flow_forecast, float):
+            self.cash_flow_forecast = Decimal(self.cash_flow_forecast)
+
+        if isinstance(self.total_assets, float):
+            self.total_assets = Decimal(self.total_assets)
+
+        if isinstance(self.rebalancing, float):
+            self.rebalancing = Decimal(self.rebalancing)
+
+        with suppress(PortfolioCashTarget.DoesNotExist):
+            cash_target = self.portfolio.cash_targets.filter(valid_date__lte=self.value_date).latest("valid_date")
+            self.min_target_cash_pct = cash_target.min_target
+            self.target_cash_pct = cash_target.target
+            self.max_target_cash_pct = cash_target.max_target
+
+        with suppress(PortfolioSwingPricing.DoesNotExist):
+            self.swing_pricing = self.portfolio.swing_pricings.filter(valid_date__lte=self.value_date).latest(
+                "valid_date"
+            )
+
+        with suppress(self.DoesNotExist):
+            if self.total_assets is None or self.pending:
+                self.total_assets = (
+                    self.portfolio.daily_cashflows.filter(value_date__lt=self.value_date)
+                    .latest("value_date")
+                    .estimated_total_assets
+                )
+
+        if self.total_assets is None:
+            self.total_assets = 0
+
+        with suppress(self.DoesNotExist):
+            if self.cash is None or self.pending:
+                earlier = self.portfolio.daily_cashflows.filter(value_date__lt=self.value_date).latest("value_date")
+                self.cash = earlier.true_cash
+
+        if self.cash is None:
+            self.cash = 0
+
+        if self.pending and self.rebalancing:
+            self.cash -= self.rebalancing
+
+        if self.pending:
+            self.estimated_total_assets = self.total_assets + self.cash_flow_forecast
+        elif self.estimated_total_assets is None:
+            self.estimated_total_assets = self.total_assets
+
+        self.cash_flow_asset_ratio = (
+            self.cash_flow_forecast / self.estimated_total_assets
+            if self.estimated_total_assets != Decimal(0)
+            else Decimal(0)
+        )
+        self.true_cash = self.cash + self.cash_flow_forecast
+        self.cash_pct = (
+            self.cash / self.estimated_total_assets if self.estimated_total_assets != Decimal(0) else Decimal(0)
+        )
+        self.true_cash_pct = (
+            self.true_cash / self.estimated_total_assets if self.estimated_total_assets != Decimal(0) else Decimal(0)
+        )
+        self.target_cash = self.estimated_total_assets * self.target_cash_pct
+        self.excess_cash = self.true_cash - self.target_cash
+
+        if self.true_cash_pct < self.min_target_cash_pct or self.true_cash_pct > self.max_target_cash_pct:
+            self.proposed_rebalancing = self.excess_cash
+        elif self.pending:
+            self.proposed_rebalancing = 0
+
+        super().save(*args, **kwargs)
+
+        if self.portfolio.daily_cashflows.filter(value_date__gt=self.value_date).exists():
+            self.portfolio.daily_cashflows.filter(value_date__gt=self.value_date).earliest("value_date").save()
+
+    class Meta:
+        verbose_name = "Daily Portfolio CashFlow"
+        verbose_name_plural = "Daily Portfolio CashFlow"
+        constraints = [
+            models.UniqueConstraint(fields=["portfolio", "value_date"], name="unique_portfolio_value_date"),
+        ]
+        permissions = [("administrate_dailyportfoliocashflow", "Can administrate Daily Portfolio CashFlow")]
+        notification_types = [
+            (
+                "wbportfolio.dailyportfoliocashflow.notify_rebalance",
+                "Rebalancing suggested",
+                "Sends a notification, when the system suggests to rebalance a portfolio due to being outside of the cash target parameters",
+                True,
+                True,
+                False,
+            ),
+            (
+                "wbportfolio.dailyportfoliocashflow.notify_swingpricing",
+                "Swing Pricing Notification",
+                "Sends a notification, when the system detects a future swing pricing event",
+                False,
+                False,
+                False,
+            ),
+        ]
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbportfolio:portfoliocashflow"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbportfolio:portfoliocashflow-list"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{portfolio}}: {{cash}}"

wbportfolio/models/portfolio_cash_targets.py

@@ -0,0 +1,46 @@
+from decimal import Decimal
+
+from django.db import models
+from wbcore.models import WBModel
+
+
+class PortfolioCashTarget(WBModel):
+    """This model stores cash targets for a given portfolio"""
+
+    portfolio = models.ForeignKey(
+        to="wbportfolio.Portfolio",
+        related_name="cash_targets",
+        on_delete=models.CASCADE,
+    )
+
+    valid_date = models.DateField()
+    min_target = models.DecimalField(max_digits=5, decimal_places=4, null=True, blank=True)
+    target = models.DecimalField(max_digits=5, decimal_places=4, default=Decimal(0))
+    max_target = models.DecimalField(max_digits=5, decimal_places=4, null=True, blank=True)
+    comment = models.TextField(default="", blank=True)
+
+    def __str__(self) -> str:
+        return f"{self.portfolio}: {self.target:.2%} ({self.valid_date:%d.%m.%Y})"
+
+    class Meta:
+        verbose_name = "Portfolio Cash Target"
+        verbose_name_plural = "Portfolio Cash Targets"
+        constraints = [
+            models.UniqueConstraint(fields=["portfolio", "valid_date"], name="unique_portfolio_valid_date"),
+        ]
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbportfolio:portfoliocashtarget"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbportfolio:portfoliocashtarget-list"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{portfolio}}: {{target}} ({{valid_date}})"

wbportfolio/models/portfolio_relationship.py

@@ -0,0 +1,135 @@
+from contextlib import suppress
+
+from django.db import models
+from django.db.models import Q
+from django.dispatch import receiver
+from wbcore.signals import pre_merge
+from wbfdm.models import Instrument
+
+
+class PortfolioBankAccountThroughModel(models.Model):
+    class PortfolioBankAccountType(models.TextChoices):
+        CASH = "CASH", "Cash"
+        SECURITIES = "SECURITIES", "Securities"
+
+    portfolio = models.ForeignKey(
+        to="wbportfolio.Portfolio", on_delete=models.CASCADE, related_name="bank_account_through"
+    )
+    bank_account = models.ForeignKey(
+        to="directory.BankingContact", on_delete=models.CASCADE, related_name="portfolio_through"
+    )
+
+    portfolio_bank_account_type = models.CharField(
+        max_length=255, choices=PortfolioBankAccountType.choices, default=PortfolioBankAccountType.CASH
+    )
+
+    def __str__(self) -> str:
+        return f"{self.bank_account}: {self.portfolio} ({self.PortfolioBankAccountType[self.portfolio_bank_account_type].label})"
+
+    class Meta:
+        verbose_name = "Portfolio Bank Account"
+        verbose_name_plural = "Portfolio Bank Accounts"
+
+        constraints = [
+            # Each portfolio and bank account can only be connected once
+            models.UniqueConstraint(
+                fields=["portfolio", "bank_account"],
+                name="unique_portfolio_bank_account",
+            ),
+            # Each portfolio can only have one bank account to hold the securities
+            models.UniqueConstraint(
+                fields=["portfolio"],
+                name="unique_portfolio_bank_account_type",
+                condition=Q(portfolio_bank_account_type="SECURITIES"),
+            ),
+        ]
+
+
+class InstrumentPortfolioThroughModel(models.Model):
+    instrument = models.ForeignKey(
+        "wbfdm.Instrument",
+        on_delete=models.CASCADE,
+        related_name="through_portfolios",
+    )
+    portfolio = models.ForeignKey(
+        "wbportfolio.Portfolio", on_delete=models.CASCADE, related_name="through_instruments"
+    )
+
+    class Meta:
+        unique_together = ("instrument", "portfolio")
+        constraints = [
+            models.UniqueConstraint(fields=["instrument"], name="unique_instrument"),
+            models.UniqueConstraint(fields=["instrument", "portfolio"], name="unique_portfolio_relationship"),
+        ]
+
+    @classmethod
+    def get_portfolio(cls, instrument):
+        with suppress(InstrumentPortfolioThroughModel.DoesNotExist):
+            return InstrumentPortfolioThroughModel.objects.get(instrument=instrument).portfolio
+
+    @classmethod
+    def get_primary_portfolio(cls, instrument):
+        if portfolio := cls.get_portfolio(instrument):
+            if primary_portfolio := portfolio.primary_portfolio:
+                return primary_portfolio
+            return portfolio
+
+
+@receiver(models.signals.class_prepared)
+def add_to_instrument(sender, **kwargs):
+    Instrument.add_to_class("portfolio", property(InstrumentPortfolioThroughModel.get_portfolio))
+    Instrument.add_to_class("primary_portfolio", property(InstrumentPortfolioThroughModel.get_primary_portfolio))
+
+
+class PortfolioInstrumentPreferredClassificationThroughModel(models.Model):
+    portfolio = models.ForeignKey(
+        "wbportfolio.Portfolio", on_delete=models.CASCADE, related_name="preferred_classification_instruments"
+    )
+    instrument = models.ForeignKey(
+        "wbfdm.Instrument",
+        on_delete=models.CASCADE,
+        related_name="preferred_classification_portfolio",
+        limit_choices_to=(models.Q(instrument_type__is_classifiable=True) & models.Q(level=0)),
+    )
+    classification = models.ForeignKey(
+        "wbfdm.Classification",
+        on_delete=models.CASCADE,
+        blank=True,
+        null=True,
+        related_name="preferred_classification_throughs",
+    )
+    classification_group = models.ForeignKey(
+        "wbfdm.ClassificationGroup",
+        on_delete=models.CASCADE,
+        blank=True,
+        null=True,
+        related_name="preferred_classification_group_throughs",
+    )
+
+    def save(self, *args, **kwargs) -> None:
+        if not self.classification_group and self.classification:
+            self.classification_group = self.classification.group
+        return super().save(*args, **kwargs)
+
+    class Meta:
+        verbose_name = "Portfolio Prefered Classification Per Instrument"
+        verbose_name_plural = "Portfolio Prefered Classification Per Instruments"
+        unique_together = ("portfolio", "instrument", "classification_group")
+
+
+@receiver(pre_merge, sender="wbfdm.Instrument")
+def pre_merge_instrument(sender: models.Model, merged_object: "Instrument", main_object: "Instrument", **kwargs):
+    """
+    Reassign all merged instrument preferred classification relationship to the main instrument
+    """
+    for through in PortfolioInstrumentPreferredClassificationThroughModel.objects.filter(instrument=merged_object):
+        if classification := through.classification:
+            PortfolioInstrumentPreferredClassificationThroughModel.objects.get_or_create(
+                portfolio=through.portfolio,
+                instrument=main_object,
+                classification_group=(
+                    through.classification_group if through.classification_group else classification.group
+                ),
+                defaults={"classification": classification},
+            )
+        through.delete()

wbportfolio/models/portfolio_swing_pricings.py

@@ -0,0 +1,51 @@
+from django.db import models
+from django.db.models import Q
+from wbcore.models import WBModel
+
+
+class PortfolioSwingPricing(WBModel):
+    valid_date = models.DateField()
+
+    portfolio = models.ForeignKey(
+        to="wbportfolio.Portfolio",
+        related_name="swing_pricings",
+        on_delete=models.CASCADE,
+    )
+
+    negative_threshold = models.DecimalField(max_digits=4, decimal_places=4)
+    negative_swing_factor = models.DecimalField(max_digits=4, decimal_places=4)
+    positive_threshold = models.DecimalField(max_digits=4, decimal_places=4)
+    positive_swing_factor = models.DecimalField(max_digits=4, decimal_places=4)
+
+    def __str__(self) -> str:
+        return f"{self.portfolio}: {self.negative_swing_factor:.2%}/{self.positive_swing_factor:.2%} ({self.valid_date:%d.%m.%Y})"
+
+    class Meta:
+        verbose_name = "Portfolio Swing Pricing"
+        verbose_name_plural = "Portfolio Swing Pricings"
+        constraints = [
+            models.CheckConstraint(
+                check=Q(negative_threshold__lt=0)
+                & Q(negative_swing_factor__lt=0)
+                & Q(positive_threshold__gt=0)
+                & Q(positive_swing_factor__gt=0),
+                name="value_polarity",
+            ),
+            models.UniqueConstraint(fields=["valid_date", "portfolio"], name="unique_valid_date_portfolio"),
+        ]
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbportfolio:portfolioswingpricing"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbportfolio:portfolioswingpricing-list"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{portfolio}}: {{swing_factor}} ({{valid_date}})"

wbportfolio/models/product_groups.py

@@ -0,0 +1,230 @@
+from decimal import Decimal
+
+import pandas as pd
+from django.db import models
+from django.db.models import F, Q, Sum
+from wbcore.models import WBModel
+from wbfdm.models import InstrumentType
+from wbfdm.models.instruments.instrument_prices import InstrumentPrice
+from wbportfolio.models.products import FeeProductPercentage, Product
+
+from .mixins.instruments import PMSInstrument
+
+
+class ProductGroup(PMSInstrument):
+    class ProductGroupType(models.TextChoices):
+        FUND = "Fund"
+
+    class ProductGroupCategory(models.TextChoices):
+        UCITS = "UCITS", "UCITS"
+        OTHER_FUNDS = "OTHER_FUNDS", "Other funds for traditional investments"
+
+    type = models.CharField(
+        max_length=64,
+        verbose_name="Type",
+        choices=ProductGroupType.choices,
+        default=ProductGroupType.FUND,
+    )
+    category = models.CharField(
+        max_length=64,
+        choices=ProductGroupCategory.choices,
+        default=ProductGroupCategory.UCITS,
+    )
+
+    umbrella = models.CharField(max_length=255, null=True, blank=True)
+    management_company = models.ForeignKey(
+        "directory.Company",
+        related_name="management_company_product_groups",
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+    )
+    depositary = models.ForeignKey(
+        "directory.Company",
+        related_name="depositary_product_groups",
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+    )
+    transfer_agent = models.ForeignKey(
+        "directory.Company",
+        related_name="transfer_agent_product_groups",
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+    )
+    administrator = models.ForeignKey(
+        "directory.Company",
+        related_name="administrator_groups",
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+    )
+    investment_manager = models.ForeignKey(
+        "directory.Company",
+        related_name="investment_manager_groups",
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+    )
+    auditor = models.ForeignKey(
+        "directory.Company",
+        related_name="auditor_groups",
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+    )
+    paying_agent = models.ForeignKey(
+        "directory.Company",
+        related_name="paying_agent_groups",
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+    )
+
+    @property
+    def products(self):  # for backward compatibility
+        return Product.objects.filter(id__in=self.children.values("id"))
+
+    def save(self, *args, **kwargs):
+        self.instrument_type = InstrumentType.objects.get_or_create(
+            key="product_group", defaults={"name": "Product Group", "short_name": "Product Group"}
+        )[0]
+        self.is_managed = True
+        super().save(*args, **kwargs)
+
+    def active_products(self, val_date):
+        return self.products.filter(
+            Q(inception_date__isnull=False)
+            & Q(inception_date__lte=val_date)
+            & (Q(delisted_date__isnull=True) | Q(delisted_date__gt=val_date))
+        )
+
+    def compute_str(self):
+        return f"{self.name} ({self.umbrella})"
+
+    class Meta:
+        verbose_name = "Product Group"
+        verbose_name_plural = "Product Groups"
+
+    def get_fund_product_table(self, val_date):
+        products = self.active_products(val_date).annotate(
+            current_net_value=InstrumentPrice.subquery_closest_value("net_value", val_date, instrument_pk_name="pk"),
+        )
+        df = pd.DataFrame(
+            products.values(
+                "name",
+                "isin",
+                "ticker",
+                "refinitiv_identifier_code",
+                "currency__key",
+                "currency__symbol",
+                "dividend",
+                "minimum_subscription",
+                "inception_date",
+                "current_net_value",
+            )
+        )
+
+        if not df.empty:
+            df["total_performance_fee"] = df["isin"].apply(
+                lambda x: Product.objects.get(isin=x).get_fees_percent(
+                    val_date, fee_type=FeeProductPercentage.Type.PERFORMANCE, net=False
+                )
+            )
+            df["management_fees"] = df["isin"].apply(
+                lambda x: Product.objects.get(isin=x).get_fees_percent(
+                    val_date, fee_type=FeeProductPercentage.Type.MANAGEMENT
+                )
+            )
+            df.management_fees = df.management_fees.apply(lambda x: f"{x:,.2%}" if x is not None else "")
+            df.total_performance_fee = df.total_performance_fee.apply(lambda x: f"{x:,.2%}" if x is not None else "")
+            df.current_net_value = df.current_net_value.apply(lambda x: f"{x:,.2f}" if x is not None else "")
+            df.inception_date = df.inception_date.apply(lambda x: f"{x:%Y-%m-%d}" if x is not None else "")
+
+            df = df[
+                [
+                    "name",
+                    "isin",
+                    "ticker",
+                    "refinitiv_identifier_code",
+                    "currency__key",
+                    "currency__symbol",
+                    "dividend",
+                    "management_fees",
+                    "total_performance_fee",
+                    "minimum_subscription",
+                    "current_net_value",
+                    "inception_date",
+                ]
+            ]
+            df = df.rename(
+                columns={
+                    "name": "share class",
+                    "ticker": "bloomberg",
+                    "currency__key": "currency",
+                    "currency__symbol": "currency symbol",
+                    "minimum_subscription": "min subscription",
+                    "management_fees": "mgmt. fees",
+                    "total_performance_fee": "perf. fees",
+                    "inception_date": "launch date",
+                    "refinitiv_identifier_code": "reuters",
+                    "current_net_value": "price",
+                }
+            )
+
+            return df
+
+    def get_total_fund_aum(self, val_date=None):
+        return Product.annotate_last_aum(
+            Product.objects.filter(parent=self, is_invested=True), val_date=val_date
+        ).aggregate(s=Sum(F("assets_under_management_usd")))["s"] or Decimal(0)
+
+    def total_shares(self, val_date):
+        return sum([product.total_shares(val_date) for product in self.products.all()])
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{name_repr}}"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbportfolio:product_grouprepresentation-list"
+
+
+class ProductGroupRepresentant(WBModel):
+    product_group = models.ForeignKey("ProductGroup", related_name="representants", on_delete=models.CASCADE)
+    representant = models.ForeignKey("directory.Company", on_delete=models.PROTECT)
+    country = models.ForeignKey(
+        "geography.Geography", on_delete=models.PROTECT, limit_choices_to={"level": 1}, null=True, blank=True
+    )
+
+    def __str__(self):
+        return f"{self.product_group.identifier} {self.representant.name} ({self.country.name})"
+
+    class Meta:
+        verbose_name = "Product Group Representant"
+        verbose_name_plural = "Product Group Representants"
+        constraints = [
+            models.UniqueConstraint(fields=("product_group", "country"), name="unique_country_product_group")
+        ]
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{representant}} {{country}}"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return None
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbportfolio:product_group"