Qubx 0.2.74__tar.gz → 0.2.76__tar.gz

{qubx-0.2.74 → qubx-0.2.76}/PKG-INFO

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

{qubx-0.2.74 → qubx-0.2.76}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "Qubx"
-version = "0.2.74"
+version = "0.2.76"
 description = "Qubx - quantitative trading framework"
 authors = ["Dmitry Marienko <dmitry@gmail.com>", "Yuriy Arabskyy <yuriy.arabskyy@gmail.com>"]
 readme = "README.md"

{qubx-0.2.74 → qubx-0.2.76}/src/qubx/__init__.py

@@ -70,6 +70,10 @@ if runtime_env() in ["notebook", "shell"]:
         # process data manager
         __manager = None
 
+        @line_magic
+        def qubx(self, line: str):
+            self.qubx_setup("dark" + " " + line)
+
         @line_magic
         def qubxd(self, line: str):
             self.qubx_setup("dark" + " " + line)

{qubx-0.2.74 → qubx-0.2.76}/src/qubx/_nb_magic.py

@@ -1,5 +1,5 @@
 """"
-Here stuff we want to have in every Jupyter notebook after calling %qube magic
+Here stuff we want to have in every Jupyter notebook after calling %qubx magic
 """
 
 import qubx
@@ -29,7 +29,7 @@ def np_fmt_reset():
 if runtime_env() in ["notebook", "shell"]:
 
     # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-    # -- all imports below will appear in notebook after calling %%alphalab magic ---
+    # -- all imports below will appear in notebook after calling %%qubx magic ---
     # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
     # - - - - Common stuff - - - -
@@ -40,16 +40,52 @@ if runtime_env() in ["notebook", "shell"]:
 
     # - - - - TA stuff and indicators - - - -
     import qubx.pandaz.ta as pta
+    import qubx.ta.indicators as ta
 
     # - - - - Portfolio analysis - - - -
+    from qubx.core.metrics import (
+        tearsheet,
+        chart_signals,
+        get_symbol_pnls,
+        get_equity,
+        portfolio_metrics,
+        pnl,
+        drop_symbols,
+        pick_symbols,
+    )
+
+    # - - - - Data reading - - - -
+    from qubx.data.readers import (
+        CsvStorageDataReader,
+        MultiQdbConnector,
+        QuestDBConnector,
+        AsOhlcvSeries,
+        AsPandasFrame,
+        AsQuotes,
+        AsTimestampedRecords,
+        RestoreTicksFromOHLC,
+    )
+
     # - - - - Simulator stuff - - - -
-    # - - - - Learn stuff - - - -
+    from qubx.backtester.simulator import simulate
+    from qubx.backtester.optimization import variate
+
     # - - - - Charting stuff - - - -
     from matplotlib import pyplot as plt
     from qubx.utils.charting.mpl_helpers import fig, subplot, sbp, plot_trends, ohlc_plot
+    from qubx.utils.charting.lookinglass import LookingGlass
 
     # - - - - Utils - - - -
-    from qubx.pandaz.utils import scols, srows, ohlc_resample, continuous_periods, generate_equal_date_ranges
+    from qubx.pandaz.utils import (
+        scols,
+        srows,
+        ohlc_resample,
+        continuous_periods,
+        generate_equal_date_ranges,
+        drop_duplicated_indexes,
+        retain_columns_and_join,
+        rolling_forward_test_split,
+    )
 
     # - setup short numpy output format
     np_fmt_short()

{qubx-0.2.74 → qubx-0.2.76}/src/qubx/core/helpers.py

@@ -357,4 +357,4 @@ def set_parameters_to_object(strategy: Any, **kwargs):
             _log_info += f"\n\tset <green>{k}</green> <- <red>{v_str}</red>"
 
     if _log_info:
-        logger.info(f"<yellow>{strategy.__class__.__name__}</yellow> new parameters:" + _log_info)
+        logger.debug(f"<yellow>{strategy.__class__.__name__}</yellow> new parameters:" + _log_info)

