wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/filters/transactions/transactions.py

@@ -0,0 +1,98 @@
+from datetime import date, timedelta
+
+from psycopg.types.range import DateRange
+from wbcore import filters as wb_filters
+from wbportfolio.models import Fees, Portfolio, Trade, Transaction
+
+
+def get_transaction_gte_default(field, request, view):
+    filter_date = date.today() - timedelta(days=90)
+    qs = Transaction.objects.none()
+    if "instrument_id" in view.kwargs:
+        qs = Transaction.objects.filter(underlying_instrument__id=view.kwargs["instrument_id"])
+    elif "portfolio_id" in view.kwargs:
+        qs = Transaction.objects.filter(portfolio__id=view.kwargs["portfolio_id"])
+    if qs.exists():
+        filter_date = qs.earliest("transaction_date").transaction_date
+    return filter_date
+
+
+def get_transaction_underlying_type_choices(*args):
+    models = [Fees, Trade]
+    choices = []
+    for model in models:
+        for choice in model.Type.choices:
+            choices.append(choice)
+    return choices
+
+
+def get_transaction_lte_default(field, request, view):
+    filter_date = date.today() + timedelta(days=7)
+    qs = Transaction.objects.none()
+    if "instrument_id" in view.kwargs:
+        qs = Transaction.objects.filter(underlying_instrument__id=view.kwargs["instrument_id"])
+    elif "portfolio_id" in view.kwargs:
+        qs = Transaction.objects.filter(portfolio__id=view.kwargs["portfolio_id"])
+    if qs.exists():
+        filter_date = qs.latest("transaction_date").transaction_date
+    return filter_date
+
+
+def get_transaction_default_date_range(*args, **kwargs):
+    return DateRange(get_transaction_gte_default(*args, **kwargs), get_transaction_lte_default(*args, **kwargs))
+
+
+class TransactionFilterSet(wb_filters.FilterSet):
+    transaction_date = wb_filters.DateRangeFilter(
+        method=wb_filters.DateRangeFilter.base_date_range_filter_method,
+        label="Date Range",
+        default=get_transaction_default_date_range,
+    )
+
+    portfolio = wb_filters.ModelChoiceFilter(
+        label="Portfolio",
+        queryset=Portfolio.objects.all(),
+        endpoint=Portfolio.get_representation_endpoint(),
+        value_key=Portfolio.get_representation_value_key(),
+        label_key=Portfolio.get_representation_label_key(),
+    )
+    total_value_usd__gte = wb_filters.NumberFilter(
+        lookup_expr="gte", field_name="total_value_usd", label="Total Value ($)"
+    )
+    total_value_usd__lte = wb_filters.NumberFilter(
+        lookup_expr="lte",
+        label="Total Value ($)",
+        field_name="total_value_usd",
+    )
+
+    transaction_underlying_type = wb_filters.ChoiceFilter(
+        label="Underlying Type",
+        choices=get_transaction_underlying_type_choices(),
+        method="filter_transaction_underlying_type",
+    )
+
+    def filter_transaction_underlying_type(self, queryset, name, value):
+        if value:
+            queryset = queryset.filter(transaction_underlying_type=value)
+        return queryset
+
+    class Meta:
+        model = Transaction
+        fields = {
+            "transaction_type": ["exact"],
+            "underlying_instrument": ["exact"],
+            "currency": ["exact"],
+            "total_value": ["gte", "exact", "lte"],
+            "total_value_fx_portfolio": ["gte", "exact", "lte"],
+        }
+
+
+class TransactionPortfolioFilterSet(TransactionFilterSet):
+    portfolio = transaction_date__gte = transaction_date__lte = None
+    transaction_date = wb_filters.DateFilter(
+        label="Transaction Date",
+        lookup_expr="exact",
+        field_name="transaction_date",
+        default=get_transaction_lte_default,
+        required=True,
+    )

wbportfolio/import_export/backends/__init__.py

@@ -0,0 +1,2 @@
+from .ubs import *
+from .wbfdm import *

wbportfolio/import_export/backends/ubs/__init__.py

@@ -0,0 +1,3 @@
+from .asset_position import *
+from .fees import *
+from .instrument_price import *

wbportfolio/import_export/backends/ubs/asset_position.py

