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

wbportfolio/factories/product_groups.py

@@ -21,10 +21,10 @@ class ProductGroupFactory(InstrumentFactory):
     paying_agent = factory.SubFactory("wbcore.contrib.directory.factories.entries.CompanyFactory")
 
     @factory.post_generation
-    def create_initial_portfolio(product_group, *args, **kwargs):
-        if product_group.id and not product_group.portfolios.exists():
+    def create_initial_portfolio(self, *args, **kwargs):
+        if self.id and not self.portfolios.exists():
             portfolio = PortfolioFactory.create()
-            InstrumentPortfolioThroughModel.objects.create(instrument=product_group, portfolio=portfolio)
+            InstrumentPortfolioThroughModel.objects.create(instrument=self, portfolio=portfolio)
 
 
 class ProductGroupRepresentantFactory(factory.django.DjangoModelFactory):

wbportfolio/factories/products.py

@@ -40,10 +40,10 @@ class ProductFactory(InstrumentFactory):
     instrument_type = factory.LazyAttribute(lambda o: InstrumentTypeFactory.create(name="Product", key="product"))
 
     @factory.post_generation
-    def create_initial_portfolio(product, *args, **kwargs):
-        if product.id and not product.portfolios.exists():
+    def create_initial_portfolio(self, *args, **kwargs):
+        if self.id and not self.portfolios.exists():
             portfolio = PortfolioFactory.create()
-            InstrumentPortfolioThroughModel.objects.create(instrument=product, portfolio=portfolio)
+            InstrumentPortfolioThroughModel.objects.create(instrument=self, portfolio=portfolio)
 
     # wbportfolio = factory.SubFactory(PortfolioFactory)
     # portfolio_computed = factory.SubFactory(PortfolioFactory)

wbportfolio/filters/assets.py

@@ -456,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/order_proposals.py

@@ -28,14 +28,11 @@ class OrderProposalFilterSet(wb_filters.FilterSet):
         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=[OrderProposal.Status.PENDING, OrderProposal.Status.DRAFT, OrderProposal.Status.APPROVED]
-            )
+            queryset = queryset.filter(status__in=input_status)
         elif value is False:
-            queryset = queryset.exclude(
-                status__in=[OrderProposal.Status.PENDING, OrderProposal.Status.DRAFT, OrderProposal.Status.APPROVED]
-            )
+            queryset = queryset.exclude(status__in=input_status)
         return queryset
 
     def filter_is_automatic_rebalancing(self, queryset, name, value):

wbportfolio/filters/portfolios.py

@@ -1,10 +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):
@@ -26,6 +27,15 @@ class PortfolioFilterSet(wb_filters.FilterSet):
         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:
@@ -42,6 +52,13 @@ class PortfolioFilterSet(wb_filters.FilterSet):
             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/fees.py