{qubx-0.2.74 → qubx-0.2.76}/src/qubx/core/lookups.py

@@ -152,8 +152,8 @@ class InstrumentsLookup:
                     v["base"],
                     v["quote"],
                     v["settle"],
-                    min_tick=float(info["tickSize"]),
-                    min_size_step=float(v["precision"]["price"]),
+                    min_tick=float(v["precision"]["price"]),
+                    min_size_step=float(v["precision"]["amount"]),
                     min_size=v["precision"]["amount"],
                     futures_info=FuturesInfo(
                         contract_type=info["type"],

{qubx-0.2.74 → qubx-0.2.76}/src/qubx/core/metrics.py

@@ -33,6 +33,9 @@ MINUTELY = HOURLY * 60
 HOURLY_FX = DAILY * 24
 MINUTELY_FX = HOURLY_FX * 60
 
+_D1 = pd.Timedelta("1D")
+_W1 = pd.Timedelta("1W")
+
 
 def absmaxdd(data: List | Tuple | pd.Series | np.ndarray) -> Tuple[float, int, int, int, pd.Series]:
     """
@@ -113,7 +116,7 @@ def max_drawdown_pct(returns):
     return np.nanmin((cumrets - max_return) / max_return)
 
 
-def portfolio_returns(portfolio_log: pd.DataFrame, method="pct", init_cash=0) -> pd.Series:
+def portfolio_returns(portfolio_log: pd.DataFrame, method="pct", init_cash: float = 0.0) -> pd.Series:
     """
     Calculates returns based on specified method.
 
@@ -323,7 +326,7 @@ def omega_ratio(returns, risk_free=0.0, required_return=0.0, periods=DAILY):
     return (numer / denom) if denom > 0.0 else np.nan
 
 
-def aggregate_returns(returns, convert_to):
+def aggregate_returns(returns: pd.Series, convert_to: str) -> pd.DataFrame | pd.Series:
     """
     Aggregates returns by specified time period
     :param returns: pd.Series or np.ndarray periodic returns of the strategy, noncumulative
@@ -583,17 +586,21 @@ def monthly_returns(
     return pd.concat((100 * r_month, acc_balance), axis=1, keys=["Returns", "Balance"])
 
 
-def portfolio_symbols(df: pd.DataFrame) -> List[str]:
+def portfolio_symbols(src: pd.DataFrame | TradingSessionResult) -> List[str]:
     """
     Get list of symbols from portfolio log
     """
+    df = src.portfolio_log if isinstance(src, TradingSessionResult) else src
     return list(df.columns[::5].str.split("_").str.get(0).values)
 
 
-def pnl(x: pd.DataFrame, c=1, cum=False, total=False, resample=None):
+def pnl(
+    src: pd.DataFrame | TradingSessionResult, c=1, cum=False, total=False, resample=None
+) -> pd.Series | pd.DataFrame:
     """
     Extract PnL from portfolio log
     """
+    x = src.portfolio_log if isinstance(src, TradingSessionResult) else src
     pl = x.filter(regex=".*_PnL").rename(lambda x: x.split("_")[0], axis=1)
     comms = x.filter(regex=".*_Commissions").rename(lambda x: x.split("_")[0], axis=1)
     r = pl - c * comms
@@ -603,18 +610,21 @@ def pnl(x: pd.DataFrame, c=1, cum=False, total=False, resample=None):
     return r.sum(axis=1) if total else r
 
 
-def drop_symbols(df: pd.DataFrame, *args, quoted="USDT"):
+def drop_symbols(src: pd.DataFrame | TradingSessionResult, *args, quoted="USDT") -> pd.DataFrame:
     """
     Drop symbols (is quoted currency) from portfolio log
     """
     s = "|".join([f"{a}{quoted}" if not a.endswith(quoted) else a for a in args])
+    df = src.portfolio_log if isinstance(src, TradingSessionResult) else src
     return df.filter(filter(lambda si: not re.match(f"^{s}_.*", si), df.columns))
 
 
-def pick_symbols(df: pd.DataFrame, *args, quoted="USDT"):
+def pick_symbols(src: pd.DataFrame | TradingSessionResult, *args, quoted="USDT") -> pd.DataFrame:
     """
     Select symbols (is quoted currency) from portfolio log
     """
+    df = src.portfolio_log if isinstance(src, TradingSessionResult) else src
+
     # - pick up from execution report
     if "instrument" in df.columns and "quantity" in df.columns:
         rx = "|".join([f"{a}.*" for a in args])
@@ -663,11 +673,19 @@ def portfolio_metrics(
         returns = returns[:end]
         returns_on_init_bp = returns_on_init_bp[:end]
 
-    # aggregate them to daily (if we have intraday portfolio)
+    # - aggregate returns to higher timeframe
     try:
-        if infer_series_frequency(returns) < pd.Timedelta("1D").to_timedelta64():
-            returns_daily = aggregate_returns(returns, "daily")
-            returns_on_init_bp = aggregate_returns(returns_on_init_bp, "daily")
+        _conversion = "daily"
+        match (_s_freq := infer_series_frequency(returns)):
+            case _ if _s_freq <= _D1.to_timedelta64():
+                _conversion = "daily"
+            case _ if _s_freq > _D1.to_timedelta64() and _s_freq <= _W1.to_timedelta64():
+                _conversion = "weekly"
+            case _:
+                _conversion = "monthly"
+
+        returns_daily = aggregate_returns(returns, _conversion)
+        returns_on_init_bp = aggregate_returns(returns_on_init_bp, _conversion)
     except:
         returns_daily = returns
 
@@ -792,7 +810,7 @@ def get_equity(
     sessions: TradingSessionResult | list[TradingSessionResult],
     account_transactions: bool = True,
     timeframe: str | None = None,
-) -> pd.DataFrame:
+) -> pd.DataFrame | pd.Series:
     if timeframe is None:
         timeframe = _estimate_timeframe(sessions)
 

qubx-0.2.76/src/qubx/data/__init__.py

@@ -0,0 +1,11 @@
+from .readers import (
+    DataReader,
+    CsvStorageDataReader,
+    MultiQdbConnector,
+    QuestDBConnector,
+    AsOhlcvSeries,
+    AsPandasFrame,
+    AsQuotes,
+    AsTimestampedRecords,
+    RestoreTicksFromOHLC,
+)

{qubx-0.2.74 → qubx-0.2.76}/src/qubx/data/readers.py

@@ -903,7 +903,7 @@ class QuestDBConnector(DataReader):
         where = f"where symbol in ({', '.join(quoted_symbols)}) and timestamp >= '{start}' and timestamp < '{stop}'"
         table_name = QuestDBSqlCandlesBuilder().get_table_name(f"{exchange}:{symbols[0]}")
 
-        _rsmpl = f"sample by {timeframe}"
+        _rsmpl = f"sample by {QuestDBSqlCandlesBuilder._convert_time_delta_to_qdb_resample_format(timeframe)}"
 
         query = f"""
         select timestamp, 
@@ -934,7 +934,7 @@ class QuestDBConnector(DataReader):
             select timestamp, symbol, sum(quote_volume) as qvolume 
             from "{table_name}"
             where timestamp >= '{start}' and timestamp < '{stop}'
-            SAMPLE BY {timeframe}
+            SAMPLE BY {QuestDBSqlCandlesBuilder._convert_time_delta_to_qdb_resample_format(timeframe)}
         )
         select symbol, avg(qvolume) as quote_volume from sampled
         group by symbol
