wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/import_export/parsers/ubs/historical_customer_trade.py

@@ -0,0 +1,67 @@
+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={
+            "Trade Date": "transaction_date",
+            "ISIN": "underlying_instrument__isin",
+            "Client Side": "client_side",
+            "Net Quantity": "shares",
+            "Price": "price",
+            "Custodian": "custodian",
+        }
+    )
+    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)
+    )
+
+    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()]
+
+    return {
+        "data": data,
+        "history": {
+            "underlying_instruments": underlying_instruments,
+            "transaction_date": df_dict.transaction_date.max().strftime("%Y-%m-%d"),
+        },
+    }

wbportfolio/import_export/parsers/ubs/valuation.py

@@ -0,0 +1,52 @@
+import datetime
+import re
+from io import BytesIO
+
+import numpy as np
+import pandas as pd
+from wbportfolio.import_export.utils import get_file_extension
+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"
+
+    return {
+        "isin": isin[0],
+    }
+
+
+def parse(import_source):
+    if get_file_extension(import_source.file) == ".xlsx":
+        df = pd.read_excel(BytesIO(import_source.file.read()), engine="openpyxl", sheet_name="Summary").dropna(
+            how="all"
+        )
+    elif get_file_extension(import_source.file) == ".xls":
+        df = pd.read_excel(BytesIO(import_source.file.read()), sheet_name="Summary").dropna(how="all")
+    else:
+        raise Exception("File not supported")
+
+    parts = file_name_parse(import_source.file.name)
+    product = Product.objects.get(isin=parts["isin"])
+
+    xx, yy = np.where(df == "Instrument")
+    df = df.iloc[: xx[0], :].transpose().dropna(how="all", axis=0).reset_index(drop=True)
+
+    df = df.rename(columns=df.iloc[0]).drop(df.index[0])
+
+    date = df.loc[:, df.columns.str.contains("Statement as at Close of Business")].dropna(how="any").iloc[0, 0]
+    date = datetime.datetime.strptime(date, "%Y-%m-%d").date()
+    value = df.loc[:, df.columns.str.contains("RPL")].dropna(how="any").iloc[0, 0]
+
+    data = [
+        {
+            "instrument": {"instrument_type": "product", "id": product.id},
+            "date": date.strftime("%Y-%m-%d"),
+            "net_value": value,
+            "calculated": False,
+        }
+    ]
+
+    return {"data": data}

wbportfolio/import_export/parsers/vontobel/asset_position.py

