wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/models/synchronization/portfolio_synchronization.py

@@ -0,0 +1,292 @@
+import logging
+from datetime import date, datetime
+from decimal import Decimal
+from typing import Any, Optional
+
+import numpy as np
+import pandas as pd
+from celery import shared_task
+from celery.canvas import Signature
+from django.db import models
+from django.db.models import F
+from django.utils import timezone
+from wbfdm.enums import MarketData
+from wbfdm.models.instruments import Instrument
+from wbportfolio.models import Portfolio
+from wbportfolio.models.transactions.trade_proposals import TradeProposal
+from wbportfolio.pms.typing import Portfolio as PortfolioDTO
+from wbportfolio.pms.typing import Position as PositionDTO
+
+from .synchronization import SynchronizationTask
+
+
+def convert_currency(x, val_date, other_currency):
+    instrument = Instrument.objects.get(id=x)
+    try:
+        return instrument.currency.convert(val_date, other_currency)
+    except Exception:
+        return np.nan
+
+
+class PortfolioSynchronization(SynchronizationTask):
+    is_automatic_validation = models.BooleanField(
+        default=True,
+        verbose_name="Automatic validation",
+        help_text="Set to True if you want to automatically implement proposed positions",
+    )
+    propagate_history = models.BooleanField(
+        default=False,
+        verbose_name="Propagate History",
+        help_text="If true, when the depends on portfolio changes at a certain date, this method will trigger a synchronization for each date (at the scheduled frequency) from that date to the latest valid date",
+    )
+
+    def synchronize(
+        self,
+        portfolio: models.Model,
+        sync_date: date,
+        task_execution_datetime: Optional[datetime] = None,
+        override_execution_datetime_validity: Optional[bool] = False,
+        post_processing: bool = True,
+        **kwargs: Any,
+    ):
+        """
+        This function compute the new portfolio composition after synchronization (returns from `_import_method`) for a
+        given date and either update or create the portfolio or create a trade proposal given the new portfolio constituent.
+
+        :param portfolio: The portfolio to synchronize the positions from
+        :param sync_date: The date at which we need to synchronize the given portfolio
+        :param task_execution_datetime: An optional datetime specifying at which time this task was initially executed.
+        :param override_execution_datetime_validity: If true, we don't valide `task_execution_datetime`
+        :param kwargs: keyword arguments
+        """
+
+        initkwargs = {**kwargs, **self.cast_kwargs}
+        if not task_execution_datetime:
+            task_execution_datetime = timezone.now()
+        if portfolio.is_active_at_date(sync_date):
+            if self.is_valid_date(task_execution_datetime) or override_execution_datetime_validity:
+                if import_res := list(zip(*self._import_method(portfolio, sync_date, **initkwargs))):
+                    effective_positions = list(filter(lambda x: x, import_res[0]))
+                    target_positions = list(filter(lambda x: x, import_res[1]))
+                    if len(target_positions) > 0:
+                        target_portfolio = PortfolioDTO(target_positions)
+
+                        effective_portfolio = (
+                            PortfolioDTO(effective_positions) if len(effective_positions) > 0 else None
+                        )
+                        if self.is_automatic_validation:
+                            # We process these positions automatically
+                            portfolio.import_positions_at_date(
+                                target_portfolio, sync_date, post_processing=post_processing
+                            )
+                        else:
+                            trade_proposal, created = TradeProposal.objects.get_or_create(
+                                trade_date=sync_date,
+                                portfolio=portfolio,
+                                defaults={"comment": "Automatic rebalancing"},
+                            )
+                            trade_proposal.create_or_update_trades(
+                                target_portfolio=target_portfolio, effective_portfolio=effective_portfolio
+                            )
+
+                        portfolio.last_synchronization = timezone.now()
+                        portfolio.save()
+
+            else:
+                logging.info(
+                    f"Synchronization invalid: {portfolio.name} synchronization with {self.name} was triggered for {sync_date} but date not valid for crontab schedule {str(self.crontab)}"
+                )
+
+    def synchronize_as_task_si(self, portfolio: models.Model, sync_date: date, **kwargs: Any) -> Signature:
+        """
+        Utility function that returns the signature of the synchronize method
+        """
+        return synchronize_portfolio_as_task.si(self.id, portfolio.id, sync_date, **kwargs)
+
+    def _tasks_signature(self, sync_date: Optional[date] = None, **kwargs: Any) -> Signature:
+        """
+        Gather all tasks that needs to run under this synchronization job as a list of celery signatures.
+        This method is expected to be implemented at each inheriting class.
+        :param args: list
+        :param kwargs: dict
+        :return: list[signature]
+        """
+        for portfolio in self.portfolios.all():
+            portfolio_sync_dates = []
+            if sync_date:
+                portfolio_sync_dates = [sync_date]
+            elif not sync_date and portfolio.assets.exists() and (latest_asset := portfolio.assets.latest("date")):
+                portfolio_sync_dates = map(
+                    lambda x: x.date(), pd.date_range(latest_asset.date, date.today(), freq="B", inclusive="left")
+                )
+            for portfolio_sync_date in portfolio_sync_dates:
+                if portfolio.is_active_at_date(portfolio_sync_date):
+                    yield synchronize_portfolio_as_task.si(self.id, portfolio.id, portfolio_sync_date, **kwargs)
+
+    @classmethod
+    def _default_callback(
+        cls,
+        portfolio: Portfolio,
+        sync_date: date,
+        portfolio_created: Optional[Portfolio] = None,
+        adjusted_weighting: Optional[Decimal] = Decimal(1.0),
+        adjusted_currency_fx_rate: Optional[Decimal] = Decimal(1.0),
+        is_estimated: Optional[bool] = False,
+        portfolio_total_value: Optional[float] = None,
+        **kwargs: Any,
+    ):
+        """Recursively calculates the position for a portfolio
+
+        Arguments:
+            portfolio {portfolio.Portfolio} -- The Portfolio on which the assets will be computed
+            sync_date {datetime.date} -- The date on which the assets will be computed
+
+        Keyword Arguments:
+            portfolio {portfolio.Portfolio} -- The core portfolio from which the computed position are created (default: {None})
+            adjusted_weighting {int} -- the adjusted weight of the current level of index (default: {1})
+            adjusted_currency_fx_rate {int} -- the adjusted currency exchange rate on the current level of index (default: {1})
+
+        Yields:
+            tuple[dict, dict] -- Two dictionaries: One with filter parameters and one with default values
+        """
+        is_root_position_estimated = False
+        if not portfolio_created:
+            if portfolio_created := portfolio.primary_portfolio:
+                is_root_position_estimated = (
+                    portfolio_created.assets.filter(date=sync_date).count() == 1
+                    and portfolio_created.assets.filter(date=sync_date, is_estimated=True).count() == 1
+                )
+        if portfolio_created:
+            child_positions = portfolio_created.assets.filter(date=sync_date)
+            asset_positions = child_positions.all()
+            # Compute the total portfolio value based on the root position child (otherwise the value is passed as
+            # parameters in the recursion
+            if not portfolio_total_value:
+                portfolio_total_value = child_positions.aggregate(tv=models.Sum(F("total_value_fx_portfolio")))["tv"]
+                if not portfolio_total_value:
+                    portfolio_total_value = portfolio_created.get_total_value(sync_date)
+            for position in child_positions:
+                if child_portfolio := position.underlying_instrument.portfolio:
+                    if child_portfolio.assets.filter(date=sync_date).exists() and position.weighting is not None:
+                        asset_positions = asset_positions.exclude(id=position.id)
+                        yield from cls._default_callback(
+                            portfolio,
+                            sync_date,
+                            portfolio_created=child_portfolio,
+                            adjusted_weighting=position.weighting * adjusted_weighting,
+                            portfolio_total_value=portfolio_total_value,
+                            adjusted_currency_fx_rate=position.currency_fx_rate * adjusted_currency_fx_rate,
+                            is_estimated=False
+                            if is_root_position_estimated
+                            else (is_estimated and position.is_estimated),
+                        )
+            df = pd.DataFrame(
+                asset_positions.values_list(
+                    "currency_fx_rate",
+                    "price",
+                    "weighting",
+                    "shares",
+                    "is_estimated",
+                    "underlying_instrument",
+                    "currency",
+                    "exchange",
+                ),
+                columns=[
+                    "currency_fx_rate",
+                    "price",
+                    "weighting",
+                    "shares",
+                    "is_estimated",
+                    "underlying_instrument",
+                    "currency",
+                    "exchange",
+                ],
+            )
+            if not df.empty:
+                df.currency_fx_rate = df.currency_fx_rate * adjusted_currency_fx_rate
+                df.weighting = df.weighting * adjusted_weighting
+
+                df = (
+                    df.groupby(["underlying_instrument", "currency", "exchange"], dropna=False)
+                    .agg(
+                        {
+                            "currency_fx_rate": "first",
+                            "price": "first",
+                            "weighting": "sum",
+                            "shares": "sum",
+                            "is_estimated": "first",
+                        }
+                    )
+                    .reset_index()
+                )
+                df[["underlying_instrument", "currency", "exchange"]] = df[
+                    ["underlying_instrument", "currency", "exchange"]
+                ].astype("object")
+                df[["currency_fx_rate", "price", "weighting", "shares"]] = df[
+                    ["currency_fx_rate", "price", "weighting", "shares"]
+                ].astype("float")
+
+                df["actual_currency_fx_rate"] = df.underlying_instrument.apply(
+                    lambda x: convert_currency(x, sync_date, portfolio.currency)
+                ).astype("float")
+                df["actual_currency_fx_rate"] = df["actual_currency_fx_rate"].fillna(df["currency_fx_rate"])
+
+                df = df.where(pd.notnull(df), None).set_index("underlying_instrument")
+                missing_prices = df.loc[df["price"].isnull(), "price"]
+                if not missing_prices.empty:
+                    prices_df = pd.DataFrame(
+                        Instrument.objects.filter(id__in=missing_prices.index).dl.market_data(
+                            values=[MarketData.CLOSE], exact_date=sync_date
+                        )
+                    )
+                    if not prices_df.empty:
+                        prices_df = prices_df[["close", "instrument_id"]].set_index("instrument_id").astype("float")
+                        df.loc[prices_df.index, "price"] = prices_df
+
+                if portfolio_total_value is not None:
+                    df["shares"] = (df["weighting"] * float(portfolio_total_value)) / (
+                        df["price"] * df["actual_currency_fx_rate"]
+                    )
+                if is_estimated:
+                    df["is_estimated"] = True
+                for underlying_instrument, asset_position in df.to_dict("index").items():
+                    if (
+                        asset_position["weighting"] or asset_position["shares"]
+                    ):  # We don't yield empty position (pos with shares and weight equal to 0 or None)
+                        # We return the position as a serialized dictionary
+                        yield None, PositionDTO(
+                            date=sync_date,
+                            asset_valuation_date=sync_date,
+                            portfolio_created=portfolio_created.id,
+                            underlying_instrument=underlying_instrument,
+                            instrument_type=Instrument.objects.get(id=underlying_instrument).security_instrument_type,
+                            currency=asset_position["currency"],
+                            exchange=asset_position["exchange"],
+                            shares=asset_position["shares"],
+                            price=asset_position["price"],
+                            currency_fx_rate=asset_position["actual_currency_fx_rate"],
+                            weighting=asset_position["weighting"],
+                            is_estimated=asset_position["is_estimated"],
+                        )
+
+    def __str__(self) -> str:
+        return self.name
+
+    @classmethod
+    def get_representation_endpoint(cls) -> str:
+        return "wbportfolio:portfoliosynchronizationrepresentation-list"
+
+    @classmethod
+    def get_representation_value_key(cls) -> str:
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls) -> str:
+        return "{{name}}"
+
+
+@shared_task(queue="portfolio")
+def synchronize_portfolio_as_task(synchronization_method_id: int, portfolio_id: int, sync_date: date, **kwargs: Any):
+    portfolio = Portfolio.objects.get(id=portfolio_id)
+    synchronization_method = PortfolioSynchronization.objects.get(id=synchronization_method_id)
+    synchronization_method.synchronize(portfolio, sync_date, **kwargs)

