wbportfolio 1.43.1__py2.py3-none-any.whl

wbportfolio/import_export/parsers/sg_lux/sylk.py

@@ -0,0 +1,248 @@
+# Author: Skip Montanaro (skip@mojam.com)
+# Version: 0.1
+# https://github.com/smontanaro/python-bits/blob/master/sylk.py
+
+"""Read SYLK files
+
+Caveat emptor!  This module has only been tested with SYLK files generated
+by AppleWorks 5.0!  It almost certainly needs work to be able to process
+files generated by other spreadsheets.
+"""
+
+import re
+
+
+class Table:
+    """
+    Table of rows used to store sylk parsed datas
+
+    rows are compound of a various amount of datas (different length)
+    """
+
+    def __init__(self):
+        self.rows = []
+
+    def __setitem__(self, xy_tuple, val):
+        """
+        Setitem method to set datas in this grid
+
+        :param tuple xy_tuple: The x,y coordinates as 2-uple
+        :param str val: The value to store in the grid
+
+        Handle the completion of a row to ensure the grid's row is wide enough
+        to set the value
+        """
+        (x, y) = xy_tuple
+        ox = x - 1
+        oy = y - 1
+        # Ensure the table is long enough to store the val
+        while len(self.rows) < y:
+            new_row = [" "] * x
+            self.rows.append(new_row)
+
+        row = self.rows[oy]
+        if val not in ("", " "):
+            # Ensure the row is large enough to store the val
+            if len(row) < x:
+                self._extend_row(row, x - len(row))
+            self.rows[oy][ox] = val
+
+    def _extend_row(self, row, missing):
+        """
+        Extend a row adding void values
+
+        :param list row: a list of datas
+        :param int missing: The number of void items to add
+        """
+        row.extend([" "] * missing)
+        return row
+
+    def __iter__(self):
+        for row in self.rows:
+            yield row
+
+
+class SYLK:
+    """class to read SYLK files and dump to CSV"""
+
+    # when time began
+    # different computers use different core dates and store dates as offsets
+    # this makes SYLK inherently unportable, but we fudge that by
+    # using the ID field to guess at the creating platform
+    # note that PCs apparently can't properly decode SYLK files generated
+    # on Macs using Appleworks/Clarisworks because they don't take this into
+    # account
+    unixepoch = (1970, 1, 1, 0, 0, 0, 0, 0, 0)
+    macepoch = (1904, 1, 1, 0, 0, 0, 0, 0, 0)
+    # this is pure fiction...
+    pcepoch = (1900, 1, 1, 0, 0, 0, 0, 0, 0)
+
+    # map SYLK format strings into data types
+    knownformats = {
+        "General": "string",
+        "0": "int",
+        "0.00": "float",
+        "#,##0": "int",
+        "#,##0.00": "float",
+        r'"$"#,##0\ ;;\("$"#,##0\,': "float",
+        r'"$"#,##0.00\ ;;\("$"#,##0.00\,': "float",
+        "0%": "float",
+        "0.00%": "float",
+        "0.00E+00": "float",
+        "m/d/yy": "date",
+        "d-mmm-yy": "date",
+        "d-mmm": "date",
+        "mmm-yy": "date",
+        "h:mm AM/PM": "time",
+        "h:mm:ss AM/PM": "time",
+        "h:mm": "time",
+        "h:mm:ss": "time",
+        "hh:mm AM/PM": "time",
+        "hh:mm:ss AM/PM": "time",
+        "m/d/yy h:mm": "datetime",
+        "m-dd-yy": "date",
+        "m-dd": "date",
+        '"$"#,##0 ;;[Red]("$"#,##0,': "float",
+        '"$"#,##0.00 ;;[Red]("$"#,##0.00,': "float",
+        "mmm d, yyyy": "date",
+        "mmmm d, yyyy": "date",
+        "ddd, mmm d, yyyy": "date",
+        "dddd, mmmm d, yyyy": "date",
+        "d, mmmm yyyy": "date",
+    }
+
+    date_output = "%d/%m/%Y"
+
+    def __init__(self):
+        self.datebase = self.unixepoch
+        self.printformats = []
+        self.currentformat = self.currenttype = ""
+        self.curx = self.cury = 0
+        self.data = Table()
+        self.unknown = {}
+
+    def escape(self, s):
+        """
+        Escape a string
+        """
+        if s[0:1] == '"':
+            return '"' + re.sub('"', '\\"\\"', s[1:-1]) + '"'
+        return s
+
+    def parse(self, stream):
+        """
+        Parse the given stream
+        """
+        lines = re.sub("[\r\n]+", "\n", stream.read()).split("\n")
+        for line in lines:
+            self.parseline(line)
+
+    def stream_rows(self):
+        """
+        Stream the rows (to be used to write a csv file for example)
+        """
+        return self.data
+
+    def addunknown(self, fld, subfld):
+        self.unknown[fld] = self.unknown.get(fld, {})
+        self.unknown[fld][subfld] = 1
+
+    def writeunknown(self, stream):
+        if self.unknown:
+            stream.write("Unrecognized fields (subfields):\n")
+            for key in list(self.unknown.keys()):
+                stream.write("%s (%s)\n" % (key, repr(list(self.unknown[key].keys()))))
+        else:
+            stream.write("No unrecognized fields\n")
+        stream.flush()
+
+    def _id_field(self, fields):
+        if fields[1][:6] in ("PClari", "PApple", "P Sage"):
+            self.datebase = self.macepoch
+
+    def _f_field(self, fields):
+        for f in fields[1:]:
+            ftd = f[0]
+            val = f[1:]
+            if ftd == "X":
+                self.curx = int(val)
+            elif ftd == "Y":
+                self.cury = int(val)
+            elif ftd == "P":
+                # references print format for the next cell
+                self.currentformat, self.currenttype = self.printformats[int(val)]
+            else:
+                self.addunknown("F", ftd)
+
+    def _c_field(self, fields):
+        for f in fields[1:]:
+            ftd = f[0]
+            val = f[1:]
+            if ftd == "X":
+                self.curx = int(val)
+
+            elif ftd == "Y":
+                self.cury = int(val)
+
+            elif ftd == "K":
+                val = eval(self.escape(val))
+                # if type(val) == int:
+                #     if self.currenttype == "date":
+                #         # value is offset in days from datebase
+                #         date = time.localtime(
+                #             time.mktime(self.datebase) +
+                #             float(val) * 24 * 60 * 60
+                #         )
+
+                #         val = time.strftime(self.date_output, date)
+                self.data[(self.curx, self.cury)] = "%s" % val
+
+            else:
+                self.addunknown("C", ftd)
+
+    def _p_fields(self, fields):
+        if fields[1][0] == "P":
+            # print formats imply data types?
+            format = fields[1][1:].replace("\\", "")
+            if format in self.knownformats:
+                self.printformats.append((format, self.knownformats[format]))
+            else:
+                # hack to guess type...
+                hasY = "y" in format
+                hasD = "d" in format
+                hasH = "h" in format
+                hasZ = "0" in format
+                hasP = "." in format
+                if (hasD or hasY) and hasH:
+                    dtype = "datetime"
+                elif hasD or hasY:
+                    dtype = "date"
+                elif hasH:
+                    dtype = "time"
+                elif hasP and hasZ:
+                    dtype = "float"
+                elif hasZ:
+                    dtype = "int"
+                else:
+                    dtype = "string"
+                self.printformats.append((format, dtype))
+        else:
+            self.addunknown("P", fields[1][0])
+
+    def parseline(self, line):
+        fields = re.split("(?i);(?=[a-z])", line)
+        if fields[0] == "ID":
+            self._id_field(fields)
+        if fields[0] == "F":
+            self._f_field(fields)
+        elif fields[0] == "C":
+            self._c_field(fields)
+        elif fields[0] == "P":
+            self._p_fields(fields)
+        else:
+            fld = fields[0]
+            for f in fields[1:]:
+                self.addunknown(fld, f)
+
+    def __iter__(self):
+        return self.data.__iter__()

