bquant 0.0.1__tar.gz → 0.0.2__tar.gz

{bquant-0.0.1 → bquant-0.0.2}/CHANGELOG.md

@@ -9,6 +9,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.2] - 2026-07-20
+
+### Added
+- **`SwingPoint.confirmation_index`** — маркер причинной доступности свинга: индекс
+  бара, к которому пивот (и его `amplitude_to_next`) причинно подтверждён. Позволяет
+  строить leak-free / look-ahead-free потребителей (устранение утечки J1). Реализован
+  для ZigZag-стратегии; прочие свинг-стратегии оставляют `None` (контракт допускает
+  мягкую деградацию). Сериализуется в `SwingContext.to_dict()`. (PR #107)
+
+### Changed
+- **`CACHE_SCHEMA_VERSION` повышена до 2** — ключ дискового кэша зон-анализа теперь
+  учитывает версию схемы вывода, инвалидируя старые кэши без `confirmation_index`.
+  Инвариант: любое изменение схемы/семантики кэшируемого вывода обязано бампать
+  `CACHE_SCHEMA_VERSION`.
+
+## [0.0.1] - 2026-01-12
+
 ### Added
 - Initial release of BQuant package
 - Complete migration from Quanto project

{bquant-0.0.1/bquant.egg-info → bquant-0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bquant
-Version: 0.0.1
+Version: 0.0.2
 Summary: Quantitative research toolkit for financial markets
 Author-email: kogriv <kogriv@gmail.com>
 License: MIT
@@ -59,6 +59,10 @@ Requires-Dist: jupyter==1.1.1; extra == "full"
 Requires-Dist: ipywidgets==8.1.7; extra == "full"
 Requires-Dist: plotly==6.3.0; extra == "full"
 Requires-Dist: kaleido==1.0.0; extra == "full"
+Provides-Extra: research
+Requires-Dist: pycatch22>=0.4.5; extra == "research"
+Requires-Dist: pyts>=0.13.0; extra == "research"
+Requires-Dist: tslearn>=0.9.0; extra == "research"
 Dynamic: license-file
 
 # BQuant - Quantitative Research Toolkit

{bquant-0.0.1 → bquant-0.0.2}/bquant/__init__.py

@@ -5,7 +5,7 @@ A comprehensive toolkit for quantitative analysis of financial data,
 starting with MACD analysis and expandable to all aspects of market research.
 """
 
-__version__ = "0.0.1"
+__version__ = "0.0.2"
 __author__ = "kogriv"
 __email__ = "kogriv@gmail.com"
 

{bquant-0.0.1 → bquant-0.0.2}/bquant/analysis/zones/models.py

@@ -43,6 +43,19 @@ class SwingPoint:
         duration_to_next: Number of bars to the next swing point (if available).
         strategy_name: Name of the strategy that detected the swing.
         strategy_params: Parameters of the strategy for traceability.
+        confirmation_index: Integer position of the bar by which this swing is
+            **causally confirmed** — i.e. the earliest bar at which a downstream,
+            leak-free consumer may treat the pivot (and therefore its
+            ``amplitude_to_next``) as known. Always ``>= index``. ``None`` means the
+            pivot is not yet confirmed within the available data (typically the last,
+            still-forming swing). The confirmation rule is **strategy-specific** (a
+            ZigZag pivot confirms once price retraces the configured deviation; a
+            fractal/pivot-point swing confirms after its fixed look-ahead window; etc.),
+            so each swing strategy populates this field per its own semantics. A strategy
+            that does not compute it leaves ``None``, and consumers must degrade
+            gracefully. This field exists to let forecasting/OOS code build prefixes
+            strictly from swings available at decision time, avoiding look-ahead through
+            ``amplitude_to_next`` (whose endpoint lies in the future of ``index``).
 
     Example:
         >>> from datetime import datetime
@@ -67,6 +80,7 @@ class SwingPoint:
     duration_to_next: Optional[int] = None
     strategy_name: str = ""
     strategy_params: Dict[str, Any] = None
+    confirmation_index: Optional[int] = None
 
     def __post_init__(self) -> None:
         if self.strategy_params is None:
@@ -162,6 +176,7 @@ class SwingContext:
                     "duration_to_next": sp.duration_to_next,
                     "strategy_name": sp.strategy_name,
                     "strategy_params": sp.strategy_params,
+                    "confirmation_index": sp.confirmation_index,
                 }
                 for sp in self.swing_points
             ],

{bquant-0.0.1 → bquant-0.0.2}/bquant/analysis/zones/pipeline.py

@@ -43,6 +43,12 @@ _SWING_CLASS_TO_NAME = {
     PivotPointsSwingStrategy: "pivot_points",
 }
 
+# Bump whenever the schema/semantics of cached analysis output changes (new
+# SwingPoint/ZoneInfo fields, changed swing computation, etc.), so that on-disk
+# caches computed under an older schema are not silently served.
+#   v2 (2026-07): SwingPoint.confirmation_index added (causal availability).
+CACHE_SCHEMA_VERSION = 2
+
 
 @dataclass
 class IndicatorConfig:
@@ -66,7 +72,7 @@ class ZoneAnalysisConfig:
     n_clusters: int = 3
     run_regression: bool = False
     run_validation: bool = False
-    swing_scope: Literal["per_zone", "global"] = "per_zone"
+    swing_scope: Literal["per_zone", "global"] = "global"
 
     def to_cache_key(self) -> str:
         """Serialize configuration into a stable JSON string for caching."""
@@ -89,6 +95,7 @@ class ZoneAnalysisConfig:
             "run_regression": self.run_regression,
             "run_validation": self.run_validation,
             "swing_scope": self.swing_scope,
+            "schema_version": CACHE_SCHEMA_VERSION,
         }
         return json.dumps(payload, sort_keys=True, default=str)
 
@@ -486,7 +493,7 @@ class ZoneAnalysisBuilder:
         result = (
             analyze_zones(df)
             .with_indicator('custom', 'macd', fast=12, slow=26, signal=9)
-            .detect_zones('zero_crossing', indicator_col='macd_histogram')
+            .detect_zones('zero_crossing', indicator_col='macd')
             .analyze(clustering=True, n_clusters=3)
             .build()
         )
@@ -511,7 +518,7 @@ class ZoneAnalysisBuilder:
         self._volume_strategy: Optional[str] = None
         self._swing_preset: Optional[str] = None
         self._auto_swing_thresholds = False
-        self._swing_scope: Literal["per_zone", "global"] = "per_zone"
+        self._swing_scope: Literal["per_zone", "global"] = "global"
         self.logger = get_logger(__name__)
     
     def with_indicator(self, 
@@ -724,7 +731,7 @@ def analyze_zones(df: pd.DataFrame) -> ZoneAnalysisBuilder:
         # Минимальный пример
         result = (
             analyze_zones(df)
-            .detect_zones('zero_crossing', indicator_col='macd_histogram')
+            .detect_zones('zero_crossing', indicator_col='macd')
             .build()
         )
         
@@ -732,7 +739,7 @@ def analyze_zones(df: pd.DataFrame) -> ZoneAnalysisBuilder:
         result = (
             analyze_zones(df)
             .with_indicator('custom', 'macd', fast=12, slow=26, signal=9)
-            .detect_zones('zero_crossing', indicator_col='macd_histogram')
+            .detect_zones('zero_crossing', indicator_col='macd')
             .analyze(clustering=True, n_clusters=3, regression=True)
             .with_cache(enable=True, ttl=7200)
             .build()

{bquant-0.0.1 → bquant-0.0.2}/bquant/analysis/zones/presets.py

@@ -40,6 +40,7 @@ def analyze_macd_zones(df: pd.DataFrame,
                        min_duration: int = 2,
                        zone_types: Optional[list] = None,
                        smooth_window: Optional[int] = None,
+                       zone_basis: str = 'line',
                        clustering: bool = True,
                        n_clusters: int = 3,
                        regression: bool = False,
@@ -62,6 +63,11 @@ def analyze_macd_zones(df: pd.DataFrame,
         min_duration: Минимальная длительность зоны в барах (default: 2)
         zone_types: Типы зон для анализа (default: ['bull', 'bear'])
         smooth_window: Окно сглаживания для детекции (optional)
+        zone_basis: На чём детектировать зону (default: 'line'):
+            'line' — по знаку линии MACD (MACD>0/<0), длинные стабильные зоны,
+                     как в методологии проекта (indicator_col='macd');
+            'histogram' — по знаку гистограммы (MACD−signal), более короткие
+                     волатильные зоны (indicator_col='macd_hist', legacy).
         clustering: Выполнять кластеризацию (default: True)
         n_clusters: Количество кластеров (default: 3)
         regression: Запустить регрессионный анализ (default: False)
@@ -90,14 +96,21 @@ def analyze_macd_zones(df: pd.DataFrame,
         # Визуализация
         result.visualize('overview')
     """
+    _basis_to_col = {'line': 'macd', 'histogram': 'macd_hist'}
+    if zone_basis not in _basis_to_col:
+        raise ValueError(
+            f"zone_basis must be 'line' or 'histogram', got {zone_basis!r}"
+        )
+    indicator_col = _basis_to_col[zone_basis]
+
     builder = (
         analyze_zones(df)
-        .with_indicator('custom', 'macd', 
-                       fast_period=fast, 
-                       slow_period=slow, 
+        .with_indicator('custom', 'macd',
+                       fast_period=fast,
+                       slow_period=slow,
                        signal_period=signal)
-        .detect_zones('zero_crossing', 
-                     indicator_col='macd_hist',
+        .detect_zones('zero_crossing',
+                     indicator_col=indicator_col,
                      min_duration=min_duration,
                      zone_types=zone_types,
                      smooth_window=smooth_window)

{bquant-0.0.1 → bquant-0.0.2}/bquant/analysis/zones/strategies/swing/zigzag.py

@@ -49,13 +49,14 @@ class ZigZagSwingStrategy:
                 len(full_data),
                 self.legs * 2,
             )
-            return SwingContext(
-                swing_points=[],
-                indices=np.array([], dtype=int),
-                full_data_length=len(full_data),
-                strategy_name='zigzag',
-                strategy_params={'legs': self.legs, 'deviation': self.deviation},
+            return self._empty_context(len(full_data))
+
+        if self._is_degenerate(full_data):
+            logger.warning(
+                "ZigZag global: degenerate input (near-constant high/low). "
+                "Skipping pandas-ta zigzag and returning empty SwingContext."
             )
+            return self._empty_context(len(full_data))
 
         from .....indicators import LibraryManager
 
@@ -71,13 +72,7 @@ class ZigZagSwingStrategy:
             logger.warning(
                 "ZigZag returned insufficient columns, no swings detected"
             )
-            return SwingContext(
-                swing_points=[],
-                indices=np.array([], dtype=int),
-                full_data_length=len(full_data),
-                strategy_name='zigzag',
-                strategy_params={'legs': self.legs, 'deviation': self.deviation},
-            )
+            return self._empty_context(len(full_data))
 
         swing_values = result.data.iloc[:, 1].dropna()
 
@@ -85,13 +80,7 @@ class ZigZagSwingStrategy:
             logger.warning(
                 "ZigZag detected fewer than two swing points in global mode"
             )
-            return SwingContext(
-                swing_points=[],
-                indices=np.array([], dtype=int),
-                full_data_length=len(full_data),
-                strategy_name='zigzag',
-                strategy_params={'legs': self.legs, 'deviation': self.deviation},
-            )
+            return self._empty_context(len(full_data))
 
         swing_points: List[SwingPoint] = []
         indices: List[int] = []
@@ -99,6 +88,9 @@ class ZigZagSwingStrategy:
         timestamps = swing_values.index.to_list()
         prices = swing_values.to_list()
 
+        high_arr = full_data['high'].to_numpy(dtype=float)
+        low_arr = full_data['low'].to_numpy(dtype=float)
+
         for point_id, (timestamp, price) in enumerate(zip(timestamps, prices)):
             ts = timestamp.to_pydatetime() if hasattr(timestamp, "to_pydatetime") else timestamp
             position_arr = full_data.index.get_indexer([timestamp])
@@ -118,6 +110,7 @@ class ZigZagSwingStrategy:
 
             amplitude_to_next: Optional[float] = None
             duration_to_next: Optional[int] = None
+            confirmation_index: Optional[int] = None
             if point_id < len(prices) - 1:
                 next_price = prices[point_id + 1]
                 next_timestamp = timestamps[point_id + 1]
@@ -127,6 +120,10 @@ class ZigZagSwingStrategy:
                     if price != 0:
                         amplitude_to_next = (next_price / price - 1) * 100
                     duration_to_next = max(0, next_position - position)
+                    confirmation_index = self._confirmation_index(
+                        position, next_position, float(price), swing_type,
+                        high_arr, low_arr,
+                    )
 
             swing_points.append(
                 SwingPoint(
@@ -139,6 +136,7 @@ class ZigZagSwingStrategy:
                     duration_to_next=duration_to_next,
                     strategy_name='zigzag',
                     strategy_params={'legs': self.legs, 'deviation': self.deviation},
+                    confirmation_index=confirmation_index,
                 )
             )
             indices.append(position)
@@ -182,6 +180,13 @@ class ZigZagSwingStrategy:
         """
         self._validate_input(zone_data)
 
+        if self._is_degenerate(zone_data):
+            logger.debug(
+                "ZigZag: degenerate zone input (near-constant high/low), "
+                "returning empty metrics"
+            )
+            return self._empty_metrics()
+
         try:
             # Import LibraryManager dynamically to avoid circular imports
             from .....indicators import LibraryManager
@@ -413,9 +418,69 @@ class ZigZagSwingStrategy:
 
         return metrics
 
+    def _confirmation_index(
+        self,
+        position: int,
+        next_position: int,
+        price: float,
+        swing_type: str,
+        high_arr: np.ndarray,
+        low_arr: np.ndarray,
+    ) -> int:
+        """Bar by which this ZigZag pivot is causally confirmed.
+
+        A peak is confirmed at the first bar after ``position`` whose low has
+        fallen ``deviation`` below the pivot price; a trough, at the first bar
+        whose high has risen ``deviation`` above it. This is the ZigZag-specific
+        realisation of the generic :attr:`SwingPoint.confirmation_index` contract:
+        it is the point at which a repainting ZigZag "locks in" the previous swing,
+        i.e. when the next leg starts drawing. It is guaranteed to occur no later
+        than ``next_position`` (the next pivot already exceeds the deviation
+        threshold), which is used as a safe upper bound if no earlier crossing is
+        found. ``deviation`` is a fraction (0.05 == 5%), matching the pivot scale.
+        """
+        if next_position <= position:
+            return next_position
+        if swing_type == 'peak':
+            threshold = price * (1.0 - self.deviation)
+            seg = low_arr[position + 1:next_position + 1]
+            hits = np.nonzero(seg <= threshold)[0]
+        else:
+            threshold = price * (1.0 + self.deviation)
+            seg = high_arr[position + 1:next_position + 1]
+            hits = np.nonzero(seg >= threshold)[0]
+        if len(hits):
+            return position + 1 + int(hits[0])
+        return next_position
+
     def _empty_metrics(self) -> SwingMetrics:
         return self._aggregate_metrics([], [])
 
+    def _empty_context(self, full_data_length: int) -> SwingContext:
+        return SwingContext(
+            swing_points=[],
+            indices=np.array([], dtype=int),
+            full_data_length=full_data_length,
+            strategy_name='zigzag',
+            strategy_params={'legs': self.legs, 'deviation': self.deviation},
+        )
+
+    def _is_degenerate(self, data: pd.DataFrame) -> bool:
+        """
+        Detect input that makes pandas-ta's numba ZigZag segfault.
+
+        The nopython ZigZag kernel has no bounds checking and crashes (native
+        SIGSEGV/SIGABRT, uncatchable by try/except) when ``high`` or ``low`` is
+        (near-)constant, i.e. lacks enough distinct levels to form pivots over
+        ``legs``-bar windows. Real OHLC data has hundreds of distinct levels and
+        is never flagged; only degenerate/flat segments are. See
+        devref/gaps/zo/zo_issue_numba_linux_testsuite_2026-07.md.
+        """
+        return (
+            data['high'].nunique() < self.legs
+            or data['low'].nunique() < self.legs
+        )
+
     def _validate_input(self, data: pd.DataFrame) -> None:
         required_cols = {'high', 'low', 'close'}
         missing = required_cols.difference(data.columns)

bquant-0.0.2/bquant/visualization/utils.py

@@ -0,0 +1,211 @@
+"""
+Утилиты для визуализации BQuant.
+
+Содержит вспомогательные функции для работы с временными рядами,
+форматирования меток осей и других задач визуализации.
+"""
+from typing import List, Tuple
+import pandas as pd
+
+
+def find_all_gaps(dt_index: pd.DatetimeIndex) -> list[list[str]]:
+    """
+    Анализирует DatetimeIndex, находит разрывы и возвращает их в формате,
+    совместимом с Plotly rangebreaks.
+    """
+    if not isinstance(dt_index, pd.DatetimeIndex) or len(dt_index) < 2:
+        return []
+
+    # 1. Вычисляем разницу во времени между соседними точками
+    time_diffs = dt_index.to_series().diff()
+
+    # 2. Определяем нормальный интервал (медиана - для устойчивости к выбросам)
+    #    и порог для определения "разрыва" (например, в 1.5 раза больше нормы)
+    normal_interval = time_diffs.median()
+    gap_threshold = normal_interval * 1.5
+
+    # 3. Находим все точки, где начинается разрыв
+    gaps = time_diffs[time_diffs > gap_threshold]
+
+    if gaps.empty:
+        return []
+
+    # 4. Формируем список интервалов для Plotly
+    #    Plotly ожидает список вида [ [start1, end1], [start2, end2], ... ]
+    #    где start и end - строки в формате ISO (например, "2025-06-28T00:00:00")
+    rangebreak_values = []
+    for gap_end_time, duration in gaps.items():
+        gap_start_time = gap_end_time - duration
+        
+        # Конвертируем Timestamp в строки ISO для Plotly
+        # Plotly rangebreaks требует строки в формате ISO
+        start_str = gap_start_time.isoformat() if hasattr(gap_start_time, 'isoformat') else str(gap_start_time)
+        end_str = gap_end_time.isoformat() if hasattr(gap_end_time, 'isoformat') else str(gap_end_time)
+        
+        # Добавляем интервал в формате, который понимает Plotly
+        rangebreak_values.append([start_str, end_str])
+    
+    return rangebreak_values
+
+
+def generate_dense_axis_labels(
+    timestamps: List[pd.Timestamp],
+    positions: List[int],
+    num_ticks_requested: int = 16
+) -> Tuple[List[int], List[str]]:
+    """
+    Генерирует умные метки для оси X в режиме 'dense'.
+    
+    Создает двухэтажные метки с адаптивным форматированием на основе
+    временного диапазона данных. Используется в визуализации зон для
+    единообразного отображения временных меток на графиках.
+    
+    Логика форматирования:
+    - < 24 часа: только время (%H:%M)
+    - < 7 дней: дата и время (%d.%m + %H:%M) - двухэтажные метки
+    - < 30 дней: дата, время опционально (если все времена одинаковые - только дата)
+    - >= 30 дней: дата, год отдельно (%d.%m + жирный год) - двухэтажные метки
+    
+    Args:
+        timestamps: Список временных меток (pd.Timestamp или совместимые типы).
+                    Может быть получен из DataFrame.index
+        positions: Список позиционных индексов (0..N-1) для оси X.
+                   Должен соответствовать timestamps по длине
+        num_ticks_requested: Желаемое количество меток (по умолчанию 16).
+                            Автоматически корректируется на основе временного
+                            диапазона для оптимальной читаемости
+    
+    Returns:
+        Кортеж (tickvals, ticktext):
+        - tickvals: List[int] - позиции на оси X для меток
+        - ticktext: List[str] - текстовые метки (могут содержать HTML для двухэтажных меток)
+    
+    Example:
+        >>> import pandas as pd
+        >>> from bquant.visualization.utils import generate_dense_axis_labels
+        >>> 
+        >>> # Подготовка данных
+        >>> timestamps = pd.date_range('2025-01-01', periods=100, freq='H')
+        >>> positions = list(range(len(timestamps)))
+        >>> 
+        >>> # Генерация меток
+        >>> tickvals, ticktext = generate_dense_axis_labels(timestamps, positions, num_ticks_requested=16)
+        >>> 
+        >>> # Использование в Plotly
+        >>> fig.update_xaxes(tickmode='array', tickvals=tickvals, ticktext=ticktext)
+    """
+    # Проверяем входные данные (безопасная проверка для pandas объектов)
+    if not timestamps or len(timestamps) == 0:
+        return [], []
+    if not positions or len(positions) == 0:
+        return [], []
+    
+    # Преобразуем timestamps в список pd.Timestamp для единообразия
+    # Обрабатываем разные типы входных данных (list, Index, Series)
+    if hasattr(timestamps, '__iter__') and not isinstance(timestamps, str):
+        x_dates = [pd.Timestamp(ts) if not isinstance(ts, pd.Timestamp) else ts for ts in timestamps]
+    else:
+        x_dates = [pd.Timestamp(timestamps)] if timestamps else []
+    
+    # Определяем количество тиков (умная логика на основе временного диапазона)
+    data_points = len(positions)
+    if data_points > 0 and len(x_dates) > 0:
+        time_range = (x_dates[-1] - x_dates[0]).total_seconds()
+        if time_range < 3600 * 24:
+            # Меньше суток: больше тиков (30 точек на тик)
+            ideal_ticks = max(8, min(20, data_points // 30))
+        elif time_range < 3600 * 24 * 7:
+            # Меньше недели: средняя плотность (6 точек на тик)
+            ideal_ticks = max(8, min(20, data_points // 6))
+        elif time_range < 3600 * 24 * 30:
+            # Меньше месяца: меньше тиков (2 точки на тик)
+            ideal_ticks = max(8, min(20, data_points // 2))
+        else:
+            # Больше месяца: минимальная плотность (10 точек на тик)
+            ideal_ticks = max(8, min(20, data_points // 10))
+        num_ticks = max(8, min(num_ticks_requested, ideal_ticks, data_points))
+    else:
+        num_ticks = max(8, min(num_ticks_requested, len(positions)))
+    
+    tick_step = max(1, len(positions) // num_ticks) if num_ticks > 0 else 1
+    tick_positions = positions[::tick_step]
+    
+    # Умное форматирование даты/времени на основе временного диапазона
+    show_date, show_time, show_year_separately = True, True, False
+    if len(x_dates) > 0:
+        time_range = (x_dates[-1] - x_dates[0]).total_seconds()
+        if time_range < 3600 * 24:
+            # Меньше суток: только время
+            date_format, time_format, show_date = '%H:%M', '%H:%M', False
+        elif time_range < 3600 * 24 * 7:
+            # Меньше недели: дата и время
+            date_format, time_format = '%d.%m', '%H:%M'
+        elif time_range < 3600 * 24 * 30:
+            # Меньше месяца: дата, время опционально
+            date_format = '%d.%m'
+            unique_times = set(dt.strftime('%H:%M') for dt in x_dates if hasattr(dt, 'strftime'))
+            if len(unique_times) == 1:
+                # Все времена одинаковые - показываем только дату
+                time_format, show_time = '%d.%m', False
+            else:
+                time_format = '%H:%M'
+        else:
+            # Больше месяца: дата, год отдельно
+            date_format, time_format, show_time, show_year_separately = '%d.%m', '%d.%m', False, True
+    else:
+        date_format, time_format = '%d.%m', '%H:%M'
+    
+    # Формируем двухэтажные метки
+    tick_labels = []
+    prev_year = None
+    for i in range(0, len(positions), tick_step):
+        if i < len(x_dates):
+            date_obj = x_dates[i]
+            current_year = date_obj.year if hasattr(date_obj, 'year') else None
+            show_year = show_year_separately and (prev_year is None or current_year != prev_year)
+            
+            if hasattr(date_obj, 'strftime'):
+                date_str = date_obj.strftime(date_format)
+                time_str = date_obj.strftime(time_format)
+            else:
+                date_str = str(date_obj)
+                time_str = str(date_obj)
+            
+            # Формируем метку с двухэтажным форматом (HTML для Plotly)
+            if show_year and current_year is not None:
+                label = f"{date_str}<br><b>{current_year}</b>"
+            elif show_date and show_time and date_str != time_str:
+                label = f"{date_str}<br>{time_str}"
+            elif show_date:
+                label = date_str
+            else:
+                label = time_str
+            
+            tick_labels.append(label)
+            prev_year = current_year
+        else:
+            tick_labels.append('')
+    
+    # Гарантируем наличие последнего тика для полноты отображения
+    if positions and positions[-1] not in tick_positions:
+        last_idx = len(positions) - 1
+        if last_idx < len(x_dates):
+            date_obj = x_dates[last_idx]
+            if hasattr(date_obj, 'strftime'):
+                date_str = date_obj.strftime(date_format)
+                time_str = date_obj.strftime(time_format)
+            else:
+                date_str = str(date_obj)
+                time_str = str(date_obj)
+            
+            if show_date and show_time and date_str != time_str:
+                label = f"{date_str}<br>{time_str}"
+            elif show_date:
+                label = date_str
+            else:
+                label = time_str
+            
+            tick_positions.append(positions[-1])
+            tick_labels.append(label)
+    
+    return tick_positions, tick_labels