wbportfolio 1.44.5__py2.py3-none-any.whl → 1.45.1__py2.py3-none-any.whl

wbportfolio/models/synchronization/price_computation.py

@@ -1,200 +0,0 @@
-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

@@ -1,188 +0,0 @@
-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()

wbportfolio/serializers/synchronization.py

@@ -1,18 +0,0 @@
-from wbcore import serializers as wb_serializers
-from wbportfolio.models import PortfolioSynchronization, PriceComputation
-
-
-class PortfolioSynchronizationRepresentationSerializer(wb_serializers.RepresentationSerializer):
-    _detail = wb_serializers.HyperlinkField(reverse_name="wbportfolio:portfolio-detail")
-
-    class Meta:
-        model = PortfolioSynchronization
-        fields = ("id", "name", "import_path", "_detail")
-
-
-class PriceComputationRepresentationSerializer(wb_serializers.RepresentationSerializer):
-    _detail = wb_serializers.HyperlinkField(reverse_name="wbportfolio:portfolio-detail")
-
-    class Meta:
-        model = PriceComputation
-        fields = ("id", "name", "import_path", "_detail")