wbportfolio 1.43.1__py2.py3-none-any.whl

wbportfolio/import_export/parsers/vontobel/historical_customer_trade.py

@@ -0,0 +1,40 @@
+import re
+from io import BytesIO
+
+import pandas as pd
+from wbfdm.models import Instrument
+from wbportfolio.models import Trade
+
+FIELD_MAP = {
+    "Trade Date": "book_date",
+    "Volume": "total_value",
+    "Price": "price",
+    "Qty": "shares",
+    "Custodian": "bank",
+}
+
+
+def parse(import_source):
+    # for extra safety we ensure that passed file satisfy some regex.
+    filename_regex = import_source.source.import_parameters.get(
+        "customer_trade_filename_regex",
+        ".*([A-Z]{2}[A-Z0-9]{9}[0-9]{1})_TransactionList_([0-9]{4}-[0-9]{2}-[0-9]{2})_[0-9]{2}_[0-9]{2}.*.xlsx",
+    )
+    if match := re.match(filename_regex, import_source.file.name):
+        isin = match.group(1)
+        max_date = match.group(2)
+        df = pd.read_excel(BytesIO(import_source.file.read()), engine="openpyxl")
+        product = Instrument.objects.get(isin=isin)
+        if not df.empty:
+            df = df.rename(columns=FIELD_MAP)
+            df = df.drop(columns=df.columns.difference(FIELD_MAP.values()))
+            df["transaction_subtype"] = df.shares.apply(
+                lambda x: Trade.Type.REDEMPTION if x < 0 else Trade.Type.SUBSCRIPTION
+            )
+            df["underlying_instrument"] = product.id
+            df["book_date"] = pd.to_datetime(df["book_date"], dayfirst=True).dt.strftime("%Y-%m-%d")
+            df["portfolio"] = product.primary_portfolio.id
+            df = df.dropna()
+            data = df.to_dict("records")
+            return {"data": data, "history": {"underlying_instrument": product.id, "book_date": max_date}}
+        return {"data": {}}

wbportfolio/import_export/parsers/vontobel/instrument.py

@@ -0,0 +1,34 @@
+import numpy as np
+import pandas as pd
+
+FIELD_MAP = {
+    "#AssetIdentifier": "identifier",
+    "AssetCurrency": "currency__key",
+    "AssetValor": "valoren",
+    "ISIN": "isin",
+    "SymbolTK": "ticker",
+    "OperatingMic": "exchange",
+    "AssetType": "instrument_type",
+    "AssetText": "name",
+}
+
+ASSET_TYPE_MAP = {
+    "EQUADR": "equity",
+    "EQUBEA": "equity",
+    "EQUREG": "equity",
+    "FNDETF": "etf",
+    "OTHOTH": np.nan,
+    "STROTH": "etf",
+    "STRPRT": "etf",
+}
+
+
+def parse(import_source):
+    df = pd.read_csv(import_source.file, encoding="utf-16", delimiter=";")
+    df = df.rename(columns=FIELD_MAP)
+    df = df.replace([np.inf, -np.inf, np.nan], None)
+    df["instrument_type"] = df["instrument_type"].apply(lambda x: ASSET_TYPE_MAP[x])
+    df = df.drop(columns=df.columns.difference(FIELD_MAP.values()))
+    df["exchange"] = df["exchange"].apply(lambda x: {"operating_mic_code": x})
+    df = df.dropna(subset="instrument_type")
+    return {"data": df.to_dict("records")}

wbportfolio/import_export/parsers/vontobel/management_fees.py

