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

wbportfolio/import_export/handlers/trade.py

@@ -51,8 +51,8 @@ class TradeImportHandler(ImportExportHandler):
             data["portfolio"] = trade_proposal.portfolio
             data["status"] = "DRAFT"
         else:
-            if external_identifier2 := data.get("external_identifier2", None):
-                data["external_identifier2"] = str(external_identifier2)
+            if external_id_alternative := data.get("external_id_alternative", None):
+                data["external_id_alternative"] = str(external_id_alternative)
             if transaction_date_str := data.get("transaction_date", None):
                 data["transaction_date"] = datetime.strptime(transaction_date_str, "%Y-%m-%d").date()
             if value_date_str := data.get("value_date", None):
@@ -92,7 +92,6 @@ class TradeImportHandler(ImportExportHandler):
     def _create_instance(self, data: Dict[str, Any], **kwargs) -> models.Model:
         if "transaction_date" not in data:  # we might get only book date and not transaction date
             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:
@@ -115,17 +114,16 @@ class TradeImportHandler(ImportExportHandler):
         )
         if "shares" in data:
             queryset = queryset.filter(shares=data["shares"])
-
         if _id := data.get("id", None):
             self.import_source.log += f"ID {_id} provided -> Load CustomerTrade"
             return self.model.objects.get(id=_id)
         # We need to check for external identifiers
         if external_id := data.get("external_id"):
             self.import_source.log += f"\nExternal Identifier used: {external_id}"
-            queryset = queryset.filter(external_id=external_id)
-            if queryset.count() == 1:
+            external_id_queryset = queryset.filter(external_id=external_id)
+            if external_id_queryset.count() == 1:
                 self.import_source.log += f"External ID {external_id} provided -> Load CustomerTrade"
-                return queryset.first()
+                return external_id_queryset.first()
 
         if portfolio := data.get("portfolio", None):
             queryset = queryset.filter(portfolio=portfolio)

wbportfolio/import_export/parsers/jpmorgan/fees.py

