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

wbportfolio/admin/__init__.py

@@ -8,5 +8,7 @@ from .product_groups import ProductGroupAdmin
 from .portfolio import PortfolioModelAdmin
 from .registers import RegisterModelAdmin
 from .roles import PortfolioRoleAdmin
-from .transactions import DividendAdmin, FeesAdmin, TradeAdmin, TransactionModelAdmin
+from .transactions import DividendAdmin, FeesAdmin, TradeAdmin
 from .reconciliations import AccountReconciliationAdmin
+from .orders import OrderProposalAdmin
+from .rebalancing import RebalancingModelAdmin, RebalancerAdmin

wbportfolio/admin/indexes.py

@@ -10,6 +10,6 @@ class IndexAdmin(InstrumentModelAdmin):
         ("Instrument Information", InstrumentModelAdmin.fieldsets[0][1]),
         (
             "Index Information",
-            {"fields": (("net_asset_value_computation_method_path",),)},
+            {"fields": (("net_asset_value_computation_method_path", "order_routing_custodian_adapter"),)},
         ),
     )

wbportfolio/admin/orders/__init__.py

@@ -0,0 +1,2 @@
+from .orders import OrderTabularInline
+from .order_proposals import OrderProposalAdmin

wbportfolio/admin/orders/order_proposals.py

@@ -0,0 +1,16 @@
+from django.contrib import admin
+
+from wbportfolio.models import OrderProposal
+
+from .orders import OrderTabularInline
+
+
+@admin.register(OrderProposal)
+class OrderProposalAdmin(admin.ModelAdmin):
+    search_fields = ["portfolio__name", "comment"]
+
+    list_display = ("portfolio", "rebalancing_model", "trade_date", "status")
+    autocomplete_fields = ["portfolio", "rebalancing_model"]
+    inlines = [OrderTabularInline]
+
+    raw_id_fields = ["portfolio", "creator", "approver"]

wbportfolio/admin/orders/orders.py

@@ -0,0 +1,32 @@
+from django.contrib import admin
+
+from wbportfolio.models.orders import Order
+
+
+class OrderTabularInline(admin.TabularInline):
+    model = Order
+    fk_name = "order_proposal"
+
+    readonly_fields = [
+        "_effective_weight",
+        "_target_weight",
+        "_effective_shares",
+        "_target_shares",
+        "total_value",
+        "total_value_gross",
+        "total_value_fx_portfolio",
+        "total_value_gross_fx_portfolio",
+        "created",
+        "updated",
+    ]
+
+    fields = [
+        "underlying_instrument",
+        "_effective_weight",
+        "_target_weight",
+        "weighting",
+        "shares",
+        "daily_return",
+    ]
+
+    raw_id_fields = ["underlying_instrument"]

wbportfolio/admin/portfolio.py

@@ -10,10 +10,6 @@ from wbportfolio.models import (
     PortfolioSwingPricing,
 )
 
-from .portfolio_relationships import (
-    PortfolioInstrumentPreferredClassificationThroughInlineModelAdmin,
-)
-
 
 @admin.register(PortfolioBankAccountThroughModel)
 class PortfolioBankAccountThroughModelModelAdmin(admin.ModelAdmin):
@@ -64,6 +60,16 @@ class PortfolioModelAdmin(admin.ModelAdmin):
                 )
             },
         ),
+        (
+            "OMS",
+            {
+                "fields": (
+                    "default_order_proposal_min_order_value",
+                    "default_order_proposal_min_weighting",
+                    "default_order_proposal_total_cash_weight",
+                )
+            },
+        ),
     )
     readonly_fields = ["updated_at"]
     list_display = (
@@ -78,7 +84,7 @@ class PortfolioModelAdmin(admin.ModelAdmin):
     inlines = [
         PortfolioBankAccountThroughModelAdmin,
         InstrumentPortfolioThroughModelAdmin,
-        PortfolioInstrumentPreferredClassificationThroughInlineModelAdmin,
+        # PortfolioInstrumentPreferredClassificationThroughInlineModelAdmin,
         PortfolioPortfolioThroughModelInlineAdmin,
     ]
     raw_id_fields = [

wbportfolio/admin/product_groups.py

@@ -30,7 +30,7 @@ class ProductGroupAdmin(InstrumentModelAdmin):
                     ("type", "category", "umbrella"),
                     ("management_company", "depositary", "transfer_agent", "administrator"),
                     ("investment_manager", "auditor", "paying_agent"),
-                    ("net_asset_value_computation_method_path", "risk_scale"),
+                    ("net_asset_value_computation_method_path", "order_routing_custodian_adapter", "risk_scale"),
                 )
             },
         ),