@@ -0,0 +1,86 @@
+import re
+from datetime import datetime
+
+import pandas as pd
+from wbportfolio.models import FeeProductPercentage, Fees
+
+from .utils import get_portfolio_id, get_product
+
+FIELD_MAP = {
+    "Transaction_Date": "transaction_date",
+    "Trade_Date": "book_date",
+    "Value_Date": "value_date",
+    "Quantity": "total_value",
+    "Currency": "currency__key",
+    "Portfolio_Identifier": "linked_product",
+    "Booking_Comment": "comment",
+}
+
+
+def parse(import_source):
+    df = pd.read_csv(import_source.file, encoding="utf-16", delimiter=";")
+    df = df.loc[(df["Order_Type"] == "xfermon_client") & (df["Bookkind"] == "forex_impl_macc"), :]
+    date_range_regex = import_source.source.import_parameters.get(
+        "date_range_regex", r"\((\b\d{2}\.\d{2}\.\d{4}\b) to (\b\d{2}\.\d{2}\.\d{4}\b)\)"
+    )
+    data = []
+    if not df.empty:
+        df = df.rename(columns=FIELD_MAP)
+        df.linked_product = df.linked_product.apply(lambda x: get_product(x))
+        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: get_portfolio_id(x))
+        df["base_management_fees"] = df.apply(
+            lambda row: float(
+                row["linked_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)
+            ),
+            axis=1,
+        )
+        df.total_value = -df.total_value
+
+        df_management = df.copy()
+        df_management["transaction_subtype"] = Fees.Type.MANAGEMENT
+        df_management["total_value"] = (
+            df_management["total_value"]
+            * df_management["base_management_fees"]
+            / (df_management["base_management_fees"] + df_management["base_bank_fees"])
+        )
+
+        df_bank = df.copy()
+        df_bank["transaction_subtype"] = Fees.Type.ISSUER
+        df_bank["total_value"] = (
+            df_bank["total_value"]
+            * df_bank["base_bank_fees"]
+            / (df_bank["base_management_fees"] + df_bank["base_bank_fees"])
+        )
+
+        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"])
+
+        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
+            if match := re.search(date_range_regex, row["comment"]):
+                from_date = datetime.strptime(match.group(1), "%d.%m.%Y").date()
+                to_date = datetime.strptime(match.group(2), "%d.%m.%Y").date()
+            else:
+                from_date = (row["transaction_date"] - pd.tseries.offsets.BDay(1)).date()
+                to_date = row["transaction_date"]
+
+            dates = pd.date_range(from_date, to_date, freq="B", inclusive="right")
+            for ts in pd.date_range(from_date, to_date, freq="B", inclusive="right"):
+                row_copy = row.copy()
+                row_copy["transaction_date"] = ts.strftime("%Y-%m-%d")
+                row_copy["total_value"] = row["total_value"] / len(dates)
+                data.append(row_copy)
+
+    return {"data": data}

wbportfolio/import_export/parsers/vontobel/performance_fees.py

@@ -0,0 +1,35 @@
+import pandas as pd
+from wbportfolio.models import Fees
+
+from .utils import get_perf_fee_isin, get_portfolio_id, get_product
+
+FIELD_MAP = {
+    "LastPriceDate": "transaction_date",
+    "EndOfDay": "value_date",
+    "AccrValueInstrCcy": "total_value",
+    "FxRate": "currency_fx_rate",
+    "TradingCurrency": "currency__key",
+    "#ClientName": "linked_product",
+    "InstrumentName": "comment",
+}
+
+PERF_FEES_INSTRUMENT_ISIN = "CH0040602242"
+
+
+def parse(import_source):
+    perf_fee_isin = get_perf_fee_isin(import_source.source)
+    df = pd.read_csv(import_source.file, encoding="utf-16", delimiter=";")
+    df = df.loc[df["ISIN"] == perf_fee_isin, :]
+    data = []
+    if not df.empty:
+        df = df.rename(columns=FIELD_MAP)
+        df = df.drop(columns=df.columns.difference(FIELD_MAP.values()))
+        df.total_value = -df.total_value
+        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["portfolio"] = df.linked_product.apply(lambda x: get_portfolio_id(x))
+        df.linked_product = df.linked_product.apply(lambda x: get_product(x).id)
+        data = df.to_dict("records")
+    return {"data": data}

wbportfolio/import_export/parsers/vontobel/trade.py

@@ -0,0 +1,38 @@
+import pandas as pd
+from wbportfolio.models import Trade
+
+from .utils import get_portfolio_id
+
+FIELD_MAP = {
+    "Transaction_Date": "transaction_date",
+    "Trade_Date": "book_date",
+    "Value_Date": "value_date",
+    "Price": "price",
+    "Quantity": "shares",
+    "Currency": "currency__key",
+    "Isin": "underlying_instrument__isin",
+    "Asset_Text": "underlying_instrument__name",
+    "Portfolio_Identifier": "portfolio",
+    "Booking_comment": "comment",
+}
+
+
+def parse(import_source):
+    df = pd.read_csv(import_source.file, encoding="utf-16", delimiter=";")
+    df = df.loc[(df["Order_Type"] == "stex_buy_secondary") & (df["Bookkind"] == "trade_asset"), :]
+    data = []
+    if not df.empty:
+        df = df.rename(columns=FIELD_MAP)
+        df = df.drop(columns=df.columns.difference(FIELD_MAP.values()))
+        df.shares = -df.shares
+        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")
+        df["transaction_subtype"] = df.shares.apply(lambda x: Trade.Type.SELL if x < 0 else Trade.Type.BUY)
+        df["portfolio"] = df["portfolio"].apply(lambda x: get_portfolio_id(x))
+        df = df.dropna(subset=["underlying_instrument__isin"])
+
+        df["underlying_instrument__currency__key"] = df["currency__key"]
+        df["bank"] = "N/A"
+        data = df.to_dict("records")
+    return {"data": data}

wbportfolio/import_export/parsers/vontobel/utils.py

@@ -0,0 +1,17 @@
+from wbportfolio.models import Product
+
+
+def get_product(identifier):
+    return Product.objects.filter(identifier=identifier).first()
+
+
+def get_portfolio_id(identifier):
+    if (product := get_product(identifier)) and (portfolio := product.primary_portfolio):
+        return portfolio.id
+
+
+def get_perf_fee_isin(source):
+    default_perf_fee_isin = "CH0040602242"
+    if source:
+        return source.import_parameters.get("performance_fees_instrument_isin", default_perf_fee_isin)
+    return default_perf_fee_isin

wbportfolio/import_export/parsers/vontobel/valuation.py

@@ -0,0 +1,29 @@
+import numpy as np
+import pandas as pd
+
+FIELD_MAP = {"Date": "date", "Quantity": "outstanding_shares", "NAV": "net_value"}
+
+
+def parse(import_source):
+    base_filename = import_source.source.import_parameters.get("valuation_base_filename", "StrategicCertificate")
+    data = []
+    if base_filename in import_source.file.name:
+        df = pd.read_excel(import_source.file, engine="openpyxl", sheet_name=0)
+        xx, yy = np.where(df == "Date")
+        product_ticker = list(filter(lambda x: "Unnamed" not in x, df.columns))
+        df = df.iloc[xx[0] :, yy[0] :]
+
+        df = df.rename(columns=df.iloc[0]).drop(df.index[0]).dropna(how="all")
+        df = df.rename(columns=FIELD_MAP)
+        df = df.drop(columns=df.columns.difference(FIELD_MAP.values()))
+        df["date"] = pd.to_datetime(df["date"]).dt.strftime("%Y-%m-%d")
+        df["outstanding_shares"] = -df["outstanding_shares"]
+
+        if len(product_ticker) == 0:
+            for k, v in import_source.source.import_parameter.items():
+                df[k] = v
+        else:
+            df["instrument__ticker"] = product_ticker[0]
+        df = df.replace([np.inf, -np.inf, np.nan], None)
+        data = df.to_dict("records")
+    return {"data": data}

wbportfolio/import_export/resources/assets.py

@@ -0,0 +1,68 @@
+from import_export import fields
+from import_export.widgets import DecimalWidget, ForeignKeyWidget
+from wbcore.contrib.currency.models import Currency
+from wbcore.contrib.io.resources import ViewResource
+from wbfdm.models import Exchange
+from wbportfolio.models import AssetPosition
+
+
+class AssetPositionResource(ViewResource):
+    """
+    The resource to download AssetPositions
+    """
+
+    exchange = fields.Field(
+        column_name="exchange",
+        attribute="exchange",
+        widget=ForeignKeyWidget(Exchange, field="name"),
+    )
+
+    price = fields.Field(column_name="price", attribute="price", widget=DecimalWidget())
+    shares = fields.Field(column_name="shares", attribute="shares", widget=DecimalWidget())
+    total_value = fields.Field(column_name="total_value", attribute="total_value", widget=DecimalWidget())
+    currency_fx_rate = fields.Field(
+        column_name="currency_fx_rate", attribute="currency_fx_rate", widget=DecimalWidget()
+    )
+    total_value_fx_portfolio = fields.Field(
+        column_name="total_value_fx_portfolio", attribute="total_value_fx_portfolio", widget=DecimalWidget()
+    )
+    total_value_fx_usd = fields.Field(
+        column_name="total_value_fx_portfolio", attribute="total_value_fx_portfolio", widget=DecimalWidget()
+    )
+
+    currency = fields.Field(
+        column_name="currency",
+        attribute="currency",
+        widget=ForeignKeyWidget(Currency, field="key"),
+    )
+
+    class Meta:
+        import_id_fields = ("id",)
+        fields = (
+            "date",
+            "exchange",
+            "price",
+            "shares",
+            "total_value",
+            "currency",
+            "currency_fx_rate",
+            "total_value_fx_portfolio",
+            "total_value_fx_usd",
+            "weighting",
+        )
+        export_order = (
+            "date",
+            "underlying_instrument_name",
+            "underlying_instrument_ticker",
+            "underlying_instrument_isin",
+            "exchange",
+            "price",
+            "shares",
+            "total_value",
+            "currency",
+            "currency_fx_rate",
+            "total_value_fx_portfolio",
+            "total_value_fx_usd",
+            "weighting",
+        )
+        model = AssetPosition

wbportfolio/import_export/resources/trades.py

@@ -0,0 +1,41 @@
+import rstr
+from faker import Faker
+from import_export import fields
+from import_export.widgets import ForeignKeyWidget
+from wbcore.contrib.io.resources import FilterModelResource
+from wbfdm.models import Instrument
+from wbportfolio.models import Trade
+
+fake = Faker()
+
+
+class TradeProposalTradeResource(FilterModelResource):
+    """
+    Trade Resource class to use to import trade from the trade proposal
+    """
+
+    DUMMY_FIELD_MAP = {
+        "underlying_instrument": lambda: rstr.xeger("([A-Z]{2}[A-Z0-9]{9}[0-9]{1})"),
+        "weighting": 1.0,
+        "shares": 1000.2536,
+        "comment": lambda: fake.sentence(),
+        "order": 1,
+    }
+    underlying_instrument = fields.Field(
+        column_name="underlying_instrument",
+        attribute="underlying_instrument",
+        widget=ForeignKeyWidget(Instrument, field="isin"),
+    )
+
+    class Meta:
+        import_id_fields = ("id",)
+        fields = (
+            "id",
+            "underlying_instrument",
+            "weighting",
+            "shares",
+            "comment",
+            "order",
+        )
+        export_order = fields
+        model = Trade

wbportfolio/import_export/utils.py

@@ -0,0 +1,42 @@
+import os
+
+import dateparser
+from xlrd.xldate import xldate_as_datetime
+
+
+def get_fields_name(model):
+    return [field.name for field in model._meta.get_fields()]
+
+
+def get_file_extension(file):
+    name, extension = os.path.splitext(file.name)
+    return extension.lower()
+
+
+def convert_string_to_number(string):
+    if string == "nan" or not string:
+        return 0.0
+    if type(string) in (int, float):
+        return float(string)
+    try:
+        return float(string.replace(" ", "").replace(",", ""))
+    except ValueError:
+        return 0.0
+
+
+def parse_date(date, formats=[]):
+    if isinstance(date, int) or isinstance(date, float):
+        return xldate_as_datetime(int(date), 0).date()
+    if isinstance(date, str):
+        if format:
+            return dateparser.parse(date, date_formats=formats).date()
+        else:
+            return dateparser.parse(date).date()
+
+
+def extract_exchange_ticker(bbg_ticker):
+    try:
+        ticker, exchange = bbg_ticker.split(" ")[0:2]
+    except Exception:
+        ticker, exchange = bbg_ticker, None
+    return ticker, exchange

wbportfolio/jinja2/wbportfolio/sql/aum_nnm.sql

@@ -0,0 +1,119 @@
+-- CTE for prices that fetch prices per product converted to USD
+WITH prices AS (
+    SELECT
+        price.date AS date,
+        price.instrument_id AS instrument_id,
+        price.net_value AS net_value,
+        price.net_value * (1 / fx.value) AS net_value_usd
+    FROM wbfdm_instrumentprice AS price
+    JOIN currency_currencyfxrates AS fx ON price.currency_fx_rate_to_usd_id = fx.id
+    WHERE price.calculated = FALSE
+),
+-- CTE for claims, that fetches approved claims
+claims AS (
+    SELECT
+        claim.shares,
+        claim.date,
+        claim.product_id,
+        account.tree_id AS tree_id,
+        trade.marked_as_internal AS marked_as_internal
+    FROM wbportfolio_claim AS claim
+    JOIN wbcrm_account AS account
+        ON claim.account_id = account.id
+    JOIN wbportfolio_trade AS trade
+        ON claim.trade_id = trade.transaction_ptr_id
+    WHERE claim.status = 'APPROVED'
+),
+-- CTE for claims, that fetches them with their shares and price at transaction date
+claims_with_nav AS (
+    SELECT
+        claims.date,
+        claims.shares,
+        claims.product_id,
+        nav.net_value_usd,
+        accounts.tree_id AS tree_id,
+        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
+    LEFT JOIN wbcrm_account AS accounts
+        ON claims.account_id = accounts.id
+    LEFT JOIN LATERAL (
+        SELECT
+            price.net_value * (1 / cc.value) AS net_value_usd
+        FROM wbfdm_instrumentprice AS price
+        LEFT JOIN currency_currencyfxrates AS cc
+            ON cc.id = price.currency_fx_rate_to_usd_id
+        WHERE
+            price.instrument_id = claims.product_id
+            AND price.date <= claims.date
+            AND claims.status = 'APPROVED'
+            AND claims.account_id IS NOT NULL
+            AND price.calculated = FALSE
+        ORDER BY price.date DESC
+        LIMIT 1
+    ) AS nav ON TRUE
+-- CTE to generate a series with year and month already extracted
+), series AS (
+    SELECT
+        (DATE_TRUNC('month', dts) + INTERVAL '1 month - 1 day')::DATE AS val_date,
+        EXTRACT(YEAR FROM dts) AS year,
+        EXTRACT(MONTH FROM dts) AS month
+    FROM GENERATE_SERIES('{{ from_date | identifier }}'::DATE, '{{ to_date | identifier }}'::DATE, '1 month'::INTERVAL) AS dts
+)
+
+SELECT
+    series.year AS year,
+    series.month AS month,
+    SUM(NAV.net_value_usd * HOLDINGS.sum_shares) AS total_assets,
+    SUM(COALESCE(NNM.nnm_usd, 0)) AS net_new_money
+
+FROM series
+-- Cartesian product with products, to get each item of the series
+-- for each product
+CROSS JOIN wbportfolio_product AS product
+
+-- If there is not product_id it means we filter for all products
+-- This means we have to filter out all products that are not
+-- invested to avoid double accounting
+
+-- Foreach product/date combination, get the last NAV date available
+LEFT JOIN LATERAL (
+    SELECT prices.net_value_usd
+    FROM prices
+    WHERE
+        prices.date <= series.val_date
+        AND prices.instrument_id = product.instrument_ptr_id
+    ORDER BY prices.date DESC
+    LIMIT 1
+) AS NAV ON TRUE
+-- For each product/date combination, get the number of shares
+LEFT JOIN LATERAL (
+    SELECT SUM(claims.shares) AS sum_shares
+    FROM claims
+    WHERE claims.date <= series.val_date
+      AND claims.product_id = product.instrument_ptr_id
+      {% if account_tree_id %}AND claims.tree_id={{ account_tree_id }}{% endif %}
+      {% if not product_id %}AND claims.marked_as_internal=False{% endif %}
+) AS HOLDINGS ON TRUE
+-- For each product/date combination, get the NNM
+LEFT JOIN LATERAL (
+    -- Get the number of shares that were created in the month of date (from the series)
+    SELECT
+        SUM(claims.shares * claims.net_value_usd) AS nnm_usd,
+        SUM(claims.shares) as shares
+    FROM claims_with_nav as claims
+    WHERE
+        EXTRACT(YEAR FROM claims.date) = series.year
+        AND EXTRACT(MONTH FROM claims.date) = series.month
+        AND claims.product_id = product.instrument_ptr_id
+        {% if account_tree_id %}AND claims.tree_id={{ account_tree_id }}{% endif %}
+        {% if not product_id %}AND claims.marked_as_internal=False{% endif %}
+    ) AS NNM ON TRUE
+
+-- if we pass in the product_id, we only display the data for this particular product
+{% if product_id %}
+WHERE product.instrument_ptr_id = {{ product_id }}
+{% endif %}
+
+GROUP BY series.year, series.month