wbportfolio 1.43.1__py2.py3-none-any.whl

wbportfolio/filters/transactions/trades.py

@@ -0,0 +1,248 @@
+from datetime import timedelta
+
+from django.db.models import Count, OuterRef, Subquery
+from wbcore import filters as wb_filters
+from wbcrm.models.accounts import Account
+from wbfdm.models import Instrument
+from wbportfolio.models import Product, Trade
+from wbportfolio.models.transactions.claim import Claim
+
+from .transactions import TransactionFilterSet
+
+
+class TradeFilter(TransactionFilterSet):
+    transaction_date = wb_filters.DateRangeFilter(
+        method=wb_filters.DateRangeFilter.base_date_range_filter_method,
+        label="Date Range",
+    )
+    underlying_instrument = wb_filters.ModelChoiceFilter(
+        label="Instrument",
+        queryset=Instrument.objects.all(),
+        endpoint=Instrument.get_representation_endpoint(),
+        value_key=Instrument.get_representation_value_key(),
+        label_key=Instrument.get_representation_label_key(),
+        filter_params={"is_investable": True},
+    )
+    only_internal_trade = wb_filters.BooleanFilter(label="Only Internal Trade", method="boolean_only_internal_trade")
+
+    completely_claimed = wb_filters.BooleanFilter(label="Completely Claimed", method="boolean_completely_claimed")
+    completely_claimed_if_approved = wb_filters.BooleanFilter(
+        label="Completely Claimed if approved", method="boolean_completely_claimed_if_approved"
+    )
+
+    claimed_shares__gte = wb_filters.NumberFilter(
+        label="Claimed Shares", lookup_expr="gte", field_name="claimed_shares"
+    )
+    claimed_shares__lte = wb_filters.NumberFilter(
+        label="Claimed Shares", field_name="claimed_shares", lookup_expr="lte"
+    )
+    claims = wb_filters.ModelChoiceFilter(
+        label="Customer Accounts",
+        queryset=Account.objects.all(),
+        endpoint=Account.get_representation_endpoint(),
+        value_key=Account.get_representation_value_key(),
+        label_key=Account.get_representation_label_key(),
+        method="filter_customer",
+    )
+    is_customer_trade = wb_filters.BooleanFilter(label="Is Customer Trade?", method="boolean_is_customer_trade")
+    # register = wb_filters.ModelChoiceFilter(
+    #     label="Register",
+    #     queryset=Register.objects.all(),
+    #     endpoint=Register.get_representation_endpoint(),
+    #     value_key=Register.get_representation_value_key(),
+    #     label_key = Register.get_representation_label_key(),
+    # )
+    total_value_usd__gte = total_value_usd__lte = transaction_underlying_type = None
+    marked_for_deletion = wb_filters.BooleanFilter(
+        label="Marked For Deletion", default=False, field_name="marked_for_deletion", lookup_expr="exact"
+    )
+    pivot_date = wb_filters.DateFilter(hidden=True, method="filter_pivot_date")
+
+    def filter_pivot_date(self, queryset, name, value):
+        if value:
+            return queryset.filter(
+                transaction_date__gte=value - timedelta(days=Trade.TRADE_WINDOW_INTERVAL),
+                transaction_date__lte=value + timedelta(days=Trade.TRADE_WINDOW_INTERVAL),
+            )
+        return queryset
+
+    def filter_customer(self, queryset, name, value):
+        if value:
+            accounts = value.get_descendants(include_self=True)
+            queryset = queryset.annotate(
+                filtered_claims=Subquery(
+                    Claim.objects.filter(trade=OuterRef("pk"), account__in=accounts)
+                    .values("account")
+                    .annotate(c=Count("account"))
+                    .values("c")[:1]
+                )
+            )
+            return queryset.filter(filtered_claims__gt=0)
+        return queryset
+
+    def boolean_is_customer_trade(self, queryset, name, value):
+        if value is True:
+            return queryset.filter(transaction_subtype__in=[Trade.Type.SUBSCRIPTION, Trade.Type.REDEMPTION])
+        elif value is False:
+            return queryset.exclude(transaction_subtype__in=[Trade.Type.SUBSCRIPTION, Trade.Type.REDEMPTION])
+        else:
+            return queryset
+
+    def boolean_completely_claimed(self, queryset, name, value):
+        if value is True:
+            return queryset.filter(completely_claimed=True)
+        elif value is False:
+            return queryset.filter(completely_claimed=False)
+        else:
+            return queryset
+
+    def boolean_completely_claimed_if_approved(self, queryset, name, value):
+        if value is True:
+            return queryset.filter(completely_claimed_if_approved=True)
+        elif value is False:
+            return queryset.filter(completely_claimed_if_approved=False)
+        else:
+            return queryset
+
+    def boolean_only_internal_trade(self, queryset, name, value):
+        if value:
+            return queryset.exclude(transaction_subtype__in=[Trade.Type.SUBSCRIPTION, Trade.Type.REDEMPTION]).filter(
+                underlying_instrument__instrument_type__key="product"
+            )
+        return queryset
+
+    class Meta:
+        model = Trade
+        fields = {
+            "shares": ["gte", "lte", "exact"],
+            "bank": ["exact", "icontains"],
+            "price": ["gte", "lte", "exact"],
+            "currency": ["exact"],
+            "currency_fx_rate": ["gte", "exact", "lte"],
+            "total_value": ["gte", "exact", "lte"],
+            "total_value_fx_portfolio": ["gte", "exact", "lte"],
+            "comment": ["icontains"],
+            "portfolio": ["exact"],
+            "register": ["exact"],
+            # 'total_value_gross_fx_portfolio': ["gte", "exact", "lte"],
+            "transaction_subtype": ["exact"],
+            "pending": ["exact"],
+        }
+
+
+class TradePortfolioFilter(TradeFilter):
+    portfolio = None
+
+    class Meta:
+        model = Trade
+        fields = {
+            "shares": ["gte", "lte", "exact"],
+            "bank": ["exact", "icontains"],
+            "price": ["gte", "lte", "exact"],
+            "currency": ["exact"],
+            "currency_fx_rate": ["gte", "exact", "lte"],
+            "total_value": ["gte", "exact", "lte"],
+            "total_value_fx_portfolio": ["gte", "exact", "lte"],
+            "comment": ["icontains"],
+            "register": ["exact"],
+            "transaction_subtype": ["exact"],
+        }
+
+
+class SubscriptionRedemptionFilterSet(TradeFilter):
+    is_customer_trade = None
+    underlying_instrument = wb_filters.ModelChoiceFilter(
+        label="Product",
+        queryset=Product.objects.all(),
+        endpoint=Product.get_representation_endpoint(),
+        value_key=Product.get_representation_value_key(),
+        label_key=Product.get_representation_label_key(),
+    )
+
+    opposite_shares = wb_filters.NumberFilter(
+        field_name="shares",
+        label="Opposite Shares",
+        method="filter_opposite_shares",
+        lookup_icon="±",
+        lookup_label="Opposite",
+    )
+
+    def filter_opposite_shares(self, queryset, name, value):
+        return queryset.filter(shares=value * -1)
+
+    opposite_approximate_shares = wb_filters.NumberFilter(
+        field_name="shares",
+        label="Opposite Approximite Shares",
+        method="filter_opposite_approximate_shares",
+        lookup_icon="≈±",
+        lookup_label="Opposite Approximate (+- 10%)",
+    )
+
+    def filter_opposite_approximate_shares(self, queryset, name, value):
+        value = float(value)
+        value_lower_bound = -0.9 * value
+        value_higher_bound = -1.1 * value
+
+        if value > 0:
+            return queryset.filter(shares__lte=value_lower_bound, shares__gte=value_higher_bound)
+        return queryset.filter(shares__lte=value_higher_bound, shares__gte=value_lower_bound)
+
+    class Meta:
+        model = Trade
+        fields = {
+            "shares": ["gte", "lte", "exact"],
+            "bank": ["exact", "icontains"],
+            "price": ["gte", "lte", "exact"],
+            "currency": ["exact"],
+            "total_value": ["gte", "exact", "lte"],
+            "comment": ["icontains"],
+            "portfolio": ["exact"],
+            "register": ["exact"],
+            # 'total_value_gross_fx_portfolio': ["gte", "exact", "lte"],
+            "transaction_subtype": ["exact"],
+            "marked_for_deletion": ["exact"],
+            "custodian": ["exact"],
+            "pending": ["exact"],
+        }
+
+
+class TradeInstrumentFilterSet(TradeFilter):
+    is_customer_trade = underlying_instrument = completely_claimed = completely_claimed_if_approved = (
+        claimed_shares__gte
+    ) = claimed_shares__lte = claims = total_value_usd__gte = None
+
+    class Meta:
+        model = Trade
+        fields = {
+            "shares": ["gte", "lte", "exact"],
+            "bank": ["exact", "icontains"],
+            "price": ["gte", "lte", "exact"],
+            "currency_fx_rate": ["gte", "exact", "lte"],
+            "total_value": ["gte", "exact", "lte"],
+            "total_value_fx_portfolio": ["gte", "exact", "lte"],
+            "total_value_gross": ["gte", "exact", "lte"],
+            "total_value_gross_fx_portfolio": ["gte", "exact", "lte"],
+            "comment": ["icontains"],
+            "portfolio": ["exact"],
+            "register": ["exact"],
+            "transaction_subtype": ["exact"],
+        }
+
+
+class SubscriptionRedemptionPortfolioFilterSet(TradeFilter):
+    is_customer_trade = None
+
+    class Meta:
+        model = Trade
+        fields = {
+            "shares": ["gte", "lte", "exact"],
+            "bank": ["exact", "icontains"],
+            "price": ["gte", "lte", "exact"],
+            "currency": ["exact"],
+            "total_value": ["gte", "exact", "lte"],
+            "comment": ["icontains"],
+            "register": ["exact"],
+            # 'total_value_gross_fx_portfolio': ["gte", "exact", "lte"],
+            "transaction_subtype": ["exact"],
+            "custodian": ["exact"],
+        }

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/fixtures/product_factsheets.yaml

