wbportfolio 1.43.1__py2.py3-none-any.whl

wbportfolio/migrations/0067_assetposition_unique_asset_position.py

@@ -0,0 +1,77 @@
+# Generated by Django 5.0.8 on 2024-10-01 14:43
+
+from collections import defaultdict
+from contextlib import suppress
+
+from django.db import migrations, models
+from tqdm import tqdm
+
+
+def remove_duplicates(apps, schema_editor):
+    changed_portfolios = defaultdict(set)
+    from wbportfolio.models import Portfolio
+
+    AssetPosition = apps.get_model("wbportfolio", "AssetPosition")
+    for row in (
+        AssetPosition.objects.values("portfolio", "date", "underlying_instrument", "portfolio_created")
+        .annotate(c=models.Count("*"))
+        .filter(c__gt=1)
+    ):
+        with suppress(Exception):
+            qs = AssetPosition.objects.filter(
+                date=row["date"],
+                portfolio=row["portfolio"],
+                underlying_instrument=row["underlying_instrument"],
+                portfolio_created=row["portfolio_created"],
+            )
+            qs.filter(weighting=0).delete()
+            base_p = qs.first()
+            for a in qs.exclude(id=base_p.id):
+                if (
+                    abs(base_p.weighting / a.weighting - 1) < 0.02
+                    or (a.import_source is None and a.portfolio_created is None)
+                    or (a.portfolio.id == 117 and a.underlying_instrument.id == 214)
+                ):
+                    changed_portfolios[a.portfolio].add(a.date)
+                    a.delete()
+            if base_p.import_source and (
+                qs.filter(import_source=base_p.import_source).count() > 1
+                or (base_p.portfolio.id == 123 and base_p.underlying_instrument.id == 214)
+            ):
+                base_p.weighting += qs.aggregate(c=models.Sum("weighting"))["c"]
+                base_p.shares += qs.aggregate(c=models.Sum("shares"))["c"]
+                base_p.save()
+                changed_portfolios[base_p.portfolio].add(base_p.date)
+                qs.filter(import_source=base_p.import_source).delete()
+
+    # Normalizing portfolio weights
+    for portfolio, dates in tqdm(changed_portfolios.items()):
+        portfolio = Portfolio.all_objects.get(id=portfolio.id)
+        for _d in dates:
+            portfolio.change_at_date(_d, recompute_weighting=True, force_recompute_weighting=True, synchronize=False)
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("currency", "0001_initial"),
+        ("io", "0007_alter_exportsource_query_params"),
+        ("wbfdm", "0026_instrument_is_cash_equivalent"),
+        ("wbportfolio", "0066_assetposition_initial_shares_at_custodian_and_more"),
+    ]
+
+    operations = [
+        migrations.RunSQL(
+            sql="SET CONSTRAINTS ALL IMMEDIATE;",
+        ),
+        migrations.RunPython(remove_duplicates),
+        migrations.RunSQL(
+            sql="SET CONSTRAINTS ALL DEFERRED;",
+        ),
+        migrations.AddConstraint(
+            model_name="assetposition",
+            constraint=models.UniqueConstraint(
+                fields=("portfolio", "date", "underlying_instrument", "portfolio_created"),
+                name="unique_asset_position",
+            ),
+        ),
+    ]

wbportfolio/migrations/0068_trade_internal_trade_trade_marked_as_internal_and_more.py

@@ -0,0 +1,59 @@
+# Generated by Django 5.0.9 on 2024-10-16 12:15
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("wbportfolio", "0067_assetposition_unique_asset_position"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="trade",
+            name="internal_trade",
+            field=models.OneToOneField(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.SET_NULL,
+                related_name="internal_subscription_redemption_trade",
+                to="wbportfolio.trade",
+            ),
+        ),
+        migrations.AddField(
+            model_name="trade",
+            name="marked_as_internal",
+            field=models.BooleanField(
+                default=False,
+                help_text="If this is checked, then this subscription or redemption is considered internal and will not be considered in any AUM computation",
+                verbose_name="Internal",
+            ),
+        ),
+        migrations.AddConstraint(
+            model_name="trade",
+            constraint=models.CheckConstraint(
+                check=models.Q(
+                    ("marked_as_internal", False),
+                    models.Q(
+                        ("marked_as_internal", True), ("transaction_subtype__in", ["REDEMPTION", "SUBSCRIPTION"])
+                    ),
+                    _connector="OR",
+                ),
+                name="marked_as_internal_only_for_subred",
+            ),
+        ),
+        migrations.AddConstraint(
+            model_name="trade",
+            constraint=models.CheckConstraint(
+                check=models.Q(
+                    ("internal_trade__isnull", True),
+                    models.Q(
+                        ("internal_trade__isnull", False), ("transaction_subtype__in", ["REDEMPTION", "SUBSCRIPTION"])
+                    ),
+                    _connector="OR",
+                ),
+                name="internal_trade_set_only_for_subred",
+            ),
+        ),
+    ]

