Qubx 0.5.5__tar.gz → 0.5.7__tar.gz

{qubx-0.5.5 → qubx-0.5.7}/PKG-INFO

@@ -1,15 +1,15 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: Qubx
-Version: 0.5.5
-Summary: Qubx - quantitative trading framework
-Home-page: https://github.com/dmarienko/Qubx
+Version: 0.5.7
+Summary: Qubx - Quantitative Trading Framework
 Author: Dmitry Marienko
-Author-email: dmitry@gmail.com
+Author-email: dmitry.marienko@xlydian.com
 Requires-Python: >=3.10,<4.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: ccxt (>=4.2.68,<5.0.0)
 Requires-Dist: croniter (>=2.0.5,<3.0.0)
 Requires-Dist: cython (==3.0.8)
@@ -42,20 +42,25 @@ Requires-Dist: statsmodels (>=0.14.2,<0.15.0)
 Requires-Dist: tabulate (>=0.9.0,<0.10.0)
 Requires-Dist: toml (>=0.10.2,<0.11.0)
 Requires-Dist: tqdm
-Project-URL: Repository, https://github.com/dmarienko/Qubx
+Project-URL: Repository, https://github.com/xLydianSoftware/Qubx
 Description-Content-Type: text/markdown
 
 # Qubx
 
