Qubx 0.1.83__tar.gz → 0.1.84__tar.gz

{qubx-0.1.83 → qubx-0.1.84}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Qubx
-Version: 0.1.83
+Version: 0.1.84
 Summary: Qubx - quantitative trading framework
 Home-page: https://github.com/dmarienko/Qubx
 Author: Dmitry Marienko

{qubx-0.1.83 → qubx-0.1.84}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "Qubx"
-version = "0.1.83"
+version = "0.1.84"
 description = "Qubx - quantitative trading framework"
 authors = ["Dmitry Marienko <dmitry@gmail.com>"]
 readme = "README.md"

{qubx-0.1.83 → qubx-0.1.84}/src/qubx/__init__.py

@@ -10,13 +10,20 @@ def formatter(record):
     end = record["extra"].get("end", "\n")
     fmt = "<lvl>{message}</lvl>%s" % end
     if record["level"].name in {"WARNING", "SNAKY"}:
-        fmt = "<cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - %s" % fmt
+        fmt = (
+            "<cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - %s" % fmt
+        )
 
-    prefix = "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> [ <level>%s</level> ] " % record["level"].icon
+    prefix = (
+        "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> [ <level>%s</level> ] "
+        % record["level"].icon
+    )
 
     if record["exception"] is not None:
         # stackprinter.set_excepthook(style='darkbg2')
-        record["extra"]["stack"] = stackprinter.format(record["exception"], style="darkbg")
+        record["extra"]["stack"] = stackprinter.format(
+            record["exception"], style="darkbg"
+        )
         fmt += "\n{extra[stack]}\n"
 
     if record["level"].name in {"TEXT"}:
@@ -25,24 +32,43 @@ def formatter(record):
     return prefix + fmt
 
 
-config = {
-    "handlers": [ {"sink": sys.stdout, "format": "{time} - {message}"}, ],
-    "extra": {"user": "someone"},
-}
+class QubxLogConfig:
 
+    @staticmethod
+    def get_log_level():
+        return os.getenv("QUBX_LOG_LEVEL", "DEBUG")
+
+    @staticmethod
+    def set_log_level(level: str):
+        os.environ["QUBX_LOG_LEVEL"] = level
+        QubxLogConfig.setup_logger(level)
+
+    @staticmethod
+    def setup_logger(level: str | None = None):
+        global logger
+        config = {
+            "handlers": [
+                {"sink": sys.stdout, "format": "{time} - {message}"},
+            ],
+            "extra": {"user": "someone"},
+        }
+        logger.configure(**config)
+        logger.remove(None)
+        level = level or QubxLogConfig.get_log_level()
+        logger.add(sys.stdout, format=formatter, colorize=True, level=level)
+        logger = logger.opt(colors=True)
+
+
+QubxLogConfig.setup_logger()
 
-logger.configure(**config)
-logger.remove(None)
-logger.add(sys.stdout, format=formatter, colorize=True)
-logger = logger.opt(colors=True)
 
 # - global lookup helper
 lookup = GlobalLookup(InstrumentsLookup(), FeesLookup())
 
 
 # registering magic for jupyter notebook
-if runtime_env() in ['notebook', 'shell']:
-    from IPython.core.magic import (Magics, magics_class, line_magic, line_cell_magic)
+if runtime_env() in ["notebook", "shell"]:
+    from IPython.core.magic import Magics, magics_class, line_magic, line_cell_magic
     from IPython import get_ipython
 
     @magics_class
@@ -52,11 +78,11 @@ if runtime_env() in ['notebook', 'shell']:
 
         @line_magic
         def qubxd(self, line: str):
-            self.qubx_setup('dark' + ' ' + line)
+            self.qubx_setup("dark" + " " + line)
 
         @line_magic
         def qubxl(self, line: str):
-            self.qubx_setup('light' + ' ' + line)
+            self.qubx_setup("light" + " " + line)
 
         @line_magic
         def qubx_setup(self, line: str):
