Qubx 0.5.7__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/backtester/data.py

@@ -0,0 +1,296 @@
+from collections import defaultdict
+from typing import Any, Dict, Optional
+
+import numpy as np
+import pandas as pd
+from tqdm.auto import tqdm
+
+from qubx import logger
+from qubx.backtester.simulated_data import IterableSimulationData
+from qubx.core.basics import (
+    CtrlChannel,
+    DataType,
+    Instrument,
+    TimestampedDict,
+)
+from qubx.core.exceptions import SimulationError
+from qubx.core.helpers import BasicScheduler
+from qubx.core.interfaces import IDataProvider
+from qubx.core.series import Bar, Quote, time_as_nsec
+from qubx.data.readers import AsDict, DataReader
+from qubx.utils.time import infer_series_frequency
+
+from .account import SimulatedAccountProcessor
+from .utils import SimulatedTimeProvider
+
+
+class SimulatedDataProvider(IDataProvider):
+    time_provider: SimulatedTimeProvider
+    channel: CtrlChannel
+
+    _scheduler: BasicScheduler
+    _account: SimulatedAccountProcessor
+    _last_quotes: Dict[Instrument, Optional[Quote]]
+    _readers: dict[str, DataReader]
+    _scheduler: BasicScheduler
+    _pregenerated_signals: dict[Instrument, pd.Series | pd.DataFrame]
+    _to_process: dict[Instrument, list]
+    _data_source: IterableSimulationData
+    _open_close_time_indent_ns: int
+
+    def __init__(
+        self,
+        exchange_id: str,
+        channel: CtrlChannel,
+        scheduler: BasicScheduler,
+        time_provider: SimulatedTimeProvider,
+        account: SimulatedAccountProcessor,
+        readers: dict[str, DataReader],
+        open_close_time_indent_secs=1,
+    ):
+        self.channel = channel
+        self.time_provider = time_provider
+        self._exchange_id = exchange_id
+        self._scheduler = scheduler
+        self._account = account
+        self._readers = readers
+
+        # - create exchange's instance
+        self._last_quotes = defaultdict(lambda: None)
+
+        # - pregenerated signals storage
+        self._pregenerated_signals = dict()
+        self._to_process = {}
+
+        # - simulation data source
+        self._data_source = IterableSimulationData(
+            self._readers, open_close_time_indent_secs=open_close_time_indent_secs
+        )
+        self._open_close_time_indent_ns = open_close_time_indent_secs * 1_000_000_000  # convert seconds to nanoseconds
+
+        logger.info(f"{self.__class__.__name__}.{exchange_id} is initialized")
+
+    def run(
+        self,
+        start: str | pd.Timestamp,
+        end: str | pd.Timestamp,
+        silent: bool = False,
+    ) -> None:
+        logger.info(f"{self.__class__.__name__} ::: Simulation started at {start} :::")
+
+        if self._pregenerated_signals:
+            self._prepare_generated_signals(start, end)
+            _run = self._process_generated_signals
+        else:
+            _run = self._process_strategy
+
+        start, end = pd.Timestamp(start), pd.Timestamp(end)
+        total_duration = end - start
+        update_delta = total_duration / 100
+        prev_dt = pd.Timestamp(start)
+
+        # - date iteration
+        qiter = self._data_source.create_iterable(start, end)
+        if silent:
+            for instrument, data_type, event, is_hist in qiter:
+                if not _run(instrument, data_type, event, is_hist):
+                    break
+        else:
+            _p = 0
+            with tqdm(total=100, desc="Simulating", unit="%", leave=False) as pbar:
+                for instrument, data_type, event, is_hist in qiter:
+                    if not _run(instrument, data_type, event, is_hist):
+                        break
+                    dt = pd.Timestamp(event.time)
+                    # update only if date has changed
+                    if dt - prev_dt > update_delta:
+                        _p += 1
+                        pbar.n = _p
+                        pbar.refresh()
+                        prev_dt = dt
+                pbar.n = 100
+                pbar.refresh()
+
+        logger.info(f"{self.__class__.__name__} ::: Simulation finished at {end} :::")
+
+    def set_generated_signals(self, signals: pd.Series | pd.DataFrame):
+        logger.debug(
+            f"[<y>{self.__class__.__name__}</y>] :: Using pre-generated signals:\n {str(signals.count()).strip('ndtype: int64')}"
+        )
+        # - sanity check
+        signals.index = pd.DatetimeIndex(signals.index)
+
+        if isinstance(signals, pd.Series):
+            self._pregenerated_signals[str(signals.name)] = signals  # type: ignore
+
+        elif isinstance(signals, pd.DataFrame):
+            for col in signals.columns:
+                self._pregenerated_signals[col] = signals[col]  # type: ignore
+        else:
+            raise ValueError("Invalid signals or strategy configuration")
+
+    @property
+    def is_simulation(self) -> bool:
+        return True
+
+    def subscribe(self, subscription_type: str, instruments: set[Instrument], reset: bool) -> None:
+        _new_instr = [i for i in instruments if not self.has_subscription(i, subscription_type)]
+        self._data_source.add_instruments_for_subscription(subscription_type, list(instruments))
+
+        # - provide historical data and last quote for subscribed instruments
+        for i in _new_instr:
+            h_data = self._data_source.peek_historical_data(i, subscription_type)
+            if h_data:
+                # _s_type = DataType.from_str(subscription_type)[0]
+                last_update = h_data[-1]
+                if last_quote := self._account.emulate_quote_from_data(i, last_update.time, last_update):  # type: ignore
+                    # - send historical data to the channel
+                    self.channel.send((i, subscription_type, h_data, True))
+
+                    # - set last quote
+                    self._last_quotes[i] = last_quote
+
+                    # - also need to pass this quote to OME !
+                    self._account._process_new_quote(i, last_quote)
+
+                    logger.debug(f" | subscribed {subscription_type} {i} -> {last_quote}")
+
+    def unsubscribe(self, subscription_type: str, instruments: set[Instrument] | Instrument | None = None) -> None:
+        # logger.debug(f" | unsubscribe: {subscription_type} -> {instruments}")
+        if instruments is not None:
+            self._data_source.remove_instruments_from_subscription(
+                subscription_type, [instruments] if isinstance(instruments, Instrument) else list(instruments)
+            )
+
+    def has_subscription(self, instrument: Instrument, subscription_type: str) -> bool:
+        return self._data_source.has_subscription(instrument, subscription_type)
+
+    def get_subscriptions(self, instrument: Instrument) -> list[str]:
+        _s_lst = self._data_source.get_subscriptions_for_instrument(instrument)
+        # logger.debug(f" | get_subscriptions {instrument} -> {_s_lst}")
+        return _s_lst
+
+    def get_subscribed_instruments(self, subscription_type: str | None = None) -> list[Instrument]:
+        _in_lst = self._data_source.get_instruments_for_subscription(subscription_type or DataType.ALL)
+        # logger.debug(f" | get_subscribed_instruments {subscription_type} -> {_in_lst}")
+        return _in_lst
+
+    def warmup(self, configs: dict[tuple[str, Instrument], str]) -> None:
+        for si, warm_period in configs.items():
+            logger.debug(f" | Warming up {si} -> {warm_period}")
+            self._data_source.set_warmup_period(si[0], warm_period)
+
+    def get_ohlc(self, instrument: Instrument, timeframe: str, nbarsback: int) -> list[Bar]:
+        _reader = self._readers.get(DataType.OHLC)
+        if _reader is None:
+            logger.error(f"Reader for {DataType.OHLC} data not configured")
+            return []
+
+        start = pd.Timestamp(self.time_provider.time())
+        end = start - nbarsback * (_timeframe := pd.Timedelta(timeframe))
+        _spec = f"{instrument.exchange}:{instrument.symbol}"
+        return self._convert_records_to_bars(
+            _reader.read(data_id=_spec, start=start, stop=end, transform=AsDict()),  # type: ignore
+            time_as_nsec(self.time_provider.time()),
+            _timeframe.asm8.item(),
+        )
+
+    def get_quote(self, instrument: Instrument) -> Quote | None:
+        return self._last_quotes[instrument]
+
+    def close(self):
+        pass
+
+    def _prepare_generated_signals(self, start: str | pd.Timestamp, end: str | pd.Timestamp):
+        for s, v in self._pregenerated_signals.items():
+            _s_inst = None
+
+            for i in self.get_subscribed_instruments():
+                # - we can process series with variable id's if we can find some similar instrument
+                if s == i.symbol or s == str(i) or s == f"{i.exchange}:{i.symbol}" or str(s) == str(i):
+                    _start, _end = pd.Timestamp(start), pd.Timestamp(end)
+                    _start_idx, _end_idx = v.index.get_indexer([_start, _end], method="ffill")
+                    sel = v.iloc[max(_start_idx, 0) : _end_idx + 1]
+
+                    # TODO: check if data has exec_price - it means we have deals
+                    self._to_process[i] = list(zip(sel.index, sel.values))
+                    _s_inst = i
+                    break
+
+            if _s_inst is None:
+                logger.error(f"Can't find instrument for pregenerated signals with id '{s}'")
+                raise SimulationError(f"Can't find instrument for pregenerated signals with id '{s}'")
+
+    def _convert_records_to_bars(
+        self, records: list[TimestampedDict], cut_time_ns: int, timeframe_ns: int
+    ) -> list[Bar]:
+        """
+        Convert records to bars and we need to cut last bar up to the cut_time_ns
+        """
+        bars = []
+
+        # - if no records, return empty list to avoid exception from infer_series_frequency
+        if not records:
+            return bars
+
+        _data_tf = infer_series_frequency([r.time for r in records[:50]])
+        timeframe_ns = _data_tf.item()
+
+        if records is not None:
+            for r in records:
+                # _b_ts_0 = np.datetime64(r.time, "ns").item()
+                _b_ts_0 = r.time
+                _b_ts_1 = _b_ts_0 + timeframe_ns - self._open_close_time_indent_ns
+
+                if _b_ts_0 <= cut_time_ns and cut_time_ns < _b_ts_1:
+                    break
+
+                bars.append(
+                    Bar(
+                        _b_ts_0, r.data["open"], r.data["high"], r.data["low"], r.data["close"], r.data.get("volume", 0)
+                    )
+                )
+
+        return bars
+
+    def _process_generated_signals(self, instrument: Instrument, data_type: str, data: Any, is_hist: bool) -> bool:
+        cc = self.channel
+        t = np.datetime64(data.time, "ns")
+
+        if not is_hist:
+            # - signals for this instrument
+            sigs = self._to_process[instrument]
+
+            while sigs and t >= (_signal_time := sigs[0][0].as_unit("ns").asm8):
+                self.time_provider.set_time(_signal_time)
+                cc.send((instrument, "event", {"order": sigs[0][1]}, False))
+                sigs.pop(0)
+
+            if q := self._account.emulate_quote_from_data(instrument, t, data):
+                self._last_quotes[instrument] = q
+
+        self.time_provider.set_time(t)
+        cc.send((instrument, data_type, data, is_hist))
+
+        return cc.control.is_set()
+
+    def _process_strategy(self, instrument: Instrument, data_type: str, data: Any, is_hist: bool) -> bool:
+        cc = self.channel
+        t = np.datetime64(data.time, "ns")
+
+        if not is_hist:
+            if t >= (_next_exp_time := self._scheduler.next_expected_event_time()):
+                # - we use exact event's time
+                self.time_provider.set_time(_next_exp_time)
+                self._scheduler.check_and_run_tasks()
+
+            if q := self._account.emulate_quote_from_data(instrument, t, data):
+                self._last_quotes[instrument] = q
+
+        self.time_provider.set_time(t)
+        cc.send((instrument, data_type, data, is_hist))
+
+        return cc.control.is_set()
+
+    def exchange(self) -> str:
+        return self._exchange_id.upper()

