Qubx 0.5.7__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/data/tardis.py

@@ -0,0 +1,100 @@
+from dataclasses import field
+from os.path import exists, expanduser
+from pathlib import Path
+from typing import Any, Iterable
+
+import pandas as pd
+from pyarrow import csv
+
+from qubx.utils.time import handle_start_stop, infer_series_frequency
+
+from .readers import CsvStorageDataReader, DataReader, DataTransformer, _recognize_t
+
+TARDIS_EXCHANGE_MAPPERS = {
+    "bitfinex.f": "bitfinex-derivatives",
+    "binance.um": "binance-futures",
+}
+
+
+class TardisCsvDataReader(DataReader):
+    def __init__(self, path: str | Path) -> None:
+        _path = expanduser(path)
+        if not exists(_path):
+            raise ValueError(f"Folder is not found at {path}")
+        self.path = Path(_path)
+
+    def get_names(self, exchange: str | None = None, data_type: str | None = None) -> list[str]:
+        symbols = []
+        exchanges = [exchange] if exchange else self.get_exchanges()
+        for exchange in exchanges:
+            exchange_path = Path(self.path) / exchange
+            if not exists(exchange_path):
+                raise ValueError(f"Exchange is not found at {exchange_path}")
+            data_types = [data_type] if data_type else self.get_data_types(exchange)
+            for data_type in data_types:
+                data_type_path = exchange_path / data_type
+                if not exists(data_type_path):
+                    return []
+                symbols += self._get_symbols(data_type_path)
+        return symbols
+
+    def read(
+        self,
+        data_id: str,
+        start: str | None = None,
+        stop: str | None = None,
+        transform: DataTransformer = DataTransformer(),
+        chunksize=0,
+        timeframe=None,
+        data_type="trades",
+    ) -> Iterable | Any:
+        if chunksize > 0:
+            raise NotImplementedError("Chunksize is not supported for TardisCsvDataReader")
+        exchange, symbol = data_id.split(":")
+        _exchange = exchange.lower()
+        _exchange = TARDIS_EXCHANGE_MAPPERS.get(_exchange, _exchange)
+        t_0, t_1 = handle_start_stop(start, stop, lambda x: pd.Timestamp(x).date().isoformat())
+        _path = self.path / _exchange / data_type
+        if not _path.exists():
+            raise ValueError(f"Data type is not found at {_path}")
+        _files = sorted(_path.glob(f"*_{symbol}.csv.gz"))
+        if not _files:
+            return None
+        _dates = [file.stem.split("_")[0] for file in _files]
+        if t_0 is None:
+            t_0 = _dates[0]
+        if t_1 is None:
+            t_1 = _dates[-1]
+        _filt_files = [file for file in _files if t_0 <= file.stem.split("_")[0] <= t_1]
+
+        tables = []
+        fieldnames = None
+        for f_path in _filt_files:
+            table = csv.read_csv(
+                f_path,
+                parse_options=csv.ParseOptions(ignore_empty_lines=True),
+            )
+            if not fieldnames:
+                fieldnames = table.column_names
+            tables.append(table.to_pandas())
+
+        transform.start_transform(data_id, fieldnames, start=start, stop=stop)
+        raw_data = pd.concat(tables).to_numpy()
+        transform.process_data(raw_data)
+
+        return transform.collect()
+
+    def get_exchanges(self) -> list[str]:
+        return [exchange.name for exchange in self.path.iterdir() if exchange.is_dir()]
+
+    def get_data_types(self, exchange: str) -> list[str]:
+        exchange_path = Path(self.path) / exchange
+        return [data_type.name for data_type in exchange_path.iterdir() if data_type.is_dir()]
+
+    def _get_symbols(self, data_type_path: Path) -> list[str]:
+        symbols = set()
+        for file in data_type_path.glob("*.gz"):
+            parts = file.stem.replace(".csv", "").split("_")
+            if len(parts) == 2:
+                symbols.add(parts[1])
+        return list(symbols)

qubx/gathering/simplest.py

