wbportfolio 1.43.1__py2.py3-none-any.whl

wbportfolio/import_export/backends/wbfdm/adjustment.py

@@ -0,0 +1,50 @@
+import json
+from datetime import datetime
+from io import BytesIO
+
+from django.core.serializers.json import DjangoJSONEncoder
+from pandas.tseries.offsets import BDay
+from wbcore.contrib.io.backends import AbstractDataBackend, register
+from wbfdm.models import Instrument
+from wbportfolio.import_export.backends.utils import (
+    get_timedelta_import_instrument_price,
+)
+
+from .mixin import DataBackendMixin
+
+
+@register("Adjustment", provider_key="wbfdm", save_data_in_import_source=False, passive_only=False)
+class DataBackend(DataBackendMixin, AbstractDataBackend):
+    DATE_LABEL = "adjustment_date"
+    DEFAULT_MAPPING = {
+        "adjustment_date": "date",
+        "adjustment_factor": "factor",
+        "cumulative_adjustment_factor": "cumulative_factor",
+        "instrument_id": "instrument",
+    }
+    NONE_NULLABLE_FIELDS = list(DEFAULT_MAPPING.values())
+
+    def get_default_queryset(self):
+        return Instrument.objects.filter(is_investable_universe=True)
+
+    def get_files(
+        self,
+        execution_time: datetime,
+        **kwargs,
+    ) -> BytesIO:
+        execution_date = execution_time.date()
+        start = kwargs.get("start", (execution_date - BDay(get_timedelta_import_instrument_price())).date())
+        data = []
+        for dict_dto in self.get_default_queryset().dl.adjustments(
+            from_date=start,
+            to_date=execution_date,
+        ):
+            if dict_dto["adjustment_factor"] is not None:
+                data.append(dict_dto)
+        if data:
+            content_file = BytesIO()
+            content_file.write(json.dumps(data, cls=DjangoJSONEncoder).encode())
+            file_name = (
+                f"adjustment_{start:%Y-%m-%d}-{execution_date:%Y-%m-%d}_{datetime.timestamp(execution_time)}.json"
+            )
+            yield file_name, content_file

wbportfolio/import_export/backends/wbfdm/dividend.py

@@ -0,0 +1,16 @@
+from wbcore.contrib.io.backends import AbstractDataBackend, register
+
+from .mixin import DataBackendMixin
+
+
+@register("Dividend", provider_key="wbfdm", save_data_in_import_source=False, passive_only=False)
+class DataBackend(DataBackendMixin, AbstractDataBackend):
+    TIMEDELTA = 1
+    ATTRIBUTE_NAME = "dividends"
+    FILE_NAME = "dividend"
+    DEFAULT_MAPPING = {
+        "instrument_id": "instrument",
+        "rate": "weighting",
+        "ex_dividend_date": "value_date",
+        "payment_date": "transaction_date",
+    }

wbportfolio/import_export/backends/wbfdm/mixin.py

@@ -0,0 +1,15 @@
+from datetime import date
+
+from django.db import models
+
+MUTUAL_FUND_TIMEDELTA_DAY_SHIFT = 7
+
+
+class DataBackendMixin:
+    DATE_LABEL = "valuation_date"
+
+    def is_object_valid(self, obj: models.Model) -> bool:
+        return super().is_object_valid(obj) and obj.assets.exists() and obj.is_active_at_date(date.today())
+
+    def get_provider_id(self, obj: models.Model) -> str:
+        return obj.id

wbportfolio/import_export/handlers/adjustment.py

