wbportfolio 1.47.1__py2.py3-none-any.whl → 1.49.0__py2.py3-none-any.whl

wbportfolio/contrib/company_portfolio/tasks.py

@@ -1,11 +1,13 @@
 from datetime import date
 
 from celery import shared_task
+from django.db.models import Exists, OuterRef
 from tqdm import tqdm
 from wbcore.contrib.currency.models import CurrencyFXRates
-from wbcore.contrib.directory.models import Company, Entry
+from wbcore.contrib.directory.models import Company
+from wbcrm.models import Account
 
-from .models import Updater
+from .models import CompanyPortfolioData, Updater
 
 
 @shared_task(queue="portfolio")
@@ -13,7 +15,9 @@ def update_all_portfolio_data(val_date: date | None = None):
     if not val_date:
         val_date = CurrencyFXRates.objects.latest("date").date
     updater = Updater(val_date)
-    account_owners = Entry.objects.filter(accounts__isnull=False)
-    qs = Company.objects.filter(id__in=account_owners)
+    qs = Company.objects.annotate(
+        has_account=Exists(Account.objects.filter(owner=OuterRef("pk"))),
+        has_portfolio_data=Exists(CompanyPortfolioData.objects.filter(company=OuterRef("pk"))),
+    )
     for company in tqdm(qs, total=qs.count()):
         updater.update_company_data(company)

wbportfolio/dynamic_preferences_registry.py

@@ -56,3 +56,12 @@ class AccountHoldingReconciliationNotificationBodyUpdate(LongStringPreference):
     section = portfolio
     name = "account_holding_reconciliation_notification_body_update"
     default = """A reconcilation has been updated and requires your review. Please review the reconciliation for the account {account} on {reconciliation_date}."""
+
+
+@global_preferences_registry.register
+class ProductTerminationNoticePeriod(IntegerPreference):
+    section = portfolio
+    name = "product_termination_notice_period"
+    default = 6 * 30  # approx 6 months
+
+    verbose_name = "Product Termination notice period"

wbportfolio/factories/__init__.py

@@ -9,18 +9,16 @@ from .claim import (
 from .custodians import CustodianFactory
 from .dividends import DividendTransactionsFactory
 from .fees import FeesFactory
-from wbfdm.factories.instrument_prices import InstrumentPriceFactory
 from .portfolios import (
     InstrumentPortfolioThroughModelFactory,
     ModelPortfolioFactory,
-    ModelPortfolioWithBaseProductFactory,
     PortfolioFactory,
 )
 from .portfolio_swing_pricings import PortfolioSwingPricingFactory
 from .portfolio_cash_targets import PortfolioCashTargetFactory
 from .portfolio_cash_flow import DailyPortfolioCashFlowFactory
 from .product_groups import ProductGroupFactory, ProductGroupRepresentantFactory
-from .products import IndexProductFactory, ProductFactory, WhiteLabelProductFactory
+from .products import IndexProductFactory, ProductFactory, WhiteLabelProductFactory, ModelPortfolioWithBaseProductFactory
 from .reconciliations import AccountReconciliationFactory, AccountReconciliationLineFactory
 from .roles import ManagerPortfolioRoleFactory, ProductPortfolioRoleFactory
 from .trades import CustomerTradeFactory, TradeFactory, TradeProposalFactory

wbportfolio/factories/portfolios.py

@@ -9,8 +9,6 @@ from wbportfolio.models import (
     PortfolioPortfolioThroughModel,
 )
 
-from .products import ProductFactory
-
 
 class PortfolioFactory(factory.django.DjangoModelFactory):
     class Meta:
@@ -43,16 +41,6 @@ class ModelPortfolioFactory(PortfolioFactory):
         )
 
 
-class ModelPortfolioWithBaseProductFactory(ModelPortfolioFactory):
-    @factory.post_generation
-    def create_instrument(self, create, extracted, **kwargs):
-        if create:
-            instrument = ProductFactory.create()
-            InstrumentPortfolioThroughModel.objects.update_or_create(
-                instrument=instrument, defaults={"portfolio": self}
-            )
-
-
 class InstrumentPortfolioThroughModelFactory(factory.django.DjangoModelFactory):
     instrument = factory.SubFactory("wbportfolio.factories.ProductFactory")
     portfolio = factory.SubFactory("wbportfolio.factories.PortfolioFactory")