@@ -34,8 +34,8 @@ def parse(import_source):
         isin = fee_data["ISIN"]
         fee_date = fee_data["Date"]
         base_data = {
-            "linked_product": {"isin": isin},
-            "transaction_date": fee_date.strftime("%Y-%m-%d"),
+            "product": {"isin": isin},
+            "fee_date": fee_date.strftime("%Y-%m-%d"),
             "calculated": False,
         }
         data.append(

wbportfolio/import_export/parsers/leonteq/customer_trade.py

@@ -1,4 +1,5 @@
 from contextlib import suppress
+from io import BytesIO
 
 import pandas as pd
 
@@ -10,7 +11,7 @@ def parse(import_source):
     df = pd.DataFrame()
     try:
         df = pd.read_excel(
-            import_source.file.read(),
+            BytesIO(import_source.file.read()),
             engine="openpyxl",
             index_col=1,
             sheet_name="TRANSACTION CONSOLIDATION",
@@ -25,7 +26,8 @@ def parse(import_source):
             with suppress(Product.DoesNotExist):
                 product = Product.objects.get(isin=trade["AMC ISIN"])
                 shares = (-1 * trade["TOTAL QUANTITY"]) / product.share_price
-                price = trade["GROSS PRICE"] * product.share_price
+                price = trade["NET PRICE"] * product.share_price
+                price_gross = trade["GROSS PRICE"] * product.share_price
                 portfolio = product.primary_portfolio
                 data.append(
                     {
@@ -38,10 +40,8 @@ def parse(import_source):
                         "bank": "Leonteq Cash Transfer",
                         "currency__key": product.currency.key,
                         "price": price,
-                        "total_value": trade["NET AMOUNT"],
-                        "total_value_gross": trade["GROSS AMOUNT"],
+                        "price_gross": price_gross,
                         "currency_fx_rate": trade["BOOKING FX"],
-                        "total_value_fx_portfolio": trade["BOOKING NET AMOUNT"],
                     }
                 )
 

wbportfolio/import_export/parsers/leonteq/fees.py

@@ -1,3 +1,5 @@
+from io import BytesIO
+
 import pandas as pd
 
 from wbportfolio.models import Fees
@@ -8,7 +10,11 @@ def parse(import_source):
     df = pd.DataFrame()
     try:
         df = pd.read_excel(
-            import_source.file.read(), engine="openpyxl", sheet_name="FEE_CONSOLIDATION", header=[0, 2], skiprows=1
+            BytesIO(import_source.file.read()),
+            engine="openpyxl",
+            sheet_name="FEE_CONSOLIDATION",
+            header=[0, 2],
+            skiprows=1,
         ).dropna(axis=1)
     except (ValueError, IndexError):
         pass
@@ -19,15 +25,13 @@ def parse(import_source):
 
             product_fees_df = product_fees_df.rename(
                 columns={
-                    "TRADE DATE": "transaction_date",
+                    "TRADE DATE": "fee_date",
                     "INDEX SPONSOR FEE": "total_value",
                     "BUSINESS EVENT": "transaction_subtype",
                 }
             )
 
-            product_fees_df.loc[:, "transaction_date"] = pd.to_datetime(
-                product_fees_df.loc[:, "transaction_date"], dayfirst=True
-            )
+            product_fees_df.loc[:, "fee_date"] = pd.to_datetime(product_fees_df.loc[:, "fee_date"], dayfirst=True)
 
             management_fees_eur = product_fees_df[
                 product_fees_df.loc[:, "transaction_subtype"] == "Management Fee EUR"
@@ -50,8 +54,8 @@ def parse(import_source):
             product_fees_df = product_fees_df.where(pd.notnull(product_fees_df), None)
             for fees in product_fees_df.to_dict("records"):
                 base_data = {
-                    "linked_product": {"isin": isin},
-                    "transaction_date": fees["transaction_date"].strftime("%Y-%m-%d"),
+                    "product": {"isin": isin},
+                    "fee_date": fees["fee_date"].strftime("%Y-%m-%d"),
                     "calculated": False,
                 }
 

wbportfolio/import_export/parsers/leonteq/trade.py

@@ -24,11 +24,8 @@ _fields_map = {
     "TOTAL QUANTITY": "shares",
     "GROSS PRICE": "price_gross",
     "NET PRICE": "price",
-    "total_value_gross": "total_value_gross",
     "currency_fx_rate": "currency_fx_rate",
     "NET AMOUNT": "total_value",
-    "GROSS AMOUNT": "total_value_gross_fx_portfolio",
-    "total_value_fx_portfolio": "total_value_fx_portfolio",
     "N°": "external_id",
 }
 
@@ -78,8 +75,6 @@ def parse(import_source):
     df["exchange"] = df["IDENTIFIER"].apply(lambda x: _get_exchange(x))
     df["currency_fx_rate"] = df["BOOKING FX"] * df["BASE CCY FX"]
 
-    df["total_value_gross"] = df["total_value_gross_fx_portfolio"] / df["BOOKING FX"]
-    df["total_value_fx_portfolio"] = df["total_value"] * df["currency_fx_rate"]
     df = df.drop(df.columns.difference(_fields_map.values()), axis=1)
     df["portfolio"] = product.primary_portfolio.id
 

wbportfolio/import_export/parsers/natixis/d1_fees.py

@@ -37,8 +37,8 @@ def parse(import_source):
             management_fees = row[management_fees_column].value
 
             base_data = {
-                "linked_product": {"isin": isin},
-                "transaction_date": valuation_date.strftime("%Y-%m-%d"),
+                "product": {"isin": isin},
+                "fee_date": valuation_date.strftime("%Y-%m-%d"),
                 "calculated": False,
             }
             if management_fees != 0:

wbportfolio/import_export/parsers/natixis/dividend.py

@@ -10,10 +10,9 @@ COLUMN_MAP = {
     "Div Crncy": "currency__key",
     "Quantity": "shares",
     "Fx Rate": "currency_fx_rate",
-    "Net Amount": "total_value_fx_portfolio",
     "Retro in%": "retrocession",
     "Gross Div": "price_gross",
-    "Ex Div Date": "transaction_date",
+    "Ex Div Date": "ex_date",
     "Value Date": "value_date",
 }
 
@@ -29,25 +28,21 @@ def parse(import_source):
         lambda x: _get_exchange_from_ticker(x)
     )
     df["underlying_instrument__ticker"] = df["underlying_instrument__ticker"].apply(lambda x: _get_ticker(x))
-    df["transaction_date"] = pd.to_datetime(df["transaction_date"], dayfirst=True).dt.strftime("%Y-%m-%d")
+    df["ex_date"] = pd.to_datetime(df["ex_date"], dayfirst=True).dt.strftime("%Y-%m-%d")
     df["value_date"] = pd.to_datetime(df["value_date"], dayfirst=True).dt.strftime("%Y-%m-%d")
     df = df[df["underlying_instrument__isin"].str.contains("([A-Z]{2})([A-Z0-9]{9})([0-9]{1})", regex=True)]
-    float_columns = ["shares", "total_value_fx_portfolio", "price_gross", "currency_fx_rate", "retrocession"]
+    float_columns = ["shares", "price_gross", "currency_fx_rate", "retrocession"]
     for float_column in float_columns:
         df[float_column] = df[float_column].str.replace(" ", "").astype("float")
     df = df.drop(columns=df.columns.difference(COLUMN_MAP.values()))
 
     df["retrocession"] = df["retrocession"] / 100.0
-    df["total_value"] = df["total_value_fx_portfolio"] / df["currency_fx_rate"]
-    df["price"] = df["total_value"] / df["shares"] / df["retrocession"]
-    df["total_value_gross"] = df["price_gross"] * df["shares"] * df["retrocession"]
-    df["total_value_gross_fx_portfolio"] = df["total_value_gross"] * df["currency_fx_rate"]
     df["portfolio"] = [{"instrument_type": "product", **product_data}] * df.shape[0]
     df = df.replace([np.inf, -np.inf, np.nan], None)
     return {
         "data": df.to_dict("records"),
         "history": {
-            "transaction_date": parts["valuation_date"].strftime("%Y-%m-%d"),
+            "value_date": parts["valuation_date"].strftime("%Y-%m-%d"),
             "product": product_data,
         },
     }

wbportfolio/import_export/parsers/natixis/fees.py

@@ -4,7 +4,7 @@ from pandas.tseries.offsets import BDay
 from .utils import file_name_parse_isin
 
 FIELD_MAP = {
-    "Date": "transaction_date",
+    "Date": "fee_date",
     "Manag. Fees Natixis": "ISSUER",
     "Manag. Fees Client": "MANAGEMENT",
     "Perf fees amount": "PERFORMANCE",
@@ -21,30 +21,28 @@ def parse(import_source):
     df = pd.read_csv(import_source.file, encoding="utf-8", delimiter=";")
     df = df.rename(columns=FIELD_MAP)
     df = df.drop(columns=df.columns.difference(FIELD_MAP.values()))
-    df["transaction_date"] = pd.to_datetime(df["transaction_date"], dayfirst=True)
+    df["fee_date"] = pd.to_datetime(df["fee_date"], dayfirst=True)
 
     # Switch the weeekend day fees to the next monday
-    df["transaction_date"] = df["transaction_date"].apply(lambda x: x + BDay(1) if x.weekday() in [5, 6] else x)
+    df["fee_date"] = df["fee_date"].apply(lambda x: x + BDay(1) if x.weekday() in [5, 6] else x)
 
     # Ensure float columns are number
     for col in ["MANAGEMENT", "ISSUER", "PERFORMANCE"]:
         df[col] = df[col].astype("str").str.replace(" ", "").astype("float")
 
     # Groupby and sum similar fees (e.g. Monday)
-    df = df.groupby("transaction_date").sum().reset_index()
+    df = df.groupby("fee_date").sum().reset_index()
     df = pd.melt(
         df,
-        id_vars=["transaction_date"],
+        id_vars=["fee_date"],
         value_vars=["MANAGEMENT", "ISSUER", "PERFORMANCE"],
         var_name="transaction_subtype",
         value_name="total_value",
     )
     df = df[df["total_value"] != 0]
 
-    df["linked_product"] = [product] * df.shape[0]
-    df["transaction_date"] = df["transaction_date"].dt.strftime("%Y-%m-%d")
+    df["product"] = [product] * df.shape[0]
+    df["fee_date"] = df["fee_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/sg_lux/customer_trade_pending_slk.py

@@ -129,7 +129,7 @@ def parse(import_source):
         )
 
         df["bank"] = df["REGISTER_DEAL_NAME"]
-        df["external_identifier2"] = df["NORDER"]
+        df["external_id_alternative"] = df["NORDER"]
         df["register__register_reference"] = df["REGISTER_ID1"]
         df["external_id"] = df.apply(assemble_transaction_reference, axis=1)
 

wbportfolio/import_export/parsers/sg_lux/fees.py

@@ -40,12 +40,12 @@ def parse(import_source):
             date = datetime.datetime.strptime(fee_data["NAV Date"], "%Y/%m/%d")
             data.append(
                 {
-                    "linked_product": {
+                    "product": {
                         "parent__identifier": fee_data["Code"],
                         "currency__key": fee_data["Local ccy"],
                         "identifier": share_class,
                     },
-                    "transaction_date": date.strftime("%Y-%m-%d"),
+                    "fee_date": date.strftime("%Y-%m-%d"),
                     "calculated": False,
                     "transaction_subtype": Fees.Type.MANAGEMENT,
                     "total_value": round(convert_string_to_number(fee_data.get("Fees - Local ccy", 0)), 6),

wbportfolio/import_export/parsers/sg_lux/perf_fees.py

@@ -26,7 +26,7 @@ def parse(import_source):
         date = datetime.datetime.strptime(fee_data[0], "%m/%d/%Y")
         data.append(
             {
-                "linked_product": {"isin": isin},
+                "product": {"isin": isin},
                 "transaction_date": date.strftime("%Y-%m-%d"),
                 "calculated": False,
                 "transaction_subtype": Fees.Type.PERFORMANCE,
@@ -35,7 +35,7 @@ def parse(import_source):
         )
         data.append(
             {
-                "linked_product": {"isin": isin},
+                "product": {"isin": isin},
                 "transaction_date": date.strftime("%Y-%m-%d"),
                 "calculated": False,
                 "transaction_subtype": Fees.Type.PERFORMANCE_CRYSTALIZED,

wbportfolio/import_export/parsers/sg_lux/utils.py

@@ -17,7 +17,7 @@ def parse_transaction_reference(trans_ref: str) -> tuple[str, str, bool]:
 
 
 def assemble_transaction_reference(data: Dict[str, Any]) -> str:
-    transaction_ref = data["external_identifier2"]
+    transaction_ref = data["external_id_alternative"]
     register_reference = data["register__register_reference"]
     if data.get("TRANSFER_REGISTER", None):
         register_reference = data["TRANSFER_REGISTER"]
@@ -29,7 +29,7 @@ def assemble_transaction_reference(data: Dict[str, Any]) -> str:
 
 
 def create_transaction_reference(customer_trade: "Trade") -> str:
-    transaction_id = customer_trade.external_identifier2
+    transaction_id = customer_trade.external_id_alternative
     outlet_id = customer_trade.register.clearing_reference
     credit_debit = "C" if customer_trade.initial_shares > 0 else "D"
 

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

@@ -4,14 +4,14 @@ import pandas as pd
 
 from wbportfolio.models import Fees
 
-BASE_MAPPING = {"managementFee": "total_value", "performanceFee": "total_value", "date": "transaction_date"}
+BASE_MAPPING = {"managementFee": "total_value", "performanceFee": "total_value", "date": "fee_date"}
 
 
 def parse(import_source):
     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["linked_product"] = [{"isin": product_isin}] * df.shape[0]
+        df["product"] = [{"isin": product_isin}] * df.shape[0]
         return df
 
     content = json.load(import_source.file)

wbportfolio/import_export/parsers/vontobel/customer_trade.py

@@ -11,10 +11,9 @@ FIELD_MAP = {
     "Trade_Date": "book_date",
     "Value_Date": "value_date",
     "Price": "price",
-    "Quantity": "total_value",
     "Currency": "currency__key",
     "Portfolio_Identifier": "underlying_instrument__identifier",
-    "External_Reference": "external_identifier2",
+    "External_Reference": "external_id_alternative",
     "Booking_Comment": "comment",
 }
 
@@ -36,8 +35,8 @@ def parse(import_source):
     data = []
     if not df.empty:
         df = df.rename(columns=FIELD_MAP)
+        df["shares"] = df["Quantity"] / df["price"]
         df = df.drop(columns=df.columns.difference(FIELD_MAP.values()))
-        df["shares"] = df["total_value"] / df["price"]
         df["transaction_date"] = pd.to_datetime(df["transaction_date"], dayfirst=True).dt.strftime("%Y-%m-%d")
         df["book_date"] = pd.to_datetime(df["book_date"], dayfirst=True).dt.strftime("%Y-%m-%d")
         df["value_date"] = pd.to_datetime(df["value_date"], dayfirst=True).dt.strftime("%Y-%m-%d")

wbportfolio/import_export/parsers/vontobel/historical_customer_trade.py

@@ -8,7 +8,6 @@ from wbportfolio.models import Trade
 
 FIELD_MAP = {
     "Trade Date": "book_date",
-    "Volume": "total_value",
     "Price": "price",
     "Qty": "shares",
     "Custodian": "bank",

wbportfolio/import_export/parsers/vontobel/management_fees.py

@@ -11,7 +11,7 @@ FIELD_MAP = {
     "Value_Date": "value_date",
     "Quantity": "total_value",
     "Currency": "currency__key",
-    "Portfolio_Identifier": "linked_product",
+    "Portfolio_Identifier": "product",
     "Booking_Comment": "comment",
 }
 
@@ -25,20 +25,20 @@ def parse(import_source):
     data = []
     if not df.empty:
         df = df.rename(columns=FIELD_MAP)
-        df.linked_product = df.linked_product.apply(lambda x: Product.objects.filter(identifier=x).first())
+        df["product"] = df["product"].apply(lambda x: Product.objects.filter(identifier=x).first())
         df["transaction_date"] = pd.to_datetime(df["transaction_date"], dayfirst=True)
         df["book_date"] = pd.to_datetime(df["book_date"], dayfirst=True).dt.strftime("%Y-%m-%d")
         df["value_date"] = pd.to_datetime(df["value_date"], dayfirst=True).dt.strftime("%Y-%m-%d")
-        df["portfolio"] = df.linked_product.apply(lambda x: x.primary_portfolio if x else None)
+        df["portfolio"] = df["product"].apply(lambda x: x.primary_portfolio if x else None)
         df["base_management_fees"] = df.apply(
             lambda row: float(
-                row["linked_product"].get_fees_percent(row["transaction_date"], FeeProductPercentage.Type.MANAGEMENT)
+                row["product"].get_fees_percent(row["transaction_date"], FeeProductPercentage.Type.MANAGEMENT)
             ),
             axis=1,
         )
         df["base_bank_fees"] = df.apply(
             lambda row: float(
-                row["linked_product"].get_fees_percent(row["transaction_date"], FeeProductPercentage.Type.BANK)
+                row["product"].get_fees_percent(row["transaction_date"], FeeProductPercentage.Type.BANK)
             ),
             axis=1,
         )
@@ -63,8 +63,8 @@ def parse(import_source):
         df = pd.concat([df_management, df_bank], axis=0)
         df = df.drop(columns=df.columns.difference(["transaction_subtype", *FIELD_MAP.values()]))
 
-        df["linked_product"] = df.linked_product.apply(lambda x: x.id)
-        df = df.dropna(subset=["linked_product"])
+        df["product"] = df["product"].apply(lambda x: x.id)
+        df = df.dropna(subset=["product"])
 
         for row in df.to_dict("records"):
             # The fee are sometime aggregated. The aggregate date range information is given in the comment. We therefore try to extract it and duplicate the averaged fees

wbportfolio/import_export/parsers/vontobel/performance_fees.py

@@ -10,7 +10,7 @@ FIELD_MAP = {
     "AccrValueInstrCcy": "total_value",
     "FxRate": "currency_fx_rate",
     "TradingCurrency": "currency__key",
-    "#ClientName": "linked_product",
+    "#ClientName": "product",
     "InstrumentName": "comment",
 }
 
@@ -29,7 +29,7 @@ def parse(import_source):
         df["transaction_subtype"] = Fees.Type.MANAGEMENT
         df["transaction_date"] = pd.to_datetime(df["transaction_date"], dayfirst=True).dt.strftime("%Y-%m-%d")
         df["value_date"] = pd.to_datetime(df["value_date"], dayfirst=True).dt.strftime("%Y-%m-%d")
-        df = df.dropna(subset=["linked_product"])
-        df.linked_product = df.linked_product.apply(lambda x: {"identifier": x})
+        df = df.dropna(subset=["product"])
+        df.product = df["product"].apply(lambda x: {"identifier": x})
         data = df.to_dict("records")
     return {"data": data}

wbportfolio/jinja2/wbportfolio/sql/aum_nnm.sql

@@ -21,7 +21,7 @@ claims AS (
     JOIN wbcrm_account AS account
         ON claim.account_id = account.id
     JOIN wbportfolio_trade AS trade
-        ON claim.trade_id = trade.transaction_ptr_id
+        ON claim.trade_id = trade.id
     WHERE claim.status = 'APPROVED'
 ),
 -- CTE for claims, that fetches them with their shares and price at transaction date
@@ -35,7 +35,7 @@ claims_with_nav AS (
         trade.marked_as_internal as marked_as_internal
     FROM wbportfolio_claim AS claims
    JOIN wbportfolio_trade AS trade
-        ON claims.trade_id = trade.transaction_ptr_id
+        ON claims.trade_id = trade.id
     LEFT JOIN wbcrm_account AS accounts
         ON claims.account_id = accounts.id
     LEFT JOIN LATERAL (

wbportfolio/migrations/0059_fees_unique_fees.py

@@ -45,7 +45,7 @@ class Migration(migrations.Migration):
         migrations.AddConstraint(
             model_name="fees",
             constraint=models.UniqueConstraint(
-                fields=("linked_product", "fee_date", "transaction_subtype", "calculated"), name="unique_fees"
+                fields=("product", "fee_date", "transaction_subtype", "calculated"), name="unique_fees"
             ),
         ),
     ]