wbportfolio/import_export/parsers/sg_lux/utils.py

@@ -0,0 +1,36 @@
+import re
+from typing import Any, Dict
+
+from wbportfolio.models import Product, Register, Trade
+
+
+def get_portfolio_id(x):
+    product = Product.objects.get(id=x)
+    portfolio = product.primary_portfolio
+    return portfolio.id
+
+
+def parse_transaction_reference(trans_ref: str) -> tuple[str, str, bool]:
+    pattern = r"([0-9]{7})([0-9]{8})([CD]{1})"
+    transaction_id, outlet_id, credit_debit = re.findall(pattern, trans_ref)[0]
+    return transaction_id, outlet_id, credit_debit == "C"
+
+
+def assemble_transaction_reference(data: Dict[str, Any]) -> str:
+    transaction_ref = data["external_identifier2"]
+    register_reference = data["register__register_reference"]
+    if data.get("TRANSFER_REGISTER", None):
+        register_reference = data["TRANSFER_REGISTER"]
+
+    outlet = Register.objects.get(register_reference=register_reference).outlet_reference
+    credit_debit = "C" if data["shares"] > 0 else "D"
+
+    return f"{int(transaction_ref):07}{int(outlet):08}{credit_debit}"
+
+
+def create_transaction_reference(customer_trade: "Trade") -> str:
+    transaction_id = customer_trade.external_identifier2
+    outlet_id = customer_trade.register.clearing_reference
+    credit_debit = "C" if customer_trade.initial_shares > 0 else "D"
+
+    return f"{transaction_id:07}{outlet_id:08}{credit_debit}"

