wbportfolio 1.52.0__py2.py3-none-any.whl → 1.59.4__py2.py3-none-any.whl

wbportfolio/factories/trades.py

@@ -1,35 +1,31 @@
 import random
+from datetime import timedelta
+from decimal import Decimal
 
 import factory
 from faker import Faker
-from pandas._libs.tslibs.offsets import BDay
 
-from wbportfolio.models import Trade, TradeProposal
-
-from .transactions import TransactionFactory
+from wbportfolio.models import Trade
 
 fake = Faker()
 
 
-class TradeFactory(TransactionFactory):
+class TradeFactory(factory.django.DjangoModelFactory):
     class Meta:
         model = Trade
 
+    currency_fx_rate = Decimal(1.0)
+    fees = Decimal(0.0)
+    portfolio = factory.SubFactory("wbportfolio.factories.PortfolioFactory")
+    underlying_instrument = factory.SubFactory("wbfdm.factories.InstrumentFactory")
+    currency = factory.SubFactory("wbcore.contrib.currency.factories.CurrencyFactory")
+    transaction_date = factory.Faker("date_object")
+    value_date = factory.LazyAttribute(lambda o: o.transaction_date + timedelta(days=1))
     bank = factory.Faker("company")
     marked_for_deletion = False
     shares = factory.Faker("pydecimal", min_value=10, max_value=1000, right_digits=4)
     price = factory.LazyAttribute(lambda o: random.randint(10, 10000))
-    # trade_proposal = factory.SubFactory("wbportfolio.factories.TradeProposalFactory")
-
-
-class TradeProposalFactory(factory.django.DjangoModelFactory):
-    class Meta:
-        model = TradeProposal
-
-    trade_date = factory.LazyAttribute(lambda o: (fake.date_object() + BDay(1)).date())
-    comment = factory.Faker("paragraph")
-    portfolio = factory.SubFactory("wbportfolio.factories.PortfolioFactory")
-    creator = factory.SubFactory("wbcore.contrib.directory.factories.PersonFactory")
+    # order_proposal = factory.SubFactory("wbportfolio.factories.OrderProposalFactory")
 
 
 class CustomerTradeFactory(TradeFactory):

wbportfolio/filters/assets.py