@@ -0,0 +1,45 @@
+import json
+from datetime import date, datetime
+from io import BytesIO
+from typing import Optional
+
+from django.db import models
+from pandas.tseries.offsets import BDay
+from wbcore.contrib.io.backends import AbstractDataBackend, register
+
+from ..utils import process_request
+from .mixin import DataBackendMixin
+
+
+@register("Asset Position", provider_key="ubs", save_data_in_import_source=True, passive_only=True)
+class DataBackend(DataBackendMixin, AbstractDataBackend):
+    def __init__(
+        self, import_credential: Optional[models.Model] = None, ubs_bank: Optional[models.Model] = None, **kwargs
+    ):
+        if not ubs_bank:
+            raise ValueError("The ubs company objects needs to be passed to this backend")
+        self.ubs_bank = ubs_bank
+        if not import_credential or not import_credential.authentication_token:
+            raise ValueError("UBS backend needs a valid import credential object")
+        self.authentication_token = import_credential.authentication_token
+
+    def get_files(
+        self,
+        execution_time: datetime,
+        start: date = None,
+        obj_external_ids: list[str] = None,
+        **kwargs,
+    ) -> BytesIO:
+        execution_date = (execution_time - BDay(1)).date()
+
+        endpoint = "https://neo.ubs.com/api/ged-amc/external/report/v1/valuation/{0}/{1}"
+        if obj_external_ids:
+            for external_id in obj_external_ids:
+                res_json = process_request(
+                    self.authentication_token, endpoint.format(external_id, execution_date.strftime("%Y-%m-%d"))
+                )
+                if res_json:
+                    content_file = BytesIO()
+                    content_file.write(json.dumps(res_json).encode())
+                    file_name = f"ubs_positions_{external_id}_{execution_date:%Y-%m-%d}_{datetime.timestamp(execution_time)}.json"
+                    yield file_name, content_file

wbportfolio/import_export/backends/ubs/fees.py

@@ -0,0 +1,63 @@
+import json
+from datetime import datetime
+from io import BytesIO
+from typing import Optional
+
+from django.db import models
+from dynamic_preferences.registries import global_preferences_registry
+from wbcore.contrib.io.backends import AbstractDataBackend, register
+
+from ..utils import process_request
+from .mixin import DataBackendMixin
+
+
+@register("Fees", provider_key="ubs", save_data_in_import_source=True, passive_only=True)
+class DataBackend(DataBackendMixin, AbstractDataBackend):
+    def __init__(
+        self, import_credential: Optional[models.Model] = None, ubs_bank: Optional[models.Model] = None, **kwargs
+    ):
+        if not ubs_bank:
+            raise ValueError("The ubs company objects needs to be passed to this backend")
+        self.ubs_bank = ubs_bank
+        if not import_credential or not import_credential.authentication_token:
+            raise ValueError("UBS backend needs a valid import credential object")
+        self.authentication_token = import_credential.authentication_token
+
+    def get_files(
+        self,
+        execution_time: datetime,
+        obj_external_ids: list[str] = None,
+        **kwargs,
+    ) -> BytesIO:
+        execution_date = execution_time.date()
+
+        mngt_fees_endpoint = "https://neo.ubs.com/api/ged-amc/external/fee/v1/management/{0}"
+        perf_fees_endpoint = "https://neo.ubs.com/api/ged-amc/external/fee/v1/performance/{0}"
+        if obj_external_ids:
+            for external_id in obj_external_ids:
+                start = kwargs.get("start", None)
+                if not start:
+                    start = global_preferences_registry.manager()["wbfdm__default_start_date_historical_import"]
+                mngt_res = process_request(
+                    self.authentication_token,
+                    mngt_fees_endpoint.format(external_id),
+                    {"fromDate": start.strftime("%Y-%m-%d"), "toDate": execution_date.strftime("%Y-%m-%d")},
+                )
+                perf_res = process_request(
+                    self.authentication_token,
+                    perf_fees_endpoint.format(external_id),
+                    {"fromDate": start.strftime("%Y-%m-%d"), "toDate": execution_date.strftime("%Y-%m-%d")},
+                )
+
+                if mngt_res or perf_res:
+                    res_json = {
+                        "performance_fees": perf_res.get("fees", []),
+                        "management_fees": mngt_res.get("fees", []),
+                        "isin": external_id,
+                    }
+
+                    if res_json:
+                        content_file = BytesIO()
+                        content_file.write(json.dumps(res_json).encode())
+                        file_name = f"ubs_fees_{external_id}_{start:%Y-%m-%d}_{execution_date:%Y-%m-%d}_{datetime.timestamp(execution_time)}.json"
+                        yield file_name, content_file

wbportfolio/import_export/backends/ubs/instrument_price.py