@@ -0,0 +1,97 @@
+import numpy as np
+import pandas as pd
+
+from .utils import get_perf_fee_isin
+
+FIELD_MAP = {
+    "EndOfDay": "date",
+    "LastPriceDate": "asset_valuation_date",
+    "LastPrice": "initial_price",
+    "Quantity": "initial_shares",
+    "TradingCurrency": "currency__key",
+    "FxRate": "initial_currency_fx_rate",
+    "ISIN": "underlying_instrument__isin",
+    "InstrumentName": "underlying_instrument__name",
+    "BuCurrency": "portfolio__currency__key",
+    "Ticker": "underlying_instrument__ticker",
+    # "TradingPlace": "exchange",
+    "Booking_comment": "comment",
+    "AssetGroup": "underlying_instrument__instrument_type",
+    "InstrumentIdentifier": "underlying_instrument__identifier",
+    "#ClientName": "portfolio__identifier",
+}
+
+ASSET_GROUP_MAP = {
+    "bond": "bond",
+    "cash": "cash",
+    "comdty": "commodity",
+    "credit": "credit",
+    "fund": "exchange_trade_product",
+    "fut": "future",
+    "fwd": "forward",
+    "idx": "index",
+    "insurpol": "insurpol",
+    "interrateopt": "interest_rate_derivative",
+    "limit": "limit",
+    "opt": "option",
+    "struct": "product",
+    "swap": "swap",
+    "cash_equivalent": "cash_equivalent",
+}
+
+
+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.rename(columns=FIELD_MAP).replace([np.inf, -np.inf, np.nan], None)
+    df = df.drop(columns=df.columns.difference(FIELD_MAP.values()))
+    if import_source.source.import_parameters.get("import_perf_fees_as_cash", False):
+        fees_idx = df["underlying_instrument__isin"] == perf_fee_isin
+        df.loc[fees_idx, "underlying_instrument__isin"] = None
+        df.loc[fees_idx, "underlying_instrument__instrument_type"] = "cash_equivalent"
+        df.loc[fees_idx, "initial_shares"] = df.loc[fees_idx, "initial_price"]  # inverse price and share
+    else:
+        df = df.loc[df["underlying_instrument__isin"] != perf_fee_isin, :]
+
+    df["underlying_instrument__instrument_type"] = df["underlying_instrument__instrument_type"].apply(
+        lambda x: ASSET_GROUP_MAP[x] if x else None
+    )
+    # we remove instrument without isin or not of type cash because we don't support these (e.g, Dividend)
+    df = df[
+        ~df["underlying_instrument__isin"].isnull()
+        | df["underlying_instrument__instrument_type"].isin(["cash", "cash_equivalent"])
+    ]
+
+    # we group by instrument identifier to be sure we don't introduce duplicated position
+    df = (
+        df.groupby("underlying_instrument__identifier", dropna=False)
+        .agg(
+            {
+                "initial_currency_fx_rate": "first",
+                "initial_price": "first",
+                "initial_shares": "sum",
+                "date": "first",
+                "asset_valuation_date": "first",
+                "currency__key": "first",
+                "underlying_instrument__isin": "first",
+                "underlying_instrument__name": "first",
+                "portfolio__currency__key": "first",
+                "underlying_instrument__ticker": "first",
+                "underlying_instrument__instrument_type": "first",
+                "portfolio__identifier": "first",
+            }
+        )
+        .reset_index(drop=True)
+    )
+    df.loc[df["underlying_instrument__instrument_type"].isin(["cash", "cash_equivalent"]), "initial_price"] = 1.0
+    df["date"] = pd.to_datetime(df["date"], dayfirst=True).dt.strftime("%Y-%m-%d")
+    df["asset_valuation_date"] = pd.to_datetime(df["asset_valuation_date"], dayfirst=True).dt.strftime("%Y-%m-%d")
+    df["is_estimated"] = False
+    df["underlying_instrument__currency__key"] = df["currency__key"]
+    df["weighting"] = df.initial_currency_fx_rate * df.initial_price * df.initial_shares
+    df["weighting"] = df.weighting / df.weighting.sum()
+    df["portfolio__currency__key"] = (
+        df["portfolio__currency__key"].ffill().bfill()
+    )  # We do that because we expect all cell value to be the same but we expect also emtpy cell (mistake from the provider)
+    df = df.replace([np.inf, -np.inf, np.nan], None)
+    return {"data": df.to_dict("records")}

wbportfolio/import_export/parsers/vontobel/customer_trade.py

@@ -0,0 +1,54 @@
+import operator
+from functools import reduce
+
+import numpy as np
+import pandas as pd
+from wbportfolio.models import Trade
+
+FIELD_MAP = {
+    "Transaction_Date": "transaction_date",
+    "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",
+    "Booking_Comment": "comment",
+}
+
+CUSTOMER_TRADE_ORDER_TYPES = [
+    "stex_issue_primary_cnt",
+    "stex_buy_secondary_cnt",
+    "stex_sell_secondary",
+    "sectrx2_rdmpt",
+    "stex_sell_secondary_cnt",
+]
+
+
+def parse(import_source):
+    df = pd.read_csv(import_source.file, encoding="utf-16", delimiter=";")
+    df = df.loc[
+        df["Order_Type"].isin(CUSTOMER_TRADE_ORDER_TYPES),
+        :,
+    ]
+    data = []
+    if not df.empty:
+        df = df.rename(columns=FIELD_MAP)
+        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")
+        df["transaction_subtype"] = df.shares.apply(
+            lambda x: Trade.Type.REDEMPTION if x < 0 else Trade.Type.SUBSCRIPTION
+        )
+        certificate_keys = import_source.source.import_parameters.get(
+            "certificate_keys", ["Index", "Strategic Certificate"]
+        )
+        df = df.dropna(subset=["underlying_instrument__identifier"])
+        df = df[reduce(operator.or_, [df["comment"].str.contains(key, case=False) for key in certificate_keys])]
+        df = df.replace([np.inf, -np.inf, np.nan], None)
+        df["bank"] = "N/A"
+        data = df.to_dict("records")
+    return {"data": data}

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