wbportfolio/migrations/0069_remove_portfolio_is_invested_and_more.py

@@ -0,0 +1,56 @@
+# Generated by Django 5.0.9 on 2024-10-18 07:35
+
+from datetime import date, timedelta
+
+import django.contrib.postgres.fields.ranges
+from django.db import migrations
+from psycopg.types.range import DateRange
+
+
+def migrate_is_invested(apps, schema_editor):
+    Portfolio = apps.get_model("wbportfolio", "Portfolio")
+    from wbportfolio.models import Product
+
+    for portfolio in Portfolio.objects.filter(is_invested=True):
+        if portfolio.instruments.exists():
+            min_inception_date = portfolio.instruments.earliest("inception_date").inception_date
+        else:
+            min_inception_date = date.min
+        portfolio.invested_timespan = DateRange(min_inception_date if min_inception_date else date.min, date.max)
+        portfolio.save()
+    for product in Product.objects.filter(
+        portfolios__in=Portfolio.objects.filter(is_invested=False).values("id")
+    ).distinct():
+        portfolio = product.portfolio
+        if product.delisted_date:
+            portfolio.invested_timespan = DateRange(product.inception_date, product.delisted_date)
+        else:
+            portfolio.invested_timespan = DateRange(
+                product.inception_date if product.inception_date else date.min,
+                product.primary_portfolio.assets.filter(underlying_instrument__instrument_type__key="product")
+                .earliest("date")
+                .date
+                - timedelta(days=1),
+            )
+        portfolio.save()
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("wbportfolio", "0068_trade_internal_trade_trade_marked_as_internal_and_more"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="portfolio",
+            name="invested_timespan",
+            field=django.contrib.postgres.fields.ranges.DateRangeField(
+                blank=True, help_text="Define when this portfolio is considered invested", null=True
+            ),
+        ),
+        migrations.RunPython(migrate_is_invested),
+        migrations.RemoveField(
+            model_name="portfolio",
+            name="is_invested",
+        ),
+    ]

wbportfolio/migrations/0070_remove_assetposition_unique_asset_position_and_more.py

@@ -0,0 +1,82 @@
+# Generated by Django 5.0.9 on 2024-11-06 13:31
+
+from collections import defaultdict
+from contextlib import suppress
+
+from django.db import migrations, models
+from tqdm import tqdm
+
+
+def remove_duplicates(apps, schema_editor):
+    changed_portfolios = defaultdict(set)
+    from wbportfolio.models import Portfolio
+
+    AssetPosition = apps.get_model("wbportfolio", "AssetPosition")
+    for row in (
+        AssetPosition.objects.values("portfolio", "date", "underlying_instrument", "portfolio_created")
+        .annotate(c=models.Count("*"))
+        .filter(c__gt=1)
+    ):
+        with suppress(Exception):
+            qs = AssetPosition.objects.filter(
+                date=row["date"],
+                portfolio=row["portfolio"],
+                underlying_instrument=row["underlying_instrument"],
+                portfolio_created=row["portfolio_created"],
+            )
+            qs.filter(weighting=0).delete()
+            base_p = qs.first()
+            for a in qs.exclude(id=base_p.id):
+                if (
+                    abs(base_p.weighting / a.weighting - 1) < 0.02
+                    or (a.import_source is None and a.portfolio_created is None)
+                    or (a.portfolio.id == 117 and a.underlying_instrument.id == 214)
+                ):
+                    changed_portfolios[a.portfolio].add(a.date)
+                    a.delete()
+            if base_p.import_source and (
+                qs.filter(import_source=base_p.import_source).count() > 1
+                or (base_p.portfolio.id == 123 and base_p.underlying_instrument.id == 214)
+            ):
+                base_p.weighting += qs.aggregate(c=models.Sum("weighting"))["c"]
+                base_p.shares += qs.aggregate(c=models.Sum("shares"))["c"]
+                base_p.save()
+                changed_portfolios[base_p.portfolio].add(base_p.date)
+                qs.filter(import_source=base_p.import_source).delete()
+
+    # Normalizing portfolio weights
+    for portfolio, dates in tqdm(changed_portfolios.items()):
+        portfolio = Portfolio.all_objects.get(id=portfolio.id)
+        for _d in dates:
+            portfolio.change_at_date(_d, recompute_weighting=True, force_recompute_weighting=True, synchronize=False)
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("currency", "0001_initial"),
+        ("io", "0007_alter_exportsource_query_params"),
+        ("wbfdm", "0027_remove_instrument_unique_ric_and_more"),
+        ("wbportfolio", "0069_remove_portfolio_is_invested_and_more"),
+    ]
+
+    operations = [
+        migrations.RemoveConstraint(
+            model_name="assetposition",
+            name="unique_asset_position",
+        ),
+        migrations.RunSQL(
+            sql="SET CONSTRAINTS ALL IMMEDIATE;",
+        ),
+        migrations.RunPython(remove_duplicates),
+        migrations.RunSQL(
+            sql="SET CONSTRAINTS ALL DEFERRED;",
+        ),
+        migrations.AddConstraint(
+            model_name="assetposition",
+            constraint=models.UniqueConstraint(
+                fields=("portfolio", "date", "underlying_instrument", "portfolio_created"),
+                name="unique_asset_position",
+                nulls_distinct=False,
+            ),
+        ),
+    ]