@@ -945,6 +945,23 @@ class QuestDBConnector(DataReader):
             return pd.Series()
         return vol_stats.set_index("symbol")["quote_volume"]
 
+    def get_fundamental_data(
+        self, exchange: str, start: str | pd.Timestamp | None = None, stop: str | pd.Timestamp | None = None
+    ) -> pd.DataFrame:
+        table_name = {"BINANCE.UM": "binance.umfutures.fundamental"}[exchange]
+        query = f"select * from {table_name}"
+        if start or stop:
+            conditions = []
+            if start:
+                conditions.append(f"timestamp >= '{start}'")
+            if stop:
+                conditions.append(f"timestamp < '{stop}'")
+            query += " where " + " and ".join(conditions)
+        df = self.execute(query)
+        if df.empty:
+            return pd.DataFrame()
+        return df.set_index(["timestamp", "symbol", "metric"]).value.unstack("metric")
+
     def get_names(self) -> List[str]:
         return self._get_names(self._builder)
 

qubx-0.2.76/src/qubx/pandaz/__init__.py

@@ -0,0 +1,15 @@
+from .utils import (
+    srows,
+    scols,
+    continuous_periods,
+    ohlc_resample,
+    retain_columns_and_join,
+    select_column_and_join,
+    dict_to_frame,
+    drop_duplicated_indexes,
+    process_duplicated_indexes,
+    generate_equal_date_ranges,
+    rolling_forward_test_split,
+    shift_series,
+    check_frame_columns,
+)

