wbportfolio 1.50.15__py2.py3-none-any.whl → 1.51.1__py2.py3-none-any.whl

wbportfolio/import_export/parsers/natixis/equity.py

@@ -1,7 +1,7 @@
 import numpy as np
 import pandas as pd
 
-from .utils import _get_underlying_instrument, file_name_parse
+from .utils import _get_underlying_instrument, file_name_parse_isin
 
 FIELD_MAP = {
     "Close": "initial_price",
@@ -28,11 +28,11 @@ def _apply_adjusting_factor(row):
 
 def parse(import_source):
     # Parse the Parts of the filename into the different parts
-    parts = file_name_parse(import_source.file.name)
+    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 = parts["product"]
+    product_data = parts["product"]
 
     # Load file into a CSV DictReader
     df = pd.read_csv(import_source.file, encoding="utf-16", delimiter=";")
@@ -50,7 +50,7 @@ def parse(import_source):
     df = df.drop(columns=df.columns.difference(FIELD_MAP.values()))
 
     df["portfolio__instrument_type"] = "product"
-    df["portfolio__id"] = product.id
+    df["portfolio__isin"] = product_data["isin"]
     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/fees.py

@@ -1,7 +1,7 @@
 import pandas as pd
 from pandas.tseries.offsets import BDay
 
-from .utils import file_name_parse
+from .utils import file_name_parse_isin
 
 FIELD_MAP = {
     "Date": "transaction_date",
@@ -14,9 +14,8 @@ FIELD_MAP = {
 
 def parse(import_source):
     # Parse the Parts of the filename into the different parts
-    parts = file_name_parse(import_source.file.name)
+    parts = file_name_parse_isin(import_source.file.name)
     # Get the valuation date and investment from the parts list
-    parts["valuation_date"]
     product = parts["product"]
 
     df = pd.read_csv(import_source.file, encoding="utf-8", delimiter=";")
@@ -42,12 +41,10 @@ def parse(import_source):
     )
     df = df[df["total_value"] != 0]
 
-    df["portfolio"] = product.primary_portfolio.id
-    df["linked_product"] = product.id
+    df["linked_product"] = [product] * df.shape[0]
     df["transaction_date"] = df["transaction_date"].dt.strftime("%Y-%m-%d")
     df["calculated"] = False
     df["total_value_gross"] = df["total_value"]
     df["total_value_fx_portfolio"] = df["total_value"]
     df["total_value_gross_fx_portfolio"] = df["total_value"]
-
     return {"data": df.to_dict("records")}

wbportfolio/import_export/parsers/natixis/trade.py

@@ -2,7 +2,7 @@ import pandas as pd
 
 from wbportfolio.models import Trade
 
-from .utils import _get_underlying_instrument, file_name_parse
+from .utils import _get_underlying_instrument, file_name_parse_isin
 
 
 def _parse_trade_type(type):
@@ -22,10 +22,10 @@ def parse(import_source):
     df = pd.read_csv(import_source.file, sep=";")
     if not df.empty:
         # Parse the Parts of the filename into the different parts
-        parts = file_name_parse(import_source.file.name)
+        parts = file_name_parse_isin(import_source.file.name)
 
         # Get the valuation date and investment from the parts list
-        product = parts["product"]
+        product_data = parts["product"]
 
         # Iterate through the CSV File and parse the data into a list
         df["underlying_instrument"] = df[["BLOOMBERG CODE", "NAME", "QUOTED_CRNCY"]].apply(
@@ -58,7 +58,7 @@ def parse(import_source):
         df.transaction_date = df.transaction_date.apply(lambda x: x.strftime("%Y-%m-%d"))
         df["transaction_subtype"] = df["transaction_subtype"].apply(lambda x: _parse_trade_type(x))
         df = df.drop(columns=df.columns.difference(columns_map.values()))
-        df["portfolio"] = product.primary_portfolio.id
+        df["portfolio"] = [{"instrument_type": "product", **product_data}] * df.shape[0]
         df["bank"] = "Natixis Cash Transfer"
         data = df.to_dict("records")
     return {"data": data}

wbportfolio/import_export/parsers/natixis/utils.py

@@ -1,11 +1,9 @@
 import datetime
 import re
 
-from django.db.models import Q
-
 from wbportfolio.models import Product
 
-INSTRUMENT_MAP_NAME = {"EDA23_AtonRa Z class": Product.objects.get(isin="LU2170995018")}
+INSTRUMENT_MAP_NAME = {"EDA23_AtonRa Z class": "LU2170995018"}
 
 
 def _get_exchange_from_ticker(ticker):
@@ -21,8 +19,8 @@ def _get_ticker(ticker):
 
 
 def _get_underlying_instrument(bbg_code, name, currency, instrument_type="equity", isin=None, cash_position=False):
-    if product := INSTRUMENT_MAP_NAME.get(bbg_code, None):
-        return {"id": product.id}
+    if isin := INSTRUMENT_MAP_NAME.get(bbg_code, None):
+        return {"isin": isin}
 
     exchange = _get_exchange_from_ticker(bbg_code)
     ticker = _get_ticker(bbg_code)
@@ -54,7 +52,7 @@ def _get_underlying_instrument(bbg_code, name, currency, instrument_type="equity
     return underlying_quote
 
 
-def file_name_parse(file_name):
+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"
@@ -68,10 +66,8 @@ def file_name_parse(file_name):
     except ValueError:
         generation_date = datetime.datetime.strptime(dates[1], "%Y%m%d").date()
 
-    product = Product.objects.get(Q(ticker=identifier[0]) | Q(isin=identifier[0]))
-
     return {
-        "product": product,
+        "product": {"isin": identifier[0]},
         "valuation_date": valuation_date,
         "generation_date": generation_date,
     }

wbportfolio/import_export/parsers/natixis/valuation.py

@@ -4,7 +4,7 @@ import datetime
 
 from wbportfolio.import_export.utils import convert_string_to_number
 
-from .utils import file_name_parse
+from .utils import file_name_parse_isin
 
 
 def parse(import_source):
@@ -20,11 +20,10 @@ def parse(import_source):
     csv_reader = csv.DictReader(csv_file, delimiter=";")
 
     # Parse the Parts of the filename into the different parts
-    parts = file_name_parse(import_source.file.name)
+    parts = file_name_parse_isin(import_source.file.name)
 
     # Get the valuation date and investment from the parts list
-    parts["valuation_date"]
-    product = parts["product"]
+    product_data = parts["product"]
 
     # Iterate through the CSV File and parse the data into a list
     data = list()
@@ -34,7 +33,7 @@ def parse(import_source):
         if date.weekday() not in [5, 6]:
             data.append(
                 {
-                    "instrument": {"instrument_type": "product", "id": product.id},
+                    "instrument": {"instrument_type": "product", **product_data},
                     "date": date.strftime("%Y-%m-%d"),
                     "net_value": round(convert_string_to_number(valuation["Index Value in%"]), 6),
                     "gross_value": round(convert_string_to_number(valuation["Index gross in%"]), 6),

wbportfolio/import_export/parsers/sg_lux/fees.py

@@ -4,7 +4,7 @@ import datetime
 import logging
 
 from wbportfolio.import_export.utils import convert_string_to_number
-from wbportfolio.models import Fees, Product
+from wbportfolio.models import Fees
 
 logger = logging.getLogger("importers.parsers.sglux.fee")
 # Shares class mapping between ticker to identifier
@@ -37,14 +37,14 @@ def parse(import_source):
     for fee_data in fee_reader:
         if (fee_description := fee_data["Fees description"]) and fee_description.startswith("Investment Manager fees"):
             share_class = fee_data["Class"]  # .split("\\")[1][0]
-            product = Product.objects.get(
-                parent__identifier=fee_data["Code"], currency__key=fee_data["Local ccy"], identifier=share_class
-            )
             date = datetime.datetime.strptime(fee_data["NAV Date"], "%Y/%m/%d")
             data.append(
                 {
-                    "portfolio": product.primary_portfolio.id,
-                    "linked_product": product.id,
+                    "linked_product": {
+                        "parent__identifier": fee_data["Code"],
+                        "currency__key": fee_data["Local ccy"],
+                        "identifier": share_class,
+                    },
                     "transaction_date": date.strftime("%Y-%m-%d"),
                     "calculated": False,
                     "transaction_subtype": Fees.Type.MANAGEMENT,

wbportfolio/import_export/parsers/sg_lux/perf_fees.py

@@ -5,7 +5,7 @@ import logging
 import re
 
 from wbportfolio.import_export.utils import convert_string_to_number
-from wbportfolio.models import Fees, Product
+from wbportfolio.models import Fees
 
 logger = logging.getLogger("importers.parsers.sglux.perf_fees")
 
@@ -18,7 +18,6 @@ def parse(import_source):
     # fee_reader = csv.DictReader(fee_file, delimiter=',')
     fee_reader = csv.reader(fee_file)
     isin = re.findall("([A-Z]{2}[A-Z0-9]{9}[0-9]{1})", import_source.file.name)[0]
-    product = Product.objects.get(isin=isin)
 
     # Iterate through the CSV File and parse the data into a list
     data = list()
@@ -27,8 +26,7 @@ def parse(import_source):
         date = datetime.datetime.strptime(fee_data[0], "%m/%d/%Y")
         data.append(
             {
-                "portfolio": product.primary_portfolio.id,
-                "linked_product": product.id,
+                "linked_product": {"isin": isin},
                 "transaction_date": date.strftime("%Y-%m-%d"),
                 "calculated": False,
                 "transaction_subtype": Fees.Type.PERFORMANCE,
@@ -37,8 +35,7 @@ def parse(import_source):
         )
         data.append(
             {
-                "portfolio": product.primary_portfolio.id,
-                "linked_product": product.id,
+                "linked_product": {"isin": isin},
                 "transaction_date": date.strftime("%Y-%m-%d"),
                 "calculated": False,
                 "transaction_subtype": Fees.Type.PERFORMANCE_CRYSTALIZED,

wbportfolio/import_export/parsers/sg_lux/registers.py

@@ -21,6 +21,10 @@ def convert_string_to_number(string):
 def parse(import_source):
     data = list()
 
+    country_title_mapping_exception = import_source.source.import_parameters.get(
+        "country_title_mapping_exception", {"great-britain": "GB", "united kingdom": "GB", "man (isle of)": "IM"}
+    )
+
     sylk_handler = SYLK()
     for line in [_line.decode("cp1252") for _line in import_source.file.open("rb").readlines()]:
         sylk_handler.parseline(line)
@@ -156,8 +160,8 @@ def parse(import_source):
     country_title_mapping = {
         country["name"].lower(): country["id"] for country in Geography.countries.all().values("id", "name")
     }
-    country_title_mapping["great-britain"] = Geography.countries.get(code_2="GB").id
-    country_title_mapping["man (isle of)"] = Geography.countries.get(code_2="IM").id
+    for title, code in country_title_mapping_exception.items():
+        country_title_mapping[title] = Geography.countries.get(code_2=code).id
 
     df["CITIZENSHIP"] = df["CITIZENSHIP"].apply(lambda x: country_code_mapping[x])
     df["RESIDENCE"] = df["RESIDENCE"].apply(lambda x: country_code_mapping[x])

wbportfolio/import_export/parsers/sg_lux/valuation.py

@@ -4,7 +4,6 @@ import datetime
 import re
 
 from wbportfolio.import_export.utils import convert_string_to_number
-from wbportfolio.models import Product
 
 
 def file_name_parse(file_name):
@@ -38,11 +37,11 @@ def parse(import_source):
 
     for valuation in csv_reader:
         valuation_date = datetime.datetime.strptime(valuation["NAV Date"], "%Y/%m/%d").date()
-        product = Product.objects.get(isin=valuation["ISIN Code"])
-        if valuation_date.weekday() not in [5, 6] and product.currency.key == valuation["Ccy"]:
+        isin = valuation["ISIN Code"]
+        if valuation_date.weekday() not in [5, 6] and valuation["ShareCurrency"] == valuation["Ccy"]:
             data.append(
                 {
-                    "instrument": {"instrument_type": "product", "id": product.id},
+                    "instrument": {"instrument_type": "product", "isin": isin},
                     "date": valuation_date.strftime("%Y-%m-%d"),
                     "net_value": round(convert_string_to_number(valuation["NAV per share"]), 6),
                     "calculated": False,

wbportfolio/import_export/parsers/societe_generale/customer_trade.py

@@ -11,14 +11,14 @@ def parse(import_source):
     df_dict = pd.read_excel(BytesIO(import_source.file.read()), engine="openpyxl", sheet_name=None)
 
     data = list()
-    products = list()
+    product_isins = set()
     max_date = datetime.date(1900, 1, 1)
 
     for sheet_name, df in df_dict.items():
         if "prices" not in sheet_name:
             isin = re.findall("([A-Z]{2}[A-Z0-9]{9}[0-9]{1})", sheet_name)
-            product = Product.objects.get(isin=isin[0])
-            products.append(product.id)
+            isin = isin[0]
+            product_isins.add(isin)
             df = df.rename(
                 columns={
                     "Trade Date": "transaction_date",
@@ -34,22 +34,23 @@ def parse(import_source):
             for trade in df.to_dict("records"):
                 max_date = max(trade["transaction_date"].date(), max_date)
 
-                shares = trade["nominal"] if trade["way"] == "S" else trade["nominal"] * -1
-                shares = shares / product.share_price
-                portfolio = product.primary_portfolio
+                nominal = trade["nominal"] if trade["way"] == "S" else trade["nominal"] * -1
                 data.append(
                     {
-                        "underlying_instrument": {"id": product.id, "instrument_type": "product"},
-                        "currency__key": product.currency.key,
-                        "portfolio": portfolio.id,
+                        "underlying_instrument": {"isin": isin, "instrument_type": "product"},
+                        "portfolio": {"isin": isin, "instrument_type": "product"},
                         "transaction_date": trade["transaction_date"].strftime("%Y-%m-%d"),
-                        "shares": shares,
-                        "transaction_subtype": Trade.Type.REDEMPTION if shares < 0 else Trade.Type.SUBSCRIPTION,
+                        "nominal": nominal,
+                        "transaction_subtype": Trade.Type.REDEMPTION if nominal < 0 else Trade.Type.SUBSCRIPTION,
                         "bank": trade["bank"],
                         "price": round(trade["price"] / 10, 6),
                     }
                 )
+    underlying_instruments = Product.objects.filter(isin__in=product_isins).values_list("id", flat=True)
     return {
         "data": data,
-        "history": {"underlying_instruments": products, "transaction_date": max_date.strftime("%Y-%m-%d")},
+        "history": {
+            "underlying_instruments": list(underlying_instruments),
+            "transaction_date": max_date.strftime("%Y-%m-%d"),
+        },
     }

wbportfolio/import_export/parsers/societe_generale/valuation.py

@@ -4,7 +4,6 @@ import numpy as np
 import pandas as pd
 
 from wbportfolio.import_export.utils import get_file_extension
-from wbportfolio.models import Product
 
 
 def parse(import_source):
@@ -25,10 +24,10 @@ def parse(import_source):
 
     data = list()
     for valuation in df.to_dict("records"):
-        product = Product.objects.get(isin=valuation["ISIN Code"])
+        isin = valuation["ISIN Code"]
         data.append(
             {
-                "instrument": {"instrument_type": "product", "id": product.id},
+                "instrument": {"instrument_type": "product", "isin": isin},
                 "date": valuation["Valuation Date"].strftime("%Y-%m-%d"),
                 "net_value": round(valuation["Bid"], 6),
                 "calculated": False,

wbportfolio/import_export/parsers/tellco/customer_trade.py

@@ -4,7 +4,7 @@ import datetime
 import re
 
 from wbportfolio.import_export.utils import convert_string_to_number
-from wbportfolio.models import Product, Trade
+from wbportfolio.models import Trade
 
 product_mapping = {
     "2304": {
@@ -42,16 +42,14 @@ def parse(import_source):
     # Iterate through the CSV File and parse the data into a list
     data = list()
     for customer_trade in csv_reader:
-        product = Product.objects.get(isin=product_mapping[identifier][customer_trade["Anteilklasse"].strip()])
+        isin = product_mapping[identifier][customer_trade["Anteilklasse"].strip()]
 
         transaction_date = datetime.datetime.strptime(customer_trade["Datum"], "%Y%m%d").date()
         shares = round(convert_string_to_number(customer_trade["Saldo - Anzahl"]), 4)
-        portfolio = product.primary_portfolio
         data.append(
             {
-                "underlying_instrument": {"id": product.id, "instrument_type": "product"},
-                "portfolio": portfolio.id,
-                "currency__key": product.currency.key,
+                "underlying_instrument": {"isin": isin, "instrument_type": "product"},
+                "portfolio": {"isin": isin, "instrument_type": "product"},
                 "transaction_date": transaction_date.strftime("%Y-%m-%d"),
                 "value_date": transaction_date.strftime("%Y-%m-%d"),
                 "shares": shares,

wbportfolio/import_export/parsers/tellco/equity.py

@@ -6,7 +6,6 @@ import pandas as pd
 from wbcore.contrib.currency.models import Currency
 
 from wbportfolio.import_export.utils import convert_string_to_number
-from wbportfolio.models import ProductGroup
 
 
 def parse(import_source):
@@ -24,7 +23,7 @@ def parse(import_source):
             basket["Assetart"] == "TRES" and "Sichtguthaben" not in basket["Assetbezeichnung"]
         ):
             continue
-        product_group = ProductGroup.objects.get(identifier=basket["Fonds-Nr."].strip())
+        identifier = basket["Fonds-Nr."].strip()
         valuation_date = datetime.datetime.strptime(basket["Datum"], "%Y%m%d")
 
         currency_key = basket["Währung"]
@@ -67,7 +66,7 @@ def parse(import_source):
                 "exchange": underlying_quote.get("exchange", None),
                 "portfolio": {
                     "instrument_type": "product_group",
-                    "id": product_group.id,
+                    "identifier": identifier,
                 },
                 "is_estimated": False,
                 "currency__key": currency_key,

wbportfolio/import_export/parsers/tellco/valuation.py

@@ -3,8 +3,6 @@ import csv
 import datetime
 import re
 
-from wbportfolio.models import Product
-
 
 def file_name_parse(file_name):
     dates = re.findall(r"([0-9]{4}-[0-9]{2}-[0-9]{2})", file_name)
@@ -37,11 +35,11 @@ def parse(import_source):
 
     for valuation in csv_reader:
         valuation_date = datetime.datetime.strptime(valuation["Bewertungsdatum"], "%Y%m%d").date()
-        product = Product.objects.get(isin=valuation["ISIN"])
+        isin = valuation["ISIN"]
         if valuation_date.weekday() not in [5, 6]:
             data.append(
                 {
-                    "instrument": {"instrument_type": "product", "id": product.id},
+                    "instrument": {"instrument_type": "product", "isin": isin},
                     "date": valuation_date.strftime("%Y-%m-%d"),
                     "net_value": float(valuation["Nettoinventarwert"]),
                     "calculated": False,

wbportfolio/import_export/parsers/ubs/api/fees.py

@@ -2,30 +2,27 @@ import json
 
 import pandas as pd
 
-from wbportfolio.models import Fees, Product
+from wbportfolio.models import Fees
 
 BASE_MAPPING = {"managementFee": "total_value", "performanceFee": "total_value", "date": "transaction_date"}
 
 
 def parse(import_source):
-    def _process_df(df, product):
+    def _process_df(df, product_isin):
         df = df.rename(columns=BASE_MAPPING).dropna(how="all", axis=1)
         df = df.drop(columns=df.columns.difference(BASE_MAPPING.values()))
-        df["currency__key"] = product.currency.key
-        df["linked_product"] = product.id
-        df["underlying_instrument"] = product.id
-        df["portfolio"] = product.primary_portfolio.id
+        df["linked_product"] = [{"isin": product_isin}] * df.shape[0]
         return df
 
     content = json.load(import_source.file)
     data = []
-    if product := Product.objects.filter(isin=content.get("isin", None)).first():
+    if isin := content.get("isin", None):
         if mngt_data := content.get("management_fees", None):
-            df = _process_df(pd.DataFrame(mngt_data), product)
+            df = _process_df(pd.DataFrame(mngt_data), isin)
             df["transaction_subtype"] = Fees.Type.MANAGEMENT.value
             data.extend(df.to_dict("records"))
         if perf_data := content.get("performance_fees", None):
-            df = _process_df(pd.DataFrame(perf_data), product)
+            df = _process_df(pd.DataFrame(perf_data), isin)
             df["transaction_subtype"] = Fees.Type.PERFORMANCE.value
             data.extend(df.to_dict("records"))
 

wbportfolio/import_export/parsers/ubs/customer_trade.py

@@ -5,29 +5,23 @@ import numpy as np
 import pandas as pd
 from wbcore.contrib.io.models import ImportSource
 
-from wbportfolio.models import Product, Trade
+from wbportfolio.models import Trade
 
 
 def parse_row(obj: Dict, import_source: ImportSource) -> Dict:
-    try:
-        isin = obj["underlying_instrument__isin"]
-        product = Product.objects.get(isin=isin)
-        shares = obj["shares"]
-        if import_source.source.import_parameters.get("negate_shares", False):
-            shares = -1 * shares
-        portfolio = product.primary_portfolio
-        return {
-            "underlying_instrument": {"id": product.id, "instrument_type": "product"},
-            "currency__key": product.currency.key,
-            "portfolio": portfolio.id,
-            "transaction_date": obj["transaction_date"].strftime("%Y-%m-%d"),
-            "shares": shares,
-            "bank": obj["custodian"],
-            "transaction_subtype": Trade.Type.REDEMPTION if shares < 0 else Trade.Type.SUBSCRIPTION,
-            "price": round(obj["price"], 6),
-        }
-    except Product.DoesNotExist:
-        import_source.log += f"Product with ISIN {isin} does not exists."
+    isin = obj["underlying_instrument__isin"]
+    shares = obj["shares"]
+    if import_source.source.import_parameters.get("negate_shares", False):
+        shares = -1 * shares
+    return {
+        "underlying_instrument": {"isin": isin, "instrument_type": "product"},
+        "portfolio": {"isin": isin, "instrument_type": "product"},
+        "transaction_date": obj["transaction_date"].strftime("%Y-%m-%d"),
+        "shares": shares,
+        "bank": obj["custodian"],
+        "transaction_subtype": Trade.Type.REDEMPTION if shares < 0 else Trade.Type.SUBSCRIPTION,
+        "price": round(obj["price"], 6),
+    }
 
 
 def parse(import_source):

wbportfolio/import_export/parsers/ubs/equity.py

@@ -3,8 +3,6 @@ import re
 
 import xlrd
 
-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)
@@ -18,8 +16,7 @@ def parse(import_source):
     book = xlrd.open_workbook(file_contents=import_source.file.read())
 
     parts = file_name_parse(import_source.file.name)
-
-    product = Product.objects.get(isin=parts["isin"])
+    isin = parts["isin"]
 
     equity_sheet = book.sheet_by_name("Equity")
     cash_sheet = book.sheet_by_name("Cash")
@@ -62,7 +59,7 @@ def parse(import_source):
                     "currency__key": equity_sheet.cell_value(row, 10),
                     "refinitiv_identifier_code": ric,
                 },
-                "portfolio": {"instrument_type": "product", "id": product.id},
+                "portfolio": {"instrument_type": "product", "isin": isin},
                 "is_estimated": False,
                 "exchange": exchange_data,
                 "initial_shares": initial_shares,
@@ -82,7 +79,7 @@ def parse(import_source):
                         "instrument_type": "cash",
                         "currency__key": cash_sheet.cell_value(row_index + 1, 1),
                     },
-                    "portfolio": {"instrument_type": "product", "id": product.id},
+                    "portfolio": {"instrument_type": "product", "isin": isin},
                     "is_estimated": False,
                     "name": cash_sheet.cell_value(row_index + 1, 1),
                     "initial_shares": round(cash_sheet.cell_value(row_index + 1, 2), 4),

wbportfolio/import_export/parsers/ubs/historical_customer_trade.py

@@ -1,39 +1,11 @@
 from io import BytesIO
-from typing import Dict
 
 import pandas as pd
-from wbcore.contrib.io.models import ImportSource
 
 from wbportfolio.models import Product, Trade
 
 
-def parse_row(obj: Dict, import_source: ImportSource) -> Dict:
-    if _id := obj["underlying_instrument_id"]:
-        product = Product.objects.get(id=_id)
-        shares = -1 * obj["shares"]
-        portfolio = product.primary_portfolio
-        return {
-            "underlying_instrument": {"id": product.id, "instrument_type": "product"},
-            "currency__key": product.currency.key,
-            "portfolio": portfolio.id,
-            "transaction_date": obj["transaction_date"].strftime("%Y-%m-%d"),
-            "shares": shares,
-            "bank": obj["custodian"] if obj["custodian"] else "NA",
-            "transaction_subtype": Trade.Type.REDEMPTION if shares < 0 else Trade.Type.SUBSCRIPTION,
-            "price": round(obj["price"], 6),
-        }
-
-
 def parse(import_source):
-    def _get_underlying_instrument_id(isin):
-        try:
-            product = Product.objects.get(isin=isin)
-            return product.id
-        except Product.DoesNotExist:
-            import_source.log += f"Product with ISIN {isin} does not exists."
-
-            return None
-
     df_dict = pd.read_excel(BytesIO(import_source.file.read()), engine="openpyxl")
     df_dict = df_dict.rename(
         columns={
@@ -47,22 +19,31 @@ def parse(import_source):
     )
     df_dict = df_dict.where(pd.notnull(df_dict), None)
     df_dict["transaction_date"] = pd.to_datetime(df_dict["transaction_date"])
-    df_dict["underlying_instrument__isin"] = df_dict["underlying_instrument__isin"].str.strip()
-    df_dict["underlying_instrument_id"] = df_dict["underlying_instrument__isin"].apply(
-        lambda x: _get_underlying_instrument_id(x)
-    )
+    product_isins = set()
 
     data = list()
-    for d in df_dict.to_dict("records"):
-        parsed_row = parse_row(d, import_source)
-        if parsed_row:
-            data.append(parse_row(d, import_source))
-    underlying_instruments = [int(_id) for _id in df_dict.underlying_instrument_id.astype("int").unique()]
+    for obj in df_dict.to_dict("records"):
+        shares = -1 * obj["shares"]
+        isin = obj["underlying_instrument__isin"]
+        data.append(
+            {
+                "underlying_instrument": {"isin": isin, "instrument_type": "product"},
+                "portfolio": {"isin": isin, "instrument_type": "product"},
+                "transaction_date": obj["transaction_date"].strftime("%Y-%m-%d"),
+                "shares": shares,
+                "bank": obj["custodian"] if obj["custodian"] else "NA",
+                "transaction_subtype": Trade.Type.REDEMPTION if shares < 0 else Trade.Type.SUBSCRIPTION,
+                "price": round(obj["price"], 6),
+            }
+        )
+        product_isins.add(isin)
+
+    underlying_instruments = Product.objects.filter(isin__in=product_isins).values_list("id", flat=True)
 
     return {
         "data": data,
         "history": {
-            "underlying_instruments": underlying_instruments,
+            "underlying_instruments": list(underlying_instruments),
             "transaction_date": df_dict.transaction_date.max().strftime("%Y-%m-%d"),
         },
     }