wbportfolio/factories/product_groups.py

@@ -1,7 +1,8 @@
 import factory
 from wbfdm.factories.instruments import InstrumentFactory
 
-from wbportfolio.models import ProductGroup, ProductGroupRepresentant
+from wbportfolio.factories import PortfolioFactory
+from wbportfolio.models import InstrumentPortfolioThroughModel, ProductGroup, ProductGroupRepresentant
 
 
 class ProductGroupFactory(InstrumentFactory):
@@ -19,6 +20,12 @@ class ProductGroupFactory(InstrumentFactory):
     auditor = factory.SubFactory("wbcore.contrib.directory.factories.entries.CompanyFactory")
     paying_agent = factory.SubFactory("wbcore.contrib.directory.factories.entries.CompanyFactory")
 
+    @factory.post_generation
+    def create_initial_portfolio(product_group, *args, **kwargs):
+        if product_group.id and not product_group.portfolios.exists():
+            portfolio = PortfolioFactory.create()
+            InstrumentPortfolioThroughModel.objects.create(instrument=product_group, portfolio=portfolio)
+
 
 class ProductGroupRepresentantFactory(factory.django.DjangoModelFactory):
     class Meta:

wbportfolio/factories/products.py

@@ -4,6 +4,8 @@ import factory
 from wbcore.contrib.directory.factories.entries import CompanyFactory
 from wbfdm.factories.instruments import InstrumentFactory, InstrumentTypeFactory
 