@@ -0,0 +1,44 @@
+import json
+from datetime import datetime
+from io import BytesIO
+from typing import Optional
+
+from django.db import models
+from pandas.tseries.offsets import BDay
+from wbcore.contrib.io.backends import AbstractDataBackend, register
+
+from ..utils import process_request
+from .mixin import DataBackendMixin
+
+
+@register("Instrument Prices", provider_key="ubs", save_data_in_import_source=True, passive_only=True)
+class DataBackend(DataBackendMixin, AbstractDataBackend):
+    def __init__(
+        self, import_credential: Optional[models.Model] = None, ubs_bank: Optional[models.Model] = None, **kwargs
+    ):
+        if not ubs_bank:
+            raise ValueError("The ubs company objects needs to be passed to this backend")
+        self.ubs_bank = ubs_bank
+        if not import_credential or not import_credential.authentication_token:
+            raise ValueError("UBS backend needs a valid import credential object")
+        self.authentication_token = import_credential.authentication_token
+
+    def get_files(
+        self,
+        execution_time: datetime,
+        obj_external_ids: list[str] = None,
+        **kwargs,
+    ) -> BytesIO:
+        execution_date = (execution_time - BDay(1)).date()
+        endpoint = "https://neo.ubs.com/api/ged-amc/external/report/v1/valuation/{0}/{1}"
+        if obj_external_ids:
+            for external_id in obj_external_ids:
+                res_json = process_request(
+                    self.authentication_token, endpoint.format(external_id, execution_date.strftime("%Y-%m-%d"))
+                )
+                res_json.pop("constituents", None)
+                if res_json:
+                    content_file = BytesIO()
+                    content_file.write(json.dumps(res_json).encode())
+                    file_name = f"ubs_instrument_price_{external_id}_{execution_date:%Y-%m-%d}_{int(datetime.timestamp(execution_time))}.json"
+                    yield file_name, content_file

wbportfolio/import_export/backends/ubs/mixin.py

@@ -0,0 +1,15 @@
+from datetime import date
+
+from django.db import models
+from wbportfolio.models.products import Product
+
+
+class DataBackendMixin:
+    def is_object_valid(self, obj: models.Model) -> bool:
+        return super().is_object_valid(obj) and obj.is_active_at_date(date.today()) and obj.isin
+
+    def get_default_queryset(self):
+        return Product.objects.filter(bank=self.ubs_bank, isin__isnull=False)
+
+    def get_provider_id(self, obj: models.Model) -> str:
+        return obj.isin

wbportfolio/import_export/backends/utils.py

@@ -0,0 +1,58 @@
+from contextlib import suppress
+
+import pandas as pd
+import requests
+from django.db.models import Q
+from dynamic_preferences.registries import global_preferences_registry
+from wbfdm.models import Instrument
+
+
+def get_timedelta_import_instrument_price():
+    return global_preferences_registry.manager()["wbportfolio__timedelta_import_instrument_price"]
+
+
+def process_request(authentication_token: str, endpoint: str | None = None, kwargs={}) -> pd.DataFrame:
+    headers = {"Authorization": authentication_token}
+    r = requests.get(endpoint, params=kwargs, headers=headers)
+    if r.status_code == requests.codes.ok:
+        with suppress(
+            requests.exceptions.JSONDecodeError
+        ):  # we catch any json decode error because the UBS api doesn't seem to respect HTTP status code rule (i.e. returns 200 even though the http content is malformed)
+            r_json = r.json()
+            if r_json.get("status", "") == "SUCCESS":
+                return r_json
+    raise ValueError(f"Issue while processing request: {r.content}")
+
+
+def filter_active_instruments(_date, queryset=None):
+    if not queryset:
+        queryset = Instrument.objects
+    queryset = queryset.filter(Q(delisted_date__isnull=True) | Q(delisted_date__gte=_date))
+    queryset = queryset.filter(
+        Q(refinitiv_mnemonic_code__isnull=False) | Q(refinitiv_identifier_code__isnull=False) | Q(isin__isnull=False)
+    )
+    return queryset.distinct()
+
+
+def chunked_queryset(queryset, chunk_size):
+    """Slice a queryset into chunks."""
+
+    start_pk = 0
+    queryset = queryset.order_by("pk")
+
+    while True:
+        # No entry left
+        if not queryset.filter(pk__gt=start_pk).exists():
+            break
+
+        try:
+            # Fetch chunk_size entries if possible
+            end_pk = queryset.filter(pk__gt=start_pk).values_list("pk", flat=True)[chunk_size - 1]
+
+            # Fetch rest entries if less than chunk_size left
+        except IndexError:
+            end_pk = queryset.values_list("pk", flat=True).last()
+
+        yield queryset.filter(pk__gt=start_pk).filter(pk__lte=end_pk)
+
+        start_pk = end_pk

wbportfolio/import_export/backends/wbfdm/__init__.py

@@ -0,0 +1,2 @@
+from .adjustment import *
+from .dividend import *

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],
+                        )