Qubx 0.7.8__tar.gz → 0.7.10__tar.gz

{qubx-0.7.8 → qubx-0.7.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Qubx
-Version: 0.7.8
+Version: 0.7.10
 Summary: Qubx - Quantitative Trading Framework
 License-File: LICENSE
 Author: Dmitry Marienko

{qubx-0.7.8 → qubx-0.7.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "Qubx"
-version = "0.7.8"
+version = "0.7.10"
 description = "Qubx - Quantitative Trading Framework"
 authors = [ "Dmitry Marienko <dmitry.marienko@xlydian.com>", "Yuriy Arabskyy <yuriy.arabskyy@xlydian.com>",]
 readme = "README.md"

{qubx-0.7.8 → qubx-0.7.10}/src/qubx/connectors/xlighter/client.py

@@ -255,6 +255,13 @@ class LighterClient:
                 resolution_ms = self._resolution_to_milliseconds(resolution)
                 start_timestamp = end_timestamp - (count_back * resolution_ms)
 
+            start_td = cast(pd.Timestamp, pd.Timestamp(start_timestamp, unit="ms"))
+            end_td = cast(pd.Timestamp, pd.Timestamp(end_timestamp, unit="ms"))
+            tf = pd.Timedelta(resolution)
+            if start_td + tf > end_td:
+                start_td = end_td - tf
+                start_timestamp = int(start_td.timestamp() * 1000)  # type: ignore
+
             start_timestamp_str = (
                 cast(pd.Timestamp, pd.Timestamp(start_timestamp, unit="ms")).strftime("%Y-%m-%d %H:%M:%S")
                 if start_timestamp is not None

{qubx-0.7.8 → qubx-0.7.10}/src/qubx/connectors/xlighter/reader.py

@@ -262,7 +262,8 @@ class XLighterDataReader(DataReader):
             max_history_start = stop_ts - self._max_history
             if start_ts < max_history_start:
                 logger.debug(
-                    f"Adjusting start time from {start_ts} to {max_history_start} due to max_history={self._max_history}"
+                    f"Adjusting start time from {start_ts} to {max_history_start} "
+                    f"due to max_history={self._max_history}"
                 )
                 start_ts = max_history_start
 
@@ -337,6 +338,92 @@ class XLighterDataReader(DataReader):
         logger.info(f"Fetched {len(df)} funding payment records for {len(instruments_to_fetch)} symbols")
         return df
 
+    def get_candles(
+        self,
+        exchange: str,
+        symbols: list[str] | None = None,
+        start: str | pd.Timestamp | None = None,
+        stop: str | pd.Timestamp | None = None,
+        timeframe: str = "1d",
+    ) -> pd.DataFrame:
+        """
+        Get candlestick data for symbols within specified time range.
+
+        Args:
+            exchange: Exchange name (should be "LIGHTER")
+            symbols: List of symbols in Qubx format (e.g., ["BTCUSDC", "ETHUSDC"]). If None, fetches all symbols.
+            start: Start time (ISO format or timestamp)
+            stop: Stop time (ISO format or timestamp)
+            timeframe: Timeframe for candles (e.g., "1m", "5m", "1h", "1d")
+
+        Returns:
+            DataFrame with MultiIndex [timestamp, symbol] and columns:
+                - open: Opening price
+                - high: Highest price
+                - low: Lowest price
+                - close: Closing price
+                - volume: Trading volume
+        """
+        if exchange.upper() != "LIGHTER":
+            logger.warning(f"Exchange {exchange} not supported by XLighterDataReader")
+            return pd.DataFrame(columns=["open", "high", "low", "close", "volume"])
+
+        # Handle time range
+        start_ts = pd.Timestamp(start) if start else pd.Timestamp.now() - pd.Timedelta(days=7)
+        stop_ts = pd.Timestamp(stop) if stop else pd.Timestamp.now()
+
+        # Apply max_history limitation
+        if self._max_history:
+            max_history_start = stop_ts - self._max_history
+            if start_ts < max_history_start:
+                logger.debug(
+                    f"Adjusting start time from {start_ts} to {max_history_start} "
+                    f"due to max_history={self._max_history}"
+                )
+                start_ts = max_history_start
+
+        # Get instruments to fetch
+        instruments_to_fetch = self._get_instruments_for_symbols(symbols)
+        if not instruments_to_fetch:
+            logger.warning("No instruments found for the specified symbols")
+            return pd.DataFrame(columns=["open", "high", "low", "close", "volume"])
+
+        # Fetch candle data for each instrument
+        all_candle_data = []
+
+        for instrument in instruments_to_fetch:
+            try:
+                # Fetch OHLCV data using existing method
+                ohlcv_list = self._fetch_ohlcv(instrument, timeframe, start_ts, stop_ts)
+
+                if not ohlcv_list:
+                    logger.debug(f"No candle data found for {instrument.symbol}")
+                    continue
+
+                # Convert to DataFrame
+                df = pd.DataFrame(
+                    ohlcv_list,
+                    columns=["timestamp", "open", "high", "low", "close", "volume"]
+                )
+                df["symbol"] = instrument.symbol
+                all_candle_data.append(df)
+
+            except Exception as e:
+                logger.error(f"Failed to fetch candle data for {instrument.symbol}: {e}")
+                continue
+
+        if not all_candle_data:
+            logger.info("No candle data found")
+            return pd.DataFrame(columns=["open", "high", "low", "close", "volume"])
+
+        # Combine all DataFrames
+        combined_df = pd.concat(all_candle_data, ignore_index=True)
+        combined_df = combined_df.sort_values("timestamp")
+        combined_df = combined_df.set_index(["timestamp", "symbol"])
+
+        logger.info(f"Fetched {len(combined_df)} candle records for {len(instruments_to_fetch)} symbols")
+        return combined_df
+
     def _get_instrument(self, data_id: str) -> Instrument | None:
         """
         Get instrument from data ID.

{qubx-0.7.8 → qubx-0.7.10}/src/qubx/core/context.py

@@ -365,7 +365,6 @@ class StrategyContext(IStrategyContext):
                     {
                         "Exchanges": "|".join(self.exchanges),
                         "Total Capital": f"${self.get_total_capital():,.0f}",
-                        "Net Leverage": f"{self.get_net_leverage():.1%}",
                         "Open Positions": len(open_positions),
                         "Instruments": len(self._initial_instruments),
                     },
@@ -414,7 +413,7 @@ class StrategyContext(IStrategyContext):
             try:
                 self._notifier.notify_stop(
                     {
-                        "Total Capital": f"{self.get_total_capital():.2f}",
+                        "Total Capital": f"{self.get_total_capital():,.0f}",
                         "Net Leverage": f"{self.get_net_leverage():.2%}",
                         "Positions": len([p for i, p in self.get_positions().items() if abs(p.quantity) > i.min_size]),
                     },

{qubx-0.7.8 → qubx-0.7.10}/src/qubx/emitters/indicator.py

@@ -75,10 +75,6 @@ class IndicatorEmitter(Indicator):
         # Since Indicator extends TimeSeries, we can pass the wrapped_indicator directly
         super().__init__(name, wrapped_indicator)
 
-        logger.debug(
-            f"[IndicatorEmitter] Created emitter '{name}' wrapping '{wrapped_indicator.name}' -> metric '{self._metric_name}'"
-        )
-
     def calculate(self, time: int, value: float, new_item_started: bool) -> float:
         """
         Calculate method that handles the emission logic.
@@ -117,10 +113,10 @@ class IndicatorEmitter(Indicator):
                 # Emit the metric with the proper timestamp
                 # Convert time to numpy datetime64 if needed
                 if isinstance(time, int):
-                    timestamp = np.datetime64(time, 'ns')
+                    timestamp = np.datetime64(time, "ns")
                 else:
                     timestamp = pd.Timestamp(time).to_datetime64()
-                    
+
                 self._metric_emitter.emit(
                     name=self._metric_name,
                     value=float(current_value),
@@ -130,10 +126,6 @@ class IndicatorEmitter(Indicator):
                 )
 
                 if not self._has_emitted:
-                    logger.debug(
-                        f"[IndicatorEmitter] '{self.name}' started emitting '{self._metric_name}' "
-                        f"values from '{self._wrapped_indicator.name}'"
-                    )
                     self._has_emitted = True
 
             except Exception as e:

{qubx-0.7.8 → qubx-0.7.10}/src/qubx/ta/indicators.pxd

@@ -223,4 +223,30 @@ cdef class Macd(Indicator):
     cdef object macd_line_series
     cdef object signal_line
 
-    cpdef double calculate(self, long long time, double value, short new_item_started)
+    cpdef double calculate(self, long long time, double value, short new_item_started)
+
+cdef class SuperTrend(IndicatorOHLC):
+    cdef int length
+    cdef double mult
+    cdef str src
+    cdef short wicks
+    cdef str atr_smoother
+
+    cdef double _prev_longstop
+    cdef double _prev_shortstop
+    cdef double _prev_direction
+
+    cdef double prev_longstop
+    cdef double prev_shortstop
+    cdef double prev_direction
+
+    cdef TimeSeries tr
+    cdef object atr_ma
+    cdef public TimeSeries utl
+    cdef public TimeSeries dtl
+
+    cdef _store(self)
+    cdef _restore(self)
+    cdef double calc_src(self, Bar bar)
+
+    cpdef double calculate(self, long long time, Bar bar, short new_item_started)

{qubx-0.7.8 → qubx-0.7.10}/src/qubx/ta/indicators.pyi

@@ -24,6 +24,7 @@ def rsi(series: TimeSeries, period: int = 13, smoother="ema") -> Indicator: ...
 def stdema(series: TimeSeries, period: int) -> Indicator: ...
 def cusum_filter(series: TimeSeries, target: TimeSeries) -> Indicator: ...
 def macd(series: TimeSeries, fast=12, slow=26, signal=9, method="ema", signal_method="ema") -> Indicator: ...
+def super_trend(series: OHLCV, length: int = 22, mult: float = 3.0, src: str = "hl2", wicks: bool = True, atr_smoother: str = "sma") -> Indicator: ...
 
 class Sma(Indicator):
     def __init__(self, name: str, series: TimeSeries, period: int): ...
@@ -84,3 +85,13 @@ class Macd(Indicator):
     def __init__(
         self, name: str, series: TimeSeries, fast: int, slow: int, signal: int, method: str, signal_method: str
     ): ...
+
+class SuperTrend(IndicatorOHLC):
+    utl: TimeSeries
+    dtl: TimeSeries
+    length: int
+    mult: float
+    src: str
+    wicks: bool
+    atr_smoother: str
+    def __init__(self, name: str, series: OHLCV, length: int, mult: float, src: str, wicks: bool, atr_smoother: str): ...

{qubx-0.7.8 → qubx-0.7.10}/src/qubx/ta/indicators.pyx

@@ -1553,4 +1553,219 @@ def macd(series: TimeSeries, fast=12, slow=26, signal=9, method="ema", signal_me
     :param signal_method: used method for averaging signal (sma, ema, tema, dema, kama)
     :return: macd indicator
     """
-    return Macd.wrap(series, fast, slow, signal, method, signal_method) # type: ignore
+    return Macd.wrap(series, fast, slow, signal, method, signal_method) # type: ignore
+
+
+cdef class SuperTrend(IndicatorOHLC):
+    """
+    SuperTrend indicator - a trend-following indicator based on ATR
+
+    The SuperTrend indicator provides trend direction and support/resistance levels.
+    It uses Average True Range (ATR) to calculate dynamic bands around price.
+
+    Returns:
+        trend: +1 for uptrend, -1 for downtrend
+        utl (upper trend line): longstop values during uptrend
+        dtl (down trend line): shortstop values during downtrend
+    """
+
+    def __init__(self, str name, OHLCV series, int length, double mult, str src, short wicks, str atr_smoother):
+        self.length = length
+        self.mult = mult
+        self.src = src
+        self.wicks = wicks
+        self.atr_smoother = atr_smoother
+
+        # - working state variables (updated during calculation)
+        self._prev_longstop = np.nan
+        self._prev_shortstop = np.nan
+        self._prev_direction = np.nan
+
+        # - saved state variables (for handling partial bar updates)
+        self.prev_longstop = np.nan
+        self.prev_shortstop = np.nan
+        self.prev_direction = np.nan
+
+        # - create internal TR series and smooth it for ATR calculation
+        self.tr = TimeSeries("tr", series.timeframe, series.max_series_length)
+        self.atr_ma = smooth(self.tr, atr_smoother, length)
+
+        # - create output series for upper and down trend lines
+        self.utl = TimeSeries("utl", series.timeframe, series.max_series_length)
+        self.dtl = TimeSeries("dtl", series.timeframe, series.max_series_length)
+
+        super().__init__(name, series)
+
+    cdef _store(self):
+        """Store current working state to saved state"""
+        self.prev_longstop = self._prev_longstop
+        self.prev_shortstop = self._prev_shortstop
+        self.prev_direction = self._prev_direction
+
+    cdef _restore(self):
+        """Restore saved state to working state"""
+        self._prev_longstop = self.prev_longstop
+        self._prev_shortstop = self.prev_shortstop
+        self._prev_direction = self.prev_direction
+
+    cdef double calc_src(self, Bar bar):
+        """Calculate source value based on src parameter"""
+        if self.src == "close":
+            return bar.close
+        elif self.src == "hl2":
+            return (bar.high + bar.low) / 2.0
+        elif self.src == "hlc3":
+            return (bar.high + bar.low + bar.close) / 3.0
+        elif self.src == "ohlc4":
+            return (bar.open + bar.high + bar.low + bar.close) / 4.0
+        else:
+            return (bar.high + bar.low) / 2.0  # - default to hl2
+
+    cpdef double calculate(self, long long time, Bar bar, short new_item_started):
+        cdef double atr_value, src_value, longstop, shortstop
+        cdef double high_price, low_price, p_high_price, p_low_price
+        cdef short is_doji4price
+        cdef double direction
+        cdef double saved_prev_longstop, saved_prev_shortstop
+        cdef double tr_value
+
+        # - need at least 2 bars for prev calculations
+        if len(self.series) < 2:
+            # - initialize on first bar
+            self._prev_longstop = np.nan
+            self._prev_shortstop = np.nan
+            self._prev_direction = np.nan
+            self._store()
+            return np.nan
+
+        # - handle store/restore for partial bar updates
+        if new_item_started:
+            self._store()
+        else:
+            self._restore()
+
+        # - calculate True Range
+        cdef Bar prev_bar = self.series[1]
+        cdef double c1 = prev_bar.close
+        cdef double h_l = abs(bar.high - bar.low)
+        cdef double h_pc = abs(bar.high - c1)
+        cdef double l_pc = abs(bar.low - c1)
+        tr_value = max(h_l, h_pc, l_pc)
+
+        # - update TR series (this will automatically update ATR via smooth)
+        self.tr.update(time, tr_value)
+
+        # - get ATR value
+        atr_value = self.atr_ma[0]
+        if np.isnan(atr_value):
+            return np.nan
+
+        atr_value = abs(self.mult) * atr_value
+
+        # - calculate source value
+        src_value = self.calc_src(bar)
+
+        # - determine which prices to use for wicks
+        if self.wicks:
+            high_price = bar.high
+            low_price = bar.low
+        else:
+            high_price = bar.close
+            low_price = bar.close
+
+        # - get previous bar's prices (prev_bar already retrieved above for TR)
+        if self.wicks:
+            p_high_price = prev_bar.high
+            p_low_price = prev_bar.low
+        else:
+            p_high_price = prev_bar.close
+            p_low_price = prev_bar.close
+
+        # - check for doji4price (all prices equal)
+        is_doji4price = (bar.open == bar.close) and (bar.open == bar.low) and (bar.open == bar.high)
+
+        # - calculate basic stops
+        longstop = src_value - atr_value
+        shortstop = src_value + atr_value
+
+        # - save previous bar's stops for direction comparison
+        saved_prev_longstop = self._prev_longstop
+        saved_prev_shortstop = self._prev_shortstop
+
+        # - adjust longstop based on previous value
+        if np.isnan(self._prev_longstop):
+            self._prev_longstop = longstop
+
+        if longstop > 0:
+            if is_doji4price:
+                longstop = self._prev_longstop
+            else:
+                if p_low_price > self._prev_longstop:
+                    longstop = max(longstop, self._prev_longstop)
+                # - else: keep calculated longstop
+        else:
+            longstop = self._prev_longstop
+
+        # - adjust shortstop based on previous value
+        if np.isnan(self._prev_shortstop):
+            self._prev_shortstop = shortstop
+
+        if shortstop > 0:
+            if is_doji4price:
+                shortstop = self._prev_shortstop
+            else:
+                if p_high_price < self._prev_shortstop:
+                    shortstop = min(shortstop, self._prev_shortstop)
+                # - else: keep calculated shortstop
+        else:
+            shortstop = self._prev_shortstop
+
+        # - determine direction based on price breaking PREVIOUS bar's stops
+        # - only check for breaks if we have valid previous stops
+        if np.isnan(saved_prev_longstop) or np.isnan(saved_prev_shortstop):
+            # - not enough data yet, forward fill previous direction or return NaN
+            direction = self._prev_direction if not np.isnan(self._prev_direction) else np.nan
+        elif low_price < saved_prev_longstop:
+            direction = -1.0
+        elif high_price > saved_prev_shortstop:
+            direction = 1.0
+        else:
+            # - no break, keep previous direction (forward fill)
+            direction = self._prev_direction if not np.isnan(self._prev_direction) else np.nan
+
+        # - update working state for next iteration
+        self._prev_longstop = longstop
+        self._prev_shortstop = shortstop
+        self._prev_direction = direction
+
+        # - update utl and dtl series based on direction
+        # - only update when we have a valid direction
+        if direction == 1.0:
+            self.utl.update(time, longstop)
+        elif direction == -1.0:
+            self.dtl.update(time, shortstop)
+
+        # - return trend direction
+        return direction
+
+
+def super_trend(series: OHLCV, length: int = 22, mult: float = 3.0, src: str = "hl2",
+                wicks: bool = True, atr_smoother: str = "sma"):
+    """
+    SuperTrend indicator - a trend-following indicator based on ATR
+
+    The SuperTrend indicator uses Average True Range (ATR) to calculate dynamic support
+    and resistance levels. It provides clear trend direction and can be used for
+    entry/exit signals.
+
+    :param series: OHLCV input series
+    :param length: ATR period (default 22)
+    :param mult: ATR multiplier (default 3.0)
+    :param src: source calculation - 'close', 'hl2', 'hlc3', 'ohlc4' (default 'hl2')
+    :param wicks: whether to use high/low (True) or close (False) for calculations (default True)
+    :param atr_smoother: smoothing method for ATR - 'sma', 'ema', etc (default 'sma')
+    :return: SuperTrend indicator with trend, utl, and dtl series
+    """
+    if not isinstance(series, OHLCV):
+        raise ValueError("Series must be OHLCV !")
+    return SuperTrend.wrap(series, length, mult, src, wicks, atr_smoother) # type: ignore