@@ -64,25 +90,26 @@ if runtime_env() in ['notebook', 'shell']:
             QUBX framework initialization
             """
             import os
-            args = [x.strip() for x in line.split(' ')]
-            
+
+            args = [x.strip() for x in line.split(" ")]
+
             # setup cython dev hooks - only if 'dev' is passed as argument
-            if line and 'dev' in args: 
+            if line and "dev" in args:
                 install_pyx_recompiler_for_dev()
 
             tpl_path = os.path.join(os.path.dirname(__file__), "_nb_magic.py")
-            with open(tpl_path, 'r', encoding="utf8") as myfile:
+            with open(tpl_path, "r", encoding="utf8") as myfile:
                 s = myfile.read()
 
             exec(s, self.shell.user_ns)
 
             # setup more funcy mpl theme instead of ugly default
             if line:
-                if 'dark' in line.lower():
-                    set_mpl_theme('dark')
+                if "dark" in line.lower():
+                    set_mpl_theme("dark")
 
-                elif 'light' in line.lower():
-                    set_mpl_theme('light')
+                elif "light" in line.lower():
+                    set_mpl_theme("light")
 
             # install additional plotly helpers
             # from qube.charting.plot_helpers import install_plotly_helpers
@@ -91,6 +118,7 @@ if runtime_env() in ['notebook', 'shell']:
         def _get_manager(self):
             if self.__manager is None:
                 import multiprocessing as m
+
                 self.__manager = m.Manager()
             return self.__manager
 
@@ -102,7 +130,7 @@ if runtime_env() in ['notebook', 'shell']:
             >>> %%proc x, y as MyProc1
             >>> x.set('Hello')
             >>> y.set([1,2,3,4])
-            
+
             """
             import multiprocessing as m
             import time, re
@@ -111,8 +139,8 @@ if runtime_env() in ['notebook', 'shell']:
             name = None
             if line:
                 # check if custom process name was provided
-                if ' as ' in line:
-                    line, name = line.split('as')
+                if " as " in line:
+                    line, name = line.split("as")
                     if not name.isspace():
                         name = name.strip()
                     else:
@@ -120,11 +148,11 @@ if runtime_env() in ['notebook', 'shell']:
                         return
 
                 ipy = get_ipython()
-                for a in [x for x in re.split('[\ ,;]', line.strip()) if x]:
+                for a in [x for x in re.split("[\ ,;]", line.strip()) if x]:
                     ipy.push({a: self._get_manager().Value(None, None)})
 
             # code to run
-            lines = '\n'.join(['    %s' % x for x in cell.split('\n')])
+            lines = "\n".join(["    %s" % x for x in cell.split("\n")])
 
             def fn():
                 result = get_ipython().run_cell(lines)
@@ -136,17 +164,18 @@ if runtime_env() in ['notebook', 'shell']:
                 if result.error_in_exec:
                     raise result.error_in_exec
 
-            t_start = str(time.time()).replace('.', '_')
-            f_id = f'proc_{t_start}' if name is None else name
+            t_start = str(time.time()).replace(".", "_")
+            f_id = f"proc_{t_start}" if name is None else name
             if self._is_task_name_already_used(f_id):
                 f_id = f"{f_id}_{t_start}"
 
             task = m.Process(target=fn, name=f_id)
             task.start()
-            print(' -> Task %s is started' % f_id)
+            print(" -> Task %s is started" % f_id)
 
         def _is_task_name_already_used(self, name):
             import multiprocessing as m
+
             for p in m.active_children():
                 if p.name == name:
                     return True
@@ -155,16 +184,17 @@ if runtime_env() in ['notebook', 'shell']:
         @line_magic
         def list_proc(self, line):
             import multiprocessing as m
+
             for p in m.active_children():
                 print(p.name)
 
         @line_magic
         def kill_proc(self, line):
             import multiprocessing as m