wbportfolio/migrations/0071_alter_trade_options_alter_trade_order.py

@@ -0,0 +1,22 @@
+# Generated by Django 5.0.9 on 2024-11-11 11:59
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("wbportfolio", "0070_remove_assetposition_unique_asset_position_and_more"),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name="trade",
+            options={"ordering": ("order",), "verbose_name": "Trade", "verbose_name_plural": "Trades"},
+        ),
+        migrations.AlterField(
+            model_name="trade",
+            name="order",
+            field=models.PositiveIntegerField(db_index=True, default=0, editable=False, verbose_name="order"),
+            preserve_default=False,
+        ),
+    ]

wbportfolio/models/__init__.py

@@ -0,0 +1,26 @@
+# Import CRM relevant data
+
+from .adjustments import Adjustment
+from .asset import AssetPosition, AssetPositionGroupBy
+from .custodians import Custodian
+from .products import Product, FeeProductPercentage
+from .indexes import Index
+from .product_groups import ProductGroup, ProductGroupRepresentant
+from .portfolio_relationship import (
+    PortfolioInstrumentPreferredClassificationThroughModel,
+    InstrumentPortfolioThroughModel,
+    PortfolioBankAccountThroughModel,
+)
+from .portfolio import Portfolio, PortfolioPortfolioThroughModel
+from .portfolio_cash_targets import PortfolioCashTarget
+from .portfolio_cash_flow import DailyPortfolioCashFlow
+from .portfolio_swing_pricings import PortfolioSwingPricing
+from .registers import Register
+from .roles import PortfolioRole
+from .synchronization import (
+    PortfolioSynchronization,
+    PriceComputation,
+    SynchronizationTask,
+)
+from .transactions import *
+from .reconciliations import AccountReconciliation, AccountReconciliationLine

wbportfolio/models/adjustments.py