@@ -0,0 +1,88 @@
+from qubx import logger
+from qubx.core.basics import Deal, Instrument, TargetPosition
+from qubx.core.interfaces import IPositionGathering, IStrategyContext
+
+
+class SimplePositionGatherer(IPositionGathering):
+    """
+    Default implementation of positions gathering by single orders through strategy context
+    """
+
+    entry_order_id: str | None = None
+
+    def _cncl_order(self, ctx: IStrategyContext, instrument: Instrument) -> None:
+        if self.entry_order_id:
+            logger.debug(
+                f"  [<y>{self.__class__.__name__}</y>(<g>{instrument}</g>)] :: Cancelling previous entry order <red>{self.entry_order_id}</red>"
+            )
+            try:
+                ctx.cancel_order(self.entry_order_id)
+            except Exception as e:
+                logger.error(f"Cancelling entry order failed: {str(e)}")
+            self.entry_order_id = None
+
+    def alter_position_size(self, ctx: IStrategyContext, target: TargetPosition) -> float:
+        #  Here is default inplementation:
+        #  just trade it through the strategy context by using market (or limit) orders.
+        #  but in general it may have complex logic for position adjustment
+        instrument, new_size, at_price = target.instrument, target.target_position_size, target.price
+        current_position = ctx.positions[instrument].quantity
+        to_trade = new_size - current_position
+
+        # - first cancel previous entry order if exists
+        self._cncl_order(ctx, instrument)
+
+        if abs(to_trade) < instrument.min_size:
+            if current_position != 0:
+                logger.debug(
+                    f"  [<y>{self.__class__.__name__}</y>(<g>{instrument}</g>)] :: Unable change position from {current_position} to {new_size} : too small difference"
+                )
+        else:
+            # - check how it should be traded: market or limit or stop order
+            opts = {}
+            _is_stop_or_limit = False
+            if at_price:
+                # - we already havbe position but it's requested to change at a specific price
+                if abs(current_position) > instrument.min_size:
+                    logger.debug(
+                        f"  [<y>{self.__class__.__name__}</y>(<g>{instrument}</g>)] :: Attempt to change current position {current_position} to {new_size} at {at_price} !"
+                    )
+
+                quote = ctx.quote(instrument)
+                assert quote is not None
+                if (to_trade > 0 and at_price > quote.ask) or (to_trade < 0 and at_price < quote.bid):
+                    opts["stop_type"] = "market"
+                    _is_stop_or_limit = True
+
+                if (to_trade > 0 and at_price <= quote.bid) or (to_trade < 0 and at_price >= quote.ask):
+                    _is_stop_or_limit = True
+
+            r = ctx.trade(instrument, to_trade, at_price, **opts)
+            if _is_stop_or_limit:
+                self.entry_order_id = r.id
+                logger.debug(
+                    f"  [<y>{self.__class__.__name__}</y>(<g>{instrument}</g>)] :: Position may be adjusted from {current_position} to {new_size} at {at_price} : {r}"
+                )
+            else:
+                self.entry_order_id = None
+                logger.debug(
+                    f"  [<y>{self.__class__.__name__}</y>(<g>{instrument}</g>)] :: Position is adjusted from {current_position} to {new_size} : {r}"
+                )
+
+            current_position = new_size
+            # - TODO: need to check how fast position is being updated on live
+            # current_position = ctx.positions[instrument].quantity
+
+        return current_position
+
+    def on_execution_report(self, ctx: IStrategyContext, instrument: Instrument, deal: Deal):
+        if deal.order_id == self.entry_order_id:
+            self.entry_order_id = None
+
+
+class SplittedOrdersPositionGatherer(IPositionGathering):
+    """
+    Gather position by splitting order into smaller parts randomly
+    """
+
+    pass

qubx/math/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ["compare_to_norm", "percentile_rank", "kde"]
+
+from .stats import compare_to_norm, kde, percentile_rank

qubx/math/stats.py