wbportfolio/models/synchronization/price_computation.py

@@ -0,0 +1,200 @@
+import logging
+import math
+from datetime import date, datetime, timedelta
+from decimal import Decimal
+from typing import Any, Optional
+
+import pandas as pd
+from celery import shared_task
+from celery.canvas import Signature
+from django.db import models
+from django.utils import timezone
+from pandas.tseries.offsets import BDay
+from wbfdm.models import Instrument
+from wbfdm.models.instruments.instrument_prices import InstrumentPrice
+
+from .synchronization import SynchronizationTask
+
+
+class PriceComputation(SynchronizationTask):
+    @property
+    def instruments(self):
+        for instrument in Instrument.active_objects.filter(
+            models.Q(id__in=self.products.values("id")) | models.Q(id__in=self.indexes.values("id"))
+        ):
+            yield instrument
+
+    def compute(
+        self,
+        instrument: models.Model,
+        sync_date: date,
+        task_execution_datetime: Optional[datetime] = None,
+        override_execution_datetime_validity: Optional[bool] = False,
+        **kwargs: Any,
+    ):
+        """
+        Given positions at t and t-1, we compute the performance and estimate the instrument price at t
+        If a price already exists at that date and is estimated already, we update it. If no price exists, we create it as estimated.
+        Otherwise, we don't do anything to protect imported real prices.
+        :param instrument: The instrument to compute the new price from
+        :param sync_date: The date at which we need to compute the new price
+        :param task_execution_datetime: An optional datetime specifying at which time this task was initially executed.
+        :param override_execution_datetime_validity: If true, we don't valide `task_execution_datetime`
+        :param kwargs: keyword arguments
+        """
+        if not task_execution_datetime:
+            task_execution_datetime = timezone.now()
+
+        if (
+            (self.is_valid_date(task_execution_datetime) or override_execution_datetime_validity)
+            and instrument.is_active_at_date(sync_date)
+            and not sync_date.weekday() in [5, 6]
+        ):
+            price_data = self._import_method(instrument, sync_date, **kwargs)
+            if (
+                price_data
+                and (_instrument := price_data.pop("instrument", None))
+                and (_date := price_data.pop("date", None))
+            ):
+                calculated = price_data.pop("calculated", True)
+                try:
+                    price = InstrumentPrice.objects.get(instrument=_instrument, date=_date, calculated=calculated)
+                    for k, v in price_data.items():
+                        setattr(price, k, v)
+                    price.save()
+                except InstrumentPrice.DoesNotExist:
+                    price = InstrumentPrice.objects.create(
+                        instrument=_instrument, date=_date, calculated=calculated, **price_data
+                    )
+
+                price.save()  # trigger explicitly save logic as update_or_create doesn't
+                if (
+                    _date == _instrument.prices.latest("date").date
+                ):  # if price date is the latest instrument price date, we recomputet the last valuation data
+                    _instrument.update_last_valuation_date()
+        else:
+            logging.info(
+                f"Price Computation invalid: {str(instrument)} price computation with {self.name} was triggered for {sync_date} but date not valid for crontab schedule {str(self.crontab)}"
+            )
+
+    def compute_price_as_task_si(self, instrument: models.Model, sync_date: date, **kwargs: Any) -> Signature:
+        """
+        Utility function that returns the signature of the compute method
+        """
+        return compute_price_as_task.si(self.id, instrument.id, sync_date, **kwargs)
+
+    def _tasks_signature(
+        self, sync_date: Optional[date] = None, to_date: Optional[date] = None, **kwargs: Any
+    ) -> Signature:
+        """
+        Gather all tasks that needs to run under this synchronization job as a list of celery signatures.
+        This method is expected to be implemented at each inheriting class.
+        :param args: list
+        :param kwargs: dict
+        :return: list[signature]
+        """
+        if not to_date:
+            to_date = date.today()
+        for instrument in self.instruments:
+            # Get latest valuation date + 1 Bday if not given by the key word arguments
+            instrument_sync_dates = []
+            if sync_date:
+                instrument_sync_dates = [sync_date]
+            elif not sync_date and instrument.prices.exists() and (last_price := instrument.prices.latest("date")):
+                instrument_sync_dates = map(
+                    lambda x: x.date(),
+                    pd.date_range(
+                        max(last_price.date, to_date - timedelta(days=7)),
+                        to_date,
+                        freq="B",
+                        inclusive="left",
+                    ),
+                )
+            for instrument_sync_date in instrument_sync_dates:
+                if instrument.is_active_at_date(instrument_sync_date):
+                    yield compute_price_as_task.si(self.id, instrument.id, instrument_sync_date, **kwargs)
+
+    @classmethod
+    def _default_callback(cls, instrument: Instrument, val_date: date, **kwargs: Any):
+        """
+        Default NAV computation function. We simply compute the performance given two positions for two dates and estimate the new price
+        based on the overall performance.
+        TODO: If exit/buy of positions, is this function still correct?
+        :param instrument: The instrument to compute the new price from
+        :param val_date: The date at which we need to compute the new price
+        :param kwargs: keyword arguments
+        """
+        if portfolio := instrument.portfolio:
+            # check if the asset portfolio of this instruments exists and has positions at the synchronization date
+            if previous_date := portfolio.get_latest_asset_position_date(val_date - BDay(1), with_estimated=True):
+                # Get the previous valid price date before sync_date, checks if it exists and if positions are available
+                # at that date.
+                # If asset position exists on the previous day but not at the sync date, maybe propagation were not done, and we try it
+                if portfolio.assets.filter(date=previous_date).exists():
+                    portfolio.propagate_or_update_assets(previous_date, val_date)
+                    if portfolio.assets.filter(date=val_date).exists():
+                        last_price = None
+                        if (
+                            last_valuation := instrument.prices.filter(date=previous_date)
+                            .order_by("calculated")
+                            .first()
+                        ):
+                            last_price = last_valuation.net_value
+                        elif not instrument.valuations.filter(date__lt=previous_date).exists():
+                            last_price = instrument.issue_price
+                        if last_price:
+                            weights = pd.DataFrame(
+                                portfolio.assets.filter(date=previous_date).values(
+                                    "weighting", "date", "underlying_instrument"
+                                )
+                            )
+                            weights = weights.pivot_table(
+                                index="date", columns=["underlying_instrument"], values="weighting", aggfunc="sum"
+                            ).astype("float")
+                            weights = weights.iloc[-1, :]
+                            perfs = pd.DataFrame(
+                                portfolio.assets.filter(date__in=[previous_date, val_date]).values(
+                                    "date", "price_fx_portfolio", "underlying_instrument"
+                                )
+                            )
+                            perfs = perfs.pivot_table(
+                                index="date",
+                                columns=["underlying_instrument"],
+                                values="price_fx_portfolio",
+                                aggfunc="mean",
+                            ).astype("float")
+                            perfs = perfs / perfs.shift(1, axis=0) - 1.0
+                            perfs = perfs.fillna(0).iloc[-1, :]
+                            total_perfs = float((perfs * weights).sum())
+                            new_gross_valuation = float(last_price) * (1.0 + total_perfs)
+                            if new_gross_valuation and not math.isnan(new_gross_valuation):
+                                return {
+                                    "instrument": instrument,
+                                    "date": val_date,
+                                    "gross_value": Decimal(new_gross_valuation),
+                                    "net_value": Decimal(new_gross_valuation),
+                                }
+
+        return None
+
+    def __str__(self) -> str:
+        return self.name
+
+    @classmethod
+    def get_representation_endpoint(cls) -> str:
+        return "wbportfolio:pricecomputationrepresentation-list"
+
+    @classmethod
+    def get_representation_value_key(cls) -> str:
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls) -> str:
+        return "{{name}}"
+
+
+@shared_task(queue="portfolio")
+def compute_price_as_task(price_computation_method_id: int, instrument_id: int, sync_date: date, **kwargs: Any):
+    instrument = Instrument.objects.get(id=instrument_id)
+    price_computation = PriceComputation.objects.get(id=price_computation_method_id)
+    price_computation.compute(instrument, sync_date, **kwargs)