+from wbportfolio.factories import ModelPortfolioFactory, PortfolioFactory
+from wbportfolio.models import InstrumentPortfolioThroughModel
 from wbportfolio.models.products import (
     AssetClass,
     InvestmentIndex,
@@ -37,6 +39,12 @@ class ProductFactory(InstrumentFactory):
     external_webpage = factory.Faker("url")
     instrument_type = factory.LazyAttribute(lambda o: InstrumentTypeFactory.create(name="Product", key="product"))
 
+    @factory.post_generation
+    def create_initial_portfolio(product, *args, **kwargs):
+        if product.id and not product.portfolios.exists():
+            portfolio = PortfolioFactory.create()
+            InstrumentPortfolioThroughModel.objects.create(instrument=product, portfolio=portfolio)
+
     # wbportfolio = factory.SubFactory(PortfolioFactory)
     # portfolio_computed = factory.SubFactory(PortfolioFactory)
 
@@ -55,3 +63,13 @@ class WhiteLabelProductFactory(ProductFactory):
 
 class IndexProductFactory(ProductFactory):
     pass
+
+
+class ModelPortfolioWithBaseProductFactory(ModelPortfolioFactory):
+    @factory.post_generation
+    def create_instrument(self, create, extracted, **kwargs):
+        if create:
+            instrument = ProductFactory.create()
+            InstrumentPortfolioThroughModel.objects.update_or_create(
+                instrument=instrument, defaults={"portfolio": self}
+            )

wbportfolio/factories/trades.py

@@ -1,11 +1,15 @@
 import random
 
 import factory
+from faker import Faker
+from pandas._libs.tslibs.offsets import BDay
 
 from wbportfolio.models import Trade, TradeProposal
 
 from .transactions import TransactionFactory
 
+fake = Faker()
+
 
 class TradeFactory(TransactionFactory):
     class Meta:
@@ -22,7 +26,7 @@ class TradeProposalFactory(factory.django.DjangoModelFactory):
     class Meta:
         model = TradeProposal
 
-    trade_date = factory.Faker("date_object")
+    trade_date = factory.LazyAttribute(lambda o: (fake.date_object() + BDay(1)).date())
     comment = factory.Faker("paragraph")
     portfolio = factory.SubFactory("wbportfolio.factories.PortfolioFactory")
     creator = factory.SubFactory("wbcore.contrib.directory.factories.PersonFactory")

wbportfolio/import_export/handlers/trade.py

@@ -24,6 +24,7 @@ class TradeImportHandler(ImportExportHandler):
         self.instrument_handler = InstrumentImportHandler(self.import_source)
         self.register_handler = RegisterImportHandler(self.import_source)
         self.currency_handler = CurrencyImportHandler(self.import_source)
+        self.trade_proposals = set()
 
     def _data_changed(self, _object, change_data: Dict[str, Any], initial_data: Dict[str, Any], **kwargs):
         if (new_register := change_data.get("register")) and (current_register := _object.register):
@@ -42,6 +43,7 @@ class TradeImportHandler(ImportExportHandler):
 
         if trade_proposal_id := data.pop("trade_proposal_id", None):
             trade_proposal = TradeProposal.objects.get(id=trade_proposal_id)
+            self.trade_proposals.add(trade_proposal)
             data["value_date"] = trade_proposal.last_effective_date
             data["transaction_date"] = trade_proposal.trade_date
             data["trade_proposal"] = trade_proposal
@@ -180,6 +182,12 @@ class TradeImportHandler(ImportExportHandler):
             if instrument.instrument_type.key == "product":
                 update_outstanding_shares_as_task.delay(instrument.id)
 
+        # if the trade import relates to a trade proposal, we reset the TP after the import to ensure it contains the deleted positions (often forgotten by user)
+        for changed_trade_proposal in self.trade_proposals:
+            changed_trade_proposal.reset_trades(
+                target_portfolio=changed_trade_proposal._build_dto().convert_to_portfolio()
+            )
+
     def _post_processing_updated_object(self, _object):
         if _object.marked_for_deletion:
             _object.marked_for_deletion = False

wbportfolio/import_export/resources/trades.py

@@ -5,7 +5,7 @@ from import_export.widgets import ForeignKeyWidget
 from wbcore.contrib.io.resources import FilterModelResource
 from wbfdm.models import Instrument
 
-from wbportfolio.models import Trade, TradeProposal
+from wbportfolio.models import Trade
 
 fake = Faker()
 
@@ -15,48 +15,37 @@ class TradeProposalTradeResource(FilterModelResource):
     Trade Resource class to use to import trade from the trade proposal
     """
 
-    def __init__(self, **kwargs):
-        self.trade_proposal = TradeProposal.objects.get(pk=kwargs["trade_proposal_id"])
-        super().__init__(**kwargs)
-
-    def before_import(self, dataset, **kwargs):
-        Trade.objects.filter(trade_proposal=self.trade_proposal).delete()
-
-    def get_or_init_instance(self, instance_loader, row):
-        try:
-            return Trade.objects.get(
-                trade_proposal=self.trade_proposal, underlying_instrument=row["underlying_instrument"]
-            )
-        except Trade.DoesNotExist:
-            return Trade(
-                trade_proposal=self.trade_proposal,
-                underlying_instrument=row["underlying_instrument"],
-                transaction_subtype=Trade.Type.BUY if row["weighting"] > 0 else Trade.Type.SELL,
-                currency=row["underlying_instrument"].currency,
-                transaction_date=self.trade_proposal.trade_date,
-                portfolio=self.trade_proposal.portfolio,
-                weighting=row["weighting"],
-                status=Trade.Status.DRAFT,
-            )
-
     DUMMY_FIELD_MAP = {
-        "underlying_instrument": lambda: rstr.xeger("([A-Z]{2}[A-Z0-9]{9}[0-9]{1})"),
+        "underlying_instrument__isin": lambda: rstr.xeger("([A-Z]{2}[A-Z0-9]{9}[0-9]{1})"),
+        "underlying_instrument__ticker": "AAA",
+        "underlying_instrument__name": "stock name",
         "weighting": 1.0,
         "shares": 1000.2536,
         "comment": lambda: fake.sentence(),
         "order": 1,
     }
-    underlying_instrument = fields.Field(
-        column_name="underlying_instrument",
+    underlying_instrument__isin = fields.Field(
+        column_name="underlying_instrument__isin",
         attribute="underlying_instrument",
         widget=ForeignKeyWidget(Instrument, field="isin"),
     )
+    underlying_instrument__name = fields.Field(
+        column_name="underlying_instrument__name",
+        attribute="underlying_instrument",
+        widget=ForeignKeyWidget(Instrument, field="name"),
+    )
+    underlying_instrument__ticker = fields.Field(
+        column_name="underlying_instrument__ticker",
+        attribute="underlying_instrument",
+        widget=ForeignKeyWidget(Instrument, field="ticker"),
+    )
 
     class Meta:
-        import_id_fields = ("underlying_instrument",)
         fields = (
             "id",
-            "underlying_instrument",
+            "underlying_instrument__isin",
+            "underlying_instrument__name",
+            "underlying_instrument__ticker",
             "weighting",
             "shares",
             "comment",

wbportfolio/metric/backends/base.py

@@ -2,12 +2,11 @@ from datetime import date
 
 import numpy as np
 import pandas as pd
-from django.db.models import Exists, OuterRef, QuerySet
+from django.db.models import QuerySet
 from wbfdm.contrib.metric.backends.base import AbstractBackend, Metric
 from wbfdm.contrib.metric.exceptions import MetricInvalidParameterException
-from wbfdm.models import InstrumentType
 
-from wbportfolio.models import AssetPosition, InstrumentPortfolioThroughModel, Portfolio
+from wbportfolio.models import AssetPosition, Portfolio
 
 
 class PortfolioMetricBaseBackend(AbstractBackend[Portfolio]):
@@ -66,18 +65,7 @@ class PortfolioMetricBaseBackend(AbstractBackend[Portfolio]):
             raise MetricInvalidParameterException()
 
     def get_queryset(self) -> QuerySet[Portfolio]:
-        product_portfolios = (
-            super()
-            .get_queryset()
-            .annotate(
-                has_product=Exists(
-                    InstrumentPortfolioThroughModel.objects.filter(
-                        instrument__instrument_type=InstrumentType.PRODUCT, portfolio=OuterRef("pk")
-                    )
-                )
-            )
-            .filter(has_product=True, is_active=True)
-        )
+        product_portfolios = super().get_queryset().filter_active_and_tracked()
         try:
             last_position_date = (
                 AssetPosition.objects.filter(portfolio__in=product_portfolios, is_estimated=False).latest("date").date

wbportfolio/migrations/0075_portfolio_initial_position_date_and_more.py

@@ -0,0 +1,28 @@
+# Generated by Django 5.0.13 on 2025-03-20 08:19
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('wbportfolio', '0074_alter_rebalancer_frequency_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='portfolio',
+            name='initial_position_date',
+            field=models.DateField(blank=True, null=True, verbose_name='Last Position Date'),
+        ),
+        migrations.AddField(
+            model_name='portfolio',
+            name='last_position_date',
+            field=models.DateField(blank=True, null=True, verbose_name='Last Position Date'),
+        ),
+        migrations.AlterField(
+            model_name='trade',
+            name='transaction_subtype',
+            field=models.CharField(choices=[('REBALANCE', 'Rebalance'), ('DECREASE', 'Decrease'), ('INCREASE', 'Increase'), ('SUBSCRIPTION', 'Subscription'), ('REDEMPTION', 'Redemption'), ('BUY', 'Buy'), ('SELL', 'Sell'), ('NO_CHANGE', 'No Change')], default='BUY', max_length=32, verbose_name='Trade Type'),
+        ),
+    ]

wbportfolio/models/__init__.py

@@ -1,5 +1,5 @@
 # Import CRM relevant data
-
+from .roles import PortfolioRole
 from .adjustments import Adjustment
 from .asset import AssetPosition, AssetPositionGroupBy
 from .custodians import Custodian
@@ -16,6 +16,5 @@ 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 .transactions import *
 from .reconciliations import AccountReconciliation, AccountReconciliationLine

wbportfolio/models/asset.py

@@ -528,7 +528,7 @@ class AssetPosition(ImportMixin, models.Model):
             shares=self._shares,
             date=self.date,
             asset_valuation_date=self.asset_valuation_date,
-            instrument_type=self.underlying_quote.instrument_type.id,
+            instrument_type=self.underlying_quote.security_instrument_type.id,
             currency=self.underlying_quote.currency.id,
             country=self.underlying_quote.country.id if self.underlying_quote.country else None,
             is_cash=self.underlying_quote.is_cash,

wbportfolio/models/portfolio.py

@@ -29,7 +29,6 @@ from django.dispatch import receiver
 from django.utils import timezone
 from django.utils.functional import cached_property
 from pandas._libs.tslibs.offsets import BDay
-from psycopg.types.range import DateRange
 from skfolio.preprocessing import prices_to_returns
 from wbcore.contrib.currency.models import Currency, CurrencyFXRates
 from wbcore.contrib.notifications.utils import create_notification_type
@@ -129,6 +128,15 @@ class DefaultPortfolioQueryset(QuerySet):
             & (Q(invested_timespan__endswith__gt=val_date) | Q(invested_timespan__endswith__isnull=True))
         )
 
+    def filter_active_and_tracked(self):
+        return self.annotate(
+            has_product=Exists(
+                InstrumentPortfolioThroughModel.objects.filter(
+                    instrument__instrument_type=InstrumentType.PRODUCT, portfolio=OuterRef("pk")
+                )
+            )
+        ).filter((Q(has_product=True) | Q(is_manageable=True)) & Q(is_active=True) & Q(is_tracked=True))
+
     def to_dependency_iterator(self, val_date: date) -> Iterable["Portfolio"]:
         """
         A method to sort the given queryset to return undependable portfolio first. This is very useful if a routine needs to be applied sequentially on portfolios by order of dependence.
@@ -171,6 +179,9 @@ class DefaultPortfolioManager(ActiveObjectManager):
     def filter_invested_at_date(self, val_date: date):
         return self.get_queryset().filter_invested_at_date(val_date)
 
+    def filter_active_and_tracked(self):
+        return self.get_queryset().filter_active_and_tracked()
+
 
 class ActiveTrackedPortfolioManager(DefaultPortfolioManager):
     def get_queryset(self):
@@ -281,6 +292,9 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         default=False, help_text="If true, this portfolio is a composition of other portfolio"
     )
     updated_at = models.DateTimeField(blank=True, null=True, verbose_name="Updated At")
