Qubx 0.0.1__cp311-cp311-manylinux_2_35_x86_64.whl

qubx/utils/pandas.py

@@ -0,0 +1,206 @@
+from typing import Dict, Union
+from datetime import timedelta
+import pandas as pd
+import numpy as np
+
+from numpy.lib.stride_tricks import as_strided as stride
+
+from qubx.utils.misc import Struct
+
+
+def drop_duplicated_indexes(df, keep='first'):
+    """
+    Drops duplicated indexes in dataframe/series
+    Keeps either first or last occurence (parameter keep)
+    """
+    return df[~df.index.duplicated(keep=keep)]
+
+
+def process_duplicated_indexes(data: Union[pd.DataFrame, pd.Series], ns=1) -> Union[pd.DataFrame, pd.Series]:
+    """
+    Finds duplicated indexes in frame/series and add shift (in nS) to every repeating one
+    :param data: time indexed dataframe/series
+    :param ns: shift constant in nanosec
+    :return: return dataframe with all no duplicated rows (each duplicate has own unique index)
+    """
+    values = data.index.duplicated(keep='first').astype(float)
+    values[values == 0] = np.NaN
+
+    missings = np.isnan(values)
+    cumsum = np.cumsum(~missings)
+    diff = np.diff(np.concatenate(([0.], cumsum[missings])))
+    values[missings] = -diff
+
+    # set new index (1 ms)
+    data.index = data.index.values + np.cumsum(values).astype(np.timedelta64) * ns
+    return data
+
+
+def scols(*xs, keys=None, names=None, keep='all') -> pd.DataFrame:
+    """
+    Concat dataframes/series from xs into single dataframe by axis 1
+    :param keys: keys of new dataframe (see pd.concat's keys parameter)
+    :param names: new column names or dict with replacements
+    :return: combined dataframe
+    
+    Example
+    -------
+    >>>  scols(
+            pd.DataFrame([1,2,3,4,-4], list('abcud')),
+            pd.DataFrame([111,21,31,14], list('xyzu')), 
+            pd.DataFrame([11,21,31,124], list('ertu')), 
+            pd.DataFrame([11,21,31,14], list('WERT')), 
+            names=['x', 'y', 'z', 'w'])
+    """
+    r = pd.concat((xs), axis=1, keys=keys)
+    if names:
+        if isinstance(names, (list, tuple)):
+            if len(names) == len(r.columns):
+                r.columns = names
+            else:
+                raise ValueError(
+                    f"if 'names' contains new column names it must have same length as resulting df ({len(r.columns)})")
+        elif isinstance(names, dict):
+            r = r.rename(columns=names)
+    return r
+
+
+def srows(*xs, keep='all', sort=True) -> Union[pd.DataFrame, pd.Series]:
+    """
+    Concat dataframes/series from xs into single dataframe by axis 0
+    :param sort: if true it sorts resulting dataframe by index (default)
+    :param keep: how to deal with duplicated indexes. 
+                 If set to 'all' it doesn't do anything (default). Otherwise keeps first or last occurences
+    :return: combined dataframe
+    
+    Example
+    -------
+    >>>  srows(
+            pd.DataFrame([1,2,3,4,-4], list('abcud')),
+            pd.DataFrame([111,21,31,14], list('xyzu')), 
+            pd.DataFrame([11,21,31,124], list('ertu')), 
+            pd.DataFrame([11,21,31,14], list('WERT')), 
+            sort=True, keep='last')
+    """
+    r = pd.concat((xs), axis=0)
+    r = r.sort_index() if sort else r
+    if keep != 'all':
+        r = drop_duplicated_indexes(r, keep=keep)
+    return r
+
+
+def retain_columns_and_join(data: dict, columns) -> pd.DataFrame:
+    """
+    Retains given columns from every value of data dictionary and concatenate them into single data frame
+
+    from qube.datasource import DataSource
+    from qube.analysis.tools import retain_columns_and_join
+
+    ds = DataSource('yahoo::daily')
+    data = ds.load_data(['aapl', 'msft', 'spy'], '2000-01-01', 'now')
+
+    closes = retain_columns_and_join(data, 'close')
+    hi_lo = retain_columns_and_join(data, ['high', 'low'])
+
+    :param data: dictionary with dataframes
+    :param columns: columns names need to be retained
+    :return: data frame
+    """
+    if not isinstance(data, dict):
+        raise ValueError('Data must be passed as dictionary')
+
+    return pd.concat([data[k][columns] for k in data.keys()], axis=1, keys=data.keys())
+
+
+def continuous_periods(xs, cond) -> Struct:
+    """
+    Detect continues periods on series xs based on condition cond
+    """
+    df = scols(xs, cond, keys=['_XS_', 'sig'])
+    df['block'] = (df.sig.shift(1) != df.sig).astype(int).cumsum()
+    idx_col_name = xs.index.name
+
+    blk = df[df.sig].reset_index().groupby('block')[idx_col_name].apply(np.array)
+    starts = blk.apply(lambda x: x[0])
+    ends = blk.apply(lambda x: x[-1])
+    se_info = scols(starts, ends, keys=['start', 'end'])
+    return Struct(blocks=blk.reset_index(drop=True), periods=se_info)
+
+
+def roll(df: pd.DataFrame, w: int, **kwargs):
+    """
+    Rolling window on dataframe using multiple columns
+    
+    >>> roll(pd.DataFrame(np.random.randn(10,3), index=list('ABCDEFGHIJ')), 3).apply(print)
+    
+    or alternatively 
+    
+    >>> pd.DataFrame(np.random.randn(10,3), index=list('ABCDEFGHIJ')).pipe(roll, 3).apply(lambda x: print(x[2]))
+    
+    :param df: pandas DataFrame
+    :param w: window size (only integers)
+    :return: rolling window
+    """
+    if w > len(df):
+        raise ValueError("Window size exceeds number of rows !")
+
+    v = df.values
+    d0, d1 = v.shape
+    s0, s1 = v.strides
+    a = stride(v, (d0 - (w - 1), w, d1), (s0, s0, s1))
+    rolled_df = pd.concat({
+        row: pd.DataFrame(values, columns=df.columns)
+        for row, values in zip(df.index, a)
+    })
+
+    return rolled_df.groupby(level=0, **kwargs)
+
+
+def dict_to_frame(x: dict, index_type=None, orient='index', columns=None, column_types=dict()) -> pd.DataFrame:
+    """
+    Utility for convert dictionary to indexed DataFrame
+    It's possible to pass columns names and type of index
+    """
+    y = pd.DataFrame().from_dict(x, orient=orient)
+    if index_type:
+        if index_type in ['ns', 'nano']:
+            index_type = 'M8[ns]'
+        y.index = y.index.astype(index_type)
+
+    # rename if needed
+    if columns:
+        columns = [columns] if not isinstance(columns, (list, tuple, set)) else columns
+        if len(columns) == len(y.columns):
+            y.rename(columns=dict(zip(y.columns, columns)), inplace=True)
+        else:
+            raise ValueError('dict_to_frame> columns argument must contain %d elements' % len(y.columns))
+
+    # if additional conversion is required
+    if column_types:
+        _existing_cols_conversion = {c: v for c, v in column_types.items() if c in y.columns}
+        y = y.astype(_existing_cols_conversion)
+
+    return y
+
+
+def select_column_and_join(data: Dict[str, pd.DataFrame], column: str) -> pd.DataFrame:
+    """
+    Select given column from every value of data dictionary and concatenate them into single data frame
+
+    from qube.datasource import DataSource
+    from qube.analysis.tools import retain_columns_and_join
+
+    ds = DataSource('yahoo::daily')
+    data = ds.load_data(['aapl', 'msft', 'spy'], '2000-01-01', 'now')
+
+    closes = select_column_and_join(data, 'close')
+    hi_lo = select_column_and_join(data, ['high', 'low'])
+
+    :param data: dictionary with dataframes
+    :param columns: column name need to be selected
+    :return: pandas data frame
+    """
+    if not isinstance(data, dict):
+        raise ValueError('Data must be passed as dictionary of pandas dataframes')
+
+    return pd.concat([data[k][column] for k in data.keys()], axis=1, keys=data.keys())

