wbportfolio 1.54.23__py2.py3-none-any.whl → 1.55.4__py2.py3-none-any.whl

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/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/rebalancing.py

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

wbportfolio/api_clients/ubs.py

@@ -0,0 +1,150 @@
+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,
+        default_execution_instruction: str = "MARKET_ON_CLOSE",
+    ):
+        """
+        :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)
+        )
+        self.default_execution_instruction = default_execution_instruction
+
+    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:
+            json_response = response.json()
+            raise HTTPError(json_response.get("errors", json_response.get("message")))
+
+    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())
+        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())
+        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())
+        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())
+        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())
+        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())
+        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())
+        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")},
+        )
+        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")},
+        )
+        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/factories/orders/order_proposals.py

@@ -1,7 +1,9 @@
 import factory
 from faker import Faker
 from pandas._libs.tslibs.offsets import BDay
+from wbcore.contrib.currency.factories import CurrencyFactory
 
+from wbportfolio.factories import PortfolioFactory
 from wbportfolio.models import OrderProposal
 
 fake = Faker()
@@ -13,5 +15,5 @@ class OrderProposalFactory(factory.django.DjangoModelFactory):
 
     trade_date = factory.LazyAttribute(lambda o: (fake.date_object() + BDay(1)).date())
     comment = factory.Faker("paragraph")
-    portfolio = factory.SubFactory("wbportfolio.factories.PortfolioFactory")
+    portfolio = factory.LazyAttribute(lambda o: PortfolioFactory.create(currency=CurrencyFactory.create(key="USD")))
     creator = factory.SubFactory("wbcore.contrib.directory.factories.PersonFactory")

wbportfolio/factories/portfolios.py

@@ -15,7 +15,7 @@ class PortfolioFactory(factory.django.DjangoModelFactory):
         model = Portfolio
 
     name = factory.Sequence(lambda n: f"Portfolio {n}")
-    currency = factory.SubFactory("wbcore.contrib.currency.factories.CurrencyFactory")
+    currency = factory.SubFactory("wbcore.contrib.currency.factories.CurrencyUSDFactory")
     is_manageable = True
     is_tracked = True
     is_lookthrough = False

wbportfolio/factories/rebalancing.py

@@ -18,6 +18,6 @@ class RebalancerFactory(factory.django.DjangoModelFactory):
     portfolio = factory.SubFactory("wbportfolio.factories.portfolios.PortfolioFactory")
     rebalancing_model = factory.SubFactory(RebalancingModelFactory)
     parameters = dict()
-    approve_order_proposal_automatically = False
+    apply_order_proposal_automatically = False
     frequency = "RRULE:FREQ=MONTHLY;"
     activation_date = None

wbportfolio/filters/orders/__init__.py

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

wbportfolio/filters/orders/order_proposals.py

@@ -0,0 +1,58 @@
+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):
+        if value is True:
+            queryset = queryset.filter(
+                status__in=[OrderProposal.Status.PENDING, OrderProposal.Status.DRAFT, OrderProposal.Status.APPROVED]
+            )
+        elif value is False:
+            queryset = queryset.exclude(
+                status__in=[OrderProposal.Status.PENDING, OrderProposal.Status.DRAFT, OrderProposal.Status.APPROVED]
+            )
+        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/portfolios.py

@@ -1,3 +1,5 @@
+from datetime import date, timedelta
+
 from wbcore import filters as wb_filters
 from wbfdm.models import Instrument
 
@@ -16,6 +18,24 @@ 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",
+    )
+
+    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:

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/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

wbportfolio/import_export/handlers/asset_position.py

@@ -146,7 +146,7 @@ class AssetPositionImportHandler(ImportExportHandler):
             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)
+                trigger_portfolio_change_as_task.delay(portfolio.id, val_date, fix_quantization=True)
 
             # check if portfolio as custodian
             latest_date = max(dates)

wbportfolio/import_export/handlers/trade.py

@@ -99,7 +99,7 @@ class TradeImportHandler(ImportExportHandler):
         if history.exists():
             queryset = history
         else:
-            queryset = self.model.objects.filter(marked_for_deletion=False)
+            queryset = self.model.objects.filter(marked_for_deletion=False).exclude(id__in=self.processed_ids)
 
         queryset = queryset.filter(
             models.Q(underlying_instrument=data["underlying_instrument"]) & models.Q(**dates_lookup)
@@ -116,7 +116,6 @@ class TradeImportHandler(ImportExportHandler):
             if external_id_queryset.count() == 1:
                 self.import_source.log += f"External ID {external_id} provided -> Load CustomerTrade"
                 return external_id_queryset.first()
-
         if portfolio := data.get("portfolio", None):
             queryset = queryset.filter(portfolio=portfolio)
         if queryset.exists():
@@ -142,6 +141,7 @@ class TradeImportHandler(ImportExportHandler):
             if queryset.exists():
                 # We try to filter by price as well
                 trade = queryset.first()
+
                 if queryset.count() == 1:
                     self.import_source.log += f"\nOne Trade found: {trade}"
                 if queryset.count() > 1:

wbportfolio/import_export/parsers/sg_lux/equity.py

@@ -76,7 +76,7 @@ def parse(import_source):
     }
 
     df["date"] = df["date"].apply(lambda x: x.replace("/", "-"))
-    df["initial_currency_fx_rate"] = df["initial_currency_fx_rate"].apply(lambda x: 1 / x if x else 1).round(5)
+    df["initial_currency_fx_rate"] = df["initial_currency_fx_rate"].apply(lambda x: 1 / x if x else 1).round(14)
 
     cash_mask = df["Accounting category"].isin(["T111"])
     cash = (

wbportfolio/import_export/parsers/societe_generale/strategy.py

@@ -73,8 +73,8 @@ def parse(import_source):
                         "exchange": exchange,
                         "asset_type": "equity",
                         "currency__key": position["currency__key"],
-                        "initial_currency_fx_rate": round(position["initial_currency_fx_rate"], 6),
-                        "weighting": round(position["weighting"], 6),
+                        "initial_currency_fx_rate": round(position["initial_currency_fx_rate"], 14),
+                        "weighting": round(position["weighting"], 8),
                         "initial_price": round(position["initial_price"], 6),
                         "date": valuation_date.strftime("%Y-%m-%d"),
                     }

wbportfolio/import_export/parsers/ubs/customer_trade.py

@@ -3,15 +3,15 @@ from typing import Dict
 
 import numpy as np
 import pandas as pd
-from wbcore.contrib.io.models import ImportSource
+from slugify import slugify
 
 from wbportfolio.models import Trade
 
 
-def parse_row(obj: Dict, import_source: ImportSource) -> Dict:
+def parse_row(obj: Dict, negate_shares: bool = False) -> Dict:
     isin = obj["underlying_instrument__isin"]
     shares = obj["shares"]
-    if import_source.source.import_parameters.get("negate_shares", False):
+    if negate_shares:
         shares = -1 * shares
     return {
         "underlying_instrument": {"isin": isin, "instrument_type": "product"},
@@ -30,6 +30,9 @@ def parse(import_source):
         xx, yy = np.where(df == "Trade Date")
         df = df.iloc[xx[0] :, yy[0] :]
         df = df.rename(columns=df.iloc[0]).drop(df.index[0]).dropna(how="all")
+    negate_shares = "net-quantity" in list(
+        map(lambda c: slugify(c), df.columns)
+    )  # we slugified the column to be more robust
     df = df.rename(columns=lambda x: x.lower())
     df = df.rename(
         columns={
@@ -50,6 +53,5 @@ def parse(import_source):
     df.loc[df["custodian"].isnull(), "custodian"] = "N/A"
     data = list()
     for d in df.to_dict("records"):
-        data.append(parse_row(d, import_source))
-
+        data.append(parse_row(d, negate_shares=negate_shares))
     return {"data": data}

wbportfolio/import_export/parsers/ubs/equity.py

@@ -40,7 +40,7 @@ def parse(import_source):
     for row in range(first_row, last_row, 1):
         initial_shares = round(equity_sheet.cell_value(row, 8), 4)
         close = round(equity_sheet.cell_value(row, 9), 4)
-        initial_currency_fx_rate = round(equity_sheet.cell_value(row, 11), 4)
+        initial_currency_fx_rate = round(equity_sheet.cell_value(row, 11), 14)
 
         bbg = equity_sheet.cell_value(row, 3)
         ric = equity_sheet.cell_value(row, 2)