+    last_position_date = models.DateField(blank=True, null=True, verbose_name="Last Position Date")
+    initial_position_date = models.DateField(blank=True, null=True, verbose_name="Last Position Date")
+
     bank_accounts = models.ManyToManyField(
         to="directory.BankingContact",
         related_name="wbportfolio_portfolios",
@@ -687,6 +701,11 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             self.evaluate_rebalancing(val_date)
 
         self.updated_at = timezone.now()
+        if self.assets.filter(date=val_date).exists():
+            if not self.last_position_date or self.last_position_date < val_date:
+                self.last_position_date = val_date
+            if not self.initial_position_date or self.initial_position_date > val_date:
+                self.initial_position_date = val_date
         self.save()
 
         if compute_metrics:
@@ -1247,18 +1266,6 @@ def default_estimate_net_value(val_date: date, instrument: Instrument) -> float
             return analytic_portfolio.get_estimate_net_value(float(last_price.net_value))
 
 
-@receiver(post_save, sender="wbportfolio.Product")
-@receiver(post_save, sender="wbportfolio.ProductGroup")
-def post_product_creation(sender, instance, created, raw, **kwargs):
-    if not raw and (created or not InstrumentPortfolioThroughModel.objects.filter(instrument=instance).exists()):
-        portfolio = Portfolio.objects.create(
-            name=f"Portfolio: {instance.name}",
-            currency=instance.currency,
-            invested_timespan=DateRange(instance.inception_date if instance.inception_date else date.min, date.max),
-        )
-        InstrumentPortfolioThroughModel.objects.get_or_create(instrument=instance, defaults={"portfolio": portfolio})
-
-
 @receiver(post_save, sender="wbportfolio.PortfolioPortfolioThroughModel")
 def post_portfolio_relationship_creation(sender, instance, created, raw, **kwargs):
     if (

wbportfolio/models/products.py

@@ -1,5 +1,5 @@
 from contextlib import suppress
-from datetime import date, datetime, time
+from datetime import date, datetime, time, timedelta
 from decimal import Decimal
 
 from celery import shared_task
@@ -25,6 +25,9 @@ from pandas.tseries.offsets import BDay
 from wbcore.contrib.ai.llm.config import add_llm_prompt
 from wbcore.contrib.currency.models import CurrencyFXRates
 from wbcore.contrib.directory.models import Entry
+from wbcore.contrib.notifications.dispatch import send_notification
+from wbcore.contrib.notifications.utils import create_notification_type
+from wbcore.permissions.shortcuts import get_internal_users
 from wbcore.signals import pre_merge
 from wbcore.utils.enum import ChoiceEnum
 from wbcrm.models.accounts import Account
@@ -34,6 +37,8 @@ from wbfdm.models.instruments.instruments import InstrumentManager, InstrumentTy
 from wbportfolio.models.llm.wbcrm.analyze_relationship import get_holding_prompt
 from wbportfolio.models.portfolio_relationship import InstrumentPortfolioThroughModel
 
+from ..preferences import get_product_termination_notice_period
+from . import PortfolioRole
 from .mixins.instruments import PMSInstrument, PMSInstrumentAbstractModel
 
 
@@ -316,6 +321,17 @@ class Product(PMSInstrumentAbstractModel):
     class Meta:
         verbose_name = "Product"
         verbose_name_plural = "Products"
+        notification_types = [
+            create_notification_type(
+                "wbportfolio.product.termination_notice",
+                "Product Termination Notice",
+                "Sends a notification when a product is expected termination in the near future",
+                True,
+                True,
+                True,
+                is_lock=True,
+            ),
+        ]
 
     def pre_save(self):
         super().pre_save()
@@ -341,6 +357,39 @@ class Product(PMSInstrumentAbstractModel):
         computed_str += f" ({self.isin})"
         return computed_str
 
+    def check_and_notify_product_termination_on_date(self, today: date) -> bool:
+        """
+        Checks if today is the expected notice date for product termination and sends notifications if applicable.
+
+        The expected notice date is calculated by subtracting the product termination notice period from the product's delisted date. Notifications are sent to users associated with the product's portfolio roles.
+
+        Args:
+            today (date): The date to check against the expected notice date.
+
+        Returns:
+            bool: True if termination is due, False otherwise.
+        """
+        if self.delisted_date:
+            product_termination_expected_notice_date = self.delisted_date - timedelta(
+                days=get_product_termination_notice_period()
+            )
+            if today == product_termination_expected_notice_date:
+                roles = PortfolioRole.objects.filter(
+                    (models.Q(instrument=self) | models.Q(instrument__isnull=True))
+                    & (models.Q(start__isnull=True) | models.Q(start__gte=today))
+                    & (models.Q(end__isnull=True) | models.Q(end__lte=today))
+                    & models.Q(person__user_account__isnull=False)
+                )
+                for user in get_internal_users().filter(is_active=True, id__in=roles.values("person__user_account")):
+                    send_notification(
+                        code="wbportfolio.product.termination_notice",
+                        title="Product Termination Notice",
+                        body=f"The product {self} will be terminated on the {self.delisted_date:%Y-%m-%d}",
+                        user=user,
+                    )
+                return True
+        return False
+
     @property
     def white_label_product(self):
         return self.white_label_customers.all().count() > 0

wbportfolio/models/transactions/rebalancing.py

@@ -133,7 +133,7 @@ class Rebalancer(ComplexToStringMixin, models.Model):
                 trade_proposal.reset_trades(target_portfolio)
                 trade_proposal.submit()
                 if self.approve_trade_proposal_automatically and self.portfolio.can_be_rebalanced:
-                    trade_proposal.approve()
+                    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
@@ -146,6 +146,12 @@ class Rebalancer(ComplexToStringMixin, models.Model):
     def rrule(self):
         return self.get_rrule()
 
+    def get_next_rebalancing_date(self, pivot_date: date) -> date | None:
+        for _dt in self.rrule:
+            _d = _dt.date()
+            if _d > pivot_date:
+                return _d
+
     @property
     def frequency_repr(self):
         return humanize_rrule(self.rrule)