bquant 0.0.2__tar.gz → 0.0.4__tar.gz

bquant-0.0.4/CHANGELOG.md

@@ -0,0 +1,185 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+
+
+## [Unreleased]
+
+## [0.0.4] - 2026-08-18
+
+Релиз о **честности `confirmation_index`**: в 0.0.2/0.0.3 поле было заявлено как маркер
+причинной доступности для leak-free потребителей, но ни одна из трёх свинг-стратегий не
+удовлетворяла контракту строго. Теперь удовлетворяют все три — проверено оракулом, который
+пере-прогоняет **реальный детектор** под усечением сырого OHLC.
+
+### Fixed
+- **ZigZag `confirmation_index` теперь replay-causal (issue #110).** `calculate_global` вызывает
+  pandas-ta zigzag с `backtest=True` — не перерисовывающий поток вместо дефолтного центрированного
+  `backtest=False`, который под усечением сырого OHLC добавлял/двигал/удалял ранние пивоты.
+  `_confirmation_index` — дивиденс-ретрейс без искусственного floor; первый пивот наследует
+  confirmation второго (детектор не эмитит ничего до 2-й свинги). Repaint-нарушения на встроенном
+  сэмпле: **35% → 0%**, стабильно на legs∈{2,3,5}. (PR #111)
+- **`find_peaks` и `pivot_points` доведены до строгой replay-safety (G14).** У `find_peaks`
+  причина оказалась не в prominence, как предполагалось изначально, а в **порядке фильтров
+  scipy**: `distance` применяется **до** `prominence`, жадно по высоте и по всему множеству сырых
+  локальных максимумов, поэтому экстремум, подавленный более высоким соседом, оживает, когда
+  сосед сам снимается ещё более высоким справа. Confirmation теперь ждёт устаканивания всей
+  цепочки подавления, а не фиксированного окна `index + distance`. У `pivot_points` N-баровый
+  паттерн локален и точен, но контекст не эмитится, пока экстремумов меньше двух, — поэтому
+  первый пивот наследует confirmation второго, как в ZigZag. Нарушений **0 на 12 конфигурациях**;
+  цена — 3 экстремума из 345 подтверждаются позже (в среднем +0.035 бара).
+
+### Changed
+- **`CACHE_VERSION` 2 → 4, `CACHE_SCHEMA_VERSION` 3 → 4** — сериализованная семантика свингов и
+  значения `confirmation_index` изменились дважды (ZigZag `backtest=True`; устаканивание
+  distance-цепочки и warm-up первого свинга). Старые кэши инвалидируются.
+
+### Added
+- **`tests/unit/test_swing_replay_causal.py`** — оракул replay-каузальности: пере-прогон реального
+  детектора под усечением, а не monkeypatch фиксированного списка пивотов. Покрывает обе стороны
+  контракта: свинг, объявленный доступным на баре `t`, обязан (а) уже присутствовать при расчёте
+  на `data[:t+1]` и (б) не исчезнуть из полной истории позже.
+
+### Known limitations
+- **Авто-prominence `find_peaks` не устойчив к усечению (G15).** При `prominence=None` — это
+  **дефолт** стратегии — порог выводится из наблюдённого диапазона цен и растёт по мере прихода
+  баров (на встроенном сэмпле 1.275 → 2.071). Экстремум, прошедший ранний меньший порог, позже
+  проваливает больший и исчезает. `confirmation_index` это не лечит: движется сам фильтр.
+  **Кому нужна replay-safety — задавайте `prominence` явно**, тогда нарушений нет. Исправление
+  требует смены семантики детекции и будет отдельным решением.
+
+## [0.0.3] - 2026-07-24
+
+### Added
+- **`confirmation_index` для стратегий `find_peaks` и `pivot_points`** — маркер причинной
+  доступности свинга теперь заполняется всеми свинг-стратегиями, а не только ZigZag (0.0.2).
+  Для `pivot_points` это точное fractal-подтверждение (`index + right_bars`); для `find_peaks` —
+  causal leak-free (`max(index + distance, бар prominence-ретрейса справа)`). Позволяет строить
+  look-ahead-free потребителей на любой свинг-стратегии. (PR #108)
+
+### Changed
+- **`CACHE_SCHEMA_VERSION` повышена 2 → 3** — `find_peaks`/`pivot_points` теперь заполняют
+  `confirmation_index`, что меняет семантику кэшируемого вывода; старые кэши инвалидируются.
+
+### Fixed
+- **ZigZag: мягкая деградация при отсутствии pandas-ta `zigzag`.** В глобальном режиме
+  (`swing_scope='global'`) стратегия теперь возвращает пустой `SwingContext` с понятным
+  предупреждением вместо исключения, когда опциональный индикатор pandas-ta `zigzag`
+  недоступен — как уже делал per-zone режим. Пайплайн больше не логирует ошибку/traceback
+  на этом пути.
+
+## [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
+- Comprehensive technical analysis framework
+- MACD zone analysis with statistical testing
+- Advanced data processing and validation
+- Professional visualization system
+- Embedded sample data for testing
+- CLI scripts for analysis automation
+- Complete documentation and examples
+- **Zone Metrics Visualization (v1.0)** - 2025-11-11
+  - Aggregate metrics display with `show_aggregate_metrics` parameter (compact/full modes)
+  - Swing points visualization on charts with `show_swings` parameter
+  - Detail mode zone metrics with `show_zone_metrics` parameter
+  - Date range filtering with automatic metrics recalculation for selected period
+  - Support for unbalanced swings in global swing mode
+  - See [docs/api/visualization/zones.md](docs/api/visualization/zones.md) for details
+
+
+## [0.0.0] - 2024-08-25
+
+### Added
+- Foundation for BQuant project
+- Basic project structure
+- Core configuration system
+- Initial test framework
+- Initial beta release
+- Basic MACD analysis functionality
+- Core data processing capabilities
+- Preliminary documentation
+
+### Structure
+
+- **Core Modules**: Configuration, exceptions, logging, performance, utilities
+- **Data Modules**: Loader, processor, validator, samples, schemas
+- **Indicators**: Base classes, MACD analyzer, factory pattern
+- **Analysis**: Statistical analysis, zone analysis, hypothesis testing
+- **Visualization**: Financial charts, zone visualization, statistical plots, themes
+- **Research Structure**: Notebooks, methodology, experiments, studies
+- **Scripts**: Analysis automation, data processing, deployment tools
+- **Documentation**: Complete API reference, user guide, tutorials, examples
+
+### Technical Features
+- **MACD Zone Analysis**: Advanced MACD analysis with zone identification
+- **Statistical Testing**: Comprehensive hypothesis testing framework
+- **Data Processing**: Robust data loading, cleaning, and validation
+- **Performance Optimization**: Caching system and optimized algorithms
+- **Visualization**: Professional charts with multiple themes
+- **Sample Data**: Embedded financial data for testing and examples
+
+### Architecture
+- **Modular Design**: Clean separation of concerns
+- **Type Safety**: Full type hints and validation
+- **Error Handling**: Comprehensive exception system
+- **Logging**: Professional logging with multiple levels
+- **Testing**: Complete test coverage with pytest
+- **Documentation**: Sphinx-based documentation system
+
+### Dependencies
+- **Core**: pandas, numpy, matplotlib, seaborn
+- **Analysis**: scipy, scikit-learn, statsmodels
+- **Visualization**: plotly, seaborn
+- **Development**: pytest, black, flake8, mypy
+
+---
+
+## Version History
+
+### Semantic Versioning
+- **MAJOR**: Incompatible API changes
+- **MINOR**: New functionality in backward-compatible manner
+- **PATCH**: Backward-compatible bug fixes
+
+### Release Schedule
+- **Major releases**: Every 6 months
+- **Minor releases**: Every 2-4 weeks
+- **Patch releases**: As needed for critical fixes
+
+### Support Policy
+- **Current version**: Full support
+- **Previous major version**: Bug fixes only
+- **Older versions**: No support
+
+---
+
+## Contributing
+
+Please see [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code of conduct and the process for submitting pull requests.
+
+## Acknowledgments
+
+- Original Quanto project contributors
+- Open source financial analysis community
+- Python packaging and documentation tools

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bquant
-Version: 0.0.2
+Version: 0.0.4
 Summary: Quantitative research toolkit for financial markets
 Author-email: kogriv <kogriv@gmail.com>
 License: MIT

{bquant-0.0.2 → bquant-0.0.4}/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.2"
+__version__ = "0.0.4"
 __author__ = "kogriv"
 __email__ = "kogriv@gmail.com"
 

{bquant-0.0.2 → bquant-0.0.4}/bquant/analysis/zones/cache.py

@@ -27,7 +27,12 @@ class ZoneAnalysisCache:
     entries are automatically invalidated when the schema version increases.
     """
 
-    CACHE_VERSION = 2
+    # v3 (issue #110): ZigZag swings now come from the non-repainting backtest=True
+    # detector, so serialized swing sets / confirmation_index differ from v2.
+    # v4 (G14): find_peaks confirmation waits for the distance-suppression chain to
+    # settle, and both find_peaks and pivot_points hold the first swing back to the
+    # second's confirmation — serialized confirmation_index values differ from v3.
+    CACHE_VERSION = 4
 
     def __init__(self, cache_manager: Optional[Any]) -> None:
         self._cache_manager = cache_manager

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

@@ -47,7 +47,11 @@ _SWING_CLASS_TO_NAME = {
 # 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
+#   v3 (2026-07): confirmation_index now populated by find_peaks & pivot_points
+#                 (previously only zigzag; changes cached swing output).
+#   v4 (2026-08): find_peaks & pivot_points confirmation_index made replay-safe
+#                 (G14) — distance-chain settling + first-swing warm-up hold.
+CACHE_SCHEMA_VERSION = 4
 
 
 @dataclass

{bquant-0.0.2 → bquant-0.0.4}/bquant/analysis/zones/strategies/swing/find_peaks.py

@@ -53,6 +53,20 @@ class FindPeaksSwingStrategy:
         swing_points: List[SwingPoint] = []
         indices: List[int] = []
 
+        high_arr = full_data['high'].to_numpy(dtype=float)
+        low_arr = full_data['low'].to_numpy(dtype=float)
+        full_len = len(full_data)
+
+        # Detection series per swing type (troughs are found on the negated lows,
+        # exactly as in `_detect_extrema`) plus their *unfiltered* local maxima —
+        # the raw input scipy's `distance` filter operates on, needed to settle
+        # that filter's verdict in `_distance_settled_bar`.
+        series_by_type = {'peak': high_arr, 'trough': -low_arr}
+        maxima_by_type = {
+            swing_type: find_peaks(series)[0]
+            for swing_type, series in series_by_type.items()
+        }
+
         for point_id, point in enumerate(extrema):
             timestamp = point['timestamp']
             ts = (
@@ -74,6 +88,14 @@ class FindPeaksSwingStrategy:
                     0, int(next_point['index']) - index_position
                 )
 
+            confirmation_index = self._confirmation_index(
+                index_position,
+                prominence_value,
+                series_by_type[point['type']],
+                maxima_by_type[point['type']],
+                full_len,
+            )
+
             swing_points.append(
                 SwingPoint(
                     point_id=point_id,
@@ -85,10 +107,22 @@ class FindPeaksSwingStrategy:
                     duration_to_next=duration_to_next,
                     strategy_name='find_peaks',
                     strategy_params=self._build_strategy_params(prominence_value),
+                    confirmation_index=confirmation_index,
                 )
             )
             indices.append(index_position)
 
+        # Warm-up (issue #110 follow-up / G14): a context is only emitted once at
+        # least two extrema exist (see the guard above), so a lone first extremum
+        # is not yet observable at its own confirmation — it appears together with
+        # the second one. Pin its availability to the second's, as ZigZag does.
+        if len(swing_points) >= 2 and swing_points[0].confirmation_index is not None \
+                and swing_points[1].confirmation_index is not None:
+            swing_points[0].confirmation_index = max(
+                swing_points[0].confirmation_index,
+                swing_points[1].confirmation_index,
+            )
+
         logger.info(
             "FindPeaks global: detected %d swing points", len(swing_points)
         )
@@ -387,6 +421,90 @@ class FindPeaksSwingStrategy:
 
         return metrics
 
+    def _distance_settled_bar(
+        self, index: int, series: np.ndarray, maxima: np.ndarray
+    ) -> int:
+        """Bar by which scipy's ``distance`` verdict for ``index`` stops changing.
+
+        scipy applies ``distance`` *before* ``prominence``, greedily over **all**
+        raw local maxima by descending height: an extremum is dropped when a
+        higher one survives strictly within ``distance`` of it. That verdict is
+        therefore **not** settled at ``index + distance`` — the neighbour that
+        suppresses this extremum may itself be dropped later by a still higher
+        one further right, reviving this extremum. Observed on the embedded
+        sample: the peak at 178 is suppressed by 180 until 182 becomes visible
+        and removes 180, so 178 only appears two bars after ``index + distance``.
+
+        The verdict depends on the transitive *suppression chain*: every local
+        maximum within ``distance`` that is at least as high, then their own
+        suppressors, and so on (heights are non-decreasing along the chain, so it
+        terminates). A chain member at ``p`` has its own neighbourhood fully
+        observable at ``p + distance``; the chain — and hence this extremum's
+        verdict — is settled at the latest such bar.
+        """
+        settled = index + self.distance
+        seen = {index}
+        frontier = [index]
+
+        while frontier:
+            q = frontier.pop()
+            lo = np.searchsorted(maxima, q - self.distance, side='right')
+            hi = np.searchsorted(maxima, q + self.distance, side='left')
+            for candidate in maxima[lo:hi]:
+                p = int(candidate)
+                # only an at-least-as-high neighbour can suppress; ties are taken
+                # as suppressors (conservative — never confirms too early)
+                if p in seen or series[p] < series[q]:
+                    continue
+                seen.add(p)
+                frontier.append(p)
+                settled = max(settled, p + self.distance)
+
+        return settled
+
+    def _confirmation_index(
+        self,
+        index: int,
+        prominence: float,
+        series: np.ndarray,
+        maxima: np.ndarray,
+        full_len: int,
+    ) -> Optional[int]:
+        """Bar by which this find_peaks extremum is causally confirmed.
+
+        ``series`` is the detection series for this extremum's type (highs for
+        peaks, negated lows for troughs, as in :meth:`_detect_extrema`), so the
+        extremum is a maximum of ``series`` either way; ``maxima`` are that
+        series' unfiltered local maxima.
+
+        An extremum survives the global pass only if it clears BOTH the
+        ``distance`` and ``prominence`` filters, so it becomes causally known at
+        the later of two events:
+
+        * **distance settling** — the bar at which the suppression chain around
+          it resolves, see :meth:`_distance_settled_bar` (never earlier than
+          ``index + distance``);
+        * **prominence retrace** — the first bar after ``index`` at which the
+          right base falls ``prominence`` below the pivot. Truncation can only
+          shorten the right-base interval, so the computed prominence grows
+          monotonically with observed bars: once this bar is reached the
+          prominence filter stays cleared. The left base does not depend on
+          truncation and already clears the threshold for a kept extremum.
+
+        Returns ``max`` of the two (both are necessary), or ``None`` if the pivot
+        cannot yet be confirmed within the available data (retrace not reached, or
+        the settling bar lies past the end — a still-forming tail swing). This is
+        the ``find_peaks`` realisation of the generic
+        :attr:`SwingPoint.confirmation_index` contract, verified replay-safe by
+        ``tests/unit/test_swing_replay_causal`` (G14).
+        """
+        hits = np.nonzero(series[index + 1:] <= series[index] - prominence)[0]
+        if not len(hits):
+            return None
+        prominence_bar = index + 1 + int(hits[0])
+        conf = max(self._distance_settled_bar(index, series, maxima), prominence_bar)
+        return conf if conf < full_len else None
+
     def _empty_metrics(self) -> SwingMetrics:
         return self._aggregate_metrics(
             [],

{bquant-0.0.2 → bquant-0.0.4}/bquant/analysis/zones/strategies/swing/pivot_points.py

@@ -92,6 +92,10 @@ class PivotPointsSwingStrategy:
                     0, int(next_point['index']) - index_position
                 )
 
+            confirmation_index = self._confirmation_index(
+                index_position, len(full_data)
+            )
+
             swing_points.append(
                 SwingPoint(
                     point_id=point_id,
@@ -103,10 +107,23 @@ class PivotPointsSwingStrategy:
                     duration_to_next=duration_to_next,
                     strategy_name='pivot_points',
                     strategy_params=self._strategy_params(),
+                    confirmation_index=confirmation_index,
                 )
             )
             indices.append(index_position)
 
+        # Warm-up (issue #110 follow-up / G14): a context is only emitted once at
+        # least two extrema exist (see the guard above), so a lone first pivot is
+        # not yet observable at its own fractal confirmation — it appears together
+        # with the second one. Pin its availability to the second pivot's, as
+        # ZigZag does. Later pivots confirm at or after that bar already.
+        if len(swing_points) >= 2 and swing_points[0].confirmation_index is not None \
+                and swing_points[1].confirmation_index is not None:
+            swing_points[0].confirmation_index = max(
+                swing_points[0].confirmation_index,
+                swing_points[1].confirmation_index,
+            )
+
         logger.info(
             "PivotPoints global: detected %d swing points", len(swing_points)
         )
@@ -391,6 +408,29 @@ class PivotPointsSwingStrategy:
 
         return metrics
 
+    def _confirmation_index(
+        self, index: int, full_data_length: int
+    ) -> Optional[int]:
+        """Bar by which this pivot is causally confirmed.
+
+        A classic N-bar pivot is defined by ``right_bars`` bars to its right that
+        are all lower (pivot high) or higher (pivot low). The pattern therefore
+        becomes complete — and the pivot causally known — exactly at
+        ``index + right_bars``: the bar at which the last required right-side bar
+        is observed. This is the ``pivot_points`` realisation of the generic
+        :attr:`SwingPoint.confirmation_index` contract (a fractal swing confirms
+        after its fixed right-hand look-ahead window). Because pivots are only
+        detected for ``index <= len - right_bars - 1``, the confirmation bar always
+        lies inside the data; the guard returns ``None`` only defensively.
+
+        The N-bar pattern is purely local, so this is exact for every pivot but the
+        first, whose availability is additionally held back by the two-extrema
+        warm-up in :meth:`calculate_global` (see the note there). Verified
+        replay-safe by ``tests/unit/test_swing_replay_causal`` (G14).
+        """
+        conf = index + self.right_bars
+        return conf if conf < full_data_length else None
+
     def _empty_metrics(self) -> SwingMetrics:
         return self._aggregate_metrics([], [])
 

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

@@ -60,13 +60,32 @@ class ZigZagSwingStrategy:
 
         from .....indicators import LibraryManager
 
-        zigzag = LibraryManager.create_indicator(
-            'pandas_ta',
-            'zigzag',
-            legs=self.legs,
-            deviation=self.deviation,
-        )
-        result = zigzag.calculate(full_data)
+        # ZigZag relies on the optional pandas-ta 'zigzag' indicator. If pandas-ta
+        # is unavailable (skipped/not installed) or ships no zigzag, degrade to an
+        # empty context with a clean warning instead of crashing the pipeline —
+        # this mirrors the per-zone calculate() fallback below.
+        try:
+            zigzag = LibraryManager.create_indicator(
+                'pandas_ta',
+                'zigzag',
+                legs=self.legs,
+                deviation=self.deviation,
+                # Issue #110: the default (backtest=False) is a repainting, centred
+                # detector — truncating the raw series at as_of relocates/adds/drops
+                # earlier pivots, so a pivot with confirmation_index <= as_of is not
+                # actually observable then. backtest=True is the non-repainting
+                # stream: once a pivot is emitted it never changes under extension
+                # (verified empirically in tests/unit/test_swing_replay_causal.py).
+                backtest=True,
+            )
+            result = zigzag.calculate(full_data)
+        except Exception as exc:
+            logger.warning(
+                "ZigZag global: pandas-ta 'zigzag' unavailable (%s). "
+                "Returning empty SwingContext.",
+                exc,
+            )
+            return self._empty_context(len(full_data))
 
         if result.data.shape[1] < 2:
             logger.warning(
@@ -141,6 +160,19 @@ class ZigZagSwingStrategy:
             )
             indices.append(position)
 
+        # Warm-up (issue #110): the backtest=True detector emits nothing until the
+        # second swing forms, so the first two pivots become observable *together*.
+        # The first pivot's own deviation-retrace can therefore fall a few bars before
+        # the detector actually reports it — pin its availability to the second
+        # pivot's (the bar they both first appear at). Later pivots' retrace times are
+        # already safe (empirically confirmation_index >= first-appearance).
+        if len(swing_points) >= 2 and swing_points[0].confirmation_index is not None \
+                and swing_points[1].confirmation_index is not None:
+            swing_points[0].confirmation_index = max(
+                swing_points[0].confirmation_index,
+                swing_points[1].confirmation_index,
+            )
+
         logger.info("ZigZag global: detected %d swing points", len(swing_points))
 
         return SwingContext(
@@ -440,18 +472,18 @@ class ZigZagSwingStrategy:
         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]
+            conf = next_position
         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
+            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]
+            conf = position + 1 + int(hits[0]) if len(hits) else next_position
+        return conf
 
     def _empty_metrics(self) -> SwingMetrics:
         return self._aggregate_metrics([], [])

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bquant
-Version: 0.0.2
+Version: 0.0.4
 Summary: Quantitative research toolkit for financial markets
 Author-email: kogriv <kogriv@gmail.com>
 License: MIT

{bquant-0.0.2 → bquant-0.0.4}/bquant.egg-info/SOURCES.txt

@@ -187,7 +187,6 @@ bquant/visualization/statistical.py
 bquant/visualization/themes.py
 bquant/visualization/utils.py
 bquant/visualization/zones.py
-docs/BUILD_ISSUES.md
 docs/README.md
 docs/index.rst
 docs/_build/html/_sources/index.rst.txt
@@ -247,11 +246,6 @@ docs/_build/html/_sources/user_guide/quick_start.md.txt
 docs/_build/html/_sources/user_guide/swing_analysis_results.md.txt
 docs/_build/html/_sources/user_guide/swing_strategies.md.txt
 docs/_build/html/_sources/user_guide/zone_analysis.md.txt
-docs/analytics/zones/layerA_ii_representations_case_study.md
-docs/analytics/zones/layerA_zone_structure_case_study.md
-docs/analytics/zones/macd_zone_consistency_case_study.md
-docs/analytics/zones/s1_swing_anatomy_case_study.md
-docs/analytics/zones/swing.md
 docs/analytics/zones/swing_strategy_comparison_case_study.md
 docs/api/README.md
 docs/api/extension_guide.md
@@ -261,9 +255,9 @@ docs/api/analysis/pipeline.md
 docs/api/analysis/statistical.md
 docs/api/analysis/strategies.md
 docs/api/analysis/zones.md
-docs/api/analysis/zones/models.md
-docs/api/analysis/zones/pipeline.md
-docs/api/analysis/zones/strategies.md
+docs/api/analysis/zones/global_swings_models.md
+docs/api/analysis/zones/global_swings_pipeline.md
+docs/api/analysis/zones/global_swings_strategies.md
 docs/api/core/README.md
 docs/api/core/config.md
 docs/api/core/exceptions.md
@@ -303,7 +297,6 @@ docs/user_guide/best_practices.md
 docs/user_guide/caching.md
 docs/user_guide/core_concepts.md
 docs/user_guide/quick_start.md
-docs/user_guide/swing_analysis_results.md
 docs/user_guide/swing_strategies.md
 docs/user_guide/zone_analysis.md
 docs/user_guide/zone_analysis_result.md
@@ -335,6 +328,7 @@ tests/analysis/zones/test_pipeline_cache.py
 tests/analysis/zones/test_swing_presets.py
 tests/analysis/zones/test_swing_thresholds.py
 tests/fixtures/__init__.py
+tests/fixtures/swing_coverage.py
 tests/fixtures/swing_mocks.py
 tests/integration/__init__.py
 tests/integration/test_backward_compatibility.py
@@ -358,6 +352,7 @@ tests/unit/test_compatibility_validation.py
 tests/unit/test_core_modules.py
 tests/unit/test_data_modules.py
 tests/unit/test_divergence_strategy_universal.py
+tests/unit/test_docs_parity.py
 tests/unit/test_find_peaks_swing_strategy.py
 tests/unit/test_imports_migration.py
 tests/unit/test_indicator_factory.py
@@ -379,6 +374,7 @@ tests/unit/test_strategy_infrastructure.py
 tests/unit/test_swing_context_memory.py
 tests/unit/test_swing_edge_cases.py
 tests/unit/test_swing_global_calculation.py
+tests/unit/test_swing_replay_causal.py
 tests/unit/test_time_metrics.py
 tests/unit/test_universal_zone_analyzer.py
 tests/unit/test_validation_suite.py

{bquant-0.0.2 → bquant-0.0.4}/docs/api/analysis/README.md

@@ -56,9 +56,9 @@ Analysis модули содержат инструменты для стати
 - **115 тестов, 100% pass rate** - доказательство универсальности
 
 **Документация по глобальным свингам:**
-- [Модели](zones/models.md) — `SwingPoint`, `SwingContext`, расширения `ZoneInfo`
-- [Пайплайн](zones/pipeline.md) — `_calculate_global_swings`, `_inject_swing_context`, `with_swing_scope()`
-- [Стратегии](zones/strategies.md) — протокол `SwingCalculationStrategy`, ZigZag/FindPeaks/PivotPoints
+- [Модели](zones/global_swings_models.md) — `SwingPoint`, `SwingContext`, расширения `ZoneInfo`
+- [Пайплайн](zones/global_swings_pipeline.md) — `_calculate_global_swings`, `_inject_swing_context`, `with_swing_scope()`
+- [Стратегии](zones/global_swings_strategies.md) — протокол `SwingCalculationStrategy`, ZigZag/FindPeaks/PivotPoints
 
 ### 🎨 [bquant.analysis.zones.strategies](strategies.md) - Strategy Pattern (New)
 

{bquant-0.0.2 → bquant-0.0.4}/docs/api/analysis/pipeline.md

@@ -135,6 +135,22 @@ result = (
 .with_cache(enable=False)
 ```
 
+#### `.with_swing_scope(scope)`
+Режим расчёта свингов.
+
+**Параметры:**
+- `scope='global'` (по умолчанию) — свинги считаются один раз по всему датасету, затем
+  агрегируются в каждую зону (`calculate_global` + `aggregate_for_zone`).
+- `scope='per_zone'` — свинги считаются локально внутри каждой зоны (совместимость).
+
+**Пример:**
+```python
+.with_strategies(swing='zigzag').with_swing_scope('global')
+```
+
+> 📖 Внутренняя механика (`_calculate_global_swings`, `_inject_swing_context`, фолбэки) —
+> в [Глобальные свинги: пайплайн](zones/global_swings_pipeline.md).
+
 #### `.build()`
 Запуск анализа и получение результата.
 
@@ -352,9 +368,9 @@ zone_features = result.zones[0].features.get('zone_type')
 
 ### 🎯 Learning Path
 - **[Examples](../../examples/README.md)** - Готовые примеры использования
-- **[Deep Dive Tutorial](../../research/notebooks/03_zones_universal.py)** - Comprehensive analysis
-- **[Advanced Features](../../research/notebooks/03_analysis_new_features.py)** - Swing, divergence, regression
-- **[Migration Guide](../../examples/02_macd_zone_analysis.py)** - Переход с legacy API
+- **[Deep Dive Tutorial](../../../research/notebooks/03_zones_universal.py)** - Comprehensive analysis
+- **[Advanced Features](../../../research/notebooks/03_analysis_new_features.py)** - Swing, divergence, regression
+- **[Migration Guide](../../../examples/02_macd_zone_analysis.py)** - Переход с legacy API
 
 ### 🏗️ Developer Resources
 - **[Architecture Patterns](../../developer_guide/README.md)** - Design Patterns, Extension Points