@@ -16,7 +16,6 @@ class FeesFilter(wb_filters.FilterSet):
     """
 
     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,
@@ -52,7 +51,6 @@ class FeesProductFilterSet(FeesFilter):
 class FeesAggregatedFilter(PandasFilterSetMixin, wb_filters.FilterSet):
     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

@@ -14,7 +14,6 @@ from .utils import get_transaction_default_date_range
 
 class TradeFilter(OppositeSharesFieldMethodMixin, wb_filters.FilterSet):
     transaction_date = wb_filters.DateRangeFilter(
-        method=wb_filters.DateRangeFilter.base_date_range_filter_method,
         label="Date Range",
         initial=get_transaction_default_date_range,
     )

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/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/handlers/asset_position.py

@@ -1,6 +1,6 @@
 from collections import defaultdict
 from contextlib import suppress
-from datetime import datetime
+from datetime import datetime, timedelta
 from decimal import Decimal
 from itertools import chain
 from typing import Any, Dict, List, Optional
@@ -31,7 +31,7 @@ class AssetPositionImportHandler(ImportExportHandler):
         self.instrument_price_handler = InstrumentPriceImportHandler(self.import_source)
         self.currency_handler = CurrencyImportHandler(self.import_source)
 
-    def _deserialize(self, data: Dict[str, Any]):
+    def _deserialize(self, data: Dict[str, Any]):  # noqa: C901
         from wbportfolio.models import Portfolio
 
         portfolio_data = data.pop("portfolio", None)
@@ -45,6 +45,10 @@ class AssetPositionImportHandler(ImportExportHandler):
                     data["initial_price"] /= 1000
             data["currency"] = currency
         data["date"] = datetime.strptime(data["date"], "%Y-%m-%d").date()
+
+        # ensure that the position falls into a weekday
+        if data["date"].weekday() == 5:
+            data["date"] -= timedelta(days=1)
         if data.get("asset_valuation_date", None):
             data["asset_valuation_date"] = datetime.strptime(data["asset_valuation_date"], "%Y-%m-%d").date()
         else:
@@ -78,14 +82,14 @@ class AssetPositionImportHandler(ImportExportHandler):
                     data["initial_price"] = data["underlying_quote"].get_price(
                         data["date"], price_date_timedelta=self.MAX_PRICE_DATE_TIMEDELTA
                     )
-                except ValueError:
-                    raise DeserializationError("Price not provided but can not be found automatically")
+                except ValueError as e:
+                    raise DeserializationError("Price not provided but can not be found automatically") from e
 
         # number type deserialization and sanitization
         # ensure the provided Decimal field are of type Decimal
         decimal_fields = ["initial_currency_fx_rate", "initial_price", "initial_shares", "weighting"]
         for field in decimal_fields:
-            if not (value := data.get(field, None)) is None:
+            if (value := data.get(field, None)) is not None:
                 data[field] = Decimal(value)
 
         if data["weighting"] == 0:

wbportfolio/import_export/handlers/dividend.py

@@ -36,7 +36,7 @@ class DividendImportHandler(ImportExportHandler):
             data["currency"] = self.currency_handler.process_object(data["currency"], read_only=True)[0]
 
         for field in self.model._meta.get_fields():
-            if not (value := data.get(field.name, None)) is None and isinstance(field, models.DecimalField):
+            if (value := data.get(field.name, None)) is not None and isinstance(field, models.DecimalField):
                 q = 1 / (math.pow(10, 4))
                 data[field.name] = Decimal(value).quantize(Decimal(str(q)))
 

wbportfolio/import_export/handlers/fees.py

@@ -24,8 +24,8 @@ class FeesImportHandler(ImportExportHandler):
                 data["product"] = Product.objects.get(**product_data)
             else:
                 data["product"] = Product.objects.get(id=product_data)
-        except Product.DoesNotExist:
-            raise DeserializationError("There is no valid linked product for in this row.")
+        except Product.DoesNotExist as e:
+            raise DeserializationError("There is no valid linked product for in this row.") from e
 
         if "currency" not in data:
             data["currency"] = data["product"].currency

wbportfolio/import_export/handlers/trade.py

@@ -65,15 +65,15 @@ class TradeImportHandler(ImportExportHandler):
                 try:
                     product = Product.objects.get(id=underlying_instrument.id)
                     data["shares"] = nominal / product.share_price
-                except Product.DoesNotExist:
+                except Product.DoesNotExist as e:
                     raise DeserializationError(
                         "We cannot compute the number of shares from the nominal value as we cannot find the product share price."
-                    )
+                    ) from e
         else:
             raise DeserializationError("We couldn't find a valid underlying instrument this row.")
 
         for field in self.model._meta.get_fields():
-            if not (value := data.get(field.name, None)) is None and isinstance(field, models.DecimalField):
+            if (value := data.get(field.name, None)) is not None and isinstance(field, models.DecimalField):
                 q = (
                     1 / (math.pow(10, 4))
                 )  # we need that convertion mechanism otherwise there is floating point approximation error while casting to decimal and get_instance does not work as expected
@@ -86,7 +86,7 @@ class TradeImportHandler(ImportExportHandler):
             data["transaction_date"] = data["book_date"]
         return self.model.objects.create(**data, import_source=self.import_source)
 
-    def _get_instance(self, data: Dict[str, Any], history: Optional[models.QuerySet] = None, **kwargs) -> models.Model:
+    def _get_instance(self, data: Dict[str, Any], history: Optional[models.QuerySet] = None, **kwargs) -> models.Model:  # noqa: C901
         self.import_source.log += "\nGet Trade Instance."
         if transaction_date := data.get("transaction_date"):
             dates_lookup = {"transaction_date": transaction_date}

wbportfolio/import_export/parsers/default_mapping.py

@@ -7,7 +7,7 @@ def parse(import_source):
     if (
         (data_backend := import_source.source.data_backend)
         and (backend_class := data_backend.backend_class)
-        and (default_mapping := getattr(backend_class, "DEFAULT_MAPPING"))
+        and (default_mapping := backend_class.DEFAULT_MAPPING)
     ):
         df = pd.read_json(import_source.file, orient="records")
         if not df.empty:

wbportfolio/import_export/parsers/jpmorgan/customer_trade.py

@@ -11,8 +11,8 @@ from wbportfolio.models import Product, Trade
 def file_name_parse(file_name):
     dates = re.findall("([0-9]{8})", file_name)
 
-    assert len(dates) > 0
-
+    if len(dates) <= 0:
+        raise ValueError("No dates found in the filename")
     parts_dict = {"valuation_date": datetime.datetime.strptime(dates[0], "%Y%m%d").date()}
 
     isin = re.findall("([A-Z]{2}[A-Z0-9]{9}[0-9]{1})", file_name)

wbportfolio/import_export/parsers/jpmorgan/fees.py

@@ -14,8 +14,8 @@ logger = logging.getLogger("importers.parsers.jpmorgan.fee")
 def file_name_parse(file_name):
     dates = re.findall("([0-9]{8})", file_name)
 
-    assert len(dates) == 1, "Not exactly 1 date found in the filename"
-
+    if len(dates) != 1:
+        raise ValueError("Not exactly 1 date found in the filename")
     return {"valuation_date": datetime.datetime.strptime(dates[0], "%Y%m%d").date()}
 
 

wbportfolio/import_export/parsers/jpmorgan/strategy.py

@@ -12,106 +12,80 @@ logger = logging.getLogger("importers.parsers.jp_morgan.strategy")
 
 def file_name_parse(file_name):
     dates = re.findall("([0-9]{8})", file_name)
-
-    assert len(dates) == 1, "Not exactly 1 date found in the filename"
-
-    return {"valuation_date": datetime.datetime.strptime(dates[0], "%Y%m%d").date()}
-
-
-def manually_create_100_position(parent_strategies, valuation_date):
-    data = []
-    from wbportfolio.models import Index, Product
-
-    for strategy_ticker in parent_strategies:
-        if index := Index.objects.filter(ticker=strategy_ticker).first():
-            for product in Product.objects.filter(ticker=strategy_ticker):
-                valuations = product.valuations.filter(date__lte=valuation_date)
-                last_price = 0
-                if valuations.exists():
-                    last_price = float(valuations.latest("date").net_value)
-                data.append(
-                    {
-                        "underlying_quote": index.id,
-                        "portfolio": {"instrument_type": "product", "id": product.id},
-                        "currency__key": index.currency.key,
-                        "initial_currency_fx_rate": 1.0,
-                        "weighting": 1.0,
-                        "is_estimated": True,  # this position is not a real position, it is created by the importer.
-                        "initial_price": last_price,
-                        "date": valuation_date.strftime("%Y-%m-%d"),
-                    }
-                )
-    return data
+    if dates:
+        return {"valuation_date": datetime.datetime.strptime(dates[0], "%Y%m%d").date()}
+    return {}
 
 
 def parse(import_source):
     # Load file into a CSV DictReader
 
     df = pd.read_csv(import_source.file, encoding="utf-16", delimiter=",")
-    df = df.replace([np.inf, -np.inf, np.nan], None)
 
     # Parse the Parts of the filename into the different parts
     parts = file_name_parse(import_source.file.name)
 
     # Get the valuation date from the parts list
-    valuation_date = parts["valuation_date"]
+    report_date = parts.get("valuation_date")
 
     # Iterate through the CSV File and parse the data into a list
     data = list()
-    parents_strategies = set()
+    if "Date" in df.columns:
+        df["Date"] = pd.to_datetime(df["Date"])
+    df.replace([np.inf, -np.inf, np.nan], None, inplace=True)
     for strategy_data in df.to_dict("records"):
-        bbg_tickers = strategy_data["BBG Ticker"].split(" ")
-        exchange = None
-        if len(bbg_tickers) == 2:
-            ticker = bbg_tickers[0]
-            instrument_type = bbg_tickers[1]
-        elif len(bbg_tickers) == 3:
-            ticker = bbg_tickers[0]
-            exchange = bbg_tickers[1]
-            instrument_type = bbg_tickers[2]
-
-        strategy = strategy_data["Strategy Ticker"].replace("Index", "").strip()
-        strategy_currency_key = strategy_data["Strategy CCY"]
-
-        position_currency_key = strategy_data["Position CCY"]
-
-        isin = strategy_data["Position ISIN"]
-        name = strategy_data["Position Description"]
-        initial_price = convert_string_to_number(strategy_data["Prices"])
-        initial_currency_fx_rate = convert_string_to_number(strategy_data["Fx Rates"])
-        if exchange:
-            exchange = {"bbg_exchange_codes": exchange}
-        try:
-            weighting = convert_string_to_number(strategy_data["Weight In Percent"].replace("%", "")) / 100
-        except Exception:
-            weighting = 0.0
-        underlying_quote = {
-            "ticker": ticker,
-            "exchange": exchange,
-            "isin": isin,
-            "name": name,
-            "currency__key": position_currency_key,
-            "instrument_type": instrument_type.lower(),
-        }
-        if isin:
-            underlying_quote["isin"] = isin
-        data.append(
-            {
-                "underlying_quote": underlying_quote,
-                "portfolio": {
-                    "instrument_type": "index",
-                    "ticker": strategy,
-                    "currency__key": strategy_currency_key,
-                },
+        valuation_date = strategy_data.get("Date", report_date)
+        if valuation_date:
+            bbg_tickers = strategy_data["BBG Ticker"].split(" ")
+            exchange = None
+            if len(bbg_tickers) == 2:
+                ticker = bbg_tickers[0]
+                instrument_type = bbg_tickers[1]
+            elif len(bbg_tickers) == 3:
+                ticker = bbg_tickers[0]
+                exchange = bbg_tickers[1]
+                instrument_type = bbg_tickers[2]
+
+            strategy = strategy_data["Strategy Ticker"].replace("Index", "").strip()
+            strategy_currency_key = strategy_data["Strategy CCY"]
+
+            position_currency_key = strategy_data["Position CCY"]
+
+            isin = strategy_data["Position ISIN"]
+            name = strategy_data["Position Description"]
+            initial_price = convert_string_to_number(strategy_data["Prices"])
+            initial_currency_fx_rate = convert_string_to_number(strategy_data["Fx Rates"])
+            if exchange:
+                exchange = {"bbg_exchange_codes": exchange}
+            try:
+                weighting = convert_string_to_number(strategy_data["Weight In Percent"].replace("%", "")) / 100
+            except Exception:
+                weighting = 0.0
+            underlying_quote = {
+                "ticker": ticker,
                 "exchange": exchange,
-                "is_estimated": False,
+                "isin": isin,
+                "name": name,
                 "currency__key": position_currency_key,
-                "initial_currency_fx_rate": initial_currency_fx_rate,
-                "weighting": weighting,
-                "initial_price": initial_price,
-                "date": valuation_date.strftime("%Y-%m-%d"),
+                "instrument_type": instrument_type.lower(),
             }
-        )
-        parents_strategies.add(strategy)
-    manual_data = manually_create_100_position(parents_strategies, valuation_date)
-    return {"data": data + manual_data}
+            if isin:
+                underlying_quote["isin"] = isin
+            data.append(
+                {
+                    "underlying_quote": underlying_quote,
+                    "portfolio": {
+                        "instrument_type": "index",
+                        "ticker": strategy,
+                        "currency__key": strategy_currency_key,
+                    },
+                    "exchange": exchange,
+                    "is_estimated": False,
+                    "currency__key": position_currency_key,
+                    "initial_currency_fx_rate": initial_currency_fx_rate,
+                    "weighting": weighting,
+                    "initial_price": initial_price,
+                    "date": valuation_date.strftime("%Y-%m-%d"),
+                }
+            )
+    return {"data": data}

wbportfolio/import_export/parsers/jpmorgan/valuation.py

@@ -13,8 +13,8 @@ logger = logging.getLogger("importers.parsers.jpmorgan.index")
 def file_name_parse(file_name):
     dates = re.findall("([0-9]{8})", file_name)
 
-    assert len(dates) == 1, "Not exactly 1 date found in the filename"
-
+    if len(dates) != 1:
+        raise ValueError("Not exactly 1 date found in the filename")
     return {"valuation_date": datetime.datetime.strptime(dates[0], "%Y%m%d").date()}
 
 

wbportfolio/import_export/parsers/leonteq/trade.py

@@ -10,7 +10,8 @@ from wbportfolio.models import Product
 def file_name_parse(file_name):
     isin = re.findall("([A-Z]{2}[A-Z0-9]{9}[0-9]{1})", file_name)
 
-    assert len(isin) == 1, "Not exactly 1 isin found in the filename"
+    if len(isin) != 1:
+        raise ValueError("Not exactly 1 isin found in the filename")
 
     return {"isin": isin[0]}
 

wbportfolio/import_export/parsers/natixis/equity.py

@@ -1,3 +1,5 @@
+from zipfile import BadZipFile
+
 import numpy as np
 import pandas as pd
 
@@ -29,15 +31,28 @@ def _apply_adjusting_factor(row):
 def parse(import_source):
     # Parse the Parts of the filename into the different parts
     parts = file_name_parse_isin(import_source.file.name)
-
     # Get the valuation date and investment from the parts list
     valuation_date = parts["valuation_date"]
     product_data = parts["product"]
 
     # Load file into a CSV DictReader
-    df = pd.read_csv(import_source.file, encoding="utf-16", delimiter=";")
+    if import_source.file.name.lower().endswith(".csv"):
+        df = pd.read_csv(import_source.file, encoding="utf-16", delimiter=";")
+    else:
+        try:
+            df = pd.read_excel(import_source.file, engine="openpyxl", sheet_name="Basket Valuation")
+        except BadZipFile:
+            df = pd.read_excel(import_source.file, engine="xlrd", sheet_name="Basket Valuation")
+        xx, yy = np.where(df.isin(["Ticker", "Code"]))
+        if xx.size > 0 and yy.size > 0:
+            df = df.iloc[xx[0] :, yy[0] :]
+            df = df.rename(columns=df.iloc[0]).drop(df.index[0]).dropna(how="all")
+            df["Quotity/Adj. factor"] = 1.0
+            df = df.rename(columns={"Code": "Ticker"})
+        else:
+            return {}
     df = df.rename(columns=FIELD_MAP)
-    df = df.dropna(subset=["initial_price"])
+    df = df.dropna(subset=["initial_price", "Name"], how="any")
     df["initial_price"] = df["initial_price"].astype("str").str.replace(" ", "").astype("float")
     df["underlying_quote"] = df[["Ticker", "Name", "currency__key"]].apply(
         lambda x: _get_underlying_instrument(*x), axis=1
@@ -50,7 +65,10 @@ def parse(import_source):
     df = df.drop(columns=df.columns.difference(FIELD_MAP.values()))
 
     df["portfolio__instrument_type"] = "product"
-    df["portfolio__isin"] = product_data["isin"]
+    if "isin" in product_data:
+        df["portfolio__isin"] = product_data["isin"]
+    if "ticker" in product_data:
+        df["portfolio__ticker"] = product_data["ticker"]
     df["is_estimated"] = False
     df["date"] = valuation_date.strftime("%Y-%m-%d")
     df["asset_valuation_date"] = pd.to_datetime(df["asset_valuation_date"], dayfirst=True).dt.strftime("%Y-%m-%d")

wbportfolio/import_export/parsers/natixis/utils.py

@@ -1,6 +1,7 @@
-import datetime
 import re
 
+from django.utils.dateparse import parse_date
+
 from wbportfolio.models import Product
 
 INSTRUMENT_MAP_NAME = {"EDA23_AtonRa Z class": "LU2170995018"}
@@ -53,21 +54,14 @@ def _get_underlying_instrument(bbg_code, name, currency, instrument_type="equity
 
 
 def file_name_parse_isin(file_name):
-    dates = re.findall(r"_([0-9]{4}-?[0-9]{2}-?[0-9]{2})", file_name)
-    identifier = re.findall(r"([A-Z]{2}(?![A-Z]{10}\b)[A-Z0-9]{10})_", file_name)
-    assert len(dates) == 2, "Not 2 dates found in the filename"
-    assert len(identifier) == 1, "Not exactly 1 identifier found in the filename"
-    try:
-        valuation_date = datetime.datetime.strptime(dates[0], "%Y-%m-%d").date()
-    except ValueError:
-        valuation_date = datetime.datetime.strptime(dates[0], "%Y%m%d").date()
-    try:
-        generation_date = datetime.datetime.strptime(dates[1], "%Y-%m-%d").date()
-    except ValueError:
-        generation_date = datetime.datetime.strptime(dates[1], "%Y%m%d").date()
-
-    return {
-        "product": {"isin": identifier[0]},
-        "valuation_date": valuation_date,
-        "generation_date": generation_date,
-    }
+    dates = re.findall(r"_([0-9]{4}[-_]?[0-9]{2}[-_]?[0-9]{2})", file_name)
+    isin = re.findall(r"([A-Z]{2}(?![A-Z]{10}\b)[A-Z0-9]{10})_", file_name)
+    ticker = re.findall(r"(NX[A-Z]*)_", file_name)
+    if len(dates) == 0:
+        raise ValueError("Not dates found in the filename")
+    res = {"valuation_date": parse_date(dates[0].replace("_", "-"))}
+    if len(isin) >= 1:
+        res["product"] = {"isin": isin[0]}
+    elif len(ticker) == 1:
+        res["product"] = {"ticker": ticker[0]}
+    return res

wbportfolio/import_export/parsers/sg_lux/equity.py

@@ -11,9 +11,10 @@ from wbportfolio.models import ProductGroup
 def file_name_parse(file_name):
     dates = re.findall(r"([0-9]{4}-[0-9]{2}-[0-9]{2})", file_name)
     isin = re.findall(r"\.([a-zA-Z0-9]*)_", file_name)
-
-    assert len(dates) == 2, "Not 2 dates found in the filename"
-    assert len(isin) == 1, "Not exactly 1 isin found in the filename"
+    if len(dates) != 2:
+        raise ValueError("Not 2 dates found in the filename")
+    if len(isin) != 1:
+        raise ValueError("Not exactly 1 isin found in the filename")
 
     return {
         "isin": isin[0],