wbportfolio/models/synchronization/synchronization.py

@@ -0,0 +1,188 @@
+import importlib
+from collections.abc import Callable
+from datetime import date, datetime, time
+from json import loads
+from typing import Any, Iterator, Optional
+
+from celery import chord, group, shared_task
+from celery.canvas import Signature, signature
+from croniter import croniter, croniter_range
+from django.contrib.contenttypes.models import ContentType
+from django.db import models
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+from django.utils import timezone
+from django_celery_beat.models import CrontabSchedule, PeriodicTask, cronexp
+
+
+class SynchronizationTask(PeriodicTask):
+    RELATIVE_TASK_MODULE_PATH = "wbportfolio.models.synchronization.synchronization.task"
+
+    dependent_task = models.ForeignKey(
+        "self", related_name="dependency_tasks", null=True, blank=True, on_delete=models.SET_NULL
+    )
+    import_path = models.CharField(max_length=512, verbose_name="Import Path", default="", blank=True)
+
+    @property
+    def cast_args(self) -> list[Any]:
+        """
+        transform the string args representation into list. We except this to become unnecessary when django beat move to jsonfield
+        :return: list
+        """
+        return loads(self.args or "[]")
+
+    @property
+    def cast_kwargs(self) -> dict[Any, Any]:
+        """
+        transform the string kwargs representation into dictionary. We except this to become unnecessary when django beat move to jsonfield
+        :return: list
+        """
+        return loads(self.kwargs or "{}")
+
+    @property
+    def _import_method(self) -> Callable[[Any], Any]:
+        """
+        If a custom task is specified, return the loaded module as callabck. Otherwise, returns the default synchronization
+        function defined in `_default_callback
+        :return: Callable
+        """
+        if import_path := self.import_path:
+            synchronize_module = importlib.import_module(import_path)
+            return synchronize_module.callback
+        else:
+            return self._default_callback
+
+    def schedule_str(self, filter_daily: Optional[bool] = False) -> str:
+        """
+        Returns the crontab string representation. If fitler_daily is true, we cast the crontab so that the lowest frequency
+        becomes daily.
+        :param filter_daily: bool (optional)
+        :return: crontab string representation
+        """
+        crontab_minute = cronexp(self.crontab.minute)
+        crontab_hour = cronexp(self.crontab.hour)
+        if filter_daily:
+            if crontab_minute == "*":
+                crontab_minute = "0"
+            if crontab_hour == "*":
+                crontab_hour = "0"
+        return "{0} {1} {2} {3} {4}".format(
+            crontab_minute,
+            crontab_hour,
+            cronexp(self.crontab.day_of_month),
+            cronexp(self.crontab.month_of_year),
+            cronexp(self.crontab.day_of_week),
+        )
+
+    def dates_range(self, from_date: date, to_date: date, filter_daily: Optional[bool] = False) -> Iterator[datetime]:
+        """
+        returns a list of valid dates given an interval and a specific crontab schedule.
+        :param from_date: date
+        :param to_date: date
+        :param filter_daily: bool (optional)
+        :return: list[date]
+        """
+        min_datetime = datetime.combine(from_date, time.min)
+        max_datetime = datetime.combine(to_date, time.max)
+        return croniter_range(min_datetime, max_datetime, self.schedule_str(filter_daily=filter_daily))
+
+    def is_valid_date(self, sync_datetime: datetime) -> bool:
+        """
+        check wether a date is valid given the stored crontab schedule
+        :param sync_datetime: datetime
+        :return: bool
+        """
+        return croniter.match(self.schedule_str(), sync_datetime)
+
+    def save(self, *args: Any, **kwargs: Any):
+        self.task = self.RELATIVE_TASK_MODULE_PATH
+        if not self.schedule:
+            self.crontab, _ = CrontabSchedule.objects.get_or_create(
+                minute="0",
+                hour="*",
+                day_of_week="*",
+                day_of_month="*",
+                month_of_year="*",
+            )
+        if not self.crontab:
+            raise ValueError("Synchronization task supports only Crontab Schedule")
+        if self.crontab.minute == "*":
+            raise ValueError("The minimum crontab frequency supported is hourly.")
+        super().save(*args, **kwargs)
+
+    def _tasks_signature(self, *args, **kwargs: Any) -> Signature:
+        """
+        Gather all tasks that needs to run under this synchronization job as a list of celery signatures.
+        This method is expected to be implemented at each inheriting class.
+        :param args: list
+        :param kwargs: dict
+        :return: list[signature]
+        """
+        raise NotImplementedError()
+
+    def _default_callback(self, *args: Any, **kwargs: Any) -> Any:
+        """
+        The default synchronization function executed if no custom task is provided for this synchronization object.
+        This method is expected to be implemented at each inheriting class.
+        :param args: list
+        :param kwargs: dict
+        :return: callable
+        """
+        raise NotImplementedError()
+
+    def _get_kwargs(self) -> Any:
+        """
+        return the base keyword argument to be injected into the `_tasks_signature` method. Define as a standalone function
+        in order to allow subclass definition.
+        :return: dict
+        """
+        return {"task_execution_datetime": timezone.now()}
+
+    def _end_task_signature(self, **kwargs: Any) -> Signature:
+        """
+        A synchronization object can defined a dependant task that will be executed at this end of all returned task from
+        _tasks_signatures.
+        This function returns the signature of this chained task.
+        :param kwargs:
+        :return: signature
+        """
+        if self.dependent_task:
+            kwargs = {"override_execution_datetime_validity": True, **self.dependent_task.cast_kwargs, **kwargs}
+            return signature(
+                self.dependent_task.task, args=self.dependent_task.cast_args, kwargs=kwargs, immutable=True
+            )
+        return None
+
+    def chord(self, **kwargs: Any) -> chord:
+        """
+        This function is the main entry point of the synchronization worklow. It is called from within the shared_task `task`
+        and create the celery chord containing the list of tasks chained to the end task (if any)
+        :param kwargs:
+        :return: chord
+        """
+        kwargs = {**kwargs, **self._get_kwargs()}
+        tasks = list(self._tasks_signature(**kwargs))
+        if end_task := self._end_task_signature(**kwargs):
+            return chord(tasks, end_task)
+        return group(tasks)
+
+
+@receiver(post_save, sender="wbportfolio.SynchronizationTask")
+@receiver(post_save, sender="wbportfolio.PortfolioSynchronization")
+@receiver(post_save, sender="wbportfolio.PriceComputation")
+def post_save_synchronization_task(sender, instance: models.Model, created: bool, raw: bool, **kwargs: Any):
+    """
+    Ensure args attribute contains the necessary arguments to retrieve the calling job from within asynchronous task
+    """
+    if (created and not raw) or not instance.args:
+        content_type = ContentType.objects.get_for_model(instance)
+        instance.args = f'["{instance.id}", "{content_type.app_label}", "{content_type.model}"]'
+        instance.save()
+
+
+@shared_task
+def task(synchronization_object_id: int, app_label: str, model: str, **kwargs: Any):
+    synchronization_object = ContentType.objects.get(app_label=app_label, model=model).get_object_for_this_type(
+        id=synchronization_object_id
+    )
+    synchronization_object.chord(**kwargs).apply_async()