wbportfolio/import_export/parsers/sg_lux/valuation.py

@@ -0,0 +1,53 @@
+import codecs
+import csv
+import datetime
+import re
+
+from wbportfolio.import_export.utils import convert_string_to_number
+from wbportfolio.models import Product
+
+
+def file_name_parse(file_name):
+    dates = re.findall(r"([0-9]{4}-[0-9]{2}-[0-9]{2})", file_name)
+    isin = re.findall(r"\.([a-zA-Z0-9]*)_", file_name)
+
+    assert len(dates) == 2, "Not 2 dates found in the filename"
+    assert len(isin) == 1, "Not exactly 1 isin found in the filename"
+
+    return {
+        "isin": isin[0],
+        "valuation_date": datetime.datetime.strptime(dates[0], "%Y-%m-%d").date(),
+        "generation_date": datetime.datetime.strptime(dates[1], "%Y-%m-%d").date(),
+    }
+
+
+def parse(import_source):
+    # Load file into a CSV DictReader
+    csv_file = import_source.file.open()
+    # 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, "latin1")
+
+    # # Read file into a CSV Dict Reader
+    csv_reader = csv.DictReader(csv_file, delimiter=",")
+
+    # # Iterate through the CSV File and parse the data into a list
+    data = list()
+
+    for valuation in csv_reader:
+        valuation_date = datetime.datetime.strptime(valuation["NAV Date"], "%Y/%m/%d").date()
+        product = Product.objects.get(isin=valuation["ISIN Code"])
+        if valuation_date.weekday() not in [5, 6] and product.currency.key == valuation["Ccy"]:
+            data.append(
+                {
+                    "instrument": {"instrument_type": "product", "id": product.id},
+                    "date": valuation_date.strftime("%Y-%m-%d"),
+                    "net_value": round(convert_string_to_number(valuation["NAV per share"]), 6),
+                    "calculated": False,
+                }
+            )
+
+    csv_file.close()
+    return {"data": data}

wbportfolio/import_export/parsers/societe_generale/customer_trade.py