qubx/backtester/management.py

@@ -0,0 +1,378 @@
+import re
+import zipfile
+from collections import defaultdict
+from pathlib import Path
+
+import pandas as pd
+import yaml
+
+from qubx.core.metrics import TradingSessionResult
+from qubx.utils.misc import blue, cyan, green, magenta, red, yellow
+
+
+class BacktestsResultsManager:
+    """
+    Manager class for handling backtesting results.
+
+    This class provides functionality to load, list and manage backtesting results stored in zip files.
+    Each result contains trading session information and metrics that can be loaded and analyzed.
+
+    Parameters
+    ----------
+    path : str
+        Path to directory containing backtesting result zip files
+
+    Methods
+    -------
+    - reload()
+        Reloads all backtesting results from the specified path
+    - list(regex="", with_metrics=False)
+        Lists all backtesting results, optionally filtered by regex and including metrics
+    - load(name)
+        Loads a specific backtesting result by name
+    - load_config(name)
+        Loads the configuration YAML file for a specific backtest result
+    - delete(name)
+        Deletes one or more backtest results
+    """
+
+    def __init__(self, path: str):
+        self.path = path
+        self.reload()
+
+    def reload(self) -> "BacktestsResultsManager":
+        self.results = {}
+        self.variations = {}
+
+        _vars = defaultdict(list)
+        names = defaultdict(lambda: 0)
+        for p in Path(self.path).glob("**/*.zip"):
+            with zipfile.ZipFile(p, "r") as zip_ref:
+                try:
+                    info = yaml.safe_load(zip_ref.read("info.yml"))
+                    info["path"] = str(p)
+                    n = info.get("name", "")
+                    var_set_name = info.get("variation_name", "")
+
+                    # - put variations aside
+                    if var_set_name:
+                        _vars[var_set_name].append(info)
+                        continue
+
+                    _new_name = n if names[n] == 0 else f"{n}.{names[n]}"
+                    names[n] += 1
+                    info["name"] = _new_name
+                    self.results[_new_name] = info
+                except Exception:
+                    pass
+
+        # - reindex
+        _idx = 1
+        for n in sorted(self.results.keys()):
+            self.results[n]["idx"] = _idx
+            _idx += 1
+
+        # - reindex variations at the end
+        for n in sorted(_vars.keys()):
+            self.variations[_idx] = {
+                "name": n,
+                "idx": _idx,
+                "variations": _vars[n],
+                "created": pd.Timestamp(_vars[n][0].get("creation_time", "")).round("1s"),
+                "author": _vars[n][0].get("author", ""),
+                "description": _vars[n][0].get("description", ""),
+            }
+            _idx += 1
+
+        return self
+
+    def __getitem__(
+        self, name: str | int | list[int] | list[str] | slice
+    ) -> TradingSessionResult | list[TradingSessionResult]:
+        return self.load(name)
+
+    def load(
+        self, name_or_idx: str | int | list[int] | list[str] | slice
+    ) -> TradingSessionResult | list[TradingSessionResult]:
+        match name_or_idx:
+            case list():
+                return [self.load(i) for i in name_or_idx]  # type: ignore
+            case str():
+                return [self.load(i) for i in self._find_indices(name_or_idx)]  # type: ignore
+            case slice():
+                return [
+                    self.load(i)
+                    for i in range(name_or_idx.start, name_or_idx.stop, name_or_idx.step if name_or_idx.step else 1)
+                ]  # type: ignore
+            case int():
+                if name_or_idx > len(self.results) and name_or_idx in self.variations:
+                    return [
+                        TradingSessionResult.from_file(v.get("path", ""))
+                        for v in self.variations[name_or_idx].get("variations", [])
+                    ]
+
+                # - load by index
+                for info in self.results.values():
+                    if info.get("idx", -1) == name_or_idx:
+                        return TradingSessionResult.from_file(info["path"])
+
+        raise ValueError(f"No result found for '{name_or_idx}' !")
+
+    def load_config(self, name: str | int) -> str:
+        """Load the configuration YAML file for a specific backtest result.
+
+        Args:
+            name (str | int): The name or index of the backtest result. If str, matches against the backtest name.
+                            If int, matches against the backtest index.
+
+        Returns:
+            str: The contents of the configuration YAML file as a string.
+
+        Raises:
+            ValueError: If no backtest result is found matching the provided name/index.
+        """
+        p = None
+        for info in self.results.values():
+            match name:
+                case int():
+                    if info.get("idx", -1) == name:
+                        n = info.get("name", "")
+                        p = info.get("path", {})
+                        break
+                case str():
+                    if info.get("name", "") == name:
+                        n = info.get("name", "")
+                        p = info.get("path", {})
+                        break
+        if p is None:
+            raise ValueError(f"No result found for {name}")
+
+        # - name may have .1, .2, etc. so we need to remove it
+        n = n.split(".")[0] if "." in n else n
+        with zipfile.ZipFile(p, "r") as zip_ref:
+            return zip_ref.read(f"{n}.yaml").decode("utf-8")
+
+    def delete(self, name: str | int | list[int] | list[str] | slice):
+        """Delete one or more backtest results.
+
+        Args:
+            name: Identifier(s) for the backtest result(s) to delete. Can be:
+                - str: Name of backtest or regex pattern to match multiple backtests
+                - int: Index of specific backtest
+                - list[int]: List of backtest indices
+                - list[str]: List of backtest names
+                - slice: Range of backtest indices to delete
+
+        Prints:
+            Message confirming which backtest(s) were deleted, or error if none found.
+            Deleted backtest names are shown in red text.
+
+        Note:
+            - For string names, supports regex pattern matching against backtest names and strategy class names
+            - Deletes the underlying results files and reloads the results index
+            - Operation is irreversible
+        """
+
+        def _del_idx(idx):
+            for info in self.results.values():
+                if info.get("idx", -1) == idx:
+                    Path(info["path"]).unlink()
+                    return info.get("name", idx)
+            return None
+
+        match name:
+            case str():
+                nms = [_del_idx(i) for i in self._find_indices(name)]
+                self.reload()
+                print(f" -> Deleted {red(', '.join(nms))} ...")
+                return
+
+            case list():
+                nms = [_del_idx(i) for i in name]
+                self.reload()
+                print(f" -> Deleted {red(', '.join(nms))} ...")
+                return
+
+            case slice():
+                nms = [_del_idx(i) for i in range(name.start, name.stop, name.step if name.step else 1)]
+                self.reload()
+                print(f" -> Deleted {red(', '.join(nms))} ...")
+                return
+
+        for info in self.results.values():
+            match name:
+                case int():
+                    if info.get("idx", -1) == name:
+                        Path(info["path"]).unlink()
+                        print(f" -> Deleted {red(info.get('name', name))} ...")
+                        self.reload()
+                        return
+                case str():
+                    if info.get("name", "") == name:
+                        Path(info["path"]).unlink()
+                        print(f" -> Deleted {red(info.get('name', name))} ...")
+                        self.reload()
+                        return
+        print(f" -> No results found for {red(name)} !")
+
+    def _find_indices(self, regex: str):
+        for n in sorted(self.results.keys()):
+            info = self.results[n]
+            s_cls = info.get("strategy_class", "").split(".")[-1]
+
+            try:
+                if not re.match(regex, n, re.IGNORECASE):
+                    # if not re.match(regex, s_cls, re.IGNORECASE):
+                    continue
+            except Exception:
+                if regex.lower() != n.lower() and regex.lower() != s_cls.lower():
+                    continue
+
+            yield info.get("idx", -1)
+
+    def list(
+        self,
+        regex: str = "",
+        with_metrics=True,
+        params=False,
+        as_table=False,
+        pretty_print=False,
+        sort_by: str | None = "sharpe",
+        ascending=False,
+        show_variations=True,
+    ):
+        """List backtesting results with optional filtering and formatting.
+
+        Args:
+            - regex (str, optional): Regular expression pattern to filter results by strategy name or class. Defaults to "".
+            - with_metrics (bool, optional): Whether to include performance metrics in output. Defaults to True.
+            - params (bool, optional): Whether to display strategy parameters. Defaults to False.
+            - as_table (bool, optional): Return results as a pandas DataFrame instead of printing. Defaults to False.
+
+        Returns:
+            - Optional[pd.DataFrame]: If as_table=True, returns a DataFrame containing the results sorted by creation time.
+            - Otherwise prints formatted results to console.
+        """
+        _t_rep = []
+        for n in sorted(self.results.keys()):
+            info = self.results[n]
+            s_cls = info.get("strategy_class", "").split(".")[-1]
+
+            if regex:
+                if not re.match(regex, n, re.IGNORECASE):
+                    # if not re.match(regex, s_cls, re.IGNORECASE):
+                    continue
+
+            name = info.get("name", "")
+            smbs = ", ".join(info.get("symbols", list()))
+            start = pd.Timestamp(info.get("start", "")).round("1s")
+            stop = pd.Timestamp(info.get("stop", "")).round("1s")
+            dscr = info.get("description", "")
+            created = pd.Timestamp(info.get("creation_time", "")).round("1s")
+            metrics = info.get("performance", {})
+            author = info.get("author", "")
+            _s = f"{yellow(str(info.get('idx')))} - {red(name)} ::: {magenta(created)} by {cyan(author)}"
+
+            _one_line_dscr = ""
+            if dscr:
+                dscr = dscr.split("\n")
+                for _d in dscr:
+                    _s += f"\n\t{magenta('# ' + _d)}"
+                    _one_line_dscr += "\u25cf " + _d + "\n"
+
+            _s += f"\n\tstrategy: {green(s_cls)}"
+            _s += f"\n\tinterval: {blue(start)} - {blue(stop)}"
+            _s += f"\n\tcapital: {blue(info.get('capital', ''))} {info.get('base_currency', '')} ({info.get('commissions', '')})"
+            _s += f"\n\tinstruments: {blue(smbs)}"
+            if params:
+                formats = ["{" + f":<{i}" + "}" for i in [50]]
+                _p = pd.DataFrame.from_dict(info.get("parameters", {}), orient="index")
+                for i in _p.to_string(
+                    max_colwidth=30,
+                    header=False,
+                    formatters=[(lambda x: cyan(fmt.format(str(x)))) for fmt in formats],
+                    justify="left",
+                ).split("\n"):
+                    _s += f"\n\t  |  {yellow(i)}"
+
+            if not as_table:
+                print(_s)
+
+            if with_metrics:
+                _m_repr = (
+                    pd.DataFrame.from_dict(metrics, orient="index")
+                    .T[["gain", "cagr", "sharpe", "qr", "max_dd_pct", "mdd_usd", "fees", "execs"]]
+                    .astype(float)
+                )
+                _m_repr = _m_repr.round(3).to_string(index=False)
+                _h, _v = _m_repr.split("\n")
+                if not as_table:
+                    print("\t " + red(_h))
+                    print("\t " + cyan(_v))
+
+            if not as_table:
+                print()
+            else:
+                metrics = {
+                    m: round(v, 3)
+                    for m, v in metrics.items()
+                    if m in ["gain", "cagr", "sharpe", "qr", "max_dd_pct", "mdd_usd", "fees", "execs"]
+                }
+                _t_rep.append(
+                    {"Index": info.get("idx", ""), "Strategy": name}
+                    | metrics
+                    | {
+                        "start": start,
+                        "stop": stop,
+                        "Created": created,
+                        "Author": author,
+                        "Description": _one_line_dscr,
+                    },
+                )
+
+        # - variations (only if not as_table for the time being)
+        if not as_table and show_variations:
+            for _i, vi in self.variations.items():
+                n = vi.get("name", "")
+                if regex:
+                    if not re.match(regex, n, re.IGNORECASE):
+                        continue
+
+                _s = f"{yellow(str(_i))} - {red(str(n))} set of {len(vi.get('variations'))} variations ::: {magenta(vi.get('created'))} by {cyan(vi.get('author'))}"
+
+                dscr = vi.get("description", "").split("\n")
+                for _d in dscr:
+                    _s += f"\n\t{magenta('# ' + _d)}"
+
+                _mtrx = {}
+                for v in vi.get("variations", []):
+                    _nm = v.get("name", "")
+                    _nm = _nm.split("_")[-1].strip("()")
+                    _mtrx[_nm] = v.get("performance", {})
+
+                _m_repr = pd.DataFrame.from_dict(_mtrx, orient="index")[
+                    ["gain", "cagr", "sharpe", "qr", "max_dd_pct", "mdd_usd", "fees", "execs"]
+                ].astype(float)
+                _m_repr = _m_repr.round(3)
+                _m_repr = _m_repr.sort_values(by=sort_by, ascending=ascending) if sort_by else _m_repr
+                _m_repr = _m_repr.to_string(index=True)
+
+                print(_s)
+                for _i, _l in enumerate(_m_repr.split("\n")):
+                    if _i == 0:
+                        print("\t " + red(_l))
+                    else:
+                        print("\t " + blue(_l))
+
+        if as_table:
+            _df = pd.DataFrame.from_records(_t_rep, index="Index")
+            _df = _df.sort_values(by=sort_by, ascending=ascending) if sort_by else _df
+            if pretty_print:
+                from IPython.display import HTML
+
+                return HTML(
+                    _df.to_html()
+                    .replace("\\n", "<br><hr style='border-color: #005000; '/>")
+                    .replace("<td>", '<td align="left" valign="top">')
+                )
+            return _df