Qubx 0.6.74__tar.gz → 0.6.76__tar.gz

{qubx-0.6.74 → qubx-0.6.76}/PKG-INFO

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

{qubx-0.6.74 → qubx-0.6.76}/pyproject.toml

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

{qubx-0.6.74 → qubx-0.6.76}/src/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-0.6.74 → qubx-0.6.76}/src/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-0.6.74 → qubx-0.6.76}/src/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-0.6.74 → qubx-0.6.76}/src/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-0.6.74 → qubx-0.6.76}/src/qubx/exporters/formatters/incremental.py

@@ -14,10 +14,10 @@ class IncrementalFormatter(DefaultFormatter):
     """
 
     def __init__(
-            self, 
-            alert_name: str, 
-            exchange_mapping: Optional[Dict[str, str]] = None,
-            account: Optional[IAccountViewer] = None
+        self,
+        alert_name: str,
+        exchange_mapping: Optional[Dict[str, str]] = None,
+        account: Optional[IAccountViewer] = None,
     ):
         """
         Initialize the IncrementalFormatter.
@@ -77,7 +77,7 @@ class IncrementalFormatter(DefaultFormatter):
                 side = "BUY" if current_leverage > 0 else "SELL"
                 return {
                     "type": "ENTRY",
-                    "data": f"{{'action':'ENTRY','exchange':'{exchange}','alertName':'{self.alert_name}','symbol':'{instrument.exchange_symbol}','side':'{side}','leverage':{abs(current_leverage)},'entryPrice':{price}}}",
+                    "data": f"{{'action':'ENTRY','exchange':'{exchange}','alertName':'{self.alert_name}','symbol':'{instrument.exchange_symbol.upper()}','side':'{side}','leverage':{abs(current_leverage)},'entryPrice':{price}}}",
                 }
             else:
                 # Same side - generate entry signal with the leverage difference
@@ -85,7 +85,7 @@ class IncrementalFormatter(DefaultFormatter):
                 side = "BUY" if current_leverage > 0 else "SELL"
                 return {
                     "type": "ENTRY",
-                    "data": f"{{'action':'ENTRY','exchange':'{exchange}','alertName':'{self.alert_name}','symbol':'{instrument.exchange_symbol}','side':'{side}','leverage':{leverage_change},'entryPrice':{price}}}",
+                    "data": f"{{'action':'ENTRY','exchange':'{exchange}','alertName':'{self.alert_name}','symbol':'{instrument.exchange_symbol.upper()}','side':'{side}','leverage':{leverage_change},'entryPrice':{price}}}",
                 }
         else:
             # Position decrease (exit)
@@ -97,7 +97,7 @@ class IncrementalFormatter(DefaultFormatter):
                 side = "BUY" if current_leverage > 0 else "SELL"
                 return {
                     "type": "ENTRY",
-                    "data": f"{{'action':'ENTRY','exchange':'{exchange}','alertName':'{self.alert_name}','symbol':'{instrument.exchange_symbol}','side':'{side}','leverage':{abs(current_leverage)},'entryPrice':{price}}}",
+                    "data": f"{{'action':'ENTRY','exchange':'{exchange}','alertName':'{self.alert_name}','symbol':'{instrument.exchange_symbol.upper()}','side':'{side}','leverage':{abs(current_leverage)},'entryPrice':{price}}}",
                 }
 
             # Calculate the fraction of the position that was closed
@@ -108,5 +108,5 @@ class IncrementalFormatter(DefaultFormatter):
 
             return {
                 "type": "EXIT",
-                "data": f"{{'action':'EXIT','exchange':'{exchange}','alertName':'{self.alert_name}','symbol':'{instrument.exchange_symbol}','exitFraction':{exit_fraction},'exitPrice':{price}}}",
+                "data": f"{{'action':'EXIT','exchange':'{exchange}','alertName':'{self.alert_name}','symbol':'{instrument.exchange_symbol.upper()}','exitFraction':{exit_fraction},'exitPrice':{price}}}",
             }

{qubx-0.6.74 → qubx-0.6.76}/src/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-0.6.74 → qubx-0.6.76}/src/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-0.6.74 → qubx-0.6.76}/src/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-0.6.74 → qubx-0.6.76}/src/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-0.6.74 → qubx-0.6.76}/src/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