@@ -0,0 +1,39 @@
+from datetime import datetime, timedelta
+
+from wbcore.contrib.io.exceptions import DeserializationError
+from wbcore.contrib.io.imports import ImportExportHandler
+from wbfdm.import_export.handlers.instrument import InstrumentImportHandler
+
+
+class AdjustmentImportHandler(ImportExportHandler):
+    MODEL_APP_LABEL = "wbportfolio.Adjustment"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.instrument_handler = InstrumentImportHandler(self.import_source)
+
+    def _deserialize(self, data):
+        data["date"] = datetime.strptime(data["date"], "%Y-%m-%d").date()
+        data["instrument"] = self.instrument_handler.process_object(
+            data["instrument"], only_security=True, read_only=True
+        )[0]
+        if data["factor"] is None:
+            raise DeserializationError("Can't process this data: no factor")
+
+    def _get_instance(self, data, history=None, **kwargs):
+        self.import_source.log += "\nGet Adjustment Instance."
+        self.import_source.log += f"\nParameter: Instrument={data['instrument']} Date={data['date']}"
+
+        if exact_adjustment := data["instrument"].pms_adjustments.filter(date=data["date"]).first():
+            return exact_adjustment
+        potential_adjustments = data["instrument"].pms_adjustments.filter(
+            date__gte=data["date"] - timedelta(days=7),
+            date__lte=data["date"] + timedelta(days=7),
+            factor=data["factor"],
+        )
+        if potential_adjustments.exists():
+            return potential_adjustments.first()
+
+    def _create_instance(self, data, **kwargs):
+        self.import_source.log += "\nCreate Adjustment datapoint."
+        return self.model.objects.create(**data, import_source=self.import_source)

wbportfolio/import_export/handlers/asset_position.py