@@ -0,0 +1 @@
+[{"model": "wbreport.colorgradient", "pk": 1, "fields": {"title": "Default Color Palette", "colors": "[\"#ffb166\", \"#d1c554\", \"#8cd66b\", \"#5fd785\", \"#05d6a1\", \"#00c1ab\", \"#01abaa\", \"#38c1d7\", \"#70d6ff\", \"#00b1ff\", \"#0585ff\", \"#2a5df2\", \"#5724d9\", \"#823edf\", \"#a359e5\", \"#e13da9\", \"#ef476f\"]"}}, {"model": "wbreport.reportasset", "pk": 1, "fields": {"key": "font-default", "description": "", "text": "", "asset": "report/assets/Roboto-Light.ttf"}}, {"model": "wbreport.reportasset", "pk": 2, "fields": {"key": "font-bd", "description": "", "text": "", "asset": "report/assets/Roboto-Medium.ttf"}}, {"model": "wbreport.reportasset", "pk": 3, "fields": {"key": "font-it", "description": "", "text": "", "asset": "report/assets/Roboto-LightItalic.ttf"}}, {"model": "wbreport.reportcategory", "pk": 1, "fields": {"title": "Test", "order": 0}}, {"model": "wbreport.reportclass", "pk": 1, "fields": {"title": "Base Product Report Class", "class_path": "wbreport.defaults.factsheets.base"}}, {"model": "wbreport.reportclass", "pk": 2, "fields": {"title": "Multindex Report Class", "class_path": "wbreport.defaults.factsheets.multitheme"}}, {"model": "wbreport.reportclass", "pk": 3, "fields": {"title": "Menu Report Class", "class_path": "wbreport.defaults.factsheets.menu"}}, {"model": "wbreport.report", "pk": 1, "fields": {"content_type": 67, "object_id": 566, "file_content_type": "PDF", "category": null, "parent_report": 5, "is_active": true, "file_disabled": false, "base_color": "#70D6FF", "is_private": false, "mailing_list": null, "report_class": 1, "title": "Base Index Factsheet", "namespace": "base-index-factsheet", "logo_file": "", "color_palette": 1}}, {"model": "wbreport.report", "pk": 2, "fields": {"content_type": 67, "object_id": 567, "file_content_type": "PDF", "category": null, "parent_report": 5, "is_active": true, "file_disabled": false, "base_color": "#05D6A1", "is_private": false, "mailing_list": null, "report_class": 1, "title": "Base Product Factsheet", "namespace": "base-product-factsheet", "logo_file": "", "color_palette": 1}}, {"model": "wbreport.report", "pk": 3, "fields": {"content_type": 67, "object_id": 629, "file_content_type": "PDF", "category": null, "parent_report": 5, "is_active": true, "file_disabled": false, "base_color": "#FFB166", "is_private": false, "mailing_list": null, "report_class": 2, "title": "Multi Indexes Factsheet", "namespace": "multi-indexes", "logo_file": "", "color_palette": 1}}, {"model": "wbreport.report", "pk": 4, "fields": {"content_type": 67, "object_id": 613, "file_content_type": "PDF", "category": null, "parent_report": 5, "is_active": true, "file_disabled": false, "base_color": "#EF476F", "is_private": false, "mailing_list": null, "report_class": 1, "title": "Share class Factsheet", "namespace": "share-class-factsheet", "logo_file": "", "color_palette": 1}}, {"model": "wbreport.report", "pk": 5, "fields": {"content_type": null, "object_id": null, "file_content_type": "PDF", "category": null, "parent_report": null, "is_active": true, "file_disabled": false, "base_color": "#FFF000", "is_private": false, "mailing_list": null, "report_class": 3, "title": "Factsheet", "namespace": "factsheet", "logo_file": "", "color_palette": 1}}, {"model": "wbreport.reportversion", "pk": 1, "fields": {"uuid": "9ebd8023-7ebb-4389-a484-410c7c4aad2a", "lookup": "august-2021", "title": "August 2021", "parameters": {"end": "2021-08-31", "start": "2021-07-30"}, "context": {}, "version_date": "2021-11-09", "creation_date": "2021-11-09T10:15:28.539Z", "update_date": "2021-11-09T13:00:00.665Z", "comment": "", "is_primary": true, "disabled": false, "report": 5}}, {"model": "wbreport.reportversion", "pk": 2, "fields": {"uuid": "8a675145-249e-4183-8f19-5cb023fce8c7", "lookup": "factsheet-august-2021", "title": "Share class - August 2021", "parameters": {"end": "2021-08-31", "start": "2021-07-30"}, "context": {}, "version_date": "2021-11-09", "creation_date": "2021-11-09T10:18:20.567Z", "update_date": "2021-11-09T13:00:01.418Z", "comment": "", "is_primary": true, "disabled": false, "report": 4}}, {"model": "wbreport.reportversion", "pk": 4, "fields": {"uuid": "8e186d05-5298-4ab3-bc0b-6a81398e622a", "lookup": "factsheet-mutli-index-august-2021", "title": "Mutli Index - August 2021", "parameters": {"end": "2021-08-31", "start": "2021-07-30"}, "context": {}, "version_date": "2021-11-09", "creation_date": "2021-11-09T10:19:05.102Z", "update_date": "2021-11-09T13:00:01.962Z", "comment": "", "is_primary": true, "disabled": false, "report": 3}}, {"model": "wbreport.reportversion", "pk": 6, "fields": {"uuid": "825c101e-54ec-4197-ad8a-678bcd6431dd", "lookup": "factsheet-base-product-august-2021", "title": "Base product - August 2021", "parameters": {"end": "2021-08-31", "start": "2021-07-30"}, "context": {}, "version_date": "2021-11-09", "creation_date": "2021-11-09T10:19:41.464Z", "update_date": "2021-11-09T13:00:02.271Z", "comment": "", "is_primary": true, "disabled": false, "report": 2}}, {"model": "wbreport.reportversion", "pk": 7, "fields": {"uuid": "5e1014f0-f211-4b81-b272-4d5284d7ef8c", "lookup": "factsheet-base-index-august-2021", "title": "Base Index - August 2021", "parameters": {"end": "2021-08-31", "start": "2021-07-30"}, "context": {}, "version_date": "2021-11-09", "creation_date": "2021-11-09T10:19:54.422Z", "update_date": "2021-11-09T13:00:02.616Z", "comment": "", "is_primary": true, "disabled": false, "report": 1}}]