qubx/utils/time.py

@@ -0,0 +1,145 @@
+from datetime import datetime
+from typing import List, Optional, Union
+import numpy as np
+import re
+
+import pandas as pd
+
+UNIX_T0 = np.datetime64('1970-01-01T00:00:00')
+
+
+time_to_str = lambda t, u='us': np.datetime_as_string(t if isinstance(t, np.datetime64) else np.datetime64(t, u), unit=u)
+
+
+def convert_tf_str_td64(c_tf: str) -> np.timedelta64:
+    """
+    Convert string timeframe to timedelta64
+
+    '15Min' -> timedelta64(15, 'm') etc
+    """
+    _t = re.findall('(\d+)([A-Za-z]+)', c_tf)
+    _dt = 0
+    for g in _t:
+        unit = g[1].lower()
+        n = int(g[0])
+        u1 = unit[0]
+        u2 = unit[:2]
+        unit = u1
+
+        if u1 in ['d', 'w']:
+            unit = u1.upper()
+
+        if u1 in ['y']:
+            n = 356 * n
+            unit = 'D'
+
+        if u2 in ['ms', 'ns', 'us', 'ps']:
+            unit = u2
+
+        _dt += np.timedelta64(n, unit)
+    
+    return _dt
+
+
+def convert_seconds_to_str(seconds: int) -> str:
+    """
+    Convert seconds to string representation: 310 -> '5Min10S' etc
+    """
+    days, seconds = divmod(seconds, 86400)
+    hours, seconds = divmod(seconds, 3600)
+    minutes, seconds = divmod(seconds, 60)
+    r = ''
+    if days > 0:
+        r += '%dD' % days
+    if hours > 0:
+        r += '%dH' % hours
+    if minutes > 0:
+        r += '%dMin' % minutes
+    if seconds > 0:
+        r += '%dS' % seconds
+    return r
+
+
+def floor_t64(time: Union[np.datetime64, datetime], dt: Union[np.timedelta64, int, str]):
+    """
+    Floor timestamp by dt
+    """
+    if isinstance(dt, int):
+        dt = np.timedelta64(dt, 's')
+
+    if isinstance(dt, str):
+        dt = convert_tf_str_td64(dt)
+
+    if isinstance(time, datetime):
+        time = np.datetime64(time)
+
+    return time - (time - UNIX_T0) % dt
+
+
+def infer_series_frequency(series: Union[List, pd.DataFrame, pd.Series, pd.DatetimeIndex]) -> np.timedelta64:
+    """
+    Infer frequency of given timeseries
+
+    :param series: Series, DataFrame, DatetimeIndex or list of timestamps object
+    :return: timedelta for found frequency
+    """
+    if isinstance(series, (pd.DataFrame, pd.Series, pd.DatetimeIndex)):
+        times_index = (series if isinstance(series, pd.DatetimeIndex) else series.index).to_pydatetime()
+    elif isinstance(series, (set, list, tuple)):
+        times_index = np.array(series)
+    elif isinstance(series, np.ndarray):
+        times_index = series
+    else:
+        raise ValueError("Can't recognize input data")
+
+    if times_index.shape[0] < 2:
+        raise ValueError("Series must have at least 2 points to determ frequency")
+
+    values = np.array(sorted([(x if isinstance(x, np.timedelta64) else x.total_seconds()) for x in np.abs(np.diff(times_index))]))
+    diff = np.concatenate(([1], np.diff(values)))
+    idx = np.concatenate((np.where(diff)[0], [len(values)]))
+    freqs = dict(zip(values[idx[:-1]], np.diff(idx)))
+    return np.timedelta64(max(freqs, key=freqs.get))
+
+
+def handle_start_stop(s: Optional[str], e: Optional[str], convert=str) -> tuple:
+    """
+    Process start/stop times
+
+        handle_start_stop('2020-01-01', '2020-02-01') # 2020-01-01, 2020-02-01
+        handle_start_stop('2020-02-01', '2020-01-01') # 2020-01-01, 2020-02-01
+        handle_start_stop('2020-01-01', '1w')         # 2020-01-01, 2020-01-01 + 1week
+        handle_start_stop('1w', '2020-01-01')         # 2020-01-01 - 1week, '2020-01-01'
+        handle_start_stop('2020-01-01', '-1w')        # 2020-01-01 - 1week, 2020-01-01,
+        handle_start_stop(None, '2020-01-01')         # None, '2020-01-01'
+        handle_start_stop('2020-01-01', None)         # '2020-01-01', None 
+        handle_start_stop(None, None)                 # None, None 
+
+    """
+    def _h_time_like(x):
+        try: 
+            return pd.Timestamp(x), False
+        except:
+            try: return pd.Timedelta(x), True
+            except: pass
+        return None, None
+
+    t0, d0 = _h_time_like(s) if s else (None, False)
+    t1, d1 = _h_time_like(e) if e else (None, False)
+    converts = lambda xs: [convert(xs[0]) if xs[0] else None, convert(xs[1]) if xs[1] else None]
+
+    if not t1 and not t0: return None, None
+    
+    if d0 and d1: raise ValueError("Start and stop can't both be deltas !")
+
+    if d0:
+        if not t1: raise ValueError("First argument is delta but stop time is not defined !")
+        return converts(sorted([t1 - abs(t0), t1]))
+    if d1:
+        if not t0: raise ValueError("Second argument is delta but start time is not defined !")
+        return converts(sorted([t0, t0 + t1]))
+
+    if t0 and t1:
+        return converts(sorted([t0, t1]))
+
+    return converts([t0, t1])