@@ -0,0 +1,54 @@
+import datetime
+import re
+from io import BytesIO
+
+import pandas as pd
+from wbportfolio.models import Product, Trade
+
+
+def parse(import_source):
+    df_dict = pd.read_excel(BytesIO(import_source.file.read()), engine="openpyxl", sheet_name=None)
+
+    data = list()
+    products = list()
+    max_date = datetime.date(1900, 1, 1)
+
+    for sheet_name, df in df_dict.items():
+        if "prices" not in sheet_name:
+            isin = re.findall("([A-Z]{2}[A-Z0-9]{9}[0-9]{1})", sheet_name)
+            product = Product.objects.get(isin=isin[0])
+            products.append(product.id)
+            df = df.rename(
+                columns={
+                    "Trade Date": "transaction_date",
+                    "Price": "price",
+                    "Nominal": "nominal",
+                    "Market CP": "bank",
+                    "Way": "way",
+                }
+            )
+            df["transaction_date"] = pd.to_datetime(
+                df["transaction_date"],
+            )
+            for trade in df.to_dict("records"):
+                max_date = max(trade["transaction_date"].date(), max_date)
+
+                shares = trade["nominal"] if trade["way"] == "S" else trade["nominal"] * -1
+                shares = shares / product.share_price
+                portfolio = product.primary_portfolio
+                data.append(
+                    {
+                        "underlying_instrument": {"id": product.id, "instrument_type": "product"},
+                        "currency__key": product.currency.key,
+                        "portfolio": portfolio.id,
+                        "transaction_date": trade["transaction_date"].strftime("%Y-%m-%d"),
+                        "shares": shares,
+                        "transaction_subtype": Trade.Type.REDEMPTION if shares < 0 else Trade.Type.SUBSCRIPTION,
+                        "bank": trade["bank"],
+                        "price": round(trade["price"] / 10, 6),
+                    }
+                )
+    return {
+        "data": data,
+        "history": {"underlying_instruments": products, "transaction_date": max_date.strftime("%Y-%m-%d")},
+    }

wbportfolio/import_export/parsers/societe_generale/strategy.py

@@ -0,0 +1,94 @@
+import datetime
+import logging
+import re
+from io import BytesIO
+
+import numpy as np
+import pandas as pd
+from wbportfolio.import_export.utils import extract_exchange_ticker
+
+logger = logging.getLogger("importers.parsers.jp_morgan.strategy")
+
+
+def file_name_parse(file_name):
+    dates = re.findall("([0-9]{8})", file_name)
+
+    assert len(dates) == 1, "Not exactly 1 date found in the filename"
+
+    return {"valuation_date": datetime.datetime.strptime(dates[0], "%Y%m%d").date()}
+
+
+def parse(import_source):
+    data = list()
+    prices = list()
+    df_dict = pd.read_excel(BytesIO(import_source.file.read()), engine="openpyxl", sheet_name=None)
+    for sheet_name, df in df_dict.items():
+        xx, yy = np.where(df == "Ticker")
+        if len(xx) == 1 and len(yy) == 1:
+            df_info = df.iloc[: xx[0] - 1, :].transpose()
+            df_info = df_info.rename(columns=df_info.iloc[0]).drop(df_info.index[0]).dropna(how="all")
+
+            strategy_ticker = df_info.loc[:, df_info.columns.str.contains("Ticker")].iloc[0, 0]
+            strategy_currency = df_info.loc[:, df_info.columns.str.contains("CCY")].iloc[0, 0]
+            valuation_date = df_info.loc[:, df_info.columns.str.contains("Date")].iloc[0, 0]
+            valuation_date = datetime.datetime.strptime(valuation_date, "%Y-%m-%d")
+            strategy_close = df_info.loc[:, df_info.columns.str.contains("Level")].iloc[0, 0]
+
+            df_positions = df.iloc[xx[0] :, yy[0] :]
+            df_positions = (
+                df_positions.rename(columns=df_positions.iloc[0]).drop(df_positions.index[0]).dropna(how="all")
+            )
+            df_positions = df_positions.rename(
+                columns={
+                    df_positions.columns[df_positions.columns.str.contains("Forex")][0]: "initial_currency_fx_rate",
+                    df_positions.columns[df_positions.columns.str.contains("Currency")][0]: "currency__key",
+                    df_positions.columns[df_positions.columns.str.contains("Weight")][0]: "weighting",
+                    df_positions.columns[df_positions.columns.str.contains("Level")][0]: "initial_price",
+                    df_positions.columns[df_positions.columns.str.contains("Ticker")][
+                        0
+                    ]: "underlying_instrument__ticker",
+                    df_positions.columns[df_positions.columns.str.contains("ISIN")][0]: "underlying_instrument__isin",
+                    df_positions.columns[df_positions.columns.str.contains("Name")][0]: "underlying_instrument__name",
+                }
+            )
+            for position in df_positions.to_dict("records"):
+                ticker, exchange = extract_exchange_ticker(position["underlying_instrument__ticker"])
+                if exchange:
+                    exchange = {"bbg_exchange_codes": exchange}
+                data.append(
+                    {
+                        "underlying_instrument": {
+                            "instrument_type": "equity",
+                            "ticker": ticker,
+                            "isin": position["underlying_instrument__isin"],
+                            "name": position["underlying_instrument__name"],
+                            "currency__key": position["currency__key"],
+                            "exchange": exchange,
+                        },
+                        "portfolio": {
+                            "instrument_type": "index",
+                            "ticker": strategy_ticker,
+                            "currency__key": strategy_currency,
+                        },
+                        "is_estimated": False,
+                        "exchange": exchange,
+                        "asset_type": "equity",
+                        "currency__key": position["currency__key"],
+                        "initial_currency_fx_rate": round(position["initial_currency_fx_rate"], 6),
+                        "weighting": round(position["weighting"], 6),
+                        "initial_price": round(position["initial_price"], 6),
+                        "date": valuation_date.strftime("%Y-%m-%d"),
+                    }
+                )
+            prices.append(
+                {
+                    "instrument": {
+                        "instrument_type": "index",
+                        "ticker": strategy_ticker,
+                        "currency__key": strategy_currency,
+                    },
+                    "date": valuation_date.strftime("%Y-%m-%d"),
+                    "net_value": strategy_close,
+                }
+            )
+    return {"data": data, "prices": prices}

