wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/import_export/parsers/natixis/d1_equity.py

@@ -0,0 +1,80 @@
+import xlrd
+from wbportfolio.models import Product
+
+
+def get_isin(sheet):
+    for row in sheet.get_rows():
+        if row[0].value == "ISIN":
+            return row[1].value
+
+
+def parse(import_source):
+    book = xlrd.open_workbook(file_contents=import_source.file.read())
+
+    product = Product.objects.get(isin=get_isin(book.sheet_by_name("Certificate")))
+    equity_sheet = book.sheet_by_name("Report - details")
+
+    # date_column = None
+    # net_value_column = None
+    # shares_column = None
+
+    data = list()
+
+    first_row = None
+    last_row = None
+
+    for i, row in enumerate(equity_sheet.get_rows()):
+        if row[0].value == "Date":
+            first_row = i
+
+        if first_row is not None and row[0].value == "":
+            last_row = i
+
+        if first_row is not None and last_row is not None:
+            valuation_date = xlrd.xldate.xldate_as_datetime(equity_sheet.cell_value(first_row + 1, 0), 0).date()
+
+            for _i in range(first_row + 3, last_row):
+                initial_shares = equity_sheet.cell_value(_i, 2)
+                isin = equity_sheet.cell_value(_i, 3)
+                equity_sheet.cell_value(_i, 4)
+                currency_key = equity_sheet.cell_value(_i, 5)
+                initial_currency_fx_rate = equity_sheet.cell_value(_i, 6)
+                initial_price = equity_sheet.cell_value(_i, 10)
+
+                ticker = Product.objects.get(isin=isin).ticker
+
+                data.append(
+                    {
+                        "underlying_instrument": {"instrument_type": "product", "ticker": ticker},
+                        "currency__key": currency_key,
+                        "date": valuation_date.strftime("%Y-%m-%d"),
+                        "asset_valuation_date": valuation_date.strftime("%Y-%m-%d"),
+                        "initial_price": initial_price,
+                        "initial_currency_fx_rate": initial_currency_fx_rate,
+                        "initial_shares": initial_shares,
+                        "portfolio": {"id": product.id, "instrument_type": "product"},
+                    }
+                )
+
+            data.append(
+                {
+                    "underlying_instrument": {
+                        "instrument_type": "cash",
+                        "ticker": "CASH",
+                        "name": f"1 {product.currency.key} AMC",
+                        "currency__key": product.currency.key,
+                    },
+                    "date": valuation_date.strftime("%Y-%m-%d"),
+                    "asset_valuation_date": valuation_date.strftime("%Y-%m-%d"),
+                    "initial_price": 1.0,
+                    "initial_currency_fx_rate": 1.0,
+                    "currency__key": product.currency.key,
+                    "initial_shares": equity_sheet.cell_value(first_row + 1, 6),
+                    "portfolio": {"id": product.id, "instrument_type": "product"},
+                }
+            )
+
+            first_row = None
+            last_row = None
+
+    return {"data": data}

wbportfolio/import_export/parsers/natixis/d1_fees.py

@@ -0,0 +1,58 @@
+import xlrd
+from wbportfolio.models import Fees, Product
+
+
+def get_isin(sheet):
+    for row in sheet.get_rows():
+        if row[0].value == "ISIN":
+            return row[1].value
+
+
+def parse(import_source):
+    book = xlrd.open_workbook(file_contents=import_source.file.read())
+
+    product = Product.objects.get(isin=get_isin(book.sheet_by_name("Certificate")))
+    valuation_sheet = book.sheet_by_name("Report")
+
+    date_column = None
+    bank_fees_column = None
+    management_fees_column = None
+    performance_fees_gross_column = None
+
+    data = list()
+    for i, row in enumerate(valuation_sheet.get_rows()):
+        if i == 0:
+            for column in range(0, valuation_sheet.ncols):
+                if "Date" in row[column].value:
+                    date_column = column
+                if "Mngt Fees Natixis" == row[column].value:
+                    bank_fees_column = column
+                if "Mngt Fees Y" == row[column].value:
+                    management_fees_column = column
+                if "Performance Fees" in row[column].value:
+                    performance_fees_gross_column = column
+        else:
+            valuation_date = xlrd.xldate.xldate_as_datetime(row[date_column].value, 0)
+            bank_fees = row[bank_fees_column].value
+            management_fees = row[management_fees_column].value
+
+            base_data = {
+                "portfolio": product.primary_portfolio.id,
+                "linked_product": product.id,
+                "transaction_date": valuation_date.strftime("%Y-%m-%d"),
+                "calculated": False,
+            }
+            if management_fees != 0:
+                data.append({"transaction_subtype": Fees.Type.MANAGEMENT, "total_value": management_fees, **base_data})
+            if bank_fees != 0:
+                data.append({"transaction_subtype": Fees.Type.ISSUER, "total_value": bank_fees, **base_data})
+            if performance_fees_gross_column and row[performance_fees_gross_column].value != 0:
+                data.append(
+                    {
+                        "transaction_subtype": Fees.Type.PERFORMANCE,
+                        "total_value_gross": row[performance_fees_gross_column].value,
+                        **base_data,
+                    }
+                )
+
+    return {"data": data}

