Qubx 0.6.74__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.75__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/connectors/ccxt/handlers/ohlc.py

@@ -89,7 +89,9 @@ class OhlcDataHandler(BaseDataTypeHandler):
         for instrument in instruments:
             start = self._data_provider._time_msec_nbars_back(timeframe, nbarsback)
             ccxt_symbol = instrument_to_ccxt_symbol(instrument)
-            ohlcv = await self._exchange_manager.exchange.fetch_ohlcv(ccxt_symbol, exch_timeframe, since=start, limit=nbarsback + 1)
+            ohlcv = await self._exchange_manager.exchange.fetch_ohlcv(
+                ccxt_symbol, exch_timeframe, since=start, limit=nbarsback + 1
+            )
 
             logger.debug(f"<yellow>{self._exchange_id}</yellow> {instrument}: loaded {len(ohlcv)} {timeframe} bars")
 
@@ -102,6 +104,12 @@ class OhlcDataHandler(BaseDataTypeHandler):
                 )
             )
 
+            if len(ohlcv) > 0:
+                # Send a quote update to the context at the end of warmup
+                channel.send((instrument, DataType.QUOTE, self._convert_ohlcv_to_quote(ohlcv, instrument), False))
+
+            self._update_quote(instrument, ohlcv)
+
     async def get_historical_ohlc(self, instrument: Instrument, timeframe: str, nbarsback: int) -> list[Bar]:
         """
         Get historical OHLC data for a single instrument (used by get_ohlc method).
@@ -121,7 +129,9 @@ class OhlcDataHandler(BaseDataTypeHandler):
 
         # Retrieve OHLC data from exchange
         # TODO: check if nbarsback > max_limit (1000) we need to do more requests
-        ohlcv_data = await self._exchange_manager.exchange.fetch_ohlcv(ccxt_symbol, exch_timeframe, since=since, limit=nbarsback + 1)
+        ohlcv_data = await self._exchange_manager.exchange.fetch_ohlcv(
+            ccxt_symbol, exch_timeframe, since=since, limit=nbarsback + 1
+        )
 
         # Convert to Bar objects using utility method
         bars = []
@@ -153,7 +163,9 @@ class OhlcDataHandler(BaseDataTypeHandler):
 
                 # ohlcv is symbol -> timeframe -> list[timestamp, open, high, low, close, volume]
                 for exch_symbol, _data in ohlcv.items():
-                    instrument = ccxt_find_instrument(exch_symbol, self._exchange_manager.exchange, _symbol_to_instrument)
+                    instrument = ccxt_find_instrument(
+                        exch_symbol, self._exchange_manager.exchange, _symbol_to_instrument
+                    )
                     for _, ohlcvs in _data.items():
                         for oh in ohlcvs:
                             # Use private processing method to avoid duplication
@@ -261,7 +273,9 @@ class OhlcDataHandler(BaseDataTypeHandler):
             individual_subscribers[instrument] = create_individual_subscriber()
 
             # Create individual unsubscriber if exchange supports it
-            if hasattr(self._exchange_manager.exchange, "un_watch_ohlcv") and callable(getattr(self._exchange_manager.exchange, "un_watch_ohlcv", None)):
+            if hasattr(self._exchange_manager.exchange, "un_watch_ohlcv") and callable(
+                getattr(self._exchange_manager.exchange, "un_watch_ohlcv", None)
+            ):
 
                 def create_individual_unsubscriber(symbol=ccxt_symbol, exchange_id=self._exchange_id):
                     async def individual_unsubscriber():
@@ -314,7 +328,7 @@ class OhlcDataHandler(BaseDataTypeHandler):
         # Use current time for health monitoring with robust conversion
         current_timestamp_ms = current_timestamp_ns // 1_000_000
         health_timestamp = pd.Timestamp(current_timestamp_ms, unit="ms").asm8
-        
+
         # Notify all listeners
         self._data_provider.notify_data_arrival(sub_type, health_timestamp)
 
@@ -329,10 +343,19 @@ class OhlcDataHandler(BaseDataTypeHandler):
             # Use provided OHLCV data or fall back to current bar
             quote_data = ohlcv_data_for_quotes or [oh]
             if quote_data:
-                _price = quote_data[-1][4]  # Close price
-                _s2 = instrument.tick_size / 2.0
-                _bid, _ask = _price - _s2, _price + _s2
-                self._data_provider._last_quotes[instrument] = Quote(current_timestamp_ns, _bid, _ask, 0.0, 0.0)
+                self._update_quote(instrument, quote_data)
+
+    def _update_quote(self, instrument: Instrument, quote_data: list):
+        quote = self._convert_ohlcv_to_quote(quote_data, instrument)
+        self._data_provider._last_quotes[instrument] = quote
+
+    def _convert_ohlcv_to_quote(self, oh: list, instrument: Instrument) -> Quote:
+        current_time = self._data_provider.time_provider.time()
+        current_timestamp_ns = current_time.astype("datetime64[ns]").view("int64")
+        _price = oh[-1][4]  # Close price
+        _s2 = instrument.tick_size / 2.0
+        _bid, _ask = _price - _s2, _price + _s2
+        return Quote(current_timestamp_ns, _bid, _ask, 0.0, 0.0)
 
     def _convert_ohlcv_to_bar(self, oh: list) -> Bar:
         """

qubx/connectors/ccxt/reader.py