wbportfolio/admin/products.py

@@ -37,7 +37,7 @@ class ProductAdmin(InstrumentModelAdmin):
             {
                 "fields": (
                     ("share_price", "initial_high_water_mark", "bank"),
-                    ("termsheet", "fee_calculation", "net_asset_value_computation_method_path"),
+                    ("fee_calculation", "net_asset_value_computation_method_path", "order_routing_custodian_adapter"),
                     (
                         "white_label_customers",
                         "default_account",
@@ -55,6 +55,7 @@ class ProductAdmin(InstrumentModelAdmin):
                     (
                         "jurisdiction",
                         "dividend",
+                        "termsheet",
                     ),
                     ("external_webpage", "minimum_subscription", "cut_off_time"),
                 )

wbportfolio/admin/{transactions/rebalancing.py → rebalancing.py}

@@ -20,7 +20,7 @@ class RebalancerAdmin(admin.ModelAdmin):
         "rebalancing_model",
         "portfolio",
         "parameters",
-        "approve_trade_proposal_automatically",
+        "apply_order_proposal_automatically",
         "activation_date",
         "frequency",
     )

wbportfolio/admin/transactions/__init__.py

@@ -1,6 +1,4 @@
-from .transactions import TransactionModelAdmin  # isort:skip
 from .claim import ClaimModelAdmin
 from .dividends import DividendAdmin
 from .fees import FeesAdmin
 from .trades import TradeAdmin
-from .rebalancing import RebalancingModelAdmin, RebalancerAdmin

wbportfolio/admin/transactions/dividends.py

@@ -1,15 +1,51 @@
 from django.contrib import admin
 
-from wbportfolio.admin.transactions import TransactionModelAdmin
 from wbportfolio.models import DividendTransaction
 
 
 @admin.register(DividendTransaction)
-class DividendAdmin(TransactionModelAdmin):
+class DividendAdmin(admin.ModelAdmin):
+    search_fields = ["portfolio__name", "underlying_instrument__computed_str"]
+    list_filter = ("distribution_method", "portfolio")
+    list_display = (
+        "distribution_method",
+        "portfolio",
+        "underlying_instrument",
+        "value_date",
+        "currency",
+        "currency_fx_rate",
+        "total_value",
+        "total_value_fx_portfolio",
+    )
     fieldsets = (
-        ("Transactions Information", TransactionModelAdmin.fieldsets[0][1]),
         (
             "Dividend Information",
-            {"fields": (("retrocession",),)},
+            {
+                "fields": (
+                    (
+                        "portfolio",
+                        "underlying_instrument",
+                        "import_source",
+                    ),
+                    ("ex_date", "record_date", "value_date"),
+                    ("currency", "currency_fx_rate"),
+                    ("price", "shares", "retrocession"),
+                    ("total_value", "total_value_gross"),
+                    ("total_value_fx_portfolio", "total_value_gross_fx_portfolio"),
+                    ("created", "updated"),
+                    ("comment",),
+                )
+            },
         ),
     )
+    readonly_fields = [
+        "total_value",
+        "total_value_gross",
+        "total_value_fx_portfolio",
+        "total_value_gross_fx_portfolio",
+        "created",
+        "updated",
+    ]
+    autocomplete_fields = ["portfolio", "underlying_instrument", "currency"]
+    ordering = ("-value_date",)
+    raw_id_fields = ["import_source"]

wbportfolio/admin/transactions/fees.py

@@ -1,27 +1,36 @@
 from django.contrib import admin
-from django.db.models import Prefetch
 
-from wbportfolio.admin.transactions import TransactionModelAdmin
-from wbportfolio.models import Fees, Portfolio
+from wbportfolio.models import Fees
 from wbportfolio.models.transactions.fees import FeeCalculation
 
 
 @admin.register(Fees)
-class FeesAdmin(TransactionModelAdmin):
-    list_filter = [*TransactionModelAdmin.list_filter, "linked_product"]
-    list_display = ["transaction_subtype", *TransactionModelAdmin.list_display[1:], "calculated"]
+class FeesAdmin(admin.ModelAdmin):
+    list_filter = ["product"]
+    list_display = [
+        "transaction_subtype",
+        "fee_date",
+        "product",
+        "currency",
+        "total_value",
+    ]
     fieldsets = (
-        ("Transaction Information", TransactionModelAdmin.fieldsets[0][1]),
-        ("Fees Information", {"fields": (("transaction_subtype", "calculated", "linked_product"),)}),
+        (
+            "Fees Information",
+            {
+                "fields": (
+                    ("transaction_subtype", "calculated", "fee_date", "product"),
+                    ("currency", "currency_fx_rate"),
+                    ("total_value", "total_value_fx_portfolio"),
+                    ("created", "updated"),
+                )
+            },
+        ),
     )
-    autocomplete_fields = [*TransactionModelAdmin.autocomplete_fields, "linked_product"]
+    autocomplete_fields = ["currency", "product"]
 
     def get_queryset(self, request):
-        return (
-            super()
-            .get_queryset(request)
-            .prefetch_related(Prefetch("portfolio", queryset=Portfolio.objects.all().only("id", "name")))
-        )
+        return super().get_queryset(request).select_related("product", "currency")
 
     def calculate(self, request, queryset):
         for fees in queryset:
@@ -29,6 +38,7 @@ class FeesAdmin(TransactionModelAdmin):
 
     calculate.short_description = "Recalculate selected Fees"
     actions = [calculate]
+    readonly_fields = ["total_value_fx_portfolio", "created", "updated"]
 
 
 @admin.register(FeeCalculation)

wbportfolio/admin/transactions/trades.py

@@ -1,50 +1,57 @@
 from django.contrib import admin
 
-from wbportfolio.admin.transactions import TransactionModelAdmin
-from wbportfolio.models import Trade, TradeProposal
+from wbportfolio.models import Trade
 
 
 @admin.register(Trade)
-class TradeAdmin(TransactionModelAdmin):
-    search_fields = [*TransactionModelAdmin.search_fields, "bank"]
-    list_filter = (*TransactionModelAdmin.list_filter, "pending")
+class TradeAdmin(admin.ModelAdmin):
+    search_fields = ["portfolio__name", "underlying_instrument__computed_str", "bank"]
+    list_filter = ("portfolio", "pending")
     list_display = (
         "transaction_subtype",
-        "status",
+        "transaction_date",
+        "underlying_instrument",
+        "portfolio",
         "shares",
         "price",
+        "total_value",
         "pending",
         "marked_for_deletion",
         "exclude_from_history",
-        *TransactionModelAdmin.list_display[1:],
+        "import_source",
     )
+
     readonly_fields = [
-        "_effective_weight",
-        "_target_weight",
-        "_effective_shares",
-        "_target_shares",
+        "total_value",
+        "total_value_gross",
+        "total_value_fx_portfolio",
+        "total_value_gross_fx_portfolio",
+        "created",
+        "updated",
     ]
     fieldsets = (
-        ("Transaction Information", TransactionModelAdmin.fieldsets[0][1]),
         (
-            "Trade Information",
+            "Transaction Information",
             {
                 "fields": (
-                    ("transaction_subtype", "status", "pending", "marked_for_deletion", "exclude_from_history"),
-                    ("price", "price_gross"),
-                    ("register", "custodian", "bank", "external_identifier2"),
-                    ("_effective_weight", "_target_weight", "weighting"),
-                    ("_effective_shares", "_target_shares", "shares"),
+                    ("transaction_subtype",),
+                    ("pending", "marked_for_deletion", "exclude_from_history"),
+                    (
+                        "portfolio",
+                        "underlying_instrument",
+                        "import_source",
+                    ),
+                    ("transaction_date", "book_date", "value_date"),
+                    ("price", "currency", "currency_fx_rate"),
+                    ("total_value", "total_value_gross"),
+                    ("total_value_fx_portfolio", "total_value_gross_fx_portfolio"),
+                    ("register", "custodian", "bank", "external_id", "external_id_alternative"),
+                    ("created", "updated"),
+                    ("comment",),
                 )
             },
         ),
     )
-    autocomplete_fields = [*TransactionModelAdmin.autocomplete_fields, "register", "custodian"]
-
-
-@admin.register(TradeProposal)
-class TradeProposalAdmin(admin.ModelAdmin):
-    search_fields = ["portfolio__name", "comment"]
-
-    list_display = ("portfolio", "rebalancing_model", "trade_date", "status")
-    autocomplete_fields = ["portfolio", "rebalancing_model"]
+    autocomplete_fields = ["portfolio", "underlying_instrument", "currency", "register", "custodian"]
+    ordering = ("-transaction_date",)
+    raw_id_fields = ["import_source", "underlying_instrument", "portfolio", "register", "custodian"]

wbportfolio/analysis/claims.py

@@ -58,13 +58,12 @@ class ConsolidatedTradeSummary:
         self.pivot_label = pivot_label
         self.queryset = self.queryset.annotate(
             internal_trade=F("trade__marked_as_internal"),
-            date_considered=ExpressionWrapper(
-                Greatest("trade__transaction_date", "date") + 1, output_field=DateField()
-            ),
+            valid_date=Greatest("trade__transaction_date", "date"),
+            date_considered=ExpressionWrapper(F("valid_date") + 1, output_field=DateField()),
             net_value=InstrumentPrice.subquery_closest_value(
-                "net_value", date_name="date_considered", instrument_pk_name="product__pk", date_lookup="exact"
+                "net_value", date_name="valid_date", instrument_pk_name="product__pk", date_lookup="exact"
             ),
-            fx_rate=CurrencyFXRates.get_fx_rates_subquery("date_considered", lookup_expr="exact"),
+            fx_rate=CurrencyFXRates.get_fx_rates_subquery("valid_date", lookup_expr="exact"),
             aum=ExpressionWrapper(F("fx_rate") * F("net_value") * F("shares"), output_field=DecimalField()),
         )
         self.queryset = Account.annotate_root_account_info(self.queryset)
@@ -158,8 +157,8 @@ class ConsolidatedTradeSummary:
         df = df.fillna(0)
         # Prepare dataframe
         df["sum_aum_start"] = df.sum_shares_start * df.price_start
-        df["sum_aum_end"] = df.sum_shares_end * df.price_end
 
+        df["sum_aum_end"] = df.sum_shares_end * df.price_end
         # Sanitize dataframe
         df = df.drop(
             columns=df.columns.difference(["id", "sum_shares_start", "sum_shares_end", "sum_aum_start", "sum_aum_end"])

wbportfolio/api_clients/ubs.py

@@ -0,0 +1,162 @@
+from datetime import date, datetime, timedelta
+from json import JSONDecodeError
+
+import requests
+from django.conf import settings
+from django.utils import timezone
+from requests import HTTPError
+
+
+class UBSNeoAPIClient:
+    BASE_URL = "https://neo.ubs.com/api"
+    SUCCESS_VALUE = "SUCCESS"
+    VIRTUAL_AMC_ISIN = "TEST_API_001"
+
+    def __init__(
+        self,
+        initial_jwt_token: str,
+        jwt_token_expiry_timestamp: datetime | None = None,
+    ):
+        """
+        :param service_account_id: Identifier for your UBS service account (for reference).
+        :param initial_jwt_token: JWT token string initially provided to authenticate API calls.
+        :param jwt_token_expiry_timestamp: UNIX timestamp when the token expires - to manage renewal.
+        """
+        self.jwt_token = initial_jwt_token
+        self.jwt_token_expiry = (
+            jwt_token_expiry_timestamp if jwt_token_expiry_timestamp else timezone.now() + timedelta(days=1)
+        )
+
+    def _is_token_expired(self) -> bool:
+        """Check if the current token is expired or near expiry (e.g. within 5 minutes)."""
+        return timezone.now() > self.jwt_token_expiry - timedelta(minutes=5)
+
+    def _renew_token(self):
+        """
+        Placeholder: Implement token renewal logic here.
+        This usually involves interacting with UBS Neo application or token service
+        before expiry to obtain a new token. This must be customized per your process.
+        """
+        raise ValueError("Token has expired. Please go to https://neo.ubs.com/ and renew it.")
+
+    def _get_headers(self) -> dict[str, str]:
+        """Prepare HTTP headers including Authorization bearer token."""
+        if self._is_token_expired():
+            self._renew_token()
+        return {"Authorization": f"Bearer {self.jwt_token}", "Content-Type": "application/json"}
+
+    def _get_json(self, response) -> dict:
+        try:
+            return response.json()
+        except JSONDecodeError:
+            return dict()
+
+    def _validate_isin(self, isin: str, test: bool = False) -> str:
+        # ensure the given isin can be used for rebalancing (e.g. debug or dev mode)
+        if test or settings.DEBUG:
+            return self.VIRTUAL_AMC_ISIN
+        return isin
+
+    def _raise_for_status(self, response):
+        try:
+            response.raise_for_status()
+        except HTTPError as e:
+            json_response = response.json()
+            raise HTTPError(json_response.get("errors", json_response.get("message"))) from e
+
+    def get_rebalance_service_status(self) -> dict:
+        """Check API connection status."""
+        url = f"{self.BASE_URL}/ged-amc/external/rebalance/v1/status"
+        response = requests.get(url, headers=self._get_headers(), timeout=10)
+        self._raise_for_status(response)
+        return self._get_json(response)
+
+    def get_rebalance_status_for_isin(self, isin: str) -> dict:
+        """Check certificate accessibility and workflow status for given ISIN."""
+        url = f"{self.BASE_URL}/ged-amc/external/rebalance/v1/status/{isin}"
+        response = requests.get(url, headers=self._get_headers(), timeout=10)
+        self._raise_for_status(response)
+        return self._get_json(response)
+
+    def submit_rebalance(self, isin: str, items: list[dict[str, str]], test: bool = False) -> dict:
+        """
+        Submit a rebalance request.
+        :param isin: Certificate ISIN string.
+        :param orders: List of dto representing order instructions.
+        :param test: If True, submits to test endpoint to validate syntax only (no persistence).
+        """
+        isin = self._validate_isin(isin, test=test)
+        url = f"{self.BASE_URL}/ged-amc/external/rebalance/v1/submit/{isin}"
+        payload = {"items": items}
+        response = requests.post(url, json=payload, headers=self._get_headers(), timeout=60)
+        self._raise_for_status(response)
+        return self._get_json(response)
+
+    def save_draft(self, isin: str, items: list[dict[str, str]]) -> dict:
+        """Save a rebalance draft."""
+        isin = self._validate_isin(isin)
+        url = f"{self.BASE_URL}/ged-amc/external/rebalance/v1/savedraft/{isin}"
+        payload = {"items": items}
+        response = requests.post(url, json=payload, headers=self._get_headers(), timeout=60)
+        self._raise_for_status(response)
+        return self._get_json(response)
+
+    def cancel_rebalance(self, isin: str) -> dict:
+        """Cancel a rebalance request."""
+        isin = self._validate_isin(isin)
+        url = f"{self.BASE_URL}/ged-amc/external/rebalance/v1/cancel/{isin}"
+        response = requests.delete(url, headers=self._get_headers(), timeout=60)
+        self._raise_for_status(response)
+        return self._get_json(response)
+
+    def get_current_rebalance_request(self, isin: str) -> dict:
+        """Fetch the current rebalance request for a certificate."""
+        url = f"{self.BASE_URL}/ged-amc/external/rebalance/v1/currentRebalanceRequest/{isin}"
+        response = requests.get(url, headers=self._get_headers(), timeout=60)
+        self._raise_for_status(response)
+        return self._get_json(response)
+
+    def get_rebalance_reports(self, isin: str, from_date: date, to_date: date) -> dict:
+        """Fetch the current rebalance request for a certificate."""
+        url = f"{self.BASE_URL}/ged-amc/external/report/v1/rebalance/{isin}"
+        response = requests.get(
+            url,
+            headers=self._get_headers(),
+            timeout=60,
+            params={"fromDate": from_date.strftime("%Y-%m-%d"), "toDate": to_date.strftime("%Y-%m-%d")},
+        )
+        self._raise_for_status(response)
+        return self._get_json(response)
+
+    def get_portfolio_at_date(self, isin: str, val_date: date) -> dict:
+        url = f"https://neo.ubs.com/api/ged-amc/external/report/v1/valuation/{isin}/{val_date:%Y-%m-%d}"
+        response = requests.get(url, headers=self._get_headers(), timeout=10)
+        self._raise_for_status(response)
+        return self._get_json(response)
+
+    def get_management_fees(self, isin: str, from_date: date, to_date: date) -> dict:
+        url = f"https://neo.ubs.com/api/ged-amc/external/fee/v1/management/{isin}"
+        response = requests.get(
+            url,
+            headers=self._get_headers(),
+            params={"fromDate": from_date.strftime("%Y-%m-%d"), "toDate": to_date.strftime("%Y-%m-%d")},
+            timeout=30,
+        )
+        self._raise_for_status(response)
+        return self._get_json(response)
+
+    def get_performance_fees(self, isin: str, from_date: date, to_date: date) -> dict:
+        url = f"https://neo.ubs.com/api/ged-amc/external/fee/v1/performance/{isin}"
+        response = requests.get(
+            url,
+            headers=self._get_headers(),
+            params={"fromDate": from_date.strftime("%Y-%m-%d"), "toDate": to_date.strftime("%Y-%m-%d")},
+            timeout=30,
+        )
+        self._raise_for_status(response)
+        return self._get_json(response)
+
+    def validate_response(self, response: dict) -> dict:
+        if response.get("status", "") == self.SUCCESS_VALUE:
+            return response
+        return dict()

wbportfolio/constants.py

@@ -0,0 +1 @@
+EQUITY_TYPE_KEYS = ["american_depository_receipt", "equity"]  # TODO might want to move this into a dynamic preference

wbportfolio/contrib/company_portfolio/configs/display.py

@@ -1,8 +1,8 @@
 from typing import Optional
 
 from django.utils.translation import gettext as _
-from wbcore.contrib.directory.viewsets.display.entries import CompanyModelDisplay as CMD
-from wbcore.contrib.directory.viewsets.display.entries import PersonModelDisplay as PMD
+from wbcore.contrib.directory.viewsets.display.entries import CompanyModelDisplay as BaseCompanyModelDisplay
+from wbcore.contrib.directory.viewsets.display.entries import PersonModelDisplay as BasePersonModelDisplay
 from wbcore.metadata.configs import display as dp
 from wbcore.metadata.configs.display.instance_display import (
     Inline,
@@ -62,14 +62,20 @@ AUM_FIELDS = Section(
 )
 
 
-class CompanyModelDisplay(CMD):
+class CompanyModelDisplay(BaseCompanyModelDisplay):
     def get_list_display(self) -> Optional[dp.ListDisplay]:
         list_display = super().get_list_display()
         list_display.fields = (
             *list_display.fields[:5],
-            dp.Field(key="invested_assets_under_management_usd", label="AUM Invested"),
-            dp.Field(key="asset_under_management", label="AUM"),
-            dp.Field(key="potential", label="Potential"),
+            dp.Field(
+                key=None,
+                label=_("AUM"),
+                children=[
+                    dp.Field(key="invested_assets_under_management_usd", label="AUM Invested", width=100),
+                    dp.Field(key="asset_under_management", label="AUM", width=100),
+                    dp.Field(key="potential", label="Potential", width=100),
+                ],
+            ),
             *list_display.fields[5:],
         )
         return list_display
@@ -134,15 +140,21 @@ class CompanyModelDisplay(CMD):
         return instance_display
 
 
-class PersonModelDisplay(PMD):
+class PersonModelDisplay(BasePersonModelDisplay):
     def get_list_display(self) -> Optional[dp.ListDisplay]:
         list_display = super().get_list_display()
 
         list_display.fields = (
             *list_display.fields[:7],
-            dp.Field(key="invested_assets_under_management_usd", label="AUM Invested"),
-            dp.Field(key="asset_under_management", label="AUM"),
-            dp.Field(key="potential", label="Potential"),
+            dp.Field(
+                key=None,
+                label=_("AUM"),
+                children=[
+                    dp.Field(key="invested_assets_under_management_usd", label="AUM Invested", width=100),
+                    dp.Field(key="asset_under_management", label="AUM", width=100),
+                    dp.Field(key="potential", label="Potential", width=100),
+                ],
+            ),
             *list_display.fields[7:],
         )
         return list_display

wbportfolio/contrib/company_portfolio/configs/previews.py

@@ -1,3 +1,5 @@
+from contextlib import suppress
+
 from wbcore.contrib.directory.viewsets.previews import EntryPreviewConfig
 from wbcore.contrib.icons import WBIcon
 from wbcore.metadata.configs import buttons as bt
@@ -17,12 +19,10 @@ class CompanyPreviewConfig(EntryPreviewConfig):
             ["asset_under_management", "invested_assets_under_management_usd"],
             [repeat_field(2, "potential")],
         ]
-        try:
+        with suppress(Exception):
             entry = self.view.get_object()
             if entry.profile_image:
                 fields.insert(0, [repeat_field(2, "profile_image")])
-        except Exception:
-            pass
 
         return create_simple_display(fields)