@@ -0,0 +1,129 @@
+import numpy as np
+import pandas as pd
+import statsmodels.api as sm
+from statsmodels.tsa.stattools import coint
+
+from qubx.utils import sbp
+
+
+def percentile_rank(x: np.ndarray, v, pctls=np.arange(1, 101)):
+    """
+    Find percentile rank of value v
+    :param x: values array
+    :param v: vakue to be ranked
+    :param pctls: percentiles
+    :return: rank
+
+    >>> percentile_rank(np.random.randn(1000), 1.69)
+    >>> 95
+    >>> percentile_rank(np.random.randn(1000), 1.69, [10,50,100])
+    >>> 2
+    """
+    return np.argmax(np.sign(np.append(np.percentile(x, pctls), np.inf) - v))
+
+
+def compare_to_norm(xs, xranges=None):
+    """
+    Compare distribution from xs against normal using estimated mean and std
+    """
+    import matplotlib.pyplot as plt
+    import scipy.stats as stats
+    import seaborn as sns
+
+    _m, _s = np.mean(xs), np.std(xs)
+    fit = stats.norm.pdf(sorted(xs), _m, _s)
+
+    sbp(12, 1)
+    plt.plot(sorted(xs), fit, "r--", lw=2, label="N(%.2f, %.2f)" % (_m, _s))
+    plt.legend(loc="upper right")
+
+    sns.kdeplot(xs, color="g", label="Data", fill=True)
+    if xranges is not None and len(xranges) > 1:
+        plt.xlim(xranges)
+    plt.legend(loc="upper right")
+
+    sbp(12, 2)
+    stats.probplot(xs, dist="norm", sparams=(_m, _s), plot=plt)
+
+
+def kde(array, cut_down=True, bw_method="scott"):
+    """
+    Kernel dense estimation
+    """
+    from scipy.stats import gaussian_kde
+
+    if cut_down:
+        bins, counts = np.unique(array, return_counts=True)
+        f_mean = counts.mean()
+        f_above_mean = bins[counts > f_mean]
+        if len(f_above_mean) > 0:
+            bounds = [f_above_mean.min(), f_above_mean.max()]
+            array = array[np.bitwise_and(bounds[0] < array, array < bounds[1])]
+
+    return gaussian_kde(array, bw_method=bw_method)
+
+
+def hurst(series: np.ndarray, max_lag: int = 20) -> float:
+    """
+    Calculate the Hurst exponent to determine the long-term memory of a time series.
+
+    The Hurst exponent (H) is a measure that helps identify:
+    - Random Walk (H ≈ 0.5): Each step is independent of past values
+    - Trending/Persistent (H > 0.5): Positive values tend to be followed by positive values
+    - Mean Reverting/Anti-persistent (H < 0.5): Positive values tend to be followed by negative values
+
+    The calculation uses the relationship between the range of the data and the time lag,
+    specifically examining how the variance of price differences scales with increasing lags.
+
+    Parameters
+    ----------
+    series : np.ndarray
+        Input time series data (typically price or returns)
+    max_lag : int, optional
+        Maximum lag to consider in calculation, by default 20
+
+    Returns
+    -------
+    float
+        Hurst exponent value between 0 and 1
+
+    Notes
+    -----
+    - Values very close to 0 or 1 may indicate issues with the data
+    - Requires sufficient data points for reliable estimation
+    - Implementation uses variance scaling method
+    """
+    tau, lagvec = [], []
+
+    # Step through the different lags
+    for lag in range(2, max_lag):
+        # Produce price different with lag
+        pp = np.subtract(series[lag:], series[:-lag])
+
+        # Write the different lags into a vector
+        lagvec.append(lag)
+
+        # Calculate the variance of the difference
+        tau.append(np.sqrt(np.std(pp)))
+
+    # Linear fit to a double-log graph to get power
+    m = np.polyfit(np.log10(lagvec), np.log10(tau), 1)
+
+    # Calculate hurst
+    return m[0] * 2
+
+
+def half_life(price: pd.Series) -> int:
+    """
+    Half-life is the period of time it takes for the price to revert back to the mean.
+    """
+    xs_lag = price.shift(1).bfill()
+    xs_ret = price.diff().bfill()
+    res = sm.OLS(xs_ret, sm.add_constant(xs_lag)).fit()
+    return int(-np.log(2) / res.params.iloc[1])
+
+
+def cointegration_test(p1: pd.Series, p2: pd.Series, alpha: float = 0.05) -> tuple[bool, float]:
+    p1, p2 = p1.dropna().align(p2.dropna(), join="inner")
+    _, pvalue, _ = coint(p1, p2)
+    return bool(pvalue < alpha), float(pvalue)

qubx/pandaz/__init__.py

@@ -0,0 +1,23 @@
+__all__ = [
+    "srows",
+    "scols",
+    "continuous_periods",
+    "ohlc_resample",
+    "retain_columns_and_join",
+    "select_column_and_join",
+    "dict_to_frame",
+    "drop_duplicated_indexes",
+    "process_duplicated_indexes",
+]
+
+from .utils import (
+    continuous_periods,
+    dict_to_frame,
+    drop_duplicated_indexes,
+    ohlc_resample,
+    process_duplicated_indexes,
+    retain_columns_and_join,
+    scols,
+    select_column_and_join,
+    srows,
+)