wbportfolio/import_export/parsers/natixis/d1_trade.py

@@ -0,0 +1,70 @@
+import xlrd
+from wbportfolio.models import Product, Trade
+
+
+def get_isin(sheet):
+    for row in sheet.get_rows():
+        if row[0].value == "ISIN":
+            return row[1].value
+
+
+def parse(import_source):
+    book = xlrd.open_workbook(file_contents=import_source.file.read())
+
+    product = Product.objects.get(isin=get_isin(book.sheet_by_name("Certificate")))
+    valuation_sheet = book.sheet_by_name("Transaction Fees")
+
+    trade_date_column = None
+    shares_column = None
+    price_column = None
+    currency_fx_rate_column = None
+    isin_column = None
+    execution_fees_column = None
+
+    data = list()
+    for i, row in enumerate(valuation_sheet.get_rows()):
+        if i == 0:
+            for column in range(0, valuation_sheet.ncols):
+                if "Trade date" == row[column].value:
+                    trade_date_column = column
+
+                if "Quantity" == row[column].value:
+                    shares_column = column
+
+                if "Price" == row[column].value:
+                    price_column = column
+
+                if "Forex" == row[column].value:
+                    currency_fx_rate_column = column
+
+                if "Reference" == row[column].value:
+                    isin_column = column
+
+                if "Exec Fees" in row[column].value:
+                    execution_fees_column = column
+
+        else:
+            transaction_date = xlrd.xldate.xldate_as_datetime(row[trade_date_column].value, 0)
+            shares = row[shares_column].value
+            price = row[price_column].value
+            currency_fx_rate = row[currency_fx_rate_column].value
+            row[execution_fees_column].value
+
+            traded_product = Product.objects.get(isin=row[isin_column].value)
+
+            data.append(
+                {
+                    "portfolio": product.primary_portfolio.id,
+                    "transaction_subtype": Trade.Type.REBALANCE,
+                    "transaction_date": transaction_date.strftime("%Y-%m-%d"),
+                    "shares": shares,
+                    "price": price,
+                    "currency__key": traded_product.currency.key,
+                    "currency_fx_rate": currency_fx_rate,
+                    "underlying_instrument": {"id": traded_product.id, "instrument_type": "product"},
+                    # 'execution_fees_percent': 0,
+                    # 'market_fees_percent': 0,
+                }
+            )
+
+    return {"data": data}

wbportfolio/import_export/parsers/natixis/d1_valuation.py

@@ -0,0 +1,41 @@
+import xlrd
+from wbportfolio.models import Product
+
+
+def get_isin(sheet):
+    for row in sheet.get_rows():
+        if row[0].value == "ISIN":
+            return row[1].value
+
+
+def parse(import_source):
+    book = xlrd.open_workbook(file_contents=import_source.file.read())
+
+    product = Product.objects.get(isin=get_isin(book.sheet_by_name("Certificate")))
+    valuation_sheet = book.sheet_by_name("Report")
+
+    date_column = None
+    net_value_column = None
+
+    data = list()
+    for i, row in enumerate(valuation_sheet.get_rows()):
+        if i == 0:
+            for column in range(0, valuation_sheet.ncols):
+                if "Date" in row[column].value:
+                    date_column = column
+                if "price" in row[column].value:
+                    net_value_column = column
+        else:
+            valuation_date = xlrd.xldate.xldate_as_datetime(row[date_column].value, 0)
+            net_value = row[net_value_column].value
+
+            data.append(
+                {
+                    "instrument": {"instrument_type": "product", "id": product.id},
+                    "date": valuation_date.strftime("%Y-%m-%d"),
+                    "net_value": net_value,
+                    "calculated": False,
+                }
+            )
+
+    return {"data": data}