+
             for p in m.active_children():
                 if line and p.name.startswith(line):
                     p.terminate()
 
-
     # - registering magic here
     get_ipython().register_magics(QubxMagics)

{qubx-0.1.83 → qubx-0.1.84}/src/qubx/data/readers.py

@@ -11,6 +11,7 @@ from functools import wraps
 from qubx import logger
 from qubx.core.series import TimeSeries, OHLCV, time_as_nsec, Quote, Trade
 from qubx.utils.time import infer_series_frequency, handle_start_stop
+from psycopg.types.datetime import TimestampLoader
 
 _DT = lambda x: pd.Timedelta(x).to_numpy().item()
 D1, H1 = _DT("1D"), _DT("1h")
@@ -20,6 +21,12 @@ STOCK_DAILY_SESSION = (_DT("9:30:00.100"), _DT("15:59:59.900"))
 CME_FUTURES_DAILY_SESSION = (_DT("8:30:00.100"), _DT("15:14:59.900"))
 
 
+class NpTimestampLoader(TimestampLoader):
+    def load(self, data) -> np.datetime64:
+        dt = super().load(data)
+        return np.datetime64(dt)
+
+
 def _recognize_t(t: Union[int, str], defaultvalue, timeunit) -> int:
     if isinstance(t, (str, pd.Timestamp)):
         try:
@@ -46,7 +53,7 @@ def _find_column_index_in_list(xs, *args):
 
 
 _FIND_TIME_COL_IDX = lambda column_names: _find_column_index_in_list(
-    column_names, "time", "timestamp", "datetime", "date", "open_time"
+    column_names, "time", "timestamp", "datetime", "date", "open_time", "ts"
 )
 
 
@@ -56,7 +63,13 @@ class DataTransformer:
         self.buffer = []
         self._column_names = []
 
-    def start_transform(self, name: str, column_names: List[str]):
+    def start_transform(
+        self,
+        name: str,
+        column_names: List[str],
+        start: str | None = None,
+        stop: str | None = None,
+    ):
         self._column_names = column_names
         self.buffer = []
 
