wbportfolio 1.48.0__tar.gz → 1.49.1__tar.gz

{wbportfolio-1.48.0 → wbportfolio-1.49.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wbportfolio
-Version: 1.48.0
+Version: 1.49.1
 Author-email: Christopher Wittlinger <c.wittlinger@stainly.com>
 License-File: LICENSE
 Requires-Dist: cryptography==3.4.*

{wbportfolio-1.48.0 → wbportfolio-1.49.1}/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-1.48.0 → wbportfolio-1.49.1}/wbportfolio/factories/dividends.py

@@ -11,5 +11,6 @@ class DividendTransactionsFactory(TransactionFactory):
     class Meta:
         model = DividendTransaction
 
+    retrocession = 1.0
     shares = factory.LazyAttribute(lambda o: random.randint(10, 10000))
     price = factory.LazyAttribute(lambda o: random.randint(10, 10000))

{wbportfolio-1.48.0 → wbportfolio-1.49.1}/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-1.48.0 → wbportfolio-1.49.1}/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-1.48.0 → wbportfolio-1.49.1}/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-1.48.0 → wbportfolio-1.49.1}/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-1.48.0 → wbportfolio-1.49.1}/wbportfolio/import_export/handlers/dividend.py

@@ -23,7 +23,7 @@ class DividendImportHandler(ImportExportHandler):
         data["value_date"] = datetime.strptime(data["value_date"], "%Y-%m-%d").date()
         from wbportfolio.models import Portfolio
 
-        data["portfolio"] = Portfolio.objects.get(id=data["portfolio"])
+        data["portfolio"] = Portfolio.all_objects.get(id=data["portfolio"])
         instrument = self.instrument_handler.process_object(
             data["underlying_instrument"], only_security=False, read_only=True
         )[0]

{wbportfolio-1.48.0 → wbportfolio-1.49.1}/wbportfolio/import_export/handlers/fees.py

@@ -26,7 +26,7 @@ class FeesImportHandler(ImportExportHandler):
 
         data["linked_product"] = Product.objects.get(id=data["linked_product"])
         if "porfolio" in data:
-            data["portfolio"] = Portfolio.objects.get(id=data["portfolio"])
+            data["portfolio"] = Portfolio.all_objects.get(id=data["portfolio"])
         else:
             data["portfolio"] = data["linked_product"].primary_portfolio
         data["underlying_instrument"] = Cash.objects.filter(currency=data["portfolio"].currency).first()

{wbportfolio-1.48.0 → wbportfolio-1.49.1}/wbportfolio/import_export/handlers/portfolio_cash_flow.py

@@ -19,7 +19,7 @@ class DailyPortfolioCashFlowImportHandler(ImportExportHandler):
 
     def _deserialize(self, data):
         data["value_date"] = datetime.strptime(data["value_date"], "%Y-%m-%d").date()
-        data["portfolio"] = Portfolio.objects.get(id=data["portfolio"])
+        data["portfolio"] = Portfolio.all_objects.get(id=data["portfolio"])
         if "cash" in data:
             data["cash"] = Decimal(data["cash"])
 

{wbportfolio-1.48.0 → wbportfolio-1.49.1}/wbportfolio/import_export/handlers/trade.py

@@ -1,3 +1,4 @@
+import math
 from datetime import datetime
 from decimal import Decimal
 from typing import Any, Dict, Optional
@@ -24,6 +25,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 +44,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
@@ -69,7 +72,10 @@ class TradeImportHandler(ImportExportHandler):
 
         for field in self.model._meta.get_fields():
             if not (value := data.get(field.name, None)) is None and isinstance(field, models.DecimalField):
-                data[field.name] = Decimal(value)
+                q = (
+                    1 / (math.pow(10, 4))
+                )  # we need that convertion mechanism otherwise there is floating point approximation error while casting to decimal and get_instance does not work as expected
+                data[field.name] = Decimal(value).quantize(Decimal(str(q)))
 
     def _create_instance(self, data: Dict[str, Any], **kwargs) -> models.Model:
         if "transaction_date" not in data:  # we might get only book date and not transaction date