wbportfolio/import_export/parsers/natixis/dividend.py

@@ -0,0 +1,53 @@
+import numpy as np
+import pandas as pd
+
+from .utils import _get_exchange_from_ticker, _get_ticker, file_name_parse
+
+COLUMN_MAP = {
+    "Ticker": "underlying_instrument__ticker",
+    "Underlying": "underlying_instrument__name",
+    "Underlying ISIN": "underlying_instrument__isin",
+    "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",
+    "Value Date": "value_date",
+}
+
+
+def parse(import_source):
+    parts = file_name_parse(import_source.file.name)
+    product = parts["product"]
+
+    df = pd.read_csv(import_source.file, sep=";", skipinitialspace=True)
+    df = df.rename(columns=COLUMN_MAP).astype("str")
+
+    df["underlying_instrument__exchange"] = df["underlying_instrument__ticker"].apply(
+        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["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"]
+    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"] = product.primary_portfolio.id
+    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"),
+            "portfolio": product.primary_portfolio.id,
+        },
+    }

wbportfolio/import_export/parsers/natixis/equity.py

@@ -0,0 +1,60 @@
+import numpy as np
+import pandas as pd
+
+from .utils import _get_underlying_instrument, file_name_parse
+
+FIELD_MAP = {
+    "Close": "initial_price",
+    "Nb of shares": "initial_shares",
+    "Fx Rate": "initial_currency_fx_rate",
+    "Valuation Date": "asset_valuation_date",
+    "Quoted Crncy": "currency__key",
+    "exchange": "exchange",
+    "underlying_instrument": "underlying_instrument",
+}
+
+
+def _apply_adjusting_factor(row):
+    """
+    If the position is a product position, then the adjusting factor adjusts the shares otherwise, it adjusts the price.
+
+    No idea why though
+    """
+    if row["underlying_instrument"]["instrument_type"] == "product":
+        return pd.Series([row["initial_price"], row["initial_shares"] * row["Quotity/Adj. factor"]])
+    else:
+        return pd.Series([row["initial_price"] * row["Quotity/Adj. factor"], row["initial_shares"]])
+
+
+def parse(import_source):
+    # Parse the Parts of the filename into the different parts
+    parts = file_name_parse(import_source.file.name)
+
+    # Get the valuation date and investment from the parts list
+    valuation_date = parts["valuation_date"]
+    product = parts["product"]
+
+    # Load file into a CSV DictReader
+    df = pd.read_csv(import_source.file, encoding="utf-16", delimiter=";")
+    df = df.rename(columns=FIELD_MAP)
+    df = df.dropna(subset=["initial_price"])
+    df["initial_price"] = df["initial_price"].astype("str").str.replace(" ", "").astype("float")
+    df["underlying_instrument"] = df[["Ticker", "Name", "currency__key"]].apply(
+        lambda x: _get_underlying_instrument(*x), axis=1
+    )
+    df["initial_price"] = df["initial_price"].replace(0, np.nan).fillna(1.0)
+    df[["initial_price", "initial_shares"]] = df[
+        ["initial_price", "initial_shares", "Quotity/Adj. factor", "underlying_instrument"]
+    ].apply(lambda x: _apply_adjusting_factor(x), axis=1)
+    df["exchange"] = df.underlying_instrument.apply(lambda x: x.get("exchange", None))
+    df = df.drop(columns=df.columns.difference(FIELD_MAP.values()))
+
+    df["portfolio__instrument_type"] = "product"
+    df["portfolio__id"] = product.id
+    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")
+
+    df["weighting"] = df.initial_currency_fx_rate * df.initial_price * df.initial_shares
+    df["weighting"] = df.weighting / df.weighting.sum()
+    return {"data": df.to_dict("records")}

wbportfolio/import_export/parsers/natixis/fees.py