@@ -452,7 +452,7 @@ class CcxtDataReader(DataReader):
 
                 # Use exchange-specific funding interval (lookup from cache or default)
                 exchange_caps = self._capabilities.get(exchange.lower(), ReaderCapabilities())
-                funding_interval_hours = self._get_funding_interval_for_symbol(
+                funding_interval_hours = self._get_funding_interval_hours_for_symbol(
                     exchange.upper(), ccxt_symbol, exchange_caps.default_funding_interval_hours
                 )
 
@@ -602,7 +602,7 @@ class CcxtDataReader(DataReader):
 
                 # Use exchange-specific funding interval (lookup from cache or default)
                 exchange_caps = self._capabilities.get(exchange.lower(), ReaderCapabilities())
-                funding_interval_hours = self._get_funding_interval_for_symbol(
+                funding_interval_hours = self._get_funding_interval_hours_for_symbol(
                     exchange.upper(), ccxt_symbol, exchange_caps.default_funding_interval_hours
                 )
 
@@ -652,12 +652,17 @@ class CcxtDataReader(DataReader):
         self._funding_intervals_cache[exchange_name] = intervals
         return intervals
 
-    def _get_funding_interval_for_symbol(self, exchange_name: str, ccxt_symbol: str, default_hours: float) -> float:
+    def _get_funding_interval_hours_for_symbol(
+        self, exchange_name: str, ccxt_symbol: str, default_hours: float
+    ) -> float:
         """
         Get funding interval for a specific symbol, with exchange-specific lookup and fallback.
         """
         intervals_dict = self._get_funding_intervals_for_exchange(exchange_name)
-        return intervals_dict.get(ccxt_symbol, default_hours)
+        interval = intervals_dict.get(ccxt_symbol, default_hours)
+        if isinstance(interval, str):
+            return pd.Timedelta(interval).total_seconds() / 3600
+        return float(interval)
 
     def _get_column_names(self, data_type: str) -> list[str]:
         match data_type:

qubx/core/mixins/market.py

@@ -110,7 +110,19 @@ class MarketManager(IMarketManager):
 
     def quote(self, instrument: Instrument) -> Quote | None:
         _data_provider = self._get_data_provider(instrument.exchange)
-        return _data_provider.get_quote(instrument)
+        quote = _data_provider.get_quote(instrument)
+        if quote is None:
+            ohlcv = self._cache.get_ohlcv(instrument)
+            if len(ohlcv) > 0:
+                last_bar = ohlcv[0]
+                quote = Quote(
+                    last_bar.time,
+                    last_bar.close - instrument.tick_size / 2,
+                    last_bar.close + instrument.tick_size / 2,
+                    0,
+                    0,
+                )
+        return quote
 
     def get_data(self, instrument: Instrument, sub_type: str) -> list[Any]:
         return self._cache.get_data(instrument, sub_type)

qubx/core/mixins/processing.py

@@ -393,13 +393,13 @@ class ProcessingManager(IProcessingManager):
                 else:
                     _init_signals.append(signal)
                     self._instruments_in_init_stage.add(instr)
-                    logger.info(f"Switching tracker for <g>{instr}</g> to post-warmup initialization")
+                    logger.debug(f"Switching tracker for <g>{instr}</g> to post-warmup initialization")
             else:
                 _std_signals.append(signal)
                 if instr in self._instruments_in_init_stage:
                     _cancel_init_stage_instruments_tracker.add(instr)
                     self._instruments_in_init_stage.remove(instr)
-                    logger.info(f"Switching tracker for <g>{instr}</g> back to defined position tracker")
+                    logger.debug(f"Switching tracker for <g>{instr}</g> back to defined position tracker")
 
         return _std_signals, _init_signals, _cancel_init_stage_instruments_tracker
 
@@ -643,6 +643,8 @@ class ProcessingManager(IProcessingManager):
                 # - update tracker
                 _targets_from_tracker = self._get_tracker_for(instrument).update(self._context, instrument, _update)
 
+                # TODO: add gatherer update
+
                 # - notify position gatherer for the new target positions
                 if _targets_from_tracker:
                     # - tracker generated new targets on update, notify position gatherer

qubx/ta/indicators.pxd

@@ -157,3 +157,12 @@ cdef class Swings(IndicatorOHLC):
     cdef public TimeSeries middles, deltas
 
     cpdef double calculate(self, long long time, Bar bar, short new_item_started)
+
+cdef class Pivots(IndicatorOHLC):
+    cdef int before, after
+    cdef object bars_buffer
+    cdef Bar current_bar
+    cdef long long current_bar_time
+    cdef public TimeSeries tops, bottoms, tops_detection_lag, bottoms_detection_lag
+    
+    cpdef double calculate(self, long long time, Bar bar, short new_item_started)

qubx/ta/indicators.pyi

@@ -1,3 +1,4 @@
+import pandas as pd
 from qubx.core.series import OHLCV, Indicator, IndicatorOHLC, TimeSeries
 
 def sma(series: TimeSeries, period: int): ...
@@ -16,6 +17,7 @@ def psar(series: OHLCV, iaf: float = 0.02, maxaf: float = 0.2): ...
 def smooth(series: TimeSeries, smoother: str, *args, **kwargs) -> Indicator: ...
 def atr(series: OHLCV, period: int = 14, smoother="sma", percentage: bool = False): ...
 def swings(series: OHLCV, trend_indicator, **indicator_args) -> Indicator: ...
+def pivots(series: OHLCV, before: int = 5, after: int = 5) -> Indicator: ...
 
 class Sma(Indicator):
     def __init__(self, name: str, series: TimeSeries, period: int): ...
@@ -45,3 +47,11 @@ class Swings(IndicatorOHLC):
     bottoms: TimeSeries
     middles: TimeSeries
     deltas: TimeSeries
+
+class Pivots(IndicatorOHLC):
+    tops: TimeSeries
+    bottoms: TimeSeries
+    tops_detection_lag: TimeSeries
+    bottoms_detection_lag: TimeSeries
+    def __init__(self, name: str, series: OHLCV, before: int, after: int): ...
+    def pd(self) -> pd.DataFrame: ...

qubx/ta/indicators.pyx

@@ -858,4 +858,156 @@ def swings(series: OHLCV, trend_indicator, **indicator_args):
     """
     if not isinstance(series, OHLCV):
         raise ValueError("Series must be OHLCV !")
-    return Swings.wrap(series, trend_indicator, **indicator_args)
+    return Swings.wrap(series, trend_indicator, **indicator_args)
+
+
+cdef class Pivots(IndicatorOHLC):
+    """
+    Pivot points detector that identifies local highs and lows using
+    lookback (before) and lookahead (after) windows.
+    """
+
+    def __init__(self, str name, OHLCV series, int before, int after):
+        self.before = before
+        self.after = after
+        
+        # Deque to store completed bars for pivot detection
+        self.bars_buffer = deque(maxlen=before + after + 1)
+        
+        # Keep track of the current unfinished bar separately
+        self.current_bar = None
+        self.current_bar_time = 0
+        
+        # TimeSeries for pivot points
+        self.tops = TimeSeries("tops", series.timeframe, series.max_series_length)
+        self.bottoms = TimeSeries("bottoms", series.timeframe, series.max_series_length)
+        self.tops_detection_lag = TimeSeries("tops_lag", series.timeframe, series.max_series_length)
+        self.bottoms_detection_lag = TimeSeries("bottoms_lag", series.timeframe, series.max_series_length)
+        
+        super().__init__(name, series)
+    
+    cpdef double calculate(self, long long time, Bar bar, short new_item_started):
+        cdef int pivot_idx, i
+        cdef double pivot_high, pivot_low
+        cdef long long pivot_time
+        cdef short is_pivot_high, is_pivot_low
+        
+        if new_item_started:
+            # If we have a previous bar that was being updated, add it to the buffer as completed
+            if self.current_bar is not None and self.current_bar_time > 0:
+                self.bars_buffer.append((self.current_bar_time, self.current_bar))
+            
+            # Start tracking the new unfinished bar
+            self.current_bar = bar
+            self.current_bar_time = time
+            
+            # Check if we have enough completed bars to detect a pivot
+            # We need exactly before + after + 1 bars in the buffer
+            if len(self.bars_buffer) < self.before + self.after + 1:
+                return np.nan
+            
+            # The pivot candidate is at index 'before'
+            pivot_idx = self.before
+            pivot_time = self.bars_buffer[pivot_idx][0]
+            pivot_bar = self.bars_buffer[pivot_idx][1]
+            pivot_high = pivot_bar.high
+            pivot_low = pivot_bar.low
+            
+            # Check for pivot high: pivot high must be > all other highs in window
+            is_pivot_high = 1
+            for i in range(len(self.bars_buffer)):
+                if i != pivot_idx:
+                    if self.bars_buffer[i][1].high >= pivot_high:
+                        is_pivot_high = 0
+                        break
+            
+            # Check for pivot low: pivot low must be < all other lows in window
+            is_pivot_low = 1
+            for i in range(len(self.bars_buffer)):
+                if i != pivot_idx:
+                    if self.bars_buffer[i][1].low <= pivot_low:
+                        is_pivot_low = 0
+                        break
+            
+            # Record pivot high if found
+            if is_pivot_high:
+                self.tops.update(pivot_time, pivot_high)
+                # Detection time is now (when we actually detect it)
+                self.tops_detection_lag.update(pivot_time, time - pivot_time)
+            
+            # Record pivot low if found
+            if is_pivot_low:
+                self.bottoms.update(pivot_time, pivot_low)
+                # Detection time is now (when we actually detect it)
+                self.bottoms_detection_lag.update(pivot_time, time - pivot_time)
+            
+            # Return 1 for pivot high, -1 for pivot low, 0 for both, nan for neither
+            if is_pivot_high and is_pivot_low:
+                return 0
+            elif is_pivot_high:
+                return 1
+            elif is_pivot_low:
+                return -1
+            else:
+                return np.nan
+        else:
+            # Just update the current unfinished bar
+            self.current_bar = bar
+            # Note: current_bar_time stays the same since we're updating the same bar
+            return np.nan
+
+    def pd(self) -> pd.DataFrame:
+        """
+        Return DataFrame with pivot points and detection lags.
+        
+        Returns a multi-column DataFrame with:
+        - Tops: price, detection_lag, spotted (time when pivot was detected)
+        - Bottoms: price, detection_lag, spotted
+        """
+        from qubx.pandaz.utils import scols
+        
+        tps = self.tops.pd()
+        bts = self.bottoms.pd()
+        tpl = self.tops_detection_lag.pd()
+        btl = self.bottoms_detection_lag.pd()
+        
+        # Convert lags to timedeltas
+        if len(tpl) > 0:
+            tpl = tpl.apply(lambda x: pd.Timedelta(x, unit='ns'))
+        if len(btl) > 0:
+            btl = btl.apply(lambda x: pd.Timedelta(x, unit='ns'))
+        
+        # Create DataFrames for tops and bottoms
+        if len(tps) > 0:
+            tops_df = pd.DataFrame({
+                'price': tps,
+                'detection_lag': tpl,
+                'spotted': pd.Series(tps.index + tpl.values, index=tps.index)
+            })
+        else:
+            tops_df = pd.DataFrame(columns=['price', 'detection_lag', 'spotted'])
+        
+        if len(bts) > 0:
+            bottoms_df = pd.DataFrame({
+                'price': bts,
+                'detection_lag': btl,
+                'spotted': pd.Series(bts.index + btl.values, index=bts.index)
+            })
+        else:
+            bottoms_df = pd.DataFrame(columns=['price', 'detection_lag', 'spotted'])
+        
+        return scols(tops_df, bottoms_df, keys=["Tops", "Bottoms"])
+
+
+def pivots(series: OHLCV, before: int = 5, after: int = 5):
+    """
+    Pivot points detector using lookback/lookahead windows.
+    
+    :param series: OHLCV series
+    :param before: Number of bars to look back
+    :param after: Number of bars to look ahead
+    :return: Pivots indicator with tops and bottoms
+    """
+    if not isinstance(series, OHLCV):
+        raise ValueError("Series must be OHLCV!")
+    return Pivots.wrap(series, before, after)

qubx/trackers/riskctrl.py

@@ -989,7 +989,7 @@ class _InitializationStageTracker(GenericRiskControllerDecorator, IPositionSizer
                 continue
 
             _current_pos = ctx.get_position(s.instrument).quantity
-            logger.info(
+            logger.debug(
                 f"[<y>{self.__class__.__name__}</y>] :: <y>Processing init signal</y> :: {s} :: Position is {_current_pos}"
             )
             _to_proceed.append(s)

qubx/utils/charting/mpl_helpers.py

@@ -1183,13 +1183,25 @@ def plot_trends(trends: pd.DataFrame | Struct, uc="w--", dc="m--", lw=2, ms=6, f
         raise ValueError("trends must be a DataFrame or Struct with 'trends' attribute")
 
 
-def plot_quantiles(data, top_n=10, bottom_n=10, title=None, ylabel=None, xlabel="Items", 
-                   figsize=(16, 10), positive_color='#2E8B57', negative_color='#DC143C',
-                   value_formatter=None, label_transformer=None, show_values=True,
-                   zero_line=True, positive_label=None, negative_label=None):
+def plot_quantiles(
+    data,
+    top_n=10,
+    bottom_n=10,
+    title=None,
+    ylabel=None,
+    xlabel="Items",
+    figsize=(16, 10),
+    positive_color="#2E8B57",
+    negative_color="#DC143C",
+    value_formatter=None,
+    label_transformer=None,
+    zero_line=True,
+    positive_label=None,
+    negative_label=None,
+):
     """
     Plot top and bottom quantiles of data as a bar chart with customizable styling.
-    
+
     Parameters:
     -----------
     data : pd.Series
@@ -1214,28 +1226,26 @@ def plot_quantiles(data, top_n=10, bottom_n=10, title=None, ylabel=None, xlabel=
         Function to format values for display (e.g., lambda x: f'{x:.1f}%')
     label_transformer : callable, optional
         Function to transform index labels (e.g., lambda x: x.replace('USDC', ''))
-    show_values : bool, default True
-        Whether to show values on bars
     zero_line : bool, default True
         Whether to show horizontal line at zero
     positive_label : str, optional
         Legend label for positive values
     negative_label : str, optional
         Legend label for negative values
-        
+
     Returns:
     --------
     fig, ax : matplotlib figure and axes objects
-    
+
     Examples:
     ---------
     # Basic usage
     plot_quantiles(data_series)
-    
+
     # Funding rates example
-    plot_quantiles(funding_rates, 
+    plot_quantiles(funding_rates,
                    title="Annualized Funding Rates",
-                   ylabel="Rate (%)", 
+                   ylabel="Rate (%)",
                    value_formatter=lambda x: f'{x:.1f}%',
                    label_transformer=lambda x: x.replace('USDC', ''),
                    positive_label="Longs pay Shorts",
@@ -1243,65 +1253,49 @@ def plot_quantiles(data, top_n=10, bottom_n=10, title=None, ylabel=None, xlabel=
     """
     import pandas as pd
     from matplotlib.patches import Patch
-    
+
     # Get top and bottom quantiles
     top_data = data.head(top_n)
     bottom_data = data.tail(bottom_n)
-    
+
     # Combine them
     combined_data = pd.concat([top_data, bottom_data])
-    
+
     # Create the plot
     fig, ax = plt.subplots(figsize=figsize)
-    
+
     # Create colors: positive_color for positive, negative_color for negative
     colors = [positive_color if value >= 0 else negative_color for value in combined_data.values]
-    
+
     # Create bar plot
-    bars = ax.bar(range(len(combined_data)), combined_data.values, color=colors, alpha=0.8,
-                  edgecolor='white', linewidth=0.5)
-    
+    bars = ax.bar(
+        range(len(combined_data)), combined_data.values, color=colors, alpha=0.8, edgecolor="white", linewidth=0.5
+    )
+
     # Customize the plot
     if title:
-        ax.set_title(title, fontsize=16, fontweight='bold', pad=20)
+        ax.set_title(title, fontsize=16, fontweight="bold", pad=20)
     if ylabel:
-        ax.set_ylabel(ylabel, fontsize=12, fontweight='bold')
-    ax.set_xlabel(xlabel, fontsize=12, fontweight='bold')
-    
+        ax.set_ylabel(ylabel, fontsize=12, fontweight="bold")
+    ax.set_xlabel(xlabel, fontsize=12, fontweight="bold")
+
     # Set x-axis labels
     if label_transformer:
         labels = [label_transformer(str(label)) for label in combined_data.index]
     else:
         labels = [str(label) for label in combined_data.index]
-    
+
     ax.set_xticks(range(len(combined_data)))
-    ax.set_xticklabels(labels, rotation=45, ha='right')
-    
+    ax.set_xticklabels(labels, rotation=45, ha="right")
+
     # Add horizontal line at zero
     if zero_line:
-        ax.axhline(y=0, color='black', linestyle='-', alpha=0.4, linewidth=1.5)
-    
+        ax.axhline(y=0, color="black", linestyle="-", alpha=0.4, linewidth=1.5)
+
     # Add grid
-    ax.grid(True, alpha=0.25, linestyle=':', linewidth=0.8, color='#666666')
+    ax.grid(True, alpha=0.25, linestyle=":", linewidth=0.8, color="#666666")
     ax.set_axisbelow(True)
-    
-    # Add value labels on bars
-    if show_values:
-        if value_formatter is None:
-            value_formatter = lambda x: f'{x:.1f}'
-            
-        for bar, value in zip(bars, combined_data.values):
-            height = bar.get_height()
-            label_offset = max(abs(height) * 0.02, 5)  # Dynamic offset based on value magnitude
-            
-            ax.text(bar.get_x() + bar.get_width()/2., 
-                   height + (label_offset if height >= 0 else -label_offset),
-                   value_formatter(value), 
-                   ha='center', 
-                   va='bottom' if height >= 0 else 'top',
-                   fontsize=10, fontweight='bold', 
-                   color='white' if abs(height) > max(abs(combined_data.min()), abs(combined_data.max())) * 0.3 else 'black')
-    
+
     # Add legend if labels provided
     if positive_label or negative_label:
         legend_elements = []
@@ -1310,8 +1304,8 @@ def plot_quantiles(data, top_n=10, bottom_n=10, title=None, ylabel=None, xlabel=
         if negative_label:
             legend_elements.append(Patch(facecolor=negative_color, label=negative_label))
         if legend_elements:
-            ax.legend(handles=legend_elements, loc='upper right', fontsize=10, framealpha=0.9)
-    
+            ax.legend(handles=legend_elements, loc="upper right", fontsize=10, framealpha=0.9)
+
     plt.tight_layout()
-    
+
     return fig, ax

qubx/utils/questdb.py

@@ -3,6 +3,7 @@ from typing import Any, Dict, List, Optional, Union
 import pandas as pd
 import psycopg as pg
 from psycopg.sql import SQL, Composed
+from questdb.ingress import IngressError, Sender
 
 
 class QuestDBClient:
@@ -34,6 +35,17 @@ class QuestDBClient:
 
         self.conn_str = conn_str
 
+    @property
+    def http_connection_string(self) -> str:
+        """Get HTTP connection string for QuestDB ingress."""
+        # Extract host from conn_str
+        host = "localhost"  # default
+        for part in self.conn_str.split():
+            if part.startswith("host="):
+                host = part.split("=", 1)[1]
+                break
+        return f"http::addr={host}:9000;"
+
     def query(self, query: str, params: Optional[Dict[str, Any]] = None) -> pd.DataFrame:
         """
         Execute a SQL query and return the results as a pandas DataFrame.
@@ -67,10 +79,61 @@ class QuestDBClient:
         """
         with pg.connect(self.conn_str) as conn:
             with conn.cursor() as cursor:
-                cursor.execute(query, params)
+                cursor.execute(query, params) # type: ignore
                 conn.commit()
                 return cursor.rowcount
 
+    def insert_dataframe(self, df: pd.DataFrame, table_name: str) -> None:
+        """
+        Insert DataFrame into QuestDB table using the HTTP ingress API.
+
+        Args:
+            df: DataFrame to insert. Must have a timestamp index or 'timestamp' column
+            table_name: Name of the target QuestDB table
+
+        Raises:
+            IngressError: If ingestion fails
+            ValueError: If DataFrame doesn't have proper timestamp information
+        """
+        try:
+            with Sender.from_conf(self.http_connection_string) as sender:
+                # Check if DataFrame has a proper timestamp index
+                if isinstance(df.index, pd.DatetimeIndex) and df.index.name:
+                    # Use the timestamp index directly
+                    sender.dataframe(df.reset_index(), table_name=table_name, at=df.index.name)
+                elif "timestamp" in df.columns:
+                    # If timestamp is a column, use it directly
+                    sender.dataframe(df, table_name=table_name, at="timestamp")
+                else:
+                    # Try to use index name if it exists
+                    if df.index.name:
+                        sender.dataframe(df.reset_index(), table_name=table_name, at=df.index.name)
+                    else:
+                        raise ValueError("DataFrame must have either a named timestamp index or a 'timestamp' column")
+                sender.flush()
+        except IngressError as e:
+            raise IngressError(f"Failed to insert DataFrame into {table_name}: {e}")
+
+    @staticmethod
+    def get_table_name(exchange: str, market: str, symbol: Optional[str], table_type: str) -> str:
+        """
+        Generate table name following the exchange.market.symbol.type pattern.
+
+        Args:
+            exchange: Exchange name (e.g., 'binance')
+            market: Market type (e.g., 'umfutures', 'spot')
+            symbol: Symbol name (e.g., 'btcusdt'), can be None for market-wide tables
+            table_type: Type of data (e.g., 'candle_1m', 'trade', 'orderbook')
+
+        Returns:
+            Formatted table name
+        """
+        parts = [exchange.lower(), market.lower()]
+        if symbol:
+            parts.append(symbol.lower())
+        parts.append(table_type.lower())
+        return ".".join(parts)
+
     def __enter__(self):
         """Context manager entry point."""
         return self

{qubx-0.6.74.dist-info → qubx-0.6.75.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: Qubx
-Version: 0.6.74
+Version: 0.6.75
 Summary: Qubx - Quantitative Trading Framework
 Author: Dmitry Marienko
 Author-email: dmitry.marienko@xlydian.com

{qubx-0.6.74.dist-info → qubx-0.6.75.dist-info}/RECORD

@@ -44,12 +44,12 @@ qubx/connectors/ccxt/handlers/base.py,sha256=1QS9uhFsisWvGwDmoAc83kLcSd1Lf3hSlnr
 qubx/connectors/ccxt/handlers/factory.py,sha256=SlMAOmaUy1dQ-q5ZzrjODj_XMcLr1BORGGZ7klLNndk,4250
 qubx/connectors/ccxt/handlers/funding_rate.py,sha256=OLlocxRBEMxQ7LAtxZgQcdn3LIZwAqxZ7Q69TUYNyT4,8918
 qubx/connectors/ccxt/handlers/liquidation.py,sha256=0QbLeZwpdEgd30PwQoWXUBKG25rrNQ0OgPz8fPLRA6U,3915
-qubx/connectors/ccxt/handlers/ohlc.py,sha256=bHAEAkjtJ9TLcevsrf5iYIZGB3Z-yKfW66E9IEBLRiE,16903
+qubx/connectors/ccxt/handlers/ohlc.py,sha256=668mHEuLb-sT-Rk0miNsvKTETfoo0XK9aAAqNa4uTCY,17706
 qubx/connectors/ccxt/handlers/open_interest.py,sha256=K3gPI51zUtxvED3V-sfFmK1Lsa-vx7k-Q-UE_eLsoRM,9957
 qubx/connectors/ccxt/handlers/orderbook.py,sha256=VuRgIAshKoHhRrI9DKW7xuVnzsOTNvboz3y5QRkvcII,9147
 qubx/connectors/ccxt/handlers/quote.py,sha256=JwQ8mXMpFMdFEpQTx3x_Xaj6VHZanC6_JI6tB9l_yDw,4464
 qubx/connectors/ccxt/handlers/trade.py,sha256=VspCqw13r9SyvF0N3a31YKIVTzUx5IjFtMDaQeSxblM,4519
-qubx/connectors/ccxt/reader.py,sha256=htCfQQHD8oP7U8248L9f0iD7RxL5wWX-NkLXYUm7H0k,26432
+qubx/connectors/ccxt/reader.py,sha256=uUG1I_ejzTf0f4bCAHpLhBzTUqtNX-JvJGFA4bi7-WU,26602
 qubx/connectors/ccxt/subscription_config.py,sha256=jbMZ_9US3nvrp6LCVmMXLQnAjXH0xIltzUSPqXJZvgs,3865
 qubx/connectors/ccxt/subscription_manager.py,sha256=ZGWf-j4ZTJm-flhVvCs2kLRGqt0zci3p4PSf4nvTKzI,12662
 qubx/connectors/ccxt/subscription_orchestrator.py,sha256=CbZMTRhmgcJZd8cofQbyBDI__N2Lbo1loYfh9_-EkFA,16512
@@ -71,18 +71,18 @@ qubx/core/loggers.py,sha256=pa28UYLTfRibhDzcbtPfbtNb3jpMZ8catTMikA0RFlc,14268
 qubx/core/lookups.py,sha256=Bed30kPZvbTGjZ8exojhIMOIVfB46j6741yF3fXGTiM,18313
 qubx/core/metrics.py,sha256=eMsg9qaL86pkKVKrQOyF9u7yf27feLRxOvJj-6qwmj8,75551
 qubx/core/mixins/__init__.py,sha256=AMCLvfNuIb1kkQl3bhCj9jIOEl2eKcVPJeyLgrkB-rk,329
-qubx/core/mixins/market.py,sha256=-_C2AlpgTMIknVA-AzhQWVS5jOpAvcKcZSJFlJPEAEo,5931
-qubx/core/mixins/processing.py,sha256=rbso204IcaRmOxqL5Gfqj57K6yxnhBTK3MB4RNMERds,42169
+qubx/core/mixins/market.py,sha256=w9OEDfy0r9xnb4KdKA-PuFsCQugNo4pMLQivGFeyqGw,6356
+qubx/core/mixins/processing.py,sha256=OgmrQfnUQKfHJ77BYrXQIu4AOz3xGlnuP8H6UvCiWhA,42216
 qubx/core/mixins/subscription.py,sha256=GcZKHHzjPyYFLAEpE7j4fpLDOlAhFKojQEYfFO3QarY,11064
 qubx/core/mixins/trading.py,sha256=zq3JO8UDwbkYgmTHy1W8Ccn9Adeo1xw3vnyFAUFU0R4,9047
 qubx/core/mixins/universe.py,sha256=mzZJA7Me6HNFbAMGg1XOpnYCMtcFKHESTiozjaXyKXY,10100
 qubx/core/mixins/utils.py,sha256=P71cLuqKjId8989MwOL_BtvvCnnwOFMkZyB1SY-0Ork,147
-qubx/core/series.cpython-312-x86_64-linux-gnu.so,sha256=GLf8S0xWchTbcCyaVFEdY12acsqX9IgqLSCLgaIU6zk,1019592
+qubx/core/series.cpython-312-x86_64-linux-gnu.so,sha256=HuFJpTNo4QYAcj9MIJlKnMR86_MPC5vq0t9JfqWZRE4,1019592
 qubx/core/series.pxd,sha256=PvnUEupOsZg8u81U5Amd-nbfmWQ0-PwZwc7yUoaZpoQ,4739
 qubx/core/series.pyi,sha256=RkM-F3AyrzT7m1H2UmOvZmmcOzU2eBeEWf2c0GUZe2o,5437
 qubx/core/series.pyx,sha256=wAn7L9HIkvVl-1Tt7bgdWhec7xy4AiHSXyDsrA4a29U,51703
 qubx/core/stale_data_detector.py,sha256=NHnnG9NkcivC93n8QMwJUzFVQv2ziUaN-fg76ppng_c,17118
-qubx/core/utils.cpython-312-x86_64-linux-gnu.so,sha256=5QMCfncQEUHIHa_h1qqzN4Vd_evnrTlSNbECmtzk3Qc,86568
+qubx/core/utils.cpython-312-x86_64-linux-gnu.so,sha256=wdcP158YeC3iUevMSdtdslbkl-02EBluUHgwFkUVOP4,86568
 qubx/core/utils.pyi,sha256=a-wS13V2p_dM1CnGq40JVulmiAhixTwVwt0ah5By0Hc,348
 qubx/core/utils.pyx,sha256=UR9achMR-LARsztd2eelFsDsFH3n0gXACIKoGNPI9X4,1766
 qubx/data/__init__.py,sha256=BlyZ99esHLDmFA6ktNkuIce9RZO99TA1IMKWe94aI8M,599
@@ -156,10 +156,10 @@ qubx/restorers/signal.py,sha256=7n7eeRhWGUBPbg179GxFH_ifywcl3pQJbwrcDklw0N0,1460
 qubx/restorers/state.py,sha256=I1VIN0ZcOjigc3WMHIYTNJeAAbN9YB21MDcMl04ZWmY,8018
 qubx/restorers/utils.py,sha256=We2gfqwQKWziUYhuUnjb-xo-5tSlbuHWpPQn0CEMTn0,1155
 qubx/ta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qubx/ta/indicators.cpython-312-x86_64-linux-gnu.so,sha256=cxYoV2RdBpqvPJYdK68Mqfbqtji2SXB7uf5mLec1ulY,704392
-qubx/ta/indicators.pxd,sha256=oEBJ-S6JTgBqEC81edGlf2uNyGJliVgCEHX5NzlQIV0,4521
-qubx/ta/indicators.pyi,sha256=j_XArS3e99fIzKiaKhXYg9OLf7syWS3lUF8oUbzsWtU,2268
-qubx/ta/indicators.pyx,sha256=7WhkkSik1ww4k_WvRoblZ4FUYc-jtyMDJbsd9TnsDOQ,29067
+qubx/ta/indicators.cpython-312-x86_64-linux-gnu.so,sha256=CQ1-s8YDcEcUupwMyLxtEmdTI1nFxJtCgzZIoFHKBbs,762760
+qubx/ta/indicators.pxd,sha256=l4JgvNdlWBuLqMzqTZVaYYn4XyZ9-c222YCyBXVv8MA,4843
+qubx/ta/indicators.pyi,sha256=kHoHONhzI7aq0qs-wP5cxyDPj96ZvQLlThEC8yQj6U4,2630
+qubx/ta/indicators.pyx,sha256=rT6OJ7xygZdTF4-pT6vr6g9MRhvbi6nYBlkTzzZYA_U,35126
 qubx/templates/__init__.py,sha256=L2U6tX5DGhtIDRarIo3tHT7ZVQKNJMlpWn_sinJPevk,153
 qubx/templates/base.py,sha256=cY9Lnvs8hvuqyyBwMN-p7rXWGETrbAx0zmE6Px19Ym4,6844
 qubx/templates/project/accounts.toml.j2,sha256=LlaYWqOalMimGf7n_4sIzJk9p28tNbhZFogg3SHplSQ,637
@@ -181,12 +181,12 @@ qubx/trackers/__init__.py,sha256=zvIahF8MwSffBMOX2BDFFNKJCWtL8TyFLQLL_DR22JM,106
 qubx/trackers/advanced.py,sha256=Q9r8g2nfx5PU3JOY2Mpyes0UDFLf078ACN89x-vB3mM,14325
 qubx/trackers/composite.py,sha256=Tjupx78SraXmRKkWhu8n81RkPjOgsDbXLd8yz6PhbaA,6318
 qubx/trackers/rebalancers.py,sha256=KFY7xuD4fGALiSLMas8MZ3ueRzlWt5wDT9329dlmNng,5150
-qubx/trackers/riskctrl.py,sha256=wLeAI5v8Z6ZZrWneQdpj4QPoOMcVyYE0UyFPEsPmrPw,52343
+qubx/trackers/riskctrl.py,sha256=xI6x1QO6ZEHBkBD1fOhOQuqTeK091fwYaT8eelUp_dg,52344
 qubx/trackers/sizers.py,sha256=j1C7YRvTf_qT3kstpeHiagMHZESFqRWFTgce4rZdy88,11841
 qubx/utils/__init__.py,sha256=FEPBtU3dhfLawBkAfm9FEUW4RuOY7pGCBfzDCtKjn9A,481
 qubx/utils/_pyxreloader.py,sha256=34kNd8kQi2ey_ZrGdVVUHbPrO1PEiHZDLEDBscIkT_s,12292
 qubx/utils/charting/lookinglass.py,sha256=PdIFQ6HrjmurIq8ZOOkpPtYsjQjWxGEkrwTpW060-Ng,41848
-qubx/utils/charting/mpl_helpers.py,sha256=4uPSmKs6gypFxT6L6gHzpFKfudrtTB_M3JUilkAGZjg,41127
+qubx/utils/charting/mpl_helpers.py,sha256=oG9aaz1jFkRHk2g-jiaLlto6mLjhFtq3KTyDUEdMGow,40147
 qubx/utils/charting/orderbook.py,sha256=NmeXxru3CUiKLtl1DzCBbQgSdL4qmTDIxV0u81p2tTw,11083
 qubx/utils/collections.py,sha256=go2sH_q2TlXqI3Vxq8GHLfNGlYL4JwS3X1lwJWbpFLE,7425
 qubx/utils/marketdata/binance.py,sha256=hWX3noZj704JIMBqlwsXA5IzUP7EgiLiC2r12dJAKQA,11565
@@ -202,7 +202,7 @@ qubx/utils/plotting/data.py,sha256=ZOg8rHAq4NVmfsyhvzFHtey4HaXywAHufxhv1IExRqg,4
 qubx/utils/plotting/interfaces.py,sha256=mtRcoWIMt2xkv-Tc2ZgXZQpr5HRiWhPcqkIslzZTeig,493
 qubx/utils/plotting/renderers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qubx/utils/plotting/renderers/plotly.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qubx/utils/questdb.py,sha256=TdjmlGPoZXdjidZ_evcBIkFtoL4nGQXPR4IQSUc6IvA,2509
+qubx/utils/questdb.py,sha256=bxlWiCyYf8IspsvXrs58tn5iXYBUtv6ojeYwOj8EXI0,5269
 qubx/utils/runner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qubx/utils/runner/_jupyter_runner.pyt,sha256=1bo06ql_wlZ7ng6go_zvemySzngrM8Uqzj-_xeOdiFg,10030
 qubx/utils/runner/accounts.py,sha256=mpiv6oxr5z97zWt7STYyARMhWQIpc_XFKungb_pX38U,3270
@@ -211,8 +211,8 @@ qubx/utils/runner/factory.py,sha256=hmtUDYNFQwVQffHEfxgrlmKwOGLcFQ6uJIH_ZLscpIY,
 qubx/utils/runner/runner.py,sha256=T2V6KSKcLNQVXYjxw4zrF7n_AhKEuHJBXjFGU0u1DQY,33252
 qubx/utils/time.py,sha256=xOWl_F6dOLFCmbB4xccLIx5yVt5HOH-I8ZcuowXjtBQ,11797
 qubx/utils/version.py,sha256=e52fIHyxzCiIuH7svCF6pkHuDlqL64rklqz-2XjWons,5309
-qubx-0.6.74.dist-info/LICENSE,sha256=qwMHOSJ2TD0nx6VUJvFhu1ynJdBfNozRMt6tnSul-Ts,35140
-qubx-0.6.74.dist-info/METADATA,sha256=mIF4kPt9lE1tHHASINkmBPxzXdyDN_Tu4OU6PUtvWD8,5836
-qubx-0.6.74.dist-info/WHEEL,sha256=UckHTmFUCaLKpi4yFY8Dewu0c6XkY-KvEAGzGOnaWo8,110
-qubx-0.6.74.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
-qubx-0.6.74.dist-info/RECORD,,
+qubx-0.6.75.dist-info/LICENSE,sha256=qwMHOSJ2TD0nx6VUJvFhu1ynJdBfNozRMt6tnSul-Ts,35140
+qubx-0.6.75.dist-info/METADATA,sha256=EtZt5Ge9ebKLsxiBUS0xT2bWr4Fpr4dCSaI9nnepZdU,5836
+qubx-0.6.75.dist-info/WHEEL,sha256=UckHTmFUCaLKpi4yFY8Dewu0c6XkY-KvEAGzGOnaWo8,110
+qubx-0.6.75.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
+qubx-0.6.75.dist-info/RECORD,,