@@ -181,7 +194,9 @@ class CsvStorageDataReader(DataReader):
 
             def _iter_chunks():
                 for n in range(0, length // chunksize + 1):
-                    transform.start_transform(data_id, fieldnames)
+                    transform.start_transform(
+                        data_id, fieldnames, start=start, stop=stop
+                    )
                     raw_data = (
                         selected_table[n * chunksize : min((n + 1) * chunksize, length)]
                         .to_pandas()
@@ -192,7 +207,7 @@ class CsvStorageDataReader(DataReader):
 
             return _iter_chunks()
 
-        transform.start_transform(data_id, fieldnames)
+        transform.start_transform(data_id, fieldnames, start=start, stop=stop)
         raw_data = selected_table.to_pandas().to_numpy()
         transform.process_data(raw_data)
         return transform.collect()
@@ -213,7 +228,7 @@ class AsPandasFrame(DataTransformer):
     def __init__(self, timestamp_units=None) -> None:
         self.timestamp_units = timestamp_units
 
-    def start_transform(self, name: str, column_names: List[str]):
+    def start_transform(self, name: str, column_names: List[str], **kwargs):
         self._time_idx = _FIND_TIME_COL_IDX(column_names)
         self._column_names = column_names
         self._frame = pd.DataFrame()
@@ -256,7 +271,7 @@ class AsOhlcvSeries(DataTransformer):
         self._data_type = None
         self.timestamp_units = timestamp_units
 
-    def start_transform(self, name: str, column_names: List[str]):
+    def start_transform(self, name: str, column_names: List[str], **kwargs):
         self._time_idx = _FIND_TIME_COL_IDX(column_names)
         self._volume_idx = None
         self._b_volume_idx = None
@@ -376,7 +391,7 @@ class AsQuotes(DataTransformer):
     Data must have appropriate structure: bid, ask, bidsize, asksize and time
     """
 
-    def start_transform(self, name: str, column_names: List[str]):
+    def start_transform(self, name: str, column_names: List[str], **kwargs):
         self.buffer = list()
         self._time_idx = _FIND_TIME_COL_IDX(column_names)
         self._bid_idx = _find_column_index_in_list(column_names, "bid")
@@ -422,7 +437,7 @@ class AsTimestampedRecords(DataTransformer):
     def __init__(self, timestamp_units: str | None = None) -> None:
         self.timestamp_units = timestamp_units
 
-    def start_transform(self, name: str, column_names: List[str]):
+    def start_transform(self, name: str, column_names: List[str], **kwargs):
         self.buffer = list()
         self._time_idx = _FIND_TIME_COL_IDX(column_names)
         self._column_names = column_names
@@ -465,7 +480,7 @@ class RestoreTicksFromOHLC(DataTransformer):
         self._d_session_start = daily_session_start_end[0]
         self._d_session_end = daily_session_start_end[1]
 
-    def start_transform(self, name: str, column_names: List[str]):
+    def start_transform(self, name: str, column_names: List[str], **kwargs):
         self.buffer = []
         # - it will fail if receive data doesn't look as ohlcv
         self._time_idx = _FIND_TIME_COL_IDX(column_names)
@@ -606,10 +621,8 @@ def _retry(fn):
             # print(x, cls._reconnect_tries)
             try:
                 return fn(*args, **kw)
-            except (pg.InterfaceError, pg.OperationalError) as e:
-                logger.warning(
-                    "Database Connection [InterfaceError or OperationalError]"
-                )
+            except (pg.InterfaceError, pg.OperationalError, AttributeError) as e:
+                logger.debug("Database Connection [InterfaceError or OperationalError]")
                 # print ("Idle for %s seconds" % (cls._reconnect_idle))
                 # time.sleep(cls._reconnect_idle)
                 cls._connect()
@@ -700,7 +713,7 @@ class QuestDBSqlCandlesBuilder(QuestDBSqlBuilder):
                 resample
             )
             if resample
-            else resample
+            else "1m"  # if resample is empty let's use 1 minute timeframe
         )
         _rsmpl = f"SAMPLE by {resample}" if resample else ""
 
@@ -749,6 +762,16 @@ class QuestDBConnector(DataReader):
         self._builder = builder
         self._connect()
 
+    def __getstate__(self):
+        if self._connection:
+            self._connection.close()
+            self._connection = None
+        if self._cursor:
+            self._cursor.close()
+            self._cursor = None
+        state = self.__dict__.copy()
+        return state
+
     def _connect(self):
         self._connection = pg.connect(self.connection_url, autocommit=True)
         self._cursor = self._connection.cursor()
@@ -761,7 +784,7 @@ class QuestDBConnector(DataReader):
         stop: str | None = None,
         transform: DataTransformer = DataTransformer(),
         chunksize=0,  # TODO: use self._cursor.fetchmany in this case !!!!
-        timeframe: str = "1m",
+        timeframe: str | None = "1m",
         data_type="candles_1m",
     ) -> Any:
         return self._read(
@@ -786,7 +809,7 @@ class QuestDBConnector(DataReader):
         stop: str | None,
         transform: DataTransformer,
         chunksize: int,  # TODO: use self._cursor.fetchmany in this case !!!!
-        timeframe: str,
+        timeframe: str | None,
         data_type: str,
         builder: QuestDBSqlBuilder,
     ) -> Any:
@@ -795,9 +818,11 @@ class QuestDBConnector(DataReader):
 
         self._cursor.execute(_req)  # type: ignore
         records = self._cursor.fetchall()  # TODO: for chunksize > 0 use fetchmany etc
+        if not records:
+            return None
 
         names = [d.name for d in self._cursor.description]  # type: ignore
-        transform.start_transform(data_id, names)
+        transform.start_transform(data_id, names, start=start, stop=stop)
 
         transform.process_data(records)
         return transform.collect()
@@ -811,54 +836,20 @@ class QuestDBConnector(DataReader):
     def __del__(self):
         for c in (self._cursor, self._connection):
             try:
-                logger.info("Closing connection")
+                logger.debug("Closing connection")
                 c.close()
             except:
                 pass
 
 
-class SnapshotsBuilder(DataTransformer):
-    """
-    Snapshots assembler from OB updates
-    """
-
-    def __init__(
-        self,
-        levels: int = -1,  # how many levels restore, 1 - TOB, -1 - all
-        as_frame=False,  # result is dataframe
-    ):
-        self.buffer = []
-        self.levels = levels
-        self.as_frame = as_frame
-
-    def start_transform(self, name: str, column_names: List[str]):
-        # initialize buffer / series etc
-        # let's keep restored snapshots into some buffer etc
-        self.buffer = []
-
-        # do additional init stuff here
-
-    def process_data(self, rows_data: List[List]) -> Any:
-        for r in rows_data:
-            # restore snapshots and put into buffer or series
-            pass
-
-    def collect(self) -> Any:
-        # - may be convert it to pandas DataFrame ?
-        if self.as_frame:
-            return pd.DataFrame.from_records(self.buffer)  # or custom transform
-
-        # - or just returns as plain list
-        return self.buffer
-
-
-class QuestDBSqlOrderBookBilder(QuestDBSqlBuilder):
+class QuestDBSqlOrderBookBuilder(QuestDBSqlCandlesBuilder):
     """
     Sql builder for snapshot data
     """
 
-    def get_table_name(self, data_id: str, sfx: str = "") -> str:
-        return ""
+    MAX_TIME_DELTA = pd.Timedelta("5h")
+    SNAPSHOT_DELTA = pd.Timedelta("1h")
+    MIN_DELTA = pd.Timedelta("1s")
 
     def prepare_data_sql(
         self,
@@ -868,7 +859,23 @@ class QuestDBSqlOrderBookBilder(QuestDBSqlBuilder):
         resample: str,
         data_type: str,
     ) -> str:
-        return ""
+        if not start or not end:
+            raise ValueError("Start and end dates must be provided for orderbook data!")
+        start_dt, end_dt = pd.Timestamp(start), pd.Timestamp(end)
+        delta = end_dt - start_dt
+        if delta > self.MAX_TIME_DELTA:
+            raise ValueError(
+                f"Time range is too big for orderbook data: {delta}, max allowed: {self.MAX_TIME_DELTA}"
+            )
+
+        raw_start_dt = start_dt.floor(self.SNAPSHOT_DELTA) - self.MIN_DELTA
+
+        table_name = self.get_table_name(data_id, data_type)
+        query = f"""
+SELECT * FROM {table_name}
+WHERE timestamp BETWEEN '{raw_start_dt}' AND '{end_dt}'
+"""
+        return query
 
 
 class TradeSql(QuestDBSqlCandlesBuilder):
@@ -931,7 +938,8 @@ class MultiQdbConnector(QuestDBConnector):
     _TYPE_TO_BUILDER = {
         "candles_1m": QuestDBSqlCandlesBuilder(),
         "trade": TradeSql(),
-        "orderbook": QuestDBSqlOrderBookBilder(),
+        "agg_trade": TradeSql(),
+        "orderbook": QuestDBSqlOrderBookBuilder(),
     }
 
     _TYPE_MAPPINGS = {
@@ -940,6 +948,9 @@ class MultiQdbConnector(QuestDBConnector):
         "ob": "orderbook",
         "trd": "trade",
         "td": "trade",
+        "aggTrade": "agg_trade",
+        "agg_trades": "agg_trade",
+        "aggTrades": "agg_trade",
     }
 
     def __init__(
@@ -974,9 +985,9 @@ class MultiQdbConnector(QuestDBConnector):
         start: str | None = None,
         stop: str | None = None,
         transform: DataTransformer = DataTransformer(),
-        chunksize=0,  # TODO: use self._cursor.fetchmany in this case !!!!
+        chunksize: int = 0,  # TODO: use self._cursor.fetchmany in this case !!!!
         timeframe: str | None = None,
-        data_type="candles",
+        data_type: str = "candles",
     ) -> Any:
         _mapped_data_type = self._TYPE_MAPPINGS.get(data_type, data_type)
         return self._read(

{qubx-0.1.83 → qubx-0.1.84}/src/qubx/utils/misc.py

@@ -8,10 +8,11 @@ from pathlib import Path
 
 def version() -> str:
     # - check current version
-    version = 'Dev'
-    try: 
+    version = "Dev"
+    try:
         import importlib_metadata
-        version = importlib_metadata.version('qubx')
+
+        version = importlib_metadata.version("qubx")
     except:
         pass
 
@@ -23,12 +24,7 @@ def install_pyx_recompiler_for_dev():
 
     # if version().lower() == 'dev':
     print(f" >  [{green('dev')}] {red('installing cython rebuilding hook')}")
-    pyx_install_loader([
-        'qubx.core', 
-        'qubx.ta', 
-        'qubx.data', 
-        'qubx.strategies'
-    ])
+    pyx_install_loader(["qubx.core", "qubx.ta", "qubx.data", "qubx.strategies"])
 
 
 def runtime_env():
@@ -42,29 +38,32 @@ def runtime_env():
     """
     try:
         from IPython.core.getipython import get_ipython
+
         shell = get_ipython().__class__.__name__
 
-        if shell == 'ZMQInteractiveShell':  # Jupyter notebook or qtconsole
-            return 'notebook'
-        elif shell.endswith('TerminalInteractiveShell'):  # Terminal running IPython
-            return 'shell'
+        if shell == "ZMQInteractiveShell":  # Jupyter notebook or qtconsole
+            return "notebook"
+        elif shell.endswith("TerminalInteractiveShell"):  # Terminal running IPython
+            return "shell"
         else:
-            return 'unknown'  # Other type (?)
+            return "unknown"  # Other type (?)
     except (NameError, ImportError):
-        return 'python'  # Probably standard Python interpreter
+        return "python"  # Probably standard Python interpreter
+
 
 _QUBX_FLDR = None
 
+
 def get_local_qubx_folder() -> str:
     global _QUBX_FLDR
 
     if _QUBX_FLDR is None:
-        _QUBX_FLDR = makedirs(os.getenv('QUBXSTORAGE', os.path.expanduser('~/.qubx')))
+        _QUBX_FLDR = makedirs(os.getenv("QUBXSTORAGE", os.path.expanduser("~/.qubx")))
 
     return _QUBX_FLDR
 
 
-def add_project_to_system_path(project_folder:str = '~/projects'):
+def add_project_to_system_path(project_folder: str = "~/projects"):
     """
     Add path to projects folder to system python path to be able importing any modules from project
     from test.Models.handy_utils import some_module
@@ -72,21 +71,23 @@ def add_project_to_system_path(project_folder:str = '~/projects'):
     import sys
     from os.path import expanduser, relpath
     from pathlib import Path
-    
+
     # we want to track folders with these files as separate paths
-    toml = Path('pyproject.toml')
-    src = Path('src')
-    
+    toml = Path("pyproject.toml")
+    src = Path("src")
+
     try:
         prj = Path(relpath(expanduser(project_folder)))
     except ValueError as e:
         # This error can occur on Windows if user folder and python file are on different drives
         print(f"Qube> Error during get path to projects folder:\n{e}")
     else:
-        insert_path_iff = lambda p: sys.path.insert(0, p.as_posix()) if p.as_posix() not in sys.path else None
+        insert_path_iff = lambda p: (
+            sys.path.insert(0, p.as_posix()) if p.as_posix() not in sys.path else None
+        )
         if prj.exists():
             insert_path_iff(prj)
-            
+
             for di in prj.iterdir():
                 _src = di / src
                 if (di / toml).exists():
@@ -96,11 +97,13 @@ def add_project_to_system_path(project_folder:str = '~/projects'):
                     else:
                         insert_path_iff(di)
         else:
-            print(f'Qube> Cant find {project_folder} folder for adding to python path !')
+            print(
+                f"Qube> Cant find {project_folder} folder for adding to python path !"
+            )
 
 
 def is_localhost(host):
-    return host.lower() == 'localhost' or host == '127.0.0.1'
+    return host.lower() == "localhost" or host == "127.0.0.1"
 
 
 def __wrap_with_color(code):
@@ -114,13 +117,13 @@ def __wrap_with_color(code):
 
 
 red, green, yellow, blue, magenta, cyan, white = (
-    __wrap_with_color('31'),
-    __wrap_with_color('32'),
-    __wrap_with_color('33'),
-    __wrap_with_color('34'),
-    __wrap_with_color('35'),
-    __wrap_with_color('36'),
-    __wrap_with_color('37'),
+    __wrap_with_color("31"),
+    __wrap_with_color("32"),
+    __wrap_with_color("33"),
+    __wrap_with_color("34"),
+    __wrap_with_color("35"),
+    __wrap_with_color("36"),
+    __wrap_with_color("37"),
 )
 
 
@@ -128,12 +131,13 @@ def logo():
     """
     Some fancy Qubx logo
     """
-    print(f"""
+    print(
+        f"""
 ⠀⠀⡰⡖⠒⠒⢒⢦⠀⠀   
 ⠀⢠⠃⠈⢆⣀⣎⣀⣱⡀  {red("QUBX")} | {cyan("Quantitative Backtesting Environment")} 
 ⠀⢳⠒⠒⡞⠚⡄⠀⡰⠁         (c) 2024, ver. {magenta(version().rstrip())}
 ⠀⠀⠱⣜⣀⣀⣈⣦⠃⠀⠀⠀ 
-        """ 
+        """
     )
 
 
@@ -146,9 +150,9 @@ class Struct:
     >>> print(a)
 
     Struct(x=1, y=2, z='Hello')
-    
+
     >>> Struct(a=234, b=Struct(c=222)).to_dict()
-    
+
     {'a': 234, 'b': {'c': 222}}
 
     >>> Struct({'a': 555}, a=123, b=Struct(c=222)).to_dict()
@@ -167,7 +171,7 @@ class Struct:
 
     def __initialize(self, fields, values):
         self._fields = list(fields)
-        self._meta = namedtuple('Struct', ' '.join(fields))
+        self._meta = namedtuple("Struct", " ".join(fields))
         self._inst = self._meta(*values)
 
     def fields(self) -> list:
@@ -179,7 +183,7 @@ class Struct:
     def __getattr__(self, k):
         return getattr(self._inst, k)
 
-    def __or__(self, other: Union[dict, 'Struct']):
+    def __or__(self, other: Union[dict, "Struct"]):
         if isinstance(other, dict):
             other = Struct.dict2struct(other)
         elif not isinstance(other, Struct):
@@ -195,7 +199,7 @@ class Struct:
         return self._inst.__repr__()
 
     def __setattr__(self, k, v):
-        if k not in ['_inst', '_meta', '_fields']:
+        if k not in ["_inst", "_meta", "_fields"]:
             new_vals = {**self._inst._asdict(), **{k: v}}
             self.__initialize(new_vals.keys(), new_vals.values())
         else:
@@ -220,14 +224,14 @@ class Struct:
         """
         return self.__ms2d(self)
 
-    def copy(self) -> 'Struct':
+    def copy(self) -> "Struct":
         """
         Returns copy of this structure
         """
         return Struct(self.to_dict())
 
     @staticmethod
-    def dict2struct(d: dict) -> 'Struct':
+    def dict2struct(d: dict) -> "Struct":
         """
         Convert dictionary to structure
         >>> s = dict2struct({'f_1_0': 1, 'z': {'x': 1, 'y': 2}})
@@ -249,52 +253,58 @@ class Struct:
 def makedirs(path: str, *args) -> str:
     path = os.path.expanduser(os.path.join(*[path, *args]))
     if not exists(path):
-        os.makedirs(path)
+        os.makedirs(path, exist_ok=True)
     return path
 
 
 class Stopwatch:
     """
-    Stopwatch timer for performance 
+    Stopwatch timer for performance
     """
-    starts: Dict[str|None, int] = {} 
-    counts: Dict[str|None, int] = defaultdict(lambda: 0)
-    latencies: Dict[str|None, int] = {} 
-    
+
+    starts: Dict[str | None, int] = {}
+    counts: Dict[str | None, int] = defaultdict(lambda: 0)
+    latencies: Dict[str | None, int] = {}
+
     def __new__(cls):
-        if not hasattr(cls, 'instance'):
+        if not hasattr(cls, "instance"):
             cls.instance = super(Stopwatch, cls).__new__(cls)
         return cls.instance
-    
+
     def start(self, scope: str | None):
         self.starts[scope] = time.perf_counter_ns()
         self.counts[scope] += 1
-        
-    def stop(self, scope: str|None=None) -> int | None:
+
+    def stop(self, scope: str | None = None) -> int | None:
         t = time.perf_counter_ns()
         s = self.starts.get(scope, None)
         lat = None
         if s:
             lat = t - s
             n = self.counts[scope]
-            self.latencies[scope] = (lat * (n - 1) + self.latencies.get(scope, lat)) // n
+            self.latencies[scope] = (
+                lat * (n - 1) + self.latencies.get(scope, lat)
+            ) // n
             del self.starts[scope]
         return lat
 
     def latency_sec(self, scope: str | None) -> float:
         return self.latencies.get(scope, 0) / 1e9
 
-    def watch(self, scope='global'):
+    def watch(self, scope="global"):
         def _decorator(func):
-            info = scope + '.' + func.__name__
+            info = scope + "." + func.__name__
+
             def wrapper(*args, **kwargs):
                 self.start(info)
                 output = func(*args, **kwargs)
                 self.stop(info)
                 return output
+
             return wrapper
+
         return _decorator
-    
+
     def reset(self):
         self.starts.clear()
         self.counts.clear()
@@ -307,7 +317,7 @@ class Stopwatch:
         return r
 
 
-def quotify(sx: Union[str, List[str]], quote='USDT'):
+def quotify(sx: Union[str, List[str]], quote="USDT"):
     """
     Make XXX<quote> from anything if that anything doesn't end with <quote>
     """
@@ -318,16 +328,16 @@ def quotify(sx: Union[str, List[str]], quote='USDT'):
     raise ValueError("Can't process input data !")
 
 
-def dequotify(sx: Union[str, List[str]], quote='USDT'):
+def dequotify(sx: Union[str, List[str]], quote="USDT"):
     """
     Turns XXX<quote> to XXX (reverse of quotify)
     """
     if isinstance(sx, str):
         quote = quote.upper()
-        if (s:=sx.upper()).endswith(quote):
-            s = s.split(':')[1] if ':' in s else s # remove exch: if presented
+        if (s := sx.upper()).endswith(quote):
+            s = s.split(":")[1] if ":" in s else s  # remove exch: if presented
             return s.split(quote)[0]
     elif isinstance(sx, (list, set, tuple)):
         return [dequotify(s, quote) for s in sx]
 
-    raise ValueError("Can't process input data !")
+    raise ValueError("Can't process input data !")