wbportfolio/import_export/parsers/societe_generale/valuation.py

@@ -0,0 +1,37 @@
+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 parse(import_source):
+    if get_file_extension(import_source.file) == ".xlsx":
+        df = pd.read_excel(BytesIO(import_source.file.read()), engine="openpyxl", sheet_name="Position").dropna(
+            how="all"
+        )
+    elif get_file_extension(import_source.file) == ".xls":
+        df = pd.read_excel(BytesIO(import_source.file.read()), sheet_name="Position").dropna(how="all")
+    else:
+        raise Exception("File not supported")
+
+    xx, yy = np.where(df == "ISIN Code")
+    df = df.iloc[xx[0] :, yy[0] :]
+    df = df.rename(columns=df.iloc[0]).drop(df.index[0]).dropna(how="all")
+
+    df["Valuation Date"] = pd.to_datetime(df["Valuation Date"])
+
+    data = list()
+    for valuation in df.to_dict("records"):
+        product = Product.objects.get(isin=valuation["ISIN Code"])
+        data.append(
+            {
+                "instrument": {"instrument_type": "product", "id": product.id},
+                "date": valuation["Valuation Date"].strftime("%Y-%m-%d"),
+                "net_value": round(valuation["Bid"], 6),
+                "calculated": False,
+            }
+        )
+
+    return {"data": data}

wbportfolio/import_export/parsers/tellco/customer_trade.py

@@ -0,0 +1,64 @@
+import codecs
+import csv
+import datetime
+import re
+
+from wbportfolio.import_export.utils import convert_string_to_number
+from wbportfolio.models import Product, Trade
+
+product_mapping = {
+    "2304": {
+        "A": "CH0442615701",
+        "B": "CH0442770316",
+    },
+    "2316": {
+        "A": "CH0583763534",
+        "B": "CH0583763542",
+    },
+}
+
+
+def file_name_parse(file_name):
+    identifier = re.findall("([0-9]{4}).*", file_name)
+    assert len(identifier) == 1, "Not exactly one identifier was found."
+    return identifier[0]
+
+
+def parse(import_source):
+    # Get the identifier from the file name to know which product group it is
+    identifier = file_name_parse(import_source.file.name)
+
+    # Load file into a CSV DictReader
+    csv_file = import_source.file.open()
+    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, "latin1")
+
+    # Read file into a CSV Dict Reader
+    csv_reader = csv.DictReader(csv_file, delimiter=";")
+
+    # Iterate through the CSV File and parse the data into a list
+    data = list()
+    for customer_trade in csv_reader:
+        product = Product.objects.get(isin=product_mapping[identifier][customer_trade["Anteilklasse"].strip()])
+
+        transaction_date = datetime.datetime.strptime(customer_trade["Datum"], "%Y%m%d").date()
+        shares = round(convert_string_to_number(customer_trade["Saldo - Anzahl"]), 4)
+        portfolio = product.primary_portfolio
+        data.append(
+            {
+                "underlying_instrument": {"id": product.id, "instrument_type": "product"},
+                "portfolio": portfolio.id,
+                "currency__key": product.currency.key,
+                "transaction_date": transaction_date.strftime("%Y-%m-%d"),
+                "value_date": transaction_date.strftime("%Y-%m-%d"),
+                "shares": shares,
+                "bank": "Tellco Trade",
+                "transaction_subtype": Trade.Type.REDEMPTION if shares < 0 else Trade.Type.SUBSCRIPTION,
+                "price": round(convert_string_to_number(customer_trade["NIW"]), 4),
+            }
+        )
+    csv_file.close()
+    return {"data": data}

