Qubx 0.0.1__cp311-cp311-manylinux_2_35_x86_64.whl

qubx/utils/charting/mpl_helpers.py

@@ -0,0 +1,182 @@
+"""
+   Misc graphics handy utilitites to be used in interactive analysis
+"""
+import numpy as np
+import pandas as pd
+import statsmodels.tsa.stattools as st
+import matplotlib
+import matplotlib.pyplot as plt
+from cycler import cycler
+
+
+DARK_MATLPLOT_THEME = [
+    ('backend', 'module://matplotlib_inline.backend_inline'),
+    ('interactive', True),
+    ('lines.color', '#5050f0'),
+    ('text.color', '#d0d0d0'),
+    ('axes.facecolor', '#000000'),
+    ('axes.edgecolor', '#404040'),
+    ('axes.grid', True),
+    ('axes.labelsize', 'large'),
+    ('axes.labelcolor', 'green'),
+    ('axes.prop_cycle', cycler('color', ['#08F7FE', '#00ff41', '#FE53BB', '#F5D300', '#449AcD', 'g',
+                                         '#f62841', 'y', '#088487', '#E24A33', '#f01010'])),
+    ('legend.fontsize', 'small'),
+    ('legend.fancybox', False),
+    ('legend.edgecolor', '#305030'),
+    ('legend.shadow', False),
+    ('lines.antialiased', True),
+    ('lines.linewidth', 0.8),  # reduced line width
+    ('patch.linewidth', 0.5),
+    ('patch.antialiased', True),
+    ('xtick.color', '#909090'),
+    ('ytick.color', '#909090'),
+    ('xtick.labelsize', 'large'),
+    ('ytick.labelsize', 'large'),
+    ('grid.color', '#404040'),
+    ('grid.linestyle', '--'),
+    ('grid.linewidth', 0.5),
+    ('grid.alpha', 0.8),
+    ('figure.figsize', [12.0, 5.0]),
+    ('figure.dpi', 80.0),
+    ('figure.facecolor', '#050505'),
+    ('figure.edgecolor', (1, 1, 1, 0)),
+    ('figure.subplot.bottom', 0.125),
+    ('savefig.facecolor', '#000000'),
+]
+
+LIGHT_MATPLOT_THEME = [
+    ('backend', 'module://matplotlib_inline.backend_inline'),
+    ('interactive', True),
+    ('lines.color', '#101010'),
+    ('text.color', '#303030'),
+    ('lines.antialiased', True),
+    ('lines.linewidth', 1),
+    ('patch.linewidth', 0.5),
+    ('patch.facecolor', '#348ABD'),
+    ('patch.edgecolor', '#eeeeee'),
+    ('patch.antialiased', True),
+    ('axes.facecolor', '#fafafa'),
+    ('axes.edgecolor', '#d0d0d0'),
+    ('axes.linewidth', 1),
+    ('axes.titlesize', 'x-large'),
+    ('axes.labelsize', 'large'),
+    ('axes.labelcolor', '#555555'),
+    ('axes.axisbelow', True),
+    ('axes.grid', True),
+    ('axes.prop_cycle', cycler('color', ['#6792E0', '#27ae60', '#c44e52', '#975CC3', '#ff914d', '#77BEDB',
+                                         '#303030', '#4168B7', '#93B851', '#e74c3c', '#bc89e0', '#ff711a',
+                                         '#3498db', '#6C7A89'])),
+    ('legend.fontsize', 'small'),
+    ('legend.fancybox', False),
+    ('xtick.color', '#707070'),
+    ('ytick.color', '#707070'),
+    ('grid.color', '#606060'),
+    ('grid.linestyle', '--'),
+    ('grid.linewidth', 0.5),
+    ('grid.alpha', 0.3),
+    ('figure.figsize', [8.0, 5.0]),
+    ('figure.dpi', 80.0),
+    ('figure.facecolor', '#ffffff'),
+    ('figure.edgecolor', '#ffffff'),
+    ('figure.subplot.bottom', 0.1)
+]
+
+
+def fig(w=16, h=5, dpi=96, facecolor=None, edgecolor=None, num=None):
+    """
+    Simple helper for creating figure
+    """
+    return plt.figure(num=num, figsize=(w, h), dpi=dpi, facecolor=facecolor, edgecolor=edgecolor)
+
+
+def subplot(shape, loc, rowspan=2, colspan=1):
+    """
+    Some handy grid splitting for plots. Example for 2x2:
+    
+    >>> subplot(22, 1); plt.plot([-1,2,-3])
+    >>> subplot(22, 2); plt.plot([1,2,3])
+    >>> subplot(22, 3); plt.plot([1,2,3])
+    >>> subplot(22, 4); plt.plot([3,-2,1])
+
+    same as following
+
+    >>> subplot((2,2), (0,0)); plt.plot([-1,2,-3])
+    >>> subplot((2,2), (0,1)); plt.plot([1,2,3])
+    >>> subplot((2,2), (1,0)); plt.plot([1,2,3])
+    >>> subplot((2,2), (1,1)); plt.plot([3,-2,1])
+
+    :param shape: scalar (like matlab subplot) or tuple
+    :param loc: scalar (like matlab subplot) or tuple
+    :param rowspan: rows spanned
+    :param colspan: columns spanned
+    """
+    isscalar = lambda x: not isinstance(x, (list, tuple, dict, np.ndarray))
+
+    if isscalar(shape):
+        if 0 < shape < 100:
+            shape = (max(shape // 10, 1), max(shape % 10, 1))
+        else:
+            raise ValueError("Wrong scalar value for shape. It should be in range (1...99)")
+
+    if isscalar(loc):
+        nm = max(shape[0], 1) * max(shape[1], 1)
+        if 0 < loc <= nm:
+            x = (loc - 1) // shape[1]
+            y = loc - 1 - shape[1] * x
+            loc = (x, y)
+        else:
+            raise ValueError("Wrong scalar value for location. It should be in range (1...%d)" % nm)
+
+    return plt.subplot2grid(shape, loc=loc, rowspan=rowspan, colspan=colspan)
+
+
+def sbp(shape, loc, r=1, c=1):
+    """
+    Just shortcut for subplot(...) function
+
+    :param shape: scalar (like matlab subplot) or tuple
+    :param loc: scalar (like matlab subplot) or tuple
+    :param r: rows spanned
+    :param c: columns spanned
+    :return:
+    """
+    return subplot(shape, loc, rowspan=r, colspan=c)
+
+
+def vline(ax, x, c, lw=1, ls='--'):
+    x = pd.to_datetime(x) if isinstance(x, str) else x
+    if not isinstance(ax, (list, tuple)):
+        ax = [ax]
+    for a in ax:
+        a.axvline(x, 0, 1, c=c, lw=1, linestyle=ls)
+
+
+def hline(*zs, mirror=True):
+    [plt.axhline(z, ls='--', c='r', lw=0.5) for z in zs]
+    if mirror:
+        [plt.axhline(-z, ls='--', c='r', lw=0.5) for z in zs]
+
+
+def ellips(ax, x, y, c='r', r=2.5, lw=2, ls='-'):
+    """
+    Draw ellips annotation on specified plot at (x,y) point
+    """
+    from matplotlib.patches import Ellipse
+    x = pd.to_datetime(x) if isinstance(x, str) else x
+    w, h = (r, r) if np.isscalar(r) else (r[0], r[1])
+    ax.add_artist(Ellipse(xy=[x, y], width=w, height=h, angle=0, fill=False, color=c, lw=lw, ls=ls))
+
+
+def set_mpl_theme(theme: str):
+    import plotly.io as pio
+
+    if 'dark' in theme.lower():
+        pio.templates.default = "plotly_dark"
+        for (k, v) in DARK_MATLPLOT_THEME:
+            matplotlib.rcParams[k] = v
+
+    elif 'light' in theme.lower():
+        pio.templates.default = "plotly_white"
+        for (k, v) in LIGHT_MATPLOT_THEME:
+            matplotlib.rcParams[k] = v

qubx/utils/marketdata/binance.py

@@ -0,0 +1,212 @@
+import numpy as np
+import pandas as pd
+from os.path import exists, join, split, basename
+# from dateutil import parser
+from tqdm.notebook import tqdm
+from typing import Any, Callable, Dict, List
+from binance.client import Client, HistoricalKlinesType, BinanceAPIException
+import requests
+
+from qubx import logger
+from qubx.utils.misc import makedirs, get_local_qubx_folder
+
+DEFALT_LOCAL_FILE_STORAGE = makedirs(get_local_qubx_folder(), 'data/export/binance_trades/')
+
+_DEFAULT_MARKET_DATA_DB = 'md'
+BINANCE_DATA_STORAGE = "https://s3-ap-northeast-1.amazonaws.com"
+BINANCE_DATA_URL = "https://data.binance.vision/"
+
+    
+def get_binance_symbol_info_for_type(market_types: List[str]) -> Dict[str, Dict[str, Any]]:
+    """
+    Get list of all symbols from binance for given list of market types:
+    possible types are: SPOT, FUTURES, COINSFUTURES
+    
+    >>> get_binance_symbol_info_for_type('FUTURES')
+    
+    :param market_type: SPOT, FUTURES (UM) or COINSFUTURES (CM)
+    """
+    client = Client()
+    infos = {}
+    for market_type in (market_types if not isinstance(market_types, str) else [market_types]):
+        if market_type in ['FUTURES', 'UM']:
+            infos['binance.um'] = client.futures_exchange_info()
+
+        elif market_type in ['COINSFUTURES', 'CM']:
+            infos['binance.cm'] = client.futures_coin_exchange_info()
+
+        elif market_type == 'SPOT':
+            infos['binance'] = client.get_exchange_info()
+        else:
+            raise ValueError("Only 'FUTURES | UM', 'COINSFUTURES | CM' or 'SPOT' are supported for market_type")
+
+    return infos
+
+            
+def fetch_file(url, local_file_storage, chunk_size=1024*1024):
+    """
+    Load file from url and store it to specified storage
+    """
+    file = split(url)[-1]
+    response = requests.get(url, stream=True)
+    with open(join(local_file_storage, file), "wb") as handle:
+        for data in tqdm(response.iter_content(chunk_size=chunk_size)):
+            handle.write(data)
+
+
+def get_trades_files(symbol: str, instr_type: str, instr_subtype: str):
+    """
+    Get list of trades files for specified instrument from Binance datastorage
+    """
+    if instr_type.lower() == 'spot':
+        instr_subtype = ''
+    filter_str =  join("data", instr_type.lower(), instr_subtype.lower(), "monthly", "trades", symbol.upper())
+    pg = requests.get(f"{BINANCE_DATA_STORAGE}/data.binance.vision?prefix={filter_str}/")
+    info = pd.read_xml(pg.text)
+    return [k for k in info.Key.dropna() if k.endswith('.zip')]
+
+
+def load_trades_for(symbol, instr_type='futures', instr_subtype='um', local_file_storage=DEFALT_LOCAL_FILE_STORAGE):
+    """
+    Load trades from Binance data storage
+    >>> load_trades_for('ETHUSDT', 'futures', 'um')
+    """
+    local_file_storage = makedirs(local_file_storage)
+
+    f_list = get_trades_files(symbol, instr_type, instr_subtype)
+    for r_file in tqdm(f_list):
+        dest_dir = join(local_file_storage, symbol.upper())
+        dest_file = join(dest_dir, basename(r_file))
+        if not exists(dest_file):
+            fetch_file(join(BINANCE_DATA_URL, r_file), dest_dir)
+        else:
+            logger.info(f"{dest_file} already loaded, skipping ...")
+
+
+# class BinanceHist:
+#     START_SPOT_HIST = pd.Timestamp('2017-01-01')
+#     START_FUT_HIST = pd.Timestamp('2019-09-08')
+    
+#     def __init__(self, api_key, secret_key):
+#         self.client = Client(api_key=api_key, api_secret=secret_key)
+    
+#     @staticmethod
+#     def from_env(path):
+#         if exists(path):
+#             return BinanceHist(**get_env_data_as_dict(path))
+#         else:
+#             raise ValueError(f"Can't find env file at {path}")
+    
+#     @staticmethod
+#     def _t2s(time):
+#         _t = pd.Timestamp(time) if not isinstance(time, pd.Timestamp) else time
+#         return _t.strftime('%d %b %Y %H:%M:%S')
+    
+#     def load_hist_spot_data(self, symbol, timeframe, start: pd.Timestamp, stop: pd.Timestamp, step='4W', timeout_sec=2):
+#         return self.load_hist_data(symbol, timeframe, start, stop, HistoricalKlinesType.SPOT, step, timeout_sec)
+    
+#     def load_hist_futures_data(self, symbol, timeframe, start: pd.Timestamp, stop: pd.Timestamp, step='4W', timeout_sec=2):
+#         return self.load_hist_data(symbol, timeframe, start, stop, HistoricalKlinesType.FUTURES, step, timeout_sec)
+
+#     def update_hist_data(self, symbol, stype, timeframe, exchange_id, drop_prev=False, step='4W', timeout_sec=2):
+#         """
+#         Update loaded data in z db:
+        
+#         >>> bh = BinanceHist.from_env('.env')
+#         >>> bh.update_hist_data('BTCUSDT', 'FUTURES', '1Min', 'BINANCEF')
+#         >>> bh.update_hist_data('BTCUSDT', 'SPOT', '1Min', 'BINANCE')
+#         """
+#         if isinstance(symbol, (tuple, list)):
+#             for s in symbol:
+#                 print(f"Working on {symbol.index(s)}th from {len(symbol)} symbols...")
+#                 self.update_hist_data(s, stype, timeframe, exchange_id, drop_prev=drop_prev, step=step, timeout_sec=timeout_sec)
+#             return
+                
+#         klt = {
+#             'futures': [HistoricalKlinesType.FUTURES, BinanceHist.START_FUT_HIST],
+#             'spot':    [HistoricalKlinesType.SPOT, BinanceHist.START_SPOT_HIST]
+#         }.get(stype.lower()) 
+        
+#         if klt is None:
+#             raise ValueError(f"Unknown instrument type '{stype}' !")
+            
+#         tD = pd.Timedelta(timeframe)
+#         now = self._t2s(pd.Timestamp(datetime.datetime.now(pytz.UTC).replace(second=0)) - tD)
+        
+#         path = f'm1/{exchange_id}:{symbol}'
+#         if drop_prev:
+#             print(f' > Deleting data at {path} ...')
+#             z_del(path, dbname=_DEFAULT_MARKET_DATA_DB)
+        
+#         mc = MongoController(dbname=_DEFAULT_MARKET_DATA_DB)
+        
+#         hist = z_ld(path, dbname=_DEFAULT_MARKET_DATA_DB)
+#         if hist is None:
+#             last_known_date = klt[1]
+#         else:   
+#             last_known_date = hist.index[-1]
+            
+#             # 're-serialize' data to be accessible through gridfs
+#             if mc.get_count(path) == 0:
+#                 z_save(path, hist, is_serialize=False, dbname=_DEFAULT_MARKET_DATA_DB)
+
+#         s_time = last_known_date.round(tD)
+            
+#         # pull up recent data
+#         def __cb(data):
+#             # print(">>>>>> new data: ", len(data))
+#             mc.append_data(path, data)
+            
+#         self.load_hist_data(symbol, timeframe, s_time, now, klt[0], step=step, timeout_sec=timeout_sec, new_data_callback=__cb)
+#         mc.close()
+        
+#         # drop _id (after update through MongoController)
+#         pdata = z_ld(path, dbname=_DEFAULT_MARKET_DATA_DB)
+#         if pdata is not None:
+#             pdata = pdata.drop(columns='_id')
+#         z_save(path, pdata, dbname=_DEFAULT_MARKET_DATA_DB)
+    
+#     def load_hist_data(self, symbol, timeframe, start: pd.Timestamp, stop: pd.Timestamp, ktype, step='4W', timeout_sec=2,
+#                        new_data_callback: Callable[[pd.DataFrame], None]=None):
+#         start = pd.Timestamp(start) if not isinstance(start, pd.Timestamp) else start
+#         stop = pd.Timestamp(stop) if not isinstance(stop, pd.Timestamp) else stop
+#         df = pd.DataFrame()
+        
+#         _tf_str = timeframe[:2].lower()
+#         tD = pd.Timedelta(timeframe)
+#         now = self._t2s(stop)
+#         tlr = pd.DatetimeIndex([start]).append(pd.date_range(start, now, freq=step).append(pd.DatetimeIndex([now])))
+        
+#         print(f' >> Loading {green(symbol)} {yellow(timeframe)} for [{red(start)}  -> {red(now)}]')
+#         s = tlr[0]
+#         for e in tqdm(tlr[1:]):
+#             if s + tD < e:
+#                 _start, _stop = self._t2s(s + tD), self._t2s(e)
+#                 # print(_start, _stop)
+#                 chunk = None
+#                 nerr = 0
+#                 while nerr < 3:
+#                     try:
+#                         chunk = self.client.get_historical_klines(symbol, _tf_str, _start, _stop, klines_type=ktype, limit=1000)
+#                         nerr = 100
+#                     except BinanceAPIException as a:
+#                         print('.', end='')
+#                         break
+#                     except Exception as err:
+#                         nerr +=1
+#                         print(red(str(err)))
+#                         time.sleep(10)
+
+#                 if chunk:
+#                     data = pd.DataFrame(chunk, columns = ['timestamp', 'open', 'high', 'low', 'close', 'volume', 'close_time', 'quote_av', 'trades', 'tb_base_av', 'tb_quote_av', 'ignore' ])
+#                     data.index = pd.to_datetime(data['timestamp'].rename('time'), unit='ms')
+#                     data = data.drop(columns=['timestamp', 'close_time', 'quote_av', 'trades', 'tb_base_av', 'tb_quote_av', 'ignore' ]).astype(float)
+#                     df = df.append(data)
+#                     # callback on new data
+#                     if new_data_callback is not None:
+#                         new_data_callback(data)
+                        
+#                 s = e
+#                 time.sleep(timeout_sec)
+#         return df
+    

qubx/utils/misc.py

@@ -0,0 +1,234 @@
+import glob, os
+from collections import OrderedDict, namedtuple
+from os.path import basename, exists, dirname, join, expanduser
+from typing import Optional, Union
+from pathlib import Path
+
+
+def version() -> str:
+    # - check current version
+    version = 'Dev'
+    try: 
+        import importlib_metadata
+        version = importlib_metadata.version('qube2')
+    except:
+        pass
+
+    return version
+
+
+from ._pyxreloader import pyx_install_loader
+
+def install_pyx_recompiler_for_dev():
+    if version().lower() == 'dev':
+        print(f" >  [{green('dev')}] {red('installed cython rebuilding hook')}")
+        pyx_install_loader(['qubx.core', 'qubx.ta', 'qubx.data', 'qubx.strategies'])
+
+
+def runtime_env():
+    """
+    Check what environment this script is being run under
+    :return: environment name, possible values:
+             - 'notebook' jupyter notebook
+             - 'shell' any interactive shell (ipython, PyCharm's console etc)
+             - 'python' standard python interpreter
+             - 'unknown' can't recognize environment
+    """
+    try:
+        from IPython 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'
+        else:
+            return 'unknown'  # Other type (?)
+    except (NameError, ImportError):
+        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')))
+
+    return _QUBX_FLDR
+
+
+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
+    """
+    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')
+    
+    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
+        if prj.exists():
+            insert_path_iff(prj)
+            
+            for di in prj.iterdir():
+                _src = di / src
+                if (di / toml).exists():
+                    # when we have src/
+                    if _src.exists() and _src.is_dir():
+                        insert_path_iff(_src)
+                    else:
+                        insert_path_iff(di)
+        else:
+            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'
+
+
+def __wrap_with_color(code):
+    def inner(text, bold=False):
+        c = code
+        if bold:
+            c = "1;%s" % c
+        return "\033[%sm%s\033[0m" % (c, text)
+
+    return inner
+
+
+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'),
+)
+
+
+class Struct:
+    """
+    Dynamic structure (similar to matlab's struct it allows to add new properties dynamically)
+
+    >>> a = Struct(x=1, y=2)
+    >>> a.z = 'Hello'
+    >>> 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()
+
+    {'a': 123, 'b': {'c': 222}}
+    """
+
+    def __init__(self, *args, **kwargs):
+        _odw = OrderedDict(**kwargs)
+        if args:
+            if isinstance(args[0], dict):
+                _odw = OrderedDict(Struct.dict2struct(args[0]).to_dict()) | _odw
+            elif isinstance(args[0], Struct):
+                _odw = args[0].to_dict() | _odw
+        self.__initialize(_odw.keys(), _odw.values())
+
+    def __initialize(self, fields, values):
+        self._fields = list(fields)
+        self._meta = namedtuple('Struct', ' '.join(fields))
+        self._inst = self._meta(*values)
+
+    def fields(self) -> list:
+        return self._fields
+
+    def __getitem__(self, idx: int):
+        return getattr(self._inst, self._fields[idx])
+
+    def __getattr__(self, k):
+        return getattr(self._inst, k)
+
+    def __or__(self, other: Union[dict, 'Struct']):
+        if isinstance(other, dict):
+            other = Struct.dict2struct(other)
+        elif not isinstance(other, Struct):
+            raise ValueError(f"Can't union with object of {type(other)} type ")
+        for f in other.fields():
+            self.__setattr__(f, other.__getattr__(f))
+        return self
+
+    def __dir__(self):
+        return self._fields
+
+    def __repr__(self):
+        return self._inst.__repr__()
+
+    def __setattr__(self, k, v):
+        if k not in ['_inst', '_meta', '_fields']:
+            new_vals = {**self._inst._asdict(), **{k: v}}
+            self.__initialize(new_vals.keys(), new_vals.values())
+        else:
+            super().__setattr__(k, v)
+
+    def __getstate__(self):
+        return self._inst._asdict()
+
+    def __setstate__(self, state):
+        self.__init__(**state)
+
+    def __ms2d(self, m) -> dict:
+        r = {}
+        for f in m._fields:
+            v = m.__getattr__(f)
+            r[f] = self.__ms2d(v) if isinstance(v, Struct) else v
+        return r
+
+    def to_dict(self) -> dict:
+        """
+        Return this structure as dictionary
+        """
+        return self.__ms2d(self)
+
+    def copy(self) -> 'Struct':
+        """
+        Returns copy of this structure
+        """
+        return Struct(self.to_dict())
+
+    @staticmethod
+    def dict2struct(d: dict) -> 'Struct':
+        """
+        Convert dictionary to structure
+        >>> s = dict2struct({'f_1_0': 1, 'z': {'x': 1, 'y': 2}})
+        >>> print(s.z.x)
+        1
+        """
+        m = Struct()
+        for k, v in d.items():
+            # skip if key is not valid identifier
+            if not k.isidentifier():
+                print(f"Struct> {k} doesn't look like as identifier - skip it")
+                continue
+            if isinstance(v, dict):
+                v = Struct.dict2struct(v)
+            m.__setattr__(k, v)
+        return m
+
+
+def makedirs(path: str, *args) -> str:
+    path = os.path.expanduser(os.path.join(*[path, *args]))
+    if not exists(path):
+        os.makedirs(path)
+    return path