@@ -127,7 +127,7 @@ class AssetPositionFilter(wb_filters.FilterSet):
     )
 
     underlying_instrument__is_cash = wb_filters.BooleanFilter(
-        label="With Cash", exclude=True, lookup_expr="exact", field_name="underlying_instrument__is_cash"
+        label="Cash", lookup_expr="exact", method="filter_is_cash"
     )
     underlying_instrument__instrument_type = wb_filters.ModelChoiceFilter(
         label="Instrument Type",
@@ -230,6 +230,13 @@ class AssetPositionFilter(wb_filters.FilterSet):
             return queryset.filter(underlying_instrument__in=value.get_classified_instruments())
         return queryset
 
+    def filter_is_cash(self, queryset, name, value):
+        if value is True:
+            return queryset.filter(Q(underlying_quote__is_cash=True) | Q(underlying_quote__is_cash_equivalent=True))
+        if value is False:
+            return queryset.filter(Q(underlying_quote__is_cash=False) & Q(underlying_quote__is_cash_equivalent=False))
+        return queryset
+
     def filter_portfolio_instrument(self, queryset, name, value):
         if value:
             return queryset.filter(
@@ -400,8 +407,8 @@ class DistributionFilter(wb_filters.FilterSet):
 
     group_by = wb_filters.ChoiceFilter(
         label="Group By",
-        choices=AssetPositionGroupBy.choices(),
-        initial=AssetPositionGroupBy.INDUSTRY.name,
+        choices=AssetPositionGroupBy.choices,
+        initial=AssetPositionGroupBy.INDUSTRY.value,
         method="fake_filter",
         clearable=False,
         required=True,
@@ -427,6 +434,14 @@ class DistributionFilter(wb_filters.FilterSet):
         endpoint=ClassificationGroup.get_representation_endpoint(),
         value_key=ClassificationGroup.get_representation_value_key(),
         label_key=ClassificationGroup.get_representation_label_key(),
+        depends_on=[{"field": "group_by", "options": {"activates_on": [AssetPositionGroupBy.INDUSTRY.value]}}],
+    )
+
+    group_by_classification_height = wb_filters.NumberFilter(
+        method="fake_filter",
+        label="Classification Height",
+        initial=0,
+        depends_on=[{"field": "group_by", "options": {"activates_on": [AssetPositionGroupBy.INDUSTRY.value]}}],
     )
 
     class Meta:
@@ -441,7 +456,6 @@ def get_default_hedged_currency(field, request, view):
 
 class ContributionChartFilter(wb_filters.FilterSet):
     date = wb_filters.FinancialPerformanceDateRangeFilter(
-        method=wb_filters.DateRangeFilter.base_date_range_filter_method,
         label="Date Range",
         required=True,
         clearable=False,

wbportfolio/filters/orders/__init__.py

@@ -0,0 +1,2 @@
+from .orders import OrderFilterSet
+from .order_proposals import OrderProposalFilterSet

wbportfolio/filters/orders/order_proposals.py

@@ -0,0 +1,55 @@
+from django.db.models import Exists, OuterRef
+from wbcore import filters as wb_filters
+
+from wbportfolio.models import InstrumentPortfolioThroughModel, OrderProposal
+
+
+class OrderProposalFilterSet(wb_filters.FilterSet):
+    has_custodian_adapter = wb_filters.BooleanFilter(
+        method="filter_has_custodian_adapter", label="Has Custodian Adapter"
+    )
+    waiting_for_input = wb_filters.BooleanFilter(method="filter_waiting_for_input", label="Waiting for Input")
+    is_automatic_rebalancing = wb_filters.BooleanFilter(
+        method="filter_is_automatic_rebalancing", label="Automatic Rebalancing"
+    )
+
+    def filter_has_custodian_adapter(self, queryset, name, value):
+        queryset = queryset.annotate(
+            has_custodian_adapter=Exists(
+                InstrumentPortfolioThroughModel.objects.filter(
+                    portfolio=OuterRef("portfolio"), instrument__net_asset_value_computation_method_path__isnull=False
+                )
+            )
+        )
+        if value is True:
+            queryset = queryset.filter(has_custodian_adapter=True)
+        elif value is False:
+            queryset = queryset.filter(has_custodian_adapter=False)
+        return queryset
+
+    def filter_waiting_for_input(self, queryset, name, value):
+        input_status = [OrderProposal.Status.PENDING, OrderProposal.Status.DRAFT, OrderProposal.Status.APPROVED]
+        if value is True:
+            queryset = queryset.filter(status__in=input_status)
+        elif value is False:
+            queryset = queryset.exclude(status__in=input_status)
+        return queryset
+
+    def filter_is_automatic_rebalancing(self, queryset, name, value):
+        if value is True:
+            queryset = queryset.filter(rebalancing_model__isnull=False)
+        elif value is False:
+            queryset = queryset.filter(rebalancing_model__isnull=True)
+        return queryset
+
+    class Meta:
+        model = OrderProposal
+        fields = {
+            "trade_date": ["exact"],
+            "status": ["exact"],
+            "rebalancing_model": ["exact"],
+            "portfolio": ["exact"],
+            "creator": ["exact"],
+            "approver": ["exact"],
+            "execution_status": ["exact"],
+        }

wbportfolio/filters/orders/orders.py

@@ -0,0 +1,11 @@
+from wbcore import filters as wb_filters
+
+from wbportfolio.models import Order
+
+
+class OrderFilterSet(wb_filters.FilterSet):
+    has_warnings = wb_filters.BooleanFilter()
+
+    class Meta:
+        model = Order
+        fields = {"underlying_instrument": ["exact"], "order_type": ["exact"]}

wbportfolio/filters/portfolios.py

@@ -1,8 +1,11 @@
+from datetime import date, timedelta
+
+from django.db.models import Exists, OuterRef
 from wbcore import filters as wb_filters
 from wbfdm.models import Instrument
 
 from wbportfolio.filters.assets import get_latest_asset_position
-from wbportfolio.models import Portfolio
+from wbportfolio.models import AssetPosition, Portfolio
 
 
 class PortfolioFilterSet(wb_filters.FilterSet):
@@ -16,12 +19,46 @@ class PortfolioFilterSet(wb_filters.FilterSet):
         filter_params={"is_managed": True},
         method="filter_instrument",
     )
+    modeled_after = wb_filters.ModelChoiceFilter(
+        label="Modeled After",
+        queryset=Portfolio.objects.all(),
+        endpoint=Portfolio.get_representation_endpoint(),
+        value_key=Portfolio.get_representation_value_key(),
+        label_key=Portfolio.get_representation_label_key(),
+        method="filter_modeled_after",
+    )
+    invests_in = wb_filters.ModelChoiceFilter(
+        label="Invests In",
+        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_universe": True},
+        method="filter_invests_in",
+    )
+
+    def filter_modeled_after(self, queryset, name, value):
+        if value:
+            modeled_after_portfolio_ids = list(
+                map(
+                    lambda p: p.portfolio.id, value.get_model_portfolio_relationships(date.today() - timedelta(days=7))
+                )
+            )
+            return queryset.filter(id__in=modeled_after_portfolio_ids)
+        return queryset
 
     def filter_instrument(self, queryset, name, value):
         if value:
             return queryset.filter(instruments=value)
         return queryset
 
+    def filter_invests_in(self, queryset, name, value):
+        if value:
+            return queryset.annotate(
+                invests_in=Exists(AssetPosition.objects.filter(underlying_quote=value, portfolio=OuterRef("pk")))
+            ).filter(invests_in=True)
+        return queryset
+
     class Meta:
         model = Portfolio
         fields = {

wbportfolio/filters/positions.py

@@ -76,7 +76,6 @@ class AssetPositionPandasFilter(DateFilterMixin, PandasFilterSetMixin, wb_filter
     date = total_value_fx_usd = total_value_fx_usd__gte = total_value_fx_usd__lte = None
 
     date = wb_filters.FinancialPerformanceDateRangeFilter(
-        method=wb_filters.DateRangeFilter.base_date_range_filter_method,
         label="Date Range",
         required=True,
         clearable=False,

wbportfolio/filters/transactions/__init__.py

@@ -10,7 +10,7 @@ from .claim import (
     NegativeTermimalAccountPerProductFilterSet,
     ProfitAndLossPandasFilter,
 )
-from .fees import FeesAggregatedFilter, FeesFilter, FeesPortfolioFilterSet
+from .fees import FeesAggregatedFilter, FeesFilter, FeesProductFilterSet
 from .trades import (
     SubscriptionRedemptionFilterSet,
     SubscriptionRedemptionPortfolioFilterSet,
@@ -18,4 +18,3 @@ from .trades import (
     TradeInstrumentFilterSet,
     TradePortfolioFilter,
 )
-from .transactions import TransactionFilterSet, TransactionPortfolioFilterSet

wbportfolio/filters/transactions/fees.py

@@ -4,10 +4,10 @@ from wbcore.pandas.filterset import PandasFilterSetMixin
 
 from wbportfolio.models import Fees
 
-from .transactions import TransactionFilterSet, get_transaction_default_date_range
+from .utils import get_transaction_default_date_range
 
 
-class FeesFilter(TransactionFilterSet):
+class FeesFilter(wb_filters.FilterSet):
     """FilterSet for Fees
 
     Currently filters:
@@ -16,28 +16,24 @@ class FeesFilter(TransactionFilterSet):
     """
 
     fee_date = wb_filters.DateRangeFilter(
-        method=wb_filters.DateRangeFilter.base_date_range_filter_method,
         label="Date Range",
         initial=get_transaction_default_date_range,
         required=True,
     )
-    total_value_usd__gte = total_value_usd__lte = transaction_underlying_type = transaction_date = None
 
     class Meta:
         model = Fees
         fields = {
             "transaction_subtype": ["exact"],
             "currency_fx_rate": ["gte", "exact", "lte"],
-            "portfolio": ["exact"],
+            "product": ["exact"],
             "currency": ["exact"],
             "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"],
         }
 
 
-class FeesPortfolioFilterSet(FeesFilter):
+class FeesProductFilterSet(FeesFilter):
     portfolio = None
 
     class Meta:
@@ -49,15 +45,12 @@ class FeesPortfolioFilterSet(FeesFilter):
             "currency": ["exact"],
             "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"],
         }
 
 
 class FeesAggregatedFilter(PandasFilterSetMixin, wb_filters.FilterSet):
-    transaction_date = wb_filters.DateRangeFilter(
+    fee_date = wb_filters.DateRangeFilter(
         label="Date Range",
-        method=wb_filters.DateRangeFilter.base_date_range_filter_method,
         required=True,
         clearable=False,
         initial=current_quarter_date_range,

wbportfolio/filters/transactions/trades.py

@@ -5,14 +5,27 @@ from wbcore import filters as wb_filters
 from wbcrm.models.accounts import Account
 from wbfdm.models import Classification, Instrument
 
-from wbportfolio.models import Product, Trade
+from wbportfolio.models import Portfolio, Product, Trade
 from wbportfolio.models.transactions.claim import Claim
 
 from .mixins import OppositeSharesFieldMethodMixin
-from .transactions import TransactionFilterSet
+from .utils import get_transaction_default_date_range
 
 
-class TradeFilter(OppositeSharesFieldMethodMixin, TransactionFilterSet):
+class TradeFilter(OppositeSharesFieldMethodMixin, wb_filters.FilterSet):
+    transaction_date = wb_filters.DateRangeFilter(
+        label="Date Range",
+        initial=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(),
+    )
+
     # we have to redefine the mixin fields because django_filters does not allow class extension with mixin
     opposite_shares = wb_filters.NumberFilter(
         field_name="shares",
@@ -28,10 +41,6 @@ class TradeFilter(OppositeSharesFieldMethodMixin, TransactionFilterSet):
         lookup_icon="≈±",
         lookup_label="Opposite Approximate (+- 10%)",
     )
-    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(),
@@ -69,7 +78,6 @@ class TradeFilter(OppositeSharesFieldMethodMixin, TransactionFilterSet):
     #     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", initial=False, field_name="marked_for_deletion", lookup_expr="exact"
     )

wbportfolio/filters/transactions/utils.py

@@ -0,0 +1,42 @@
+from datetime import date, timedelta
+
+from psycopg.types.range import DateRange
+
+from wbportfolio.models import Fees, Trade
+
+
+def get_transaction_gte_default(field, request, view):
+    filter_date = date.today() - timedelta(days=90)
+    qs = Trade.objects.none()
+    if "instrument_id" in view.kwargs:
+        qs = Trade.objects.filter(underlying_instrument__id=view.kwargs["instrument_id"])
+    elif "portfolio_id" in view.kwargs:
+        qs = Trade.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 = Trade.objects.none()
+    if "instrument_id" in view.kwargs:
+        qs = Trade.objects.filter(underlying_instrument__id=view.kwargs["instrument_id"])
+    elif "portfolio_id" in view.kwargs:
+        qs = Trade.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))

wbportfolio/import_export/backends/ubs/__init__.py

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

wbportfolio/import_export/backends/ubs/asset_position.py

@@ -7,7 +7,8 @@ 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 wbportfolio.api_clients.ubs import UBSNeoAPIClient
+
 from .mixin import DataBackendMixin
 
 
@@ -21,7 +22,8 @@ class DataBackend(DataBackendMixin, AbstractDataBackend):
         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
+        self.authentication_token = import_credential.authentication_token.replace("Bearer ", "")
+        self.token_expiry_date = import_credential.validity_end
 
     def get_files(
         self,
@@ -31,13 +33,10 @@ class DataBackend(DataBackendMixin, AbstractDataBackend):
         **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:
+            client = UBSNeoAPIClient(self.authentication_token, self.token_expiry_date)
             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 = client.validate_response(client.get_portfolio_at_date(external_id, execution_date))
                 if res_json:
                     content_file = BytesIO()
                     content_file.write(json.dumps(res_json).encode())

wbportfolio/import_export/backends/ubs/fees.py

@@ -7,7 +7,8 @@ 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 wbportfolio.api_clients.ubs import UBSNeoAPIClient
+
 from .mixin import DataBackendMixin
 
 
@@ -21,7 +22,8 @@ class DataBackend(DataBackendMixin, AbstractDataBackend):
         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
+        self.authentication_token = import_credential.authentication_token.replace("Bearer ", "")
+        self.token_expiry_date = import_credential.validity_end
 
     def get_files(
         self,
@@ -30,32 +32,20 @@ class DataBackend(DataBackendMixin, AbstractDataBackend):
         **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:
+            client = UBSNeoAPIClient(self.authentication_token, self.token_expiry_date)
+            start = kwargs.get("start", None)
+            if not start:
+                start = global_preferences_registry.manager()["wbfdm__default_start_date_historical_import"]
             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")},
-                )
-
+                mngt_res = client.validate_response(client.get_management_fees(external_id, start, execution_date))
+                perf_res = client.validate_response(client.get_performance_fees(external_id, start, execution_date))
                 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())

wbportfolio/import_export/backends/ubs/instrument_price.py

@@ -7,7 +7,8 @@ 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 wbportfolio.api_clients.ubs import UBSNeoAPIClient
+
 from .mixin import DataBackendMixin
 
 
@@ -21,7 +22,8 @@ class DataBackend(DataBackendMixin, AbstractDataBackend):
         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
+        self.authentication_token = import_credential.authentication_token.replace("Bearer ", "")
+        self.token_expiry_date = import_credential.validity_end
 
     def get_files(
         self,
@@ -30,12 +32,10 @@ class DataBackend(DataBackendMixin, AbstractDataBackend):
         **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:
+            client = UBSNeoAPIClient(self.authentication_token, self.token_expiry_date)
             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 = client.validate_response(client.get_portfolio_at_date(external_id, execution_date))
                 res_json.pop("constituents", None)
                 if res_json:
                     content_file = BytesIO()

wbportfolio/import_export/backends/ubs/trade.py

@@ -0,0 +1,48 @@
+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 wbportfolio.api_clients.ubs import UBSNeoAPIClient
+
+from .mixin import DataBackendMixin
+
+
+@register("Trade", 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.replace("Bearer ", "")
+        self.token_expiry_date = import_credential.validity_end
+
+    def get_files(
+        self,
+        execution_time: datetime,
+        start: date = None,
+        obj_external_ids: list[str] = None,
+        **kwargs,
+    ) -> BytesIO:
+        if not start:
+            start = (execution_time - BDay(2)).date()
+        end = execution_time.date()
+        if obj_external_ids:
+            client = UBSNeoAPIClient(self.authentication_token, self.token_expiry_date)
+            for external_id in obj_external_ids:
+                res_json = client.validate_response(
+                    client.get_rebalance_reports(external_id, from_date=start, to_date=end)
+                )
+                if res_json:
+                    content_file = BytesIO()
+                    content_file.write(json.dumps(res_json).encode())
+                    file_name = f"ubs_trades_{external_id}_{start:%Y-%m-%d}-{end:%Y-%m-%d}_{datetime.timestamp(execution_time)}.json"
+                    yield file_name, content_file

wbportfolio/import_export/backends/utils.py

@@ -1,7 +1,3 @@
-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
@@ -11,19 +7,6 @@ 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