@@ -0,0 +1,53 @@
+import pandas as pd
+from pandas.tseries.offsets import BDay
+
+from .utils import file_name_parse
+
+FIELD_MAP = {
+    "Date": "transaction_date",
+    "Manag. Fees Natixis": "ISSUER",
+    "Manag. Fees Client": "MANAGEMENT",
+    "Perf fees amount": "PERFORMANCE"
+    # "Currency": "currency"
+}
+
+
+def parse(import_source):
+    # Parse the Parts of the filename into the different parts
+    parts = file_name_parse(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=";")
+    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)
+
+    # 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)
+
+    # 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 = pd.melt(
+        df,
+        id_vars=["transaction_date"],
+        value_vars=["MANAGEMENT", "ISSUER", "PERFORMANCE"],
+        var_name="transaction_subtype",
+        value_name="total_value",
+    )
+    df = df[df["total_value"] != 0]
+
+    df["portfolio"] = product.primary_portfolio.id
+    df["linked_product"] = product.id
+    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

@@ -0,0 +1,63 @@
+import pandas as pd
+from wbportfolio.models import Trade
+
+from .utils import _get_underlying_instrument, file_name_parse
+
+
+def _parse_trade_type(type):
+    choices = {
+        "Decrease": Trade.Type.DECREASE,
+        "Increase": Trade.Type.INCREASE,
+        "Rebalancing": Trade.Type.REBALANCE,
+        "Buy": Trade.Type.BUY,
+        "Sell": Trade.Type.SELL,
+    }
+
+    return choices[type]
+
+
+def parse(import_source):
+    data = list()
+    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)
+
+        # Get the valuation date and investment from the parts list
+        product = parts["product"]
+
+        # Iterate through the CSV File and parse the data into a list
+        df["underlying_instrument"] = df[["BLOOMBERG CODE", "NAME", "QUOTED_CRNCY"]].apply(
+            lambda x: _get_underlying_instrument(*x), axis=1
+        )
+        df["exchange"] = df.underlying_instrument.apply(lambda x: x.get("exchange", None))
+        columns_map = {
+            "underlying_instrument": "underlying_instrument",
+            "TRADE DATE": "transaction_date",
+            "EXECUTED QTY": "shares",
+            "EXECUTED PRICE": "price",
+            "FX RATE": "currency_fx_rate",
+            "NET PRICE(Stock crncy)": "price",
+            "PRICE(USD)": "price_gross",
+            "TRADE TYPE": "transaction_subtype",
+            "QUOTED_CRNCY": "currency__key",
+        }
+        df = df.rename(columns=columns_map)
+        float_fields = ["shares", "price", "currency_fx_rate", "price", "price_gross"]
+        for field in float_fields:
+            if field in df:
+                df[field] = df[field].apply(
+                    lambda x: float(x.replace("-", "").replace(" ", "") if isinstance(x, str) else x)
+                )
+
+        df["price"] = df.apply(
+            lambda x: x["price"] * x["QUOTITY/ADJ. FACTOR"] if "QUOTITY/ADJ. FACTOR" in x else x["price"], axis=1
+        )
+        df.transaction_date = pd.to_datetime(df.transaction_date, dayfirst=True)
+        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["bank"] = "Natixis Cash Transfer"
+        data = df.to_dict("records")
+    return {"data": data}

wbportfolio/import_export/parsers/natixis/utils.py