@@ -0,0 +1,167 @@
+from collections import defaultdict
+from datetime import datetime
+from decimal import Decimal
+from itertools import chain
+from typing import Any, Dict, List, Optional
+
+from django.db import models
+from wbcore.contrib.authentication.authentication import User
+from wbcore.contrib.currency.import_export.handlers import CurrencyImportHandler
+from wbcore.contrib.io.exceptions import DeserializationError
+from wbcore.contrib.io.imports import ImportExportHandler
+from wbcore.contrib.notifications.dispatch import send_notification
+from wbfdm.import_export.handlers.instrument import InstrumentImportHandler
+from wbfdm.import_export.handlers.instrument_price import InstrumentPriceImportHandler
+from wbfdm.models.exchanges import Exchange
+from wbportfolio.models.roles import PortfolioRole
+
+
+class AssetPositionImportHandler(ImportExportHandler):
+    MODEL_APP_LABEL: str = "wbportfolio.AssetPosition"
+    PRICE_DATE_TIMEDELTA: int = 7
+    MAX_PRICE_DATE_TIMEDELTA: int = 360
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.instrument_handler = InstrumentImportHandler(self.import_source)
+        self.instrument_price_handler = InstrumentPriceImportHandler(self.import_source)
+        self.currency_handler = CurrencyImportHandler(self.import_source)
+
+    def _deserialize(self, data: Dict[str, Any]):
+        from wbportfolio.models import Portfolio
+
+        portfolio_data = data.pop("portfolio", None)
+        underlying_instrument_data = data.pop("underlying_instrument", None)
+        if "currency" in data:
+            data["currency"] = self.currency_handler.process_object(data["currency"], read_only=True)[0]
+        data["date"] = datetime.strptime(data["date"], "%Y-%m-%d").date()
+        if data.get("asset_valuation_date", None):
+            data["asset_valuation_date"] = datetime.strptime(data["asset_valuation_date"], "%Y-%m-%d").date()
+        else:
+            data["asset_valuation_date"] = data["date"]
+
+        if exchange_data := data.pop("exchange", None):
+            sanitized_dict = {k: v for k, v in exchange_data.items() if v is not None}
+            if sanitized_dict:
+                data["exchange"] = Exchange.dict_to_model(sanitized_dict)
+
+        data["portfolio"] = Portfolio._get_or_create_portfolio(self.instrument_handler, portfolio_data)
+        data["underlying_instrument"] = self.instrument_handler.process_object(
+            underlying_instrument_data, only_security=False, read_only=True
+        )[0]
+
+        # number type deserialization and sanitization
+        # ensure the provided Decimal field are of type Decimal
+        decimal_fields = ["initial_currency_fx_rate", "initial_price", "initial_shares", "weighting"]
+        for field in decimal_fields:
+            if not (value := data.get(field, None)) is None:
+                data[field] = Decimal(value)
+
+        # Ensure that for shares and weighting, a None value default to 0
+        if "initial_shares" in data and data["initial_shares"] is None:
+            data["initial_shares"] = Decimal(0)
+        if "weighting" in data and data["weighting"] is None:
+            data["weighting"] = Decimal(0)
+
+        # if the initial price is not provided, we try to get it directly from the dataloader
+        if data.get("initial_price") is None:
+            try:
+                data["initial_price"] = data["underlying_instrument"].get_price(
+                    data["date"], price_date_timedelta=self.PRICE_DATE_TIMEDELTA
+                )
+            except ValueError:
+                # If we cannot find a price with the default timedelta, we try with a bigger range (in case the instrument stopped trading for some time for instance)
+                try:
+                    data["initial_price"] = data["underlying_instrument"].get_price(
+                        data["date"], price_date_timedelta=self.MAX_PRICE_DATE_TIMEDELTA
+                    )
+                except ValueError:
+                    raise DeserializationError("Price not provided but can not be found automatically")
+
+    def _process_raw_data(self, data: Dict[str, Any]):
+        if prices := data.get("prices", None):
+            self.import_source.log += "Instrument Prices found: Importing"
+            self.instrument_price_handler.process({"data": prices})
+
+    def _get_instance(self, data: Dict[str, Any], history: Optional[models.QuerySet] = None, **kwargs) -> models.Model:
+        self.import_source.log += "\nTrying to get asset position instance"
+        position = data["portfolio"].assets.filter(
+            date=data["date"], underlying_instrument=data["underlying_instrument"]
+        )
+        if position.exists():
+            self.import_source.log += "\nAsset Position found."
+            if position.count() > 1:
+                position = position.filter(is_estimated=False)
+            if position.count() > 1:
+                raise ValueError(f'We should find only one Assetposition:{position.values_list("id", flat=True)}')
+            return position.first()
+        self.import_source.log += "\nAsset Position not found. A new one will be created"
+        return None
+
+    def _create_instance(self, data: Dict[str, Any], **kwargs) -> models.Model:
+        instance = self.model(
+            portfolio=data["portfolio"],
+            underlying_instrument=data["underlying_instrument"],
+            date=data["date"],
+            asset_valuation_date=data["asset_valuation_date"],
+            weighting=data.get("weighting", None),
+            initial_price=data["initial_price"],
+            initial_shares=data.get("initial_shares", None),
+            initial_currency_fx_rate=data.get("initial_currency_fx_rate", 1),
+            import_source=self.import_source,
+            currency=data.get("currency", None),
+        )
+
+        return self._save_object(instance, **kwargs)
+
+    def _save_object(self, _object, **kwargs):
+        _object.underlying_instrument_price = (
+            None  # detech possibly already attached instrument price to retrigger the save mechanism
+        )
+        _object.save(create_underlying_instrument_price_if_missing=True)
+        return _object
+
+    def _post_processing_objects(
+        self,
+        created_objs: List[models.Model],
+        modified_objs: List[models.Model],
+        unmodified_objs: List[models.Model],
+    ):
+        from wbportfolio.models.portfolio import trigger_portfolio_change_as_task
+
+        portfolio_to_resynch = defaultdict(set)
+        imported_ids = defaultdict(set)
+        for obj in chain(created_objs, modified_objs, unmodified_objs):
+            portfolio_to_resynch[obj.portfolio].add(obj.date)
+            imported_ids[obj.portfolio].add(obj.id)
+
+        for portfolio, dates in portfolio_to_resynch.items():
+            # We remove leftovers positions from wrongly imported file
+            leftovers_positions = self.model.objects.filter(portfolio=portfolio, date__in=dates)
+            for obj_id in imported_ids[portfolio]:
+                leftovers_positions = leftovers_positions.exclude(id=obj_id)
+            for position in leftovers_positions:
+                position.delete()
+            for val_date in sorted(dates):
+                trigger_portfolio_change_as_task.delay(portfolio.id, val_date, recompute_weighting=True)
+
+        portfolios = set([(obj.portfolio, obj.date) for obj in chain(created_objs, modified_objs)])
+
+        for portfolio, val_date in portfolios:
+            custodian = portfolio.dependency_through.filter(type="CUSTODIAN")
+            if custodian.exists():
+                differences = portfolio.check_related_portfolio_at_date(
+                    val_date, custodian.first().dependency_portfolio
+                )
+                if differences.exists():
+                    for user in User.objects.filter(
+                        profile_id__in=PortfolioRole.portfolio_managers().values_list("person", flat=True)
+                    ):
+                        send_notification(
+                            code="wbportfolio.portfolio.check_custodian_portfolio",
+                            title="There is a discrepency between two portfolios",
+                            body=f"There has been a discrepency between two portfolios: {portfolio} and {custodian.first().dependency_portfolio}.",
+                            user=user,
+                            reverse_name="wbportfolio:portfolio-modelcompositionpandas-list",
+                            reverse_args=[portfolio.id],
+                        )