{qubx-0.2.74 → qubx-0.2.76}/src/qubx/pandaz/utils.py

@@ -90,11 +90,11 @@ def rolling_forward_test_split(
             yield (np.array(range(i - training_period, i)), np.array(range(i, i + test_period)))
 
 
-def generate_equal_date_ranges(start: str | pd.Timestamp, end: str | pd.Timestamp, freq: int, units: str) -> Iterable:
+def generate_equal_date_ranges(start: str, end: str, freq, units):
     """
     Generator for date ranges:
 
-    for s,e in generate_equal_date_ranges('2019-01-01', '2022-05-17', 1, 'Y'):
+    for s,e in generate_ranges('2019-01-01', '2022-05-17', 1, 'Y'):
         print(s, e)
     ------------------
     2019-01-01 2019-12-31
@@ -103,9 +103,8 @@ def generate_equal_date_ranges(start: str | pd.Timestamp, end: str | pd.Timestam
     2022-01-01 2022-05-17
     """
     _as_f = lambda x: pd.Timestamp(x).strftime("%Y-%m-%d")
-
-    # - for case when end - start < freq it won't got into the loop
-    b = [start, start] if _as_f(start) > _as_f(end) else [start, end]
+    if pd.Timestamp(end) - pd.Timestamp(start) < freq * pd.Timedelta(f"1{units}"):
+        b = [start, end]
 
     for a, b in rolling_forward_test_split(pd.Series(0, pd.date_range(start, end)), freq, freq, units=units):
         yield _as_f(a[0]), _as_f(a[-1])

{qubx-0.2.74 → qubx-0.2.76}/src/qubx/utils/__init__.py

@@ -1,4 +1,4 @@
 from .time import convert_seconds_to_str, convert_tf_str_td64, floor_t64, time_to_str, infer_series_frequency
 from .misc import runtime_env, version, Struct, Stopwatch
-from .charting.mpl_helpers import set_mpl_theme, fig, sbp, vline, hline, ellips, set_mpl_theme, ohlc_plot
+from .charting.mpl_helpers import fig, sbp, vline, hline, ellips, set_mpl_theme, ohlc_plot, plot_trends
 from .charting.lookinglass import LookingGlass

qubx-0.2.74/src/qubx/pandaz/__init__.py

@@ -1,4 +0,0 @@
-from .utils import (
-    srows, scols, continuous_periods, ohlc_resample, retain_columns_and_join, dict_to_frame, 
-    generate_equal_date_ranges, rolling_forward_test_split
-)