wbportfolio/import_export/parsers/tellco/equity.py

@@ -0,0 +1,86 @@
+import codecs
+import csv
+import datetime
+
+import pandas as pd
+from wbcore.contrib.currency.models import Currency
+from wbportfolio.import_export.utils import convert_string_to_number
+from wbportfolio.models import ProductGroup
+
+
+def parse(import_source):
+    # Load file into a CSV DictReader and convert the encoding to latin1 due to hyphonation
+    csv_file = import_source.file.open()
+    csv_file = codecs.iterdecode(csv_file, "latin1")
+
+    # Read file into a CSV Dict Reader
+    csv_reader = csv.DictReader(csv_file, delimiter=";")
+
+    # Iterate through the CSV File and parse the data into a list
+    data = list()
+    for basket in csv_reader:
+        if basket["Assetart"] == "CPON" or (
+            basket["Assetart"] == "TRES" and "Sichtguthaben" not in basket["Assetbezeichnung"]
+        ):
+            continue
+        product_group = ProductGroup.objects.get(identifier=basket["Fonds-Nr."].strip())
+        valuation_date = datetime.datetime.strptime(basket["Datum"], "%Y%m%d")
+
+        currency_key = basket["Währung"]
+        currency = Currency.objects.get(key=currency_key)
+        group_currency = Currency.objects.get(key=basket["Assetwährung"])
+
+        if basket["Assetart"] == "TRES":
+            initial_currency_fx_rate = convert_string_to_number(basket["Wertpapierkurs"])
+
+            ticker = "CASH"
+            title = currency.title
+            initial_price = 1
+            underlying_instrument = {
+                "instrument_type": "cash",
+                "ticker": ticker,
+                "name": title,
+                "currency__key": currency.key,
+            }
+        elif basket["Assetart"] == "VMOB":
+            instrument_type = "equity"
+            if "STRUKT" in basket.get("TL2", ""):
+                instrument_type = "product"
+            initial_currency_fx_rate = float(currency.convert(valuation_date, group_currency))
+            initial_price = basket["Wertpapierkurs"]
+
+            exchange = f'X{basket["Bloomberg Code"]}' if basket["Bloomberg Code"] else None
+            underlying_instrument = {
+                "instrument_type": instrument_type,
+                "isin": basket["ISIN"],
+                "exchange": {"mic_code": exchange},
+                "name": basket["Assetbezeichnung"],
+                "currency__key": currency.key,
+            }
+
+        initial_shares = basket["Stk / Nominal"]
+
+        data.append(
+            {
+                "underlying_instrument": underlying_instrument,
+                "exchange": underlying_instrument.get("exchange", None),
+                "portfolio": {
+                    "instrument_type": "product_group",
+                    "id": product_group.id,
+                },
+                "is_estimated": False,
+                "currency__key": currency_key,
+                "date": valuation_date.strftime("%Y-%m-%d"),
+                "asset_valuation_date": valuation_date.strftime("%Y-%m-%d"),
+                "initial_price": round(convert_string_to_number(initial_price), 4),
+                "initial_currency_fx_rate": initial_currency_fx_rate,
+                "initial_shares": round(convert_string_to_number(initial_shares), 4),
+            }
+        )
+    csv_file.close()
+
+    df = pd.DataFrame(data)  # quick Hack to compute weighting on import
+    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")}