wbportfolio/import_export/handlers/dividend.py

@@ -0,0 +1,80 @@
+import math
+from datetime import datetime
+from decimal import Decimal
+from typing import Any, Dict
+
+from django.db import models
+from wbcore.contrib.currency.import_export.handlers import CurrencyImportHandler
+from wbcore.contrib.io.exceptions import DeserializationError
+from wbcore.contrib.io.imports import ImportExportHandler
+from wbfdm.import_export.handlers.instrument import InstrumentImportHandler
+
+
+class DividendImportHandler(ImportExportHandler):
+    MODEL_APP_LABEL = "wbportfolio.DividendTransaction"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.instrument_handler = InstrumentImportHandler(self.import_source)
+        self.currency_handler = CurrencyImportHandler(self.import_source)
+
+    def _deserialize(self, data):
+        data["transaction_date"] = datetime.strptime(data["transaction_date"], "%Y-%m-%d").date()
+        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"])
+        instrument = self.instrument_handler.process_object(
+            data["underlying_instrument"], only_security=False, read_only=True
+        )[0]
+        if not instrument:
+            raise DeserializationError("Can't process this data: underlying instrument not found")
+        data["underlying_instrument"] = instrument
+        if "currency" not in data:
+            data["currency"] = data["portfolio"].currency
+        else:
+            data["currency"] = self.currency_handler.process_object(data["currency"], read_only=True)[0]
+
+        for field in self.model._meta.get_fields():
+            if not (value := data.get(field.name, None)) is None and isinstance(field, models.DecimalField):
+                q = 1 / (math.pow(10, 4))
+                data[field.name] = Decimal(value).quantize(Decimal(str(q)))
+
+    def _get_instance(self, data, history=None, **kwargs):
+        self.import_source.log += "\nGet DividendTransaction Instance."
+        self.import_source.log += f"\nParameter: Portfolio={data['portfolio']} Underlying={data['underlying_instrument']} Date={data['transaction_date']}"
+        dividends = history if history is not None else self.model.objects
+
+        dividends = dividends.filter(
+            portfolio=data["portfolio"],
+            transaction_date=data["transaction_date"],
+            value_date=data["value_date"],
+            underlying_instrument=data["underlying_instrument"],
+            price_gross=data["price_gross"],
+        )
+        if dividends.count() == 1:
+            self.import_source.log += "\nDividendTransaction Instance Found." ""
+            return dividends.first()
+
+    def _create_instance(self, data, **kwargs):
+        self.import_source.log += "\nCreate DividendTransaction."
+        return self.model.objects.create(**data, import_source=self.import_source)
+
+    def _get_history(self: models.Model, history: Dict[str, Any]) -> models.QuerySet:
+        val_date = datetime.strptime(history["transaction_date"], "%Y-%m-%d")
+        if portfolio_id := history.get("portfolio", None):
+            dividends = self.model.objects.filter(transaction_date__lte=val_date, portfolio=portfolio_id)
+            if underlying_instrument_id := history.get("underlying_instrument", None):
+                dividends = dividends.filter(underlying_instrument=underlying_instrument_id)
+            return dividends
+
+    def _post_processing_history(self: models.Model, history: models.QuerySet):
+        self.import_source.log += "===================="
+        self.import_source.log += (
+            "It was a historical import and the following DividendTransaction have to be deleted:"
+        )
+        for dividend in history.order_by("transaction_date"):
+            self.import_source.log += (
+                f"\n{dividend.transaction_date:%d.%m.%Y}: {dividend.shares} {dividend.price} ==> Deleted"
+            )
+            dividend.delete()