@@ -0,0 +1,76 @@
+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")}
+
+
+def _get_exchange_from_ticker(ticker):
+    try:
+        ticker, exchange = ticker.split(" ")
+    except Exception:
+        ticker, exchange = ticker, None
+    return exchange
+
+
+def _get_ticker(ticker):
+    return ticker.split(" ")[0]
+
+
+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}
+
+    exchange = _get_exchange_from_ticker(bbg_code)
+    ticker = _get_ticker(bbg_code)
+
+    cash_position = cash_position or "CASH" == bbg_code or len(re.findall("(CASH [A-Z]{3})", bbg_code)) > 0
+    if cash_position:
+        underlying_instrument = {"instrument_type": "cash", "currency__key": currency}
+    else:
+        underlying_instrument = {
+            "exchange": {"bbg_exchange_codes": exchange},
+            "currency__key": currency,
+            "name": name.split(" @")[0].split("/")[
+                0
+            ],  # we remove anything after @ and also any trailing symbol (which represents some country information at natixis)
+            "ticker": ticker,
+            "instrument_type": instrument_type,
+        }
+        if not isin:
+            isin_re = re.findall("([A-Z]{2}[A-Z0-9]{9}[0-9]{1})", ticker)
+            if len(isin_re) > 0:
+                isin = isin_re[0]
+                # Natixis gives us ISIN as ticker for product. in that case, we registered the isin but we remove the ticker
+                underlying_instrument["instrument_type"] = "product"
+                del underlying_instrument["ticker"]
+            elif Product.objects.filter(ticker=ticker).exists():
+                underlying_instrument["instrument_type"] = "product"
+        if isin:
+            underlying_instrument["isin"] = isin
+    return underlying_instrument
+
+
+def file_name_parse(file_name):
+    dates = re.findall(r"_([0-9]{4}-?[0-9]{2}-?[0-9]{2})", file_name)
+    identifier = re.findall(r"([A-Z]{2}(?![A-Z]{10}\b)[A-Z0-9]{10})_", file_name)
+    assert len(dates) == 2, "Not 2 dates found in the filename"
+    assert len(identifier) == 1, "Not exactly 1 identifier found in the filename"
+    try:
+        valuation_date = datetime.datetime.strptime(dates[0], "%Y-%m-%d").date()
+    except ValueError:
+        valuation_date = datetime.datetime.strptime(dates[0], "%Y%m%d").date()
+    try:
+        generation_date = datetime.datetime.strptime(dates[1], "%Y-%m-%d").date()
+    except ValueError:
+        generation_date = datetime.datetime.strptime(dates[1], "%Y%m%d").date()
+
+    product = Product.objects.get(Q(ticker=identifier[0]) | Q(isin=identifier[0]))
+
+    return {
+        "product": product,
+        "valuation_date": valuation_date,
+        "generation_date": generation_date,
+    }

wbportfolio/import_export/parsers/natixis/valuation.py

@@ -0,0 +1,46 @@
+import codecs
+import csv
+import datetime
+
+from wbportfolio.import_export.utils import convert_string_to_number
+
+from .utils import file_name_parse
+
+
+def parse(import_source):
+    # Load file into a CSV DictReader
+    csv_file = import_source.file.open(mode="rt")
+    csv_file_type = type(csv_file.read())
+
+    # If the file is a byte string, then we need to convert it.
+    if csv_file_type is bytes:
+        csv_file = codecs.iterdecode(csv_file, "utf-8")
+
+    # Read file into a CSV Dict Reader
+    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)
+
+    # Get the valuation date and investment from the parts list
+    parts["valuation_date"]
+    product = parts["product"]
+
+    # Iterate through the CSV File and parse the data into a list
+    data = list()
+
+    for valuation in csv_reader:
+        date = datetime.datetime.strptime(valuation["Date"], "%d/%m/%Y").date()
+        if date.weekday() not in [5, 6]:
+            data.append(
+                {
+                    "instrument": {"instrument_type": "product", "id": product.id},
+                    "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),
+                    "calculated": False,
+                }
+            )
+
+    csv_file.close()
+    return {"data": data}

wbportfolio/import_export/parsers/refinitiv/adjustment.py

@@ -0,0 +1,24 @@
+import numpy as np
+import pandas as pd
+from wbfdm.import_export.parsers.refinitiv.utils import _clean_and_return_dict
+
+DEFAULT_MAPPING = {
+    "AX": "factor",
+    "Dates": "date",
+    "Instrument": "instrument",
+}
+
+
+def parse(import_source):
+    df = pd.read_json(import_source.file, orient="records")
+    df = df.replace([np.inf, -np.inf, np.nan], None)
+    df = df.rename(columns=DEFAULT_MAPPING).dropna(how="all", axis=1)
+    df = df.dropna(how="all", subset=df.columns.difference(["instrument"]))
+    df["date"] = pd.to_datetime(df["date"], utc=True, unit="ms")
+    df.date = df.date.dt.strftime("%Y-%m-%d")
+    df = df.dropna(how="any")
+    data = list()
+    if not df.empty:
+        df = df.groupby(["instrument", "date"]).first().reset_index()
+        data = _clean_and_return_dict(df)
+    return {"data": data}