@@ -0,0 +1,246 @@
+import datetime
+import logging
+import operator
+from decimal import Decimal
+from functools import reduce
+from typing import Optional
+
+import numpy as np
+from celery import chain, shared_task
+from django.db import models
+from django.db.models.signals import post_delete, post_save
+from django.dispatch import receiver
+from django_fsm import FSMField, transition
+from pandas.tseries.offsets import BDay
+from wbcore.contrib.authentication.models import User
+from wbcore.contrib.icons import WBIcon
+from wbcore.contrib.io.mixins import ImportMixin
+from wbcore.contrib.notifications.dispatch import send_notification
+from wbcore.enums import RequestType
+from wbcore.metadata.configs.buttons import ActionButton
+from wbcore.signals import pre_merge
+from wbfdm.models.instruments.instruments import Instrument, import_prices_as_task
+from wbportfolio.import_export.handlers.adjustment import AdjustmentImportHandler
+from wbportfolio.models.roles import PortfolioRole
+
+logger = logging.getLogger(__name__)
+
+
+class Adjustment(ImportMixin, models.Model):
+    import_export_handler_class = AdjustmentImportHandler
+
+    class Status(models.TextChoices):
+        PENDING = "PENDING", "Pending"
+        APPLIED = "APPLIED", "Applied"
+        DENIED = "DENIED", "Denied"
+
+    status = FSMField(default=Status.PENDING, choices=Status.choices, verbose_name="Status")
+
+    date = models.DateField(verbose_name="Executive Date")
+    instrument = models.ForeignKey(
+        "wbfdm.Instrument",
+        on_delete=models.CASCADE,
+        related_name="pms_adjustments",
+        limit_choices_to=models.Q(("children__isnull", True)),
+    )
+    factor = models.DecimalField(default=Decimal(1), max_digits=30, decimal_places=17, verbose_name="Factor")
+    cumulative_factor = models.DecimalField(
+        default=Decimal(1), max_digits=30, decimal_places=17, verbose_name="Cumulative Factor"
+    )
+    last_handler = models.ForeignKey(
+        "directory.Person", blank=True, null=True, on_delete=models.SET_NULL, related_name="last_handled_adjustments"
+    )
+
+    def __str__(self) -> str:
+        return f"Instrument {str(self.instrument)} (date: {self.date}, factor: {self.factor})"
+
+    @property
+    def adjustment_date(self) -> datetime.date:
+        return (self.date - BDay(1)).date()
+
+    def save(self, *args, **kwargs):
+        if not self.cumulative_factor or self.cumulative_factor == Decimal(1):
+            self.cumulative_factor = self.get_cumulative_factor()
+        super().save(*args, **kwargs)
+
+    def get_cumulative_factor(self) -> Decimal:
+        applied_parent_adjustments_factors = list(
+            Adjustment.objects.exclude(id=self.id)
+            .filter(status=self.Status.APPLIED, instrument=self.instrument, date__gte=self.date)
+            .values_list("factor", flat=True)
+        )
+        return Decimal(np.prod([*applied_parent_adjustments_factors]))
+
+    def automatically_applied_adjustments_on_assets(self) -> bool:
+        return reduce(operator.or_, [1 / self.factor % i == 0 for i in range(2, 5)])
+
+    def apply_adjustment_on_assets(self):
+        self.instrument.assets.filter(
+            models.Q(date__lte=self.adjustment_date)
+            | (models.Q(applied_adjustment__isnull=True) & models.Q(applied_adjustment__date__lt=self.date))
+        ).update(applied_adjustment=self)
+
+    def revert_adjustment_on_assets(self):
+        self.adjustmented_assets.update(applied_adjustment=None)
+        future_adjustments = self.instrument.pms_adjustments.filter(date__gt=self.date)
+        if future_adjustments.exists():
+            future_adjustments.earliest(
+                "date"
+            ).apply_adjustment_on_assets()  # We reevalute the next future adjustment in order to check if this one can replace the reverted adjustment
+        self.status = self.Status.PENDING
+        self.save()
+
+    @transition(
+        field=status,
+        source=[Status.PENDING],
+        target=Status.APPLIED,
+        permission=lambda instance, user: PortfolioRole.is_portfolio_manager(user.profile),
+        custom={
+            "_transition_button": ActionButton(
+                method=RequestType.PATCH,
+                identifiers=("wbportfolio:adjustment",),
+                icon=WBIcon.APPROVE.icon,
+                key="apply",
+                label="Apply",
+                action_label="Apply",
+                # description_fields="<p>Start: {{start}}</p><p>End: {{end}}</p><p>Title: {{title}}</p>",
+            )
+        },
+    )
+    def apply(self, by: Optional["User"] = None, description: Optional[str] = None, **kwargs):
+        if profile := getattr(by, "profile", None):
+            self.last_handler = profile
+        apply_adjustment_on_assets_as_task.delay(self.id)
+
+    @transition(
+        field=status,
+        source=[Status.PENDING],
+        target=Status.DENIED,
+        permission=lambda instance, user: PortfolioRole.is_portfolio_manager(user.profile),
+        custom={
+            "_transition_button": ActionButton(
+                method=RequestType.PATCH,
+                identifiers=("wbportfolio:adjustment",),
+                icon=WBIcon.DENY.icon,
+                key="deny",
+                label="Deny",
+                action_label="Deny",
+                # description_fields="<p>Start: {{start}}</p><p>End: {{end}}</p><p>Title: {{title}}</p>",
+            )
+        },
+    )
+    def deny(self, by=None, description=None, **kwargs):
+        if profile := getattr(by, "profile", None):
+            self.last_handler = profile
+
+    @transition(
+        field=status,
+        source=[Status.APPLIED],
+        target=Status.PENDING,
+        permission=lambda instance, user: PortfolioRole.is_portfolio_manager(user.profile),
+        custom={
+            "_transition_button": ActionButton(
+                method=RequestType.PATCH,
+                identifiers=("wbportfolio:adjustment",),
+                icon=WBIcon.UNDO.icon,
+                key="revert",
+                label="Revert",
+                action_label="Revert",
+            )
+        },
+    )
+    def revert(self, by=None, description=None, **kwargs):
+        if profile := getattr(by, "profile", None):
+            self.last_handler = profile
+        revert_adjustment_on_assets_as_task.delay(self.id)
+
+    def import_instrument_prices(self):
+        # If the adjusted instrument is not within any portfolio, we automatically approve (and applied) the adjustments
+        # We reimport prices when a adjustment comes in, not really the most efficient but at least, we are sure we keep having corrected price
+        chain(
+            import_prices_as_task.si(self.instrument.id, clear=True),
+            post_adjustment_on_prices.si(self.id, automatically_confirm_approve_adjustment_on_assets=True),
+        ).apply_async()
+
+    class Meta:
+        verbose_name = "Datum Adjustment"
+        verbose_name_plural = "Data Adjustment"
+        unique_together = ("date", "instrument")
+        indexes = [
+            models.Index(
+                name="instrument_adjustment_idx",
+                fields=["instrument", "-date"],
+            )
+        ]
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbportfolio:adjustment"
+
+
+# Shared tasks
+
+
+@shared_task(queue="portfolio")
+def apply_adjustment_on_assets_as_task(adjustment_id):
+    adjustment = Adjustment.objects.get(id=adjustment_id)
+    adjustment.apply_adjustment_on_assets()
+
+
+@shared_task(queue="portfolio")
+def revert_adjustment_on_assets_as_task(adjustment_id):
+    adjustment = Adjustment.objects.get(id=adjustment_id)
+    adjustment.revert_adjustment_on_assets()
+
+
+@shared_task(queue="portfolio")
+def post_adjustment_on_prices(adjustment_id, automatically_confirm_approve_adjustment_on_assets: bool | None = False):
+    # We just notified the concerned users that a adjustment has been processed, prices have been reimported and as there
+    # are assets on the instrument, manually confirmation is needed before apply the adjustment
+    adjustment = Adjustment.objects.get(id=adjustment_id)
+    if adjustment.instrument.assets.filter(date__lte=adjustment.date).exists():
+        if (
+            adjustment.automatically_applied_adjustments_on_assets()
+            or automatically_confirm_approve_adjustment_on_assets
+        ):
+            adjustment.apply_adjustment_on_assets()
+            adjustment.status = Adjustment.Status.APPLIED
+        else:
+            for user in User.objects.filter(profile__in=PortfolioRole.portfolio_managers()):
+                send_notification(
+                    code="wbportfolio.adjustment.add",
+                    title="A new adjustment was imported",
+                    body=f"A adjustment for {str(adjustment.instrument)} with ex Date  {adjustment.date} and factor {adjustment.factor} was imported. Please confirm (to apply) or deny it.",
+                    user=user,
+                    reverse_name="wbportfolio:adjustment-detail",
+                    reverse_args=[adjustment.id],
+                )
+    else:
+        adjustment.status = Adjustment.Status.APPLIED
+    adjustment.save()
+
+
+# Receivers
+
+
+@receiver(post_delete, sender=Adjustment)
+def post_delete_adjustment(sender, instance, **kwargs):
+    for adjustment in Adjustment.objects.filter(instrument=instance.instrument).order_by("date"):
+        adjustment.save()
+
+
+@receiver(post_save, sender="wbportfolio.Adjustment")
+def post_save_adjustment(sender, instance, created, raw, **kwargs):
+    if created and (instance.instrument.assets.exists() or instance.instrument.prices.exists()):
+        instance.import_instrument_prices()
+
+
+@receiver(pre_merge, sender="wbfdm.Instrument")
+def pre_merge_instrument(sender: models.Model, merged_object: "Instrument", main_object: "Instrument", **kwargs):
+    """
+    Simply reassign the adjustments of the merged instrument to the main instrument if they don't already exist for that day, otherwise simply delete them
+    """
+    merged_object.pms_adjustments.annotate(
+        already_exists=models.Exists(Adjustment.objects.filter(date=models.OuterRef("date"), instrument=main_object))
+    ).filter(already_exists=True).delete()
+    merged_object.pms_adjustments.update(instrument=main_object)