wbportfolio/import_export/handlers/fees.py

@@ -0,0 +1,58 @@
+from datetime import datetime
+
+from wbcore.contrib.currency.import_export.handlers import CurrencyImportHandler
+from wbcore.contrib.io.imports import ImportExportHandler
+from wbfdm.models.instruments import Cash
+from wbportfolio.models.products import Product
+
+
+class FeesImportHandler(ImportExportHandler):
+    MODEL_APP_LABEL: str = "wbportfolio.Fees"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.currency_handler = CurrencyImportHandler(self.import_source)
+
+    def _deserialize(self, data):
+        data["transaction_date"] = datetime.strptime(data["transaction_date"], "%Y-%m-%d").date()
+        data["fee_date"] = data["transaction_date"]
+        if value_date_str := data.get("value_date", None):
+            data["value_date"] = datetime.strptime(value_date_str, "%Y-%m-%d").date()
+        if book_date_str := data.get("book_date", None):
+            data["book_date"] = datetime.strptime(book_date_str, "%Y-%m-%d").date()
+
+        from wbportfolio.models import Portfolio
+
+        data["linked_product"] = Product.objects.get(id=data["linked_product"])
+        if "porfolio" in data:
+            data["portfolio"] = Portfolio.objects.get(id=data["portfolio"])
+        else:
+            data["portfolio"] = data["linked_product"].primary_portfolio
+        data["underlying_instrument"] = Cash.objects.filter(currency=data["portfolio"].currency).first()
+        if "currency" not in data:
+            data["currency"] = data["portfolio"].currency
+        else:
+            data["currency"] = self.currency_handler.process_object(data["currency"], read_only=True)[0]
+        data["currency_fx_rate"] = 1.0
+        data["total_value"] = data.get("total_value", data.get("total_value_gross", None))
+        data["total_value_gross"] = data.get("total_value_gross", data["total_value"])
+        data["calculated"] = data.get("calculated", False)
+
+    def _get_instance(self, data, history=None, **kwargs):
+        self.import_source.log += "\nGet Fees Instance."
+        self.import_source.log += f"\nParameter: Portfolio={data['portfolio']} Date={data['transaction_date']}"
+        fees = self.model.objects.filter(
+            linked_product=data["linked_product"],
+            fee_date=data["fee_date"],
+            transaction_subtype=data["transaction_subtype"],
+            calculated=data["calculated"],
+        )
+        if fees.exists():
+            if fees.count() > 1:
+                raise ValueError(f'Number of similar fees found > 1: {fees.values_list("id", flat=True)}')
+            self.import_source.log += "\nFees Instance Found." ""
+            return fees.first()
+
+    def _create_instance(self, data, **kwargs):
+        self.import_source.log += "\nCreate Fees."
+        return self.model.objects.create(**data, import_source=self.import_source)

wbportfolio/import_export/handlers/portfolio_cash_flow.py