qubx-0.0.1.dist-info/METADATA

@@ -0,0 +1,39 @@
+Metadata-Version: 2.1
+Name: Qubx
+Version: 0.0.1
+Summary: Qubx - quantitative trading framework
+Home-page: https://github.com/dmarienko/Qubx
+Author: Dmitry Marienko
+Author-email: dmitry@gmail.com
+Requires-Python: >=3.9,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: cython (==3.0.8)
+Requires-Dist: loguru (>=0.7.2,<0.8.0)
+Requires-Dist: ntplib (>=0.4.0,<0.5.0)
+Requires-Dist: numpy (>=1.26.3,<2.0.0)
+Requires-Dist: pyarrow (>=15.0.0,<16.0.0)
+Requires-Dist: pydantic (>=1.10.2,<2.0.0)
+Requires-Dist: pymongo (>=4.6.1,<5.0.0)
+Requires-Dist: pytest[lazyfixture] (>=7.2.0,<8.0.0)
+Requires-Dist: python-binance (>=1.0.19,<2.0.0)
+Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
+Requires-Dist: scipy (>=1.12.0,<2.0.0)
+Requires-Dist: stackprinter (>=0.2.10,<0.3.0)
+Project-URL: Repository, https://github.com/dmarienko/Qubx
+Description-Content-Type: text/markdown
+
+# Qubx
+
+### Next generation of Qube quantitative backtesting framework (QUBX)
+```          
+   /////\    
+  /////  \   
+  \\\\\  /   
+   \\\\\/    (c) 2024, by M.D.E
+```                                          
+
+