@@ -79,7 +85,6 @@ class TradeImportHandler(ImportExportHandler):
 
     def _get_instance(self, data: Dict[str, Any], history: Optional[models.QuerySet] = None, **kwargs) -> models.Model:
         self.import_source.log += "\nGet Trade Instance."
-
         if transaction_date := data.get("transaction_date"):
             dates_lookup = {"transaction_date": transaction_date}
         elif book_date := data.get("book_date"):
@@ -180,6 +185,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-1.48.0 → wbportfolio-1.49.1}/wbportfolio/import_export/parsers/sg_lux/custodian_positions.py

@@ -29,7 +29,7 @@ def get_portfolio_id(row: pd.Series) -> int:
     Raises: Portfolio.DoesNotExist: We raise an error intentionally if the portfolio does not exist to make the import fail
     """
     iban = str(IBAN.generate(BANK_COUNTRY_CODE, bank_code=BANK_CODE, account_code=str(row["account_number"])))
-    return Portfolio.objects.get(bank_accounts__iban=iban).id
+    return Portfolio.all_objects.get(bank_accounts__iban=iban).id
 
 
 def parse(import_source: "ImportSource") -> dict:

{wbportfolio-1.48.0 → wbportfolio-1.49.1}/wbportfolio/import_export/parsers/sg_lux/portfolio_future_cash_flow.py

@@ -13,7 +13,7 @@ def parse(import_source):
 
     def get_portfolio_id(row) -> int | None:
         with suppress(Portfolio.DoesNotExist):
-            return Portfolio.objects.get(instruments__children__isin__in=[row["Isin"]]).pk
+            return Portfolio.all_objects.get(instruments__children__isin__in=[row["Isin"]]).pk
 
     df = df[~df["Isin"].isnull()]
     df["Trade date"] = df["Trade date"].ffill()

wbportfolio-1.49.1/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-1.49.1/wbportfolio/migrations/0076_alter_dividendtransaction_price_and_more.py

@@ -0,0 +1,126 @@
+# Generated by Django 5.0.13 on 2025-03-21 12:30
+
+import django.db.models.expressions
+from decimal import Decimal
+from django.db import migrations, models
+
+def migrate_default_values(apps, schema_editor):
+    Transaction = apps.get_model("wbportfolio", "Transaction")
+    Trade = apps.get_model("wbportfolio", "Trade")
+    Expiry = apps.get_model("wbportfolio", "Expiry")
+    DividendTransaction = apps.get_model("wbportfolio", "DividendTransaction")
+    Transaction.objects.filter(book_date__isnull=True).update(book_date=models.F("transaction_date"))
+    Transaction.objects.filter(value_date__isnull=True).update(value_date=models.F("transaction_date"))
+    Trade.objects.filter(price_gross__isnull=True).update(price_gross=models.F("price"))
+    Expiry.objects.filter(price_gross__isnull=True).update(price_gross=models.F("price"))
+    DividendTransaction.objects.filter(price_gross__isnull=True).update(price_gross=models.F("price"))
+    Transaction.objects.filter(total_value_gross__isnull=True).update(total_value_gross=models.F("total_value"))
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('wbportfolio', '0075_portfolio_initial_position_date_and_more'),
+    ]
+
+    operations = [
+        migrations.RunPython(migrate_default_values),
+        migrations.AlterField(
+            model_name='transaction',
+            name='book_date',
+            field=models.DateField(help_text='The date that this transaction was booked.',
+                                   verbose_name='Trade Date'),
+            preserve_default=False,
+        ),
+        migrations.AlterField(
+            model_name='transaction',
+            name='value_date',
+            field=models.DateField(help_text='The date that this transaction was valuated.',
+                                   verbose_name='Value Date'),
+            preserve_default=False,
+        ),
+        migrations.AlterField(
+            model_name='dividendtransaction',
+            name='price',
+            field=models.DecimalField(decimal_places=4, default=Decimal('0.0'), help_text='The price per share.', max_digits=16, verbose_name='Price'),
+        ),
+        migrations.AlterField(
+            model_name='dividendtransaction',
+            name='price_gross',
+            field=models.DecimalField(decimal_places=4, default=Decimal('0.0'), help_text='The gross price per share.', max_digits=16, verbose_name='Gross Price'),
+            preserve_default=False,
+        ),
+        migrations.AlterField(
+            model_name='dividendtransaction',
+            name='shares',
+            field=models.DecimalField(decimal_places=4, default=Decimal('0.0'), help_text='The number of shares that were traded.', max_digits=15, verbose_name='Shares'),
+        ),
+        migrations.AlterField(
+            model_name='expiry',
+            name='price',
+            field=models.DecimalField(decimal_places=4, default=Decimal('0.0'), help_text='The price per share.', max_digits=16, verbose_name='Price'),
+        ),
+        migrations.AlterField(
+            model_name='expiry',
+            name='price_gross',
+            field=models.DecimalField(decimal_places=4, default=Decimal('0.0'), help_text='The gross price per share.', max_digits=16, verbose_name='Gross Price'),
+            preserve_default=False,
+        ),
+        migrations.AlterField(
+            model_name='expiry',
+            name='shares',
+            field=models.DecimalField(decimal_places=4, default=Decimal('0.0'), help_text='The number of shares that were traded.', max_digits=15, verbose_name='Shares'),
+        ),
+        migrations.AlterField(
+            model_name='trade',
+            name='price',
+            field=models.DecimalField(decimal_places=4, default=Decimal('0.0'), help_text='The price per share.', max_digits=16, verbose_name='Price'),
+        ),
+        migrations.AlterField(
+            model_name='trade',
+            name='price_gross',
+            field=models.DecimalField(decimal_places=4, default=Decimal('0.0'), help_text='The gross price per share.', max_digits=16, verbose_name='Gross Price'),
+            preserve_default=False,
+        ),
+        migrations.AlterField(
+            model_name='trade',
+            name='shares',
+            field=models.DecimalField(decimal_places=4, default=Decimal('0.0'), help_text='The number of shares that were traded.', max_digits=15, verbose_name='Shares'),
+        ),
+
+        migrations.AlterField(
+            model_name='transaction',
+            name='total_value',
+            field=models.DecimalField(decimal_places=4, default=Decimal('0.0'), max_digits=20, verbose_name='Total Value'),
+            preserve_default=False,
+        ),
+        migrations.AlterField(
+            model_name='transaction',
+            name='total_value_gross',
+            field=models.DecimalField(decimal_places=4, default=Decimal('0.0'), max_digits=20, verbose_name='Total Value Gross'),
+            preserve_default=False,
+        ),
+        migrations.RemoveField(
+            model_name='transaction',
+            name='total_value_fx_portfolio',
+        ),
+        migrations.RemoveField(
+            model_name='transaction',
+            name='total_value_gross_fx_portfolio',
+        ),
+        migrations.AddField(
+            model_name='transaction',
+            name='total_value_fx_portfolio',
+            field=models.GeneratedField(db_persist=True, expression=django.db.models.expressions.CombinedExpression(
+                models.F('currency_fx_rate'), '*', models.F('total_value')),
+                                        output_field=models.DecimalField(decimal_places=4, max_digits=20)),
+            preserve_default=False,
+        ),
+        migrations.AddField(
+            model_name='transaction',
+            name='total_value_gross_fx_portfolio',
+            field=models.GeneratedField(db_persist=True, expression=django.db.models.expressions.CombinedExpression(models.F('currency_fx_rate'), '*', models.F('total_value_gross')), output_field=models.DecimalField(decimal_places=4, max_digits=20)),
+            preserve_default=False,
+        ),
+
+    ]

{wbportfolio-1.48.0 → wbportfolio-1.49.1}/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
@@ -293,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",
@@ -409,7 +411,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
         )
 
     def __str__(self):
-        return f"{self.id:06} ({self.name})"
+        return f"{self.id:06}: {self.name}"
 
     class Meta:
         verbose_name = "Portfolio"
@@ -699,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:
@@ -972,7 +979,11 @@ class Portfolio(DeleteToDisableMixin, WBModel):
             for position in positions:
                 position.portfolio = self
                 update_dates.add(position.date)
-            # self.assets.filter(date__in=update_dates, is_estimated=True).delete()
+
+            # we need to delete the existing estimated portfolio because otherwise we risk to have existing and not
+            # overlapping positions remaining (as they will not be updating by the bulk create). E.g. when someone
+            # change completely the trades of a portfolio model and drift it.
+            self.assets.filter(date__in=update_dates, is_estimated=True).delete()
             leftover_positions_ids = list(
                 self.assets.filter(date__in=update_dates).values_list("id", flat=True)
             )  # we need to get the ids otherwise the queryset is reevaluated later
@@ -1007,7 +1018,7 @@ class Portfolio(DeleteToDisableMixin, WBModel):
     @classmethod
     def _get_or_create_portfolio(cls, instrument_handler, portfolio_data):
         if isinstance(portfolio_data, int):
-            return Portfolio.objects.get(id=portfolio_data)
+            return Portfolio.all_objects.get(id=portfolio_data)
         instrument = portfolio_data
         if isinstance(portfolio_data, dict):
             instrument = instrument_handler.process_object(instrument, only_security=False, read_only=True)[0]
@@ -1259,18 +1270,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-1.48.0 → wbportfolio-1.49.1}/wbportfolio/models/transactions/claim.py

@@ -14,6 +14,7 @@ from django.db.models import (
 )
 from django.db.models.functions import Greatest
 from django.dispatch import receiver
+from django.utils.translation import gettext_lazy as _
 from django_fsm import FSMField, transition
 from wbcore.contrib.ai.llm.config import add_llm_prompt
 from wbcore.contrib.authentication.models import User
@@ -335,13 +336,13 @@ class Claim(ReferenceIDMixin, WBModel):
         errors = dict()
 
         if not self.trade:
-            errors["trade"] = ["With this status, this has to be provided."]
+            errors["trade"] = [_("With this status, this has to be provided.")]
 
         if not self.product:
-            errors["product"] = ["With this status, this has to be provided."]
+            errors["product"] = [_("With this status, this has to be provided.")]
 
         if not self.account:
-            errors["account"] = ["With this status, this has to be provided."]
+            errors["account"] = [_("With this status, this has to be provided.")]
 
         # check if the specified product have a valid nav at the specified date
         if (
@@ -350,13 +351,13 @@ class Claim(ReferenceIDMixin, WBModel):
             and not product.valuations.filter(date=claim_date).exists()
         ):
             if (prices_qs := product.valuations.filter(date__lt=claim_date)).exists():
-                errors["date"] = (
+                errors["date"] = [
                     f"For product {product.name}, the latest valid valuation date before {claim_date:%Y-%m-%d} is {prices_qs.latest('date').date:%Y-%m-%d}: Please select a valid date."
-                )
+                ]
             else:
-                errors["date"] = (
+                errors["date"] = [
                     f"There is no valuation before {claim_date:%Y-%m-%d} for product {product.name}: Please select a valid date."
-                )
+                ]
         return errors
 
     @transition(

wbportfolio-1.49.1/wbportfolio/models/transactions/dividends.py

@@ -0,0 +1,15 @@
+from decimal import Decimal
+
+from django.db import models
+
+from wbportfolio.import_export.handlers.dividend import DividendImportHandler
+
+from .transactions import ShareMixin, Transaction
+
+
+class DividendTransaction(Transaction, ShareMixin, models.Model):
+    import_export_handler_class = DividendImportHandler
+    retrocession = models.FloatField(default=1)
+
+    def save(self, *args, **kwargs):
+        super().save(*args, factor=Decimal(self.retrocession), **kwargs)

{wbportfolio-1.48.0 → wbportfolio-1.49.1}/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)