+[![CI](https://github.com/xLydianSoftware/Qubx/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/xLydianSoftware/Qubx/actions/workflows/ci.yml)
+
 ## Next generation of Qube quantitative backtesting framework (QUBX)
 ```          
 ⠀⠀⡰⡖⠒⠒⢒⢦⠀⠀
 ⠀⢠⠃⠈⢆⣀⣎⣀⣱⡀  QUBX | Quantitative Backtesting Environment
 ⠀⢳⠒⠒⡞⠚⡄⠀⡰⠁         (c) 2024, by Dmytro Mariienko
 ⠀⠀⠱⣜⣀⣀⣈⣦⠃⠀⠀⠀
-
 ```                                          
 
+## Documentation
+
+See [Qubx Documentation](https://xlydiansoftware.github.io/Qubx/en/latest/)
+
 ## Installation
 > pip install qubx
 
@@ -76,7 +81,6 @@ base_currency = USDT
 ```
 
 ## Running tests
-
 We use `pytest` for running tests. For running unit tests execute
 ```
 just test
@@ -99,4 +103,3 @@ To run the tests simply call
 ```
 just test-integration
 ```
-

{qubx-0.5.5 → qubx-0.5.7}/README.md

@@ -1,14 +1,19 @@
 # Qubx
 
+[![CI](https://github.com/xLydianSoftware/Qubx/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/xLydianSoftware/Qubx/actions/workflows/ci.yml)
+
 ## Next generation of Qube quantitative backtesting framework (QUBX)
 ```          
 ⠀⠀⡰⡖⠒⠒⢒⢦⠀⠀
 ⠀⢠⠃⠈⢆⣀⣎⣀⣱⡀  QUBX | Quantitative Backtesting Environment
 ⠀⢳⠒⠒⡞⠚⡄⠀⡰⠁         (c) 2024, by Dmytro Mariienko
 ⠀⠀⠱⣜⣀⣀⣈⣦⠃⠀⠀⠀
-
 ```                                          
 
+## Documentation
+
+See [Qubx Documentation](https://xlydiansoftware.github.io/Qubx/en/latest/)
+
 ## Installation
 > pip install qubx
 
@@ -29,7 +34,6 @@ base_currency = USDT
 ```
 
 ## Running tests
-
 We use `pytest` for running tests. For running unit tests execute
 ```
 just test
@@ -51,4 +55,4 @@ BINANCE_FUTURES_SECRET=...
 To run the tests simply call
 ```
 just test-integration
-```
+```

{qubx-0.5.5 → qubx-0.5.7}/build.py

@@ -4,18 +4,14 @@ import os
 import platform
 import shutil
 import subprocess
-import sysconfig
-
 from pathlib import Path
-import os
+
 import numpy as np
 import toml
-from Cython.Build import build_ext
-from Cython.Build import cythonize
+from Cython.Build import build_ext, cythonize
 from Cython.Compiler import Options
 from Cython.Compiler.Version import version as cython_compiler_version
-from setuptools import Distribution
-from setuptools import Extension
+from setuptools import Distribution, Extension
 
 RED, BLUE, GREEN, YLW, RES = "\033[31m", "\033[36m", "\033[32m", "\033[33m", "\033[0m"
 

{qubx-0.5.5 → qubx-0.5.7}/pyproject.toml

@@ -1,14 +1,14 @@
 [tool.poetry]
 name = "Qubx"
-version = "0.5.5"
-description = "Qubx - quantitative trading framework"
+version = "0.5.7"
+description = "Qubx - Quantitative Trading Framework"
 authors = [
-    "Dmitry Marienko <dmitry@gmail.com>",
-    "Yuriy Arabskyy <yuriy.arabskyy@gmail.com>",
+    "Dmitry Marienko <dmitry.marienko@xlydian.com>",
+    "Yuriy Arabskyy <yuriy.arabskyy@xlydian.com>",
 ]
 readme = "README.md"
 packages = [{ include = "qubx", from = "src" }]
-repository = "https://github.com/dmarienko/Qubx"
+repository = "https://github.com/xLydianSoftware/Qubx"
 include = [
     # Compiled extensions must be included in the wheel distributions
     { path = "src/**/*.so", format = "wheel" },
@@ -61,6 +61,7 @@ ipykernel = "^6.29.4"
 iprogress = "^0.4"
 click = "^8.1.7"
 ipywidgets = "^8.1.5"
+ruff = "^0.9.7"
 
 [build-system]
 requires = [
@@ -79,18 +80,26 @@ generate-setup-file = false
 [tool.poetry.group.test.dependencies]
 pytest = { extras = ["lazyfixture"], version = "^8.2.0" }
 pytest-asyncio = "^0.24.0"
-pytest-mock = "*"
+pytest-mock = "^3.12.0"
+pytest-lazy-fixture = "^0.6.3"
+pytest-cov = "^4.1.0"
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 asyncio_default_fixture_loop_scope = "function"
 pythonpath = ["src"]
 markers = ["integration: mark a test as an integration test"]
-addopts = "--disable-warnings -s"
+addopts = "--disable-warnings"
 filterwarnings = ["ignore:.*Jupyter is migrating.*:DeprecationWarning"]
 
 [tool.ruff]
 line-length = 120
+lint.extend-select = ["I"]
+lint.ignore = [
+    "E731",
+    "E722",
+    "E741",
+] # Ignore lambda assignments, bare except, and ambiguous variable names
 
 [tool.ruff.lint.extend-per-file-ignores]
 "*.ipynb" = ["F405", "F401", "E701", "E402", "F403", "E401", "E702"]

{qubx-0.5.5 → qubx-0.5.7}/src/qubx/_nb_magic.py

@@ -32,25 +32,25 @@ if runtime_env() in ["notebook", "shell"]:
     # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
     # - - - - Common stuff - - - -
-    from datetime import time, timedelta
+    from datetime import time, timedelta  # noqa: F401
 
-    import numpy as np
-    import pandas as pd
+    import numpy as np  # noqa: F401
+    import pandas as pd  # noqa: F401
 
     # - - - - Charting stuff - - - -
-    from matplotlib import pyplot as plt
-    from tqdm.auto import tqdm
+    from matplotlib import pyplot as plt  # noqa: F401
+    from tqdm.auto import tqdm  # noqa: F401
 
     # - - - - TA stuff and indicators - - - -
-    import qubx.pandaz.ta as pta
-    import qubx.ta.indicators as ta
-    from qubx.backtester.optimization import variate
+    import qubx.pandaz.ta as pta  # noqa: F401
+    import qubx.ta.indicators as ta  # noqa: F401
+    from qubx.backtester.optimization import variate  # noqa: F401
 
     # - - - - Simulator stuff - - - -
-    from qubx.backtester.simulator import simulate
+    from qubx.backtester.simulator import simulate  # noqa: F401
 
     # - - - - Portfolio analysis - - - -
-    from qubx.core.metrics import (
+    from qubx.core.metrics import (  # noqa: F401
         chart_signals,
         drop_symbols,
         get_symbol_pnls,
@@ -59,10 +59,10 @@ if runtime_env() in ["notebook", "shell"]:
         portfolio_metrics,
         tearsheet,
     )
-    from qubx.data.helpers import loader
+    from qubx.data.helpers import loader  # noqa: F401
 
     # - - - - Data reading - - - -
-    from qubx.data.readers import (
+    from qubx.data.readers import (  # noqa: F401
         AsOhlcvSeries,
         AsPandasFrame,
         AsQuotes,
@@ -74,7 +74,7 @@ if runtime_env() in ["notebook", "shell"]:
     )
 
     # - - - - Utils - - - -
-    from qubx.pandaz.utils import (
+    from qubx.pandaz.utils import (  # noqa: F401
         continuous_periods,
         drop_duplicated_indexes,
         generate_equal_date_ranges,
@@ -84,9 +84,9 @@ if runtime_env() in ["notebook", "shell"]:
         scols,
         srows,
     )
-    from qubx.utils.charting.lookinglass import LookingGlass
-    from qubx.utils.charting.mpl_helpers import fig, ohlc_plot, plot_trends, sbp, subplot
-    from qubx.utils.misc import this_project_root
+    from qubx.utils.charting.lookinglass import LookingGlass  # noqa: F401
+    from qubx.utils.charting.mpl_helpers import fig, ohlc_plot, plot_trends, sbp, subplot  # noqa: F401
+    from qubx.utils.misc import this_project_root  # noqa: F401
 
     # - setup short numpy output format
     np_fmt_short()

{qubx-0.5.5 → qubx-0.5.7}/src/qubx/backtester/__init__.py

@@ -1,3 +1,5 @@
+__all__ = ["BacktestsResultsManager", "variate", "simulate"]
+
 from .management import BacktestsResultsManager
 from .optimization import variate
 from .simulator import simulate

{qubx-0.5.5 → qubx-0.5.7}/src/qubx/backtester/account.py

@@ -48,14 +48,15 @@ class SimulatedAccountProcessor(BasicAccountProcessor):
         if self._fill_stop_order_at_price:
             logger.info(f"[<y>{self.__class__.__name__}</y>] :: emulates stop orders executions at exact price")
 
-    def get_orders(self, instrument: Instrument | None = None) -> list[Order]:
+    def get_orders(self, instrument: Instrument | None = None) -> dict[str, Order]:
         if instrument is not None:
             ome = self.ome.get(instrument)
             if ome is None:
                 raise ValueError(f"ExchangeService:get_orders :: No OME configured for '{instrument}'!")
-            return ome.get_open_orders()
 
-        return [o for ome in self.ome.values() for o in ome.get_open_orders()]
+            return {o.id: o for o in ome.get_open_orders()}
+
+        return {o.id: o for ome in self.ome.values() for o in ome.get_open_orders()}
 
     def get_position(self, instrument: Instrument) -> Position:
         if instrument in self.positions:

{qubx-0.5.5 → qubx-0.5.7}/src/qubx/backtester/data.py

@@ -229,6 +229,10 @@ class SimulatedDataProvider(IDataProvider):
         """
         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()
 

qubx-0.5.7/src/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