@@ -0,0 +1,57 @@
+from contextlib import suppress
+from datetime import datetime
+from decimal import Decimal
+from typing import TYPE_CHECKING
+
+from django.contrib.auth import get_user_model
+from django.db.models import Q
+from wbcore.contrib.io.imports import ImportExportHandler
+from wbcore.contrib.notifications.dispatch import send_notification
+from wbportfolio.models import Portfolio
+
+if TYPE_CHECKING:
+    from wbportfolio.models.portfolio_cash_flow import DailyPortfolioCashFlow
+
+
+class DailyPortfolioCashFlowImportHandler(ImportExportHandler):
+    MODEL_APP_LABEL = "wbportfolio.DailyPortfolioCashFlow"
+
+    def _deserialize(self, data):
+        data["value_date"] = datetime.strptime(data["value_date"], "%Y-%m-%d").date()
+        data["portfolio"] = Portfolio.objects.get(id=data["portfolio"])
+        if "cash" in data:
+            data["cash"] = Decimal(data["cash"])
+
+        if "total_assets" in data:
+            data["total_assets"] = Decimal(data["total_assets"])
+
+        if "cash_flow_forecast" in data:
+            data["cash_flow_forecast"] = Decimal(data["cash_flow_forecast"])
+
+    def _get_instance(self, data, history=None, **kwargs):
+        self.import_source.log += "\nGet Daily Portfolio Cash Flow Instance."
+        self.import_source.log += f"\nParameter: Portfolio={data['portfolio']} Value Date={data['value_date']}"
+
+        with suppress(self.model.DoesNotExist):
+            return self.model.objects.get(portfolio=data["portfolio"], value_date=data["value_date"])
+
+    def _post_processing_created_object(self, _object: "DailyPortfolioCashFlow"):
+        if not _object.portfolio.daily_cashflows.filter(value_date__gt=_object.value_date).exists():
+            if _object.proposed_rebalancing != Decimal(0):
+                color = "red" if _object.proposed_rebalancing < 0 else "green"
+                for user in (
+                    get_user_model()
+                    .objects.filter(
+                        Q(user_permissions__codename="view_dailyportfoliocashflow")
+                        | Q(groups__permissions__codename="view_dailyportfoliocashflow")
+                    )
+                    .distinct()
+                ):
+                    send_notification(
+                        code="wbportfolio.dailyportfoliocashflow.notify_rebalance",
+                        title=f"Proposed Rebalancing in the portfolio: {_object.portfolio}",
+                        body=f"The workbench proposes to rebalance the portfolio {_object.portfolio} by <span style='color:{color}'>{_object.proposed_rebalancing:+,.2f}</span>",
+                        user=user,
+                        reverse_name="wbportfolio:portfoliocashflow-detail",
+                        reverse_args=[_object.pk],
+                    )

wbportfolio/import_export/handlers/register.py

@@ -0,0 +1,43 @@
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+from django.db import models
+from wbcore.contrib.geography.models import Geography
+from wbcore.contrib.io.imports import ImportExportHandler
+
+
+class RegisterImportHandler(ImportExportHandler):
+    MODEL_APP_LABEL = "wbportfolio.Register"
+
+    def _deserialize(self, data: Dict[str, Any]):
+        if "opened" in data:
+            data["opened"] = datetime.strptime(data["opened"], "%Y-%m-%d").date()
+        if residence_id := data.get("residence"):
+            data["residence"] = Geography.countries.get(id=residence_id)
+        if citizenship_id := data.get("citizenship"):
+            data["citizenship"] = Geography.countries.get(id=citizenship_id)
+        if outlet_country_id := data.get("outlet_country"):
+            data["outlet_country"] = Geography.countries.get(id=outlet_country_id)
+        if custodian_country_id := data.get("custodian_country"):
+            data["custodian_country"] = Geography.countries.get(id=custodian_country_id)
+
+        outlet_city = data.pop("outlet_city", None)
+        if (outlet_country := data.get("outlet_country", None)) and outlet_city:
+            if res := outlet_country.lookup_descendants(outlet_city, level=Geography.Level.CITY.value):
+                data["outlet_city"] = res
+
+        custodian_city = data.pop("custodian_city", None)
+        if (custodian_country := data.get("custodian_country", None)) and custodian_city:
+            if res := custodian_country.lookup_descendants(custodian_city, level=Geography.Level.CITY.value):
+                data["custodian_city"] = res
+
+    def _get_instance(self, data: Dict[str, Any], history: Optional[models.QuerySet] = None, **kwargs) -> models.Model:
+        self.import_source.log += "Get Register Instance."
+        self.import_source.log += f"Parameter: Reference={data['register_reference']}"
+        if isinstance(data, int):
+            return self.model.objects.get(id=data)
+        return self.model.objects.filter(register_reference=data["register_reference"]).first()
+
+    def _create_instance(self, data: Dict[str, Any], **kwargs) -> models.Model:
+        self.import_source.log += "Create Register."
+        return self.model.objects.create(import_source=self.import_source, **data)