wbportfolio/import_export/backends/__init__.py

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

wbportfolio/import_export/backends/refinitiv/adjustment.py

@@ -0,0 +1,40 @@
+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 wbfdm.import_export.backends.refinitiv.utils import Controller
+from wbportfolio.import_export.backends.utils import (
+    get_timedelta_import_instrument_price,
+)
+
+from ..wbfdm.mixin import DataBackendMixin
+
+DEFAULT_MAPPING = {"AX": "factor"}
+
+
+@register("Adjustment", provider_key="refinitiv")
+class DataBackend(DataBackendMixin, AbstractDataBackend):
+    CHUNK_SIZE = 50
+
+    def __init__(self, import_credential: Optional[models.Model] = None, **kwargs):
+        self.controller = Controller(import_credential.username, import_credential.password)
+
+    def get_files(
+        self,
+        execution_time: datetime,
+        obj_external_ids: list[str] = None,
+        **kwargs,
+    ) -> BytesIO:
+        execution_date = execution_time.date()
+        start = kwargs.get("start", (execution_date - BDay(get_timedelta_import_instrument_price())).date())
+        fields = list(DEFAULT_MAPPING.keys())
+        if obj_external_ids:
+            df = self.controller.get_data(obj_external_ids, fields, start, execution_date)
+            if not df.empty:
+                content_file = BytesIO()
+                df.to_json(content_file, orient="records")
+                file_name = f"adjustment_chunk-{start:%Y-%m-%d}-{execution_date:%Y-%m-%d}_{datetime.timestamp(execution_time)}.json"
+                yield file_name, content_file

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 *