qubx-0.0.1.dist-info/RECORD

@@ -0,0 +1,27 @@
+qubx/__init__.py,sha256=eEkknShL0X-WdqY3SkF7DNUt1rUDmB10VW3kqRHUgxQ,5133
+qubx/_nb_magic.py,sha256=xKWVljqr71K6Nkv2oI_EAI7xzRLV4pSGEBp7dtpDgiI,2357
+qubx/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qubx/core/basics.py,sha256=Ki_fQbgrmTDvZQRUCzUUU5fjBcykifz8FfYIqE_jTe0,10251
+qubx/core/lookups.py,sha256=XDniSpIiC5HzPwhD_2cmWVpkL4f7VHdA5HOpvbR9vSA,6284
+qubx/core/series.cpython-311-x86_64-linux-gnu.so,sha256=B0-FN_voDNfbDFZWgrDph1Jyp8eBXwWkRAwAFuItA5c,3686656
+qubx/core/series.pxd,sha256=q1XWnq8nPX6-IP9BJDTrLKJq5Pg3eA-ugWInivn6hEE,2283
+qubx/core/series.pyx,sha256=5niSMhSEjAlLZXCs7SbceTM6CiSgIVAWRjQfLCzEu3k,25097
+qubx/core/strategy.py,sha256=T0R0mgalgpfq5qm9X5uoAg9oRwrwUei6Zx9DBxEEqrM,2342
+qubx/core/utils.cpython-311-x86_64-linux-gnu.so,sha256=rGKvoGS0Fqk8Db92swP02skH22pYp9HTk2VIhWSrJvE,324992
+qubx/core/utils.pyx,sha256=6dQ8R02bl8V3f-W3Wk9-e86D9OvDz-5-4NA_dlF_xwc,1368
+qubx/data/readers.py,sha256=6l3GDS3W43xu5slEmwTV4vB3IVmgf5Drek9wlmh1i6o,14928
+qubx/math/__init__.py,sha256=AavTKCtU7gRffG9T10Z0uv4LdI31bVvBn-L_Iv81FRk,33
+qubx/math/stats.py,sha256=LnZZFe_3_vj1yW-wcQdtOmI9t5yGkiYfLWa4kVFXkjA,1176
+qubx/ta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qubx/ta/indicators.cpython-311-x86_64-linux-gnu.so,sha256=Xg6mKakEkfgo0aYonRTHRrrVw2_LLGNe68-0y6PI7D0,1450408
+qubx/ta/indicators.pyx,sha256=P-GEYUks2lSHo6hbtUFAB7TWE1AunjLR4jIjwqPHrwU,7708
+qubx/utils/__init__.py,sha256=mYNqttT_TaTDoz3lUp0Oh4fn7w1q7Mg_d2gmXugQnrw,283
+qubx/utils/_pyxreloader.py,sha256=_YHcM9uya_6Ni-eSSFBPOrkk_0J4iEMtL_2Y8YHUfoE,11894
+qubx/utils/charting/mpl_helpers.py,sha256=nfbyG2lU_cv64CHQu1m4spPeZNSmey-E6NawOcQeR1Q,5937
+qubx/utils/marketdata/binance.py,sha256=cZkCrgSmPYxUE-rxzMnCtP0oLIqj1ctOvui1C4X9Obo,9162
+qubx/utils/misc.py,sha256=thfl1KP6Zv-ci1JFdtOEMO84qZ8DWVZNXpBD7MY57Xg,6908
+qubx/utils/pandas.py,sha256=psgDABGe76Bik5up012xg_JYq0LiALawyXGzw2Y0Rks,7281
+qubx/utils/time.py,sha256=cklczM8-N5S6NMUHzW176v08QKp_9zgGobqVPXfnIeE,4604
+qubx-0.0.1.dist-info/METADATA,sha256=YcSydQX7TVBGegU6jqfGYlfTLsHrnz4Whb_mOeR-nVo,1292
+qubx-0.0.1.dist-info/WHEEL,sha256=MLOa6LysROdjgj4FVxsHitAnIh8Be2D_c9ZSBHKrz2M,110
+qubx-0.0.1.dist-info/RECORD,,

qubx-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: false
+Tag: cp311-cp311-manylinux_2_35_x86_64