opencode-pyneruntime 6.6.4__py3-none-any.whl

pynecore/core/aggregator.py

@@ -0,0 +1,257 @@
+"""
+OHLCV timeframe aggregation — converts lower timeframe data to higher timeframes.
+
+Uses Resampler.get_bar_time() for correct bar boundary alignment across all
+timeframe types including weekly and monthly. Multi-period targets (nD/nW/nM,
+n > 1) live on the year-reset scheduled grid (see ``resampler`` module docs);
+'observed' symbols (exchange-listed) count the actual trading days seen in the
+source stream, which reproduces TradingView's holiday-aware grid.
+"""
+from datetime import timezone as dt_timezone
+from pathlib import Path
+from zoneinfo import ZoneInfo
+
+from .ohlcv_file import OHLCVReader, OHLCVWriter
+from .resampler import (
+    Resampler, ObservedDayCounter, grid_mode, overnight_opens, trading_day,
+)
+from ..lib.timeframe import in_seconds, _process_tf
+from ..types.ohlcv import OHLCV
+
+
+def validate_aggregation(source_tf: str, target_tf: str) -> None:
+    """
+    Validate that aggregation from source to target timeframe is possible.
+
+    :param source_tf: Source timeframe string (e.g., '5', '1D')
+    :param target_tf: Target timeframe string (e.g., '60', '1W')
+    :raises ValueError: If timeframes are incompatible
+    """
+    source_sec = in_seconds(source_tf)
+    target_sec = in_seconds(target_tf)
+
+    if target_sec <= source_sec:
+        raise ValueError(
+            f"Target timeframe ({target_tf}) must be larger than "
+            f"source timeframe ({source_tf})"
+        )
+
+    if target_sec % source_sec != 0:
+        raise ValueError(
+            f"Target timeframe ({target_tf}) must be evenly divisible by "
+            f"source timeframe ({source_tf})"
+        )
+
+
+def _merge_candles(candles: list[OHLCV], bar_time: int) -> OHLCV:
+    """
+    Merge a window of candles into a single aggregated candle.
+
+    :param candles: Non-empty list of OHLCV candles belonging to the same bar
+    :param bar_time: Aligned bar opening timestamp in seconds
+    :return: Aggregated OHLCV candle
+    """
+    return OHLCV(
+        timestamp=bar_time,
+        open=candles[0].open,
+        high=max(c.high for c in candles),
+        low=min(c.low for c in candles),
+        close=candles[-1].close,
+        volume=sum(c.volume for c in candles),
+    )
+
+
+def aggregate_ohlcv(
+        source_path: Path,
+        target_path: Path,
+        target_tf: str,
+        tz: ZoneInfo | dt_timezone | None = None,
+        session_starts: list | None = None,
+        opening_hours: list | None = None,
+        sym_type: str | None = None,
+        source_tf: str | None = None,
+) -> tuple[int, int]:
+    """
+    Aggregate OHLCV data from a lower timeframe file to a higher timeframe file.
+
+    :param source_path: Path to source .ohlcv file
+    :param target_path: Path to target .ohlcv file (will be overwritten)
+    :param target_tf: Target timeframe string (e.g., '60', '1W')
+    :param tz: Timezone for day/week/month boundary alignment.
+               Should match the data's timezone (from TOML metadata).
+    :param session_starts: Per-trading-day primary opens for intraday session
+               anchoring and multi-period grids. When given, intraday bars align
+               to the session open (TradingView behaviour) instead of the UTC
+               clock; ``None`` keeps the pure clock-floor.
+               See :meth:`Resampler.get_bar_time`.
+    :param opening_hours: ``SymInfo.opening_hours`` — trading-day roll source
+               for multi-period (nD/nW/nM) grids.
+    :param sym_type: ``SymInfo.type`` for :func:`grid_mode` classification of
+               multi-period grids. Exchange-listed symbols ('observed' mode)
+               count the actual trading days present in the source data; for an
+               exact TradingView-matching grid their source data should reach
+               back to the year's first trading day (the in-year counter is
+               otherwise approximated from the weekday grid).
+    :param source_tf: Source timeframe string. On multi-period (nD/nW/nM)
+               targets an intraday source bar belongs to the trading day its
+               *last* instant falls into — the bar containing a session open
+               starts the new day even when its timestamp precedes the open
+               (see the ``resampler`` module docs).
+    :return: Tuple of (source_candles_read, target_candles_written)
+    """
+    # noinspection PyProtectedMember
+    modifier, multiplier = _process_tf(target_tf)
+    mode = grid_mode(sym_type, opening_hours)
+
+    src_off = 0
+    fold = False
+    if modifier in ('D', 'W', 'M') and multiplier > 1 and source_tf:
+        # noinspection PyProtectedMember
+        src_mod, _ = _process_tf(source_tf)
+        if src_mod in ('', 'S'):
+            src_off = in_seconds(source_tf) - 1
+            # An intraday source carries the per-bar end instants the observed
+            # holiday half-day fold needs (a daily source is already folded).
+            fold = True
+
+    if modifier in ('D', 'W', 'M') and multiplier > 1 and mode == 'observed':
+        return _aggregate_observed(
+            source_path, target_path, modifier, multiplier, tz,
+            session_starts, opening_hours, src_off, fold)
+
+    resampler = Resampler.get_resampler(target_tf)
+
+    source_count = 0
+    target_count = 0
+
+    with OHLCVReader(source_path) as reader:
+        with OHLCVWriter(target_path, truncate=True) as writer:
+            window: list[OHLCV] = []
+            current_bar_time: int | None = None
+
+            start_ts = reader.start_timestamp
+            if start_ts is None:
+                if reader.size == 1:
+                    # A single-record source has no derivable interval (the reader
+                    # needs two timestamps to infer one), so ``start_timestamp`` is
+                    # None and ``read_from`` yields nothing — yet that lone bar IS a
+                    # whole target period and must be emitted. Floor its timestamp
+                    # onto the target grid (exactly as the loop below does) so HTF
+                    # confirmation (the ``bar_opens`` clamp) and
+                    # ``request.security(.., time)`` see the period boundary, not the
+                    # raw sub-bar instant.
+                    only = reader.read(0)
+                    only_bar_time = resampler.get_bar_time(
+                        (only.timestamp + src_off) * 1000, tz=tz,
+                        session_starts=session_starts,
+                        opening_hours=opening_hours, mode=mode) // 1000
+                    writer.write(_merge_candles([only], only_bar_time))
+                    return 1, 1
+                return 0, 0
+
+            for candle in reader.read_from(start_ts):
+                source_count += 1
+
+                # Resampler works in ms, OHLCV timestamps are in seconds.
+                # src_off resolves multi-period bars by their last instant.
+                bar_time_ms = resampler.get_bar_time(
+                    (candle.timestamp + src_off) * 1000, tz=tz,
+                    session_starts=session_starts,
+                    opening_hours=opening_hours, mode=mode)
+                bar_time = bar_time_ms // 1000
+
+                if current_bar_time is not None and bar_time != current_bar_time:
+                    # New bar boundary — flush the window
+                    writer.write(_merge_candles(window, current_bar_time))
+                    target_count += 1
+                    window = []
+
+                current_bar_time = bar_time
+                window.append(candle)
+
+            # Flush last window
+            if window and current_bar_time is not None:
+                writer.write(_merge_candles(window, current_bar_time))
+                target_count += 1
+
+    return source_count, target_count
+
+
+def _aggregate_observed(
+        source_path: Path,
+        target_path: Path,
+        modifier: str,
+        multiplier: int,
+        tz: ZoneInfo | dt_timezone | None,
+        session_starts: list | None,
+        opening_hours: list | None,
+        src_off: int = 0,
+        fold: bool = False,
+) -> tuple[int, int]:
+    """
+    Multi-period aggregation for 'observed' symbols (exchange-listed).
+
+    TradingView's grid on these symbols counts its holiday calendar's scheduled
+    trading days; the actual daily data realizes that calendar, so counting the
+    trading days present in the source stream reproduces the grid (year-reset
+    counter, verified 100% on CME 2022+). Periods are stamped with their first
+    source candle — TradingView's stamp on these symbols is the period's first
+    actual session.
+
+    The first (partial) year's counter is seeded from the weekday grid: the
+    trading days between Jan 1 and the data start are not observable, so the
+    phase there is approximate. Data reaching back to a year start is exact
+    from that year on.
+
+    :param source_path: Path to source .ohlcv file
+    :param target_path: Path to target .ohlcv file (will be overwritten)
+    :param modifier: 'D', 'W' or 'M' (from ``_process_tf``)
+    :param multiplier: Period multiplier (> 1)
+    :param tz: Exchange timezone
+    :param session_starts: ``SymInfo.session_starts`` template
+    :param opening_hours: ``SymInfo.opening_hours`` template
+    :param src_off: Source bar open -> last instant offset in seconds; a bar
+               belongs to the trading day its last instant falls into
+    :param fold: Fold holiday half-days into the early-close day (intraday
+               source only; see :class:`ObservedDayCounter`)
+    :return: Tuple of (source_candles_read, target_candles_written)
+    """
+    on = overnight_opens(opening_hours, session_starts)
+
+    source_count = 0
+    target_count = 0
+
+    with OHLCVReader(source_path) as reader:
+        with OHLCVWriter(target_path, truncate=True) as writer:
+            window: list[OHLCV] = []
+            window_start: int | None = None
+            group_key: tuple | None = None
+            counter = ObservedDayCounter(tz, opening_hours, fold=fold)
+
+            start_ts = reader.start_timestamp
+            if start_ts is None:
+                return 0, 0
+
+            for candle in reader.read_from(start_ts):
+                source_count += 1
+                td = trading_day(candle.timestamp + src_off, tz, on)
+                bar_end = candle.timestamp + src_off + 1 if fold else None
+                counter.ordinal(td, bar_end)
+                key = counter.key(modifier, multiplier)
+
+                if group_key is not None and key != group_key:
+                    writer.write(_merge_candles(window, window_start))
+                    target_count += 1
+                    window = []
+                    window_start = None
+
+                group_key = key
+                if window_start is None:
+                    window_start = candle.timestamp
+                window.append(candle)
+
+            if window and window_start is not None:
+                writer.write(_merge_candles(window, window_start))
+                target_count += 1
+
+    return source_count, target_count

pynecore/core/bar_magnifier.py

@@ -0,0 +1,168 @@
+"""
+Bar Magnifier — groups lower-timeframe OHLCV candles into chart-timeframe windows.
+
+Used by ScriptRunner when use_bar_magnifier=true: the script sees aggregated chart-TF
+bars, while the broker emulator processes orders against each sub-bar for accurate fills.
+
+Multi-period chart timeframes (nD/nW/nM, n > 1) live on the year-reset scheduled
+grid (see the ``resampler`` module docs); 'observed' symbols (exchange-listed)
+count the actual trading days seen in the sub-bar stream, which reproduces
+TradingView's holiday-aware grid.
+"""
+from dataclasses import dataclass
+from datetime import timezone as dt_timezone
+from typing import Iterable, Iterator
+from zoneinfo import ZoneInfo
+
+from .aggregator import _merge_candles
+from .resampler import (
+    Resampler, ObservedDayCounter, grid_mode, overnight_opens, trading_day,
+)
+from ..lib.timeframe import in_seconds, _process_tf
+from ..types.ohlcv import OHLCV
+
+__all__ = ['BarMagnifier', 'MagnifiedWindow']
+
+
+@dataclass(slots=True)
+class MagnifiedWindow:
+    """A single chart-timeframe bar with its constituent sub-bars."""
+    sub_bars: list[OHLCV]
+    aggregated: OHLCV
+    is_last_window: bool
+
+
+class BarMagnifier:
+    """
+    Groups sub-timeframe OHLCV candles into chart-timeframe windows.
+
+    Uses Resampler for bar boundary alignment (same logic as aggregator.py);
+    multi-period (nD/nW/nM) chart timeframes on 'observed' symbols count the
+    actual trading days in the stream instead. Yields MagnifiedWindow objects
+    with peek-ahead for last-window detection.
+    """
+
+    def __init__(
+            self,
+            ohlcv_iter: Iterable[OHLCV],
+            chart_tf: str,
+            tz: ZoneInfo | dt_timezone | None = None,
+            session_starts: 'list | None' = None,
+            opening_hours: 'list | None' = None,
+            sym_type: str | None = None,
+            source_tf: str | None = None,
+    ):
+        """
+        :param ohlcv_iter: Iterator of sub-timeframe OHLCV candles
+        :param chart_tf: Chart timeframe string (e.g., '60', '1D')
+        :param tz: Timezone for day/week/month boundary alignment
+        :param session_starts: Per-trading-day primary opens for intraday session
+            anchoring and multi-period grids. ``None`` keeps the pure clock-floor
+            (see :meth:`Resampler.get_bar_time`).
+        :param opening_hours: ``SymInfo.opening_hours`` — trading-day roll source
+            for multi-period (nD/nW/nM) grids.
+        :param sym_type: ``SymInfo.type`` for :func:`grid_mode` classification of
+            multi-period grids.
+        :param source_tf: Sub-bar timeframe string. On multi-period chart
+            timeframes an intraday sub-bar belongs to the trading day its *last*
+            instant falls into — the bar containing a session open starts the
+            new day even when its timestamp precedes the open.
+        """
+        self._ohlcv_iter = ohlcv_iter
+        self._resampler = Resampler.get_resampler(chart_tf)
+        self._tz = tz
+        self._session_starts = session_starts
+        self._opening_hours = opening_hours
+
+        # noinspection PyProtectedMember
+        modifier, multiplier = _process_tf(chart_tf)
+        self._modifier = modifier
+        self._multiplier = multiplier
+        multi = modifier in ('D', 'W', 'M') and multiplier > 1
+        self._mode = grid_mode(sym_type, opening_hours) if multi else None
+
+        self._src_off = 0
+        self._fold = False
+        if multi and source_tf:
+            # noinspection PyProtectedMember
+            src_mod, _ = _process_tf(source_tf)
+            if src_mod in ('', 'S'):
+                self._src_off = in_seconds(source_tf) - 1
+                # Intraday sub-bars carry the end instants the holiday half-day
+                # fold needs (a daily source stream is already folded).
+                self._fold = True
+
+        if multi and self._mode == 'observed':
+            self._overnight = overnight_opens(opening_hours, session_starts)
+            self._counter: ObservedDayCounter | None = ObservedDayCounter(
+                tz, opening_hours, fold=self._fold)
+        else:
+            self._overnight = {}
+            self._counter = None
+
+    def _key_and_stamp(self, candle: OHLCV) -> tuple[object, int]:
+        """
+        Grouping key and window-opening timestamp (seconds) for a sub-bar.
+
+        For 'observed' multi-period grids the key counts the actual trading
+        days and the window is stamped by its first sub-bar; everything else
+        uses the scheduled-grid bar time as both.
+        """
+        if self._counter is not None:
+            td = trading_day(candle.timestamp + self._src_off, self._tz, self._overnight)
+            bar_end = candle.timestamp + self._src_off + 1 if self._fold else None
+            self._counter.ordinal(td, bar_end)
+            key = self._counter.key(self._modifier, self._multiplier)
+            return key, candle.timestamp
+
+        bar_time_ms = self._resampler.get_bar_time(
+            (candle.timestamp + self._src_off) * 1000, tz=self._tz,
+            session_starts=self._session_starts,
+            opening_hours=self._opening_hours, mode=self._mode)
+        bar_time = bar_time_ms // 1000
+        return bar_time, bar_time
+
+    def __iter__(self) -> Iterator[MagnifiedWindow]:
+        window: list[OHLCV] = []
+        current_key: object | None = None
+        window_stamp: int | None = None
+        next_window: MagnifiedWindow | None = None
+
+        for candle in self._ohlcv_iter:
+            key, stamp = self._key_and_stamp(candle)
+
+            if current_key is not None and key != current_key:
+                # New bar boundary — flush current window
+                new_window = MagnifiedWindow(
+                    sub_bars=window,
+                    aggregated=_merge_candles(window, window_stamp),
+                    is_last_window=False,
+                )
+
+                # Peek-ahead: yield the previous window (now we know it's not the last)
+                if next_window is not None:
+                    yield next_window
+                next_window = new_window
+                window = []
+                window_stamp = None
+
+            current_key = key
+            if window_stamp is None:
+                window_stamp = stamp
+            window.append(candle)
+
+        # Flush last window
+        if window and window_stamp is not None:
+            last_window = MagnifiedWindow(
+                sub_bars=window,
+                aggregated=_merge_candles(window, window_stamp),
+                is_last_window=True,
+            )
+
+            if next_window is not None:
+                yield next_window
+            yield last_window
+        elif next_window is not None:
+            # Edge case: no trailing candles, previous window is the last
+            next_window.is_last_window = True
+            yield next_window

pynecore/core/broker/__init__.py

@@ -0,0 +1,64 @@
+"""
+Broker plugin runtime support.
+
+- :mod:`pynecore.core.broker.models` — intent, event, exchange-state,
+  capability and requirement dataclasses.
+- :mod:`pynecore.core.broker.exceptions` — broker error hierarchy.
+- :mod:`pynecore.core.broker.position` — :class:`BrokerPosition` live
+  position tracker (no simulation).
+"""
+from pynecore.core.broker.exceptions import (
+    AuthenticationError,
+    BrokerError,
+    ExchangeCapabilityError,
+    ExchangeConnectionError,
+    ExchangeOrderRejectedError,
+    ExchangeRateLimitError,
+    InsufficientMarginError,
+    OrderSyncError,
+    UnexpectedCancelError,
+)
+from pynecore.core.broker.models import (
+    OrderStatus,
+    OrderType,
+    LegType,
+    CapabilityLevel,
+    ExchangeOrder,
+    OrderEvent,
+    ExchangePosition,
+    ExchangeCapabilities,
+    EntryIntent,
+    ExitIntent,
+    CloseIntent,
+    CancelIntent,
+    ScriptRequirements,
+    InterceptorResult,
+)
+from pynecore.core.broker.position import BrokerPosition
+
+__all__ = [
+    'AuthenticationError',
+    'BrokerError',
+    'ExchangeCapabilityError',
+    'ExchangeConnectionError',
+    'ExchangeOrderRejectedError',
+    'ExchangeRateLimitError',
+    'InsufficientMarginError',
+    'OrderSyncError',
+    'UnexpectedCancelError',
+    'OrderStatus',
+    'OrderType',
+    'LegType',
+    'CapabilityLevel',
+    'ExchangeOrder',
+    'OrderEvent',
+    'ExchangePosition',
+    'ExchangeCapabilities',
+    'EntryIntent',
+    'ExitIntent',
+    'CloseIntent',
+    'CancelIntent',
+    'ScriptRequirements',
+    'InterceptorResult',
+    'BrokerPosition',
+]

pynecore/core/broker/defaults.py

@@ -0,0 +1,113 @@
+"""
+Cross-broker runtime defaults loaded from ``workdir/config/brokers.toml``.
+
+Holds policies that are broker-agnostic by design — the four
+``on_unexpected_cancel`` modes, for instance, share identical semantics
+regardless of which exchange the plugin talks to. Living here rather than
+in each plugin's own config keeps the user-facing knob in a single place
+and prevents every new broker plugin from copy-pasting the same field.
+
+The CLI (``pyne run --broker``) loads :class:`BrokerDefaults` once and
+injects the resolved values onto the plugin instance just before the
+script runner starts. Plugin code reads them through the
+:class:`~pynecore.core.plugin.broker.BrokerPlugin` class attributes that
+they shadow.
+"""
+from dataclasses import dataclass
+from pathlib import Path
+
+from pynecore.core.config import ensure_config
+
+__all__ = [
+    'BrokerDefaults',
+    'VALID_UNEXPECTED_CANCEL_POLICIES',
+    'VALID_INVENTORY_CONFLICT_POLICIES',
+    'load_broker_defaults',
+]
+
+
+VALID_UNEXPECTED_CANCEL_POLICIES = frozenset({
+    "stop",
+    "stop_and_cancel",
+    "re_place",
+    "ignore",
+    "halt",
+})
+
+VALID_INVENTORY_CONFLICT_POLICIES = frozenset({
+    "quarantine",
+    "halt",
+})
+
+
+@dataclass
+class BrokerDefaults:
+    """Cross-broker runtime defaults.
+
+    Loaded from ``workdir/config/brokers.toml`` via
+    :func:`load_broker_defaults`. The file is self-healing — fields at
+    their default are emitted as commented-out lines, user-edited values
+    are preserved across regenerations.
+    """
+
+    on_unexpected_cancel: str = "stop"
+    """Policy when a bot-owned order disappears without the bot cancelling it.
+
+    ``"stop"`` (default) — quarantine: trading stops (no new or
+    exposure-increasing dispatch) but the process stays alive — event
+    ingestion, cancels and closes keep working and observability can
+    page. Resumed by an operator restart.
+    ``"stop_and_cancel"`` — quarantine plus a best-effort cancel pass
+    over the remaining bot-owned orders.
+    ``"re_place"`` — no-op on the cancel; the sync engine re-dispatches
+    the protective order on the next diff cycle.
+    ``"ignore"`` — silently continue. Only safe when manual external
+    cancellations are an expected part of the operational workflow.
+    ``"halt"`` — exit the process via the graceful manual-intervention
+    path, leaving any remaining orders unsupervised until restart.
+    """
+
+    on_inventory_conflict: str = "quarantine"
+    """Policy for a confirmed spot balance-invariant conflict.
+
+    Only used by plugins that opt into the core spot inventory layer.
+    ``"quarantine"`` (default) — trading stops, the process stays alive
+    as an observer; recovery is an operator rebaseline plus restart.
+    ``"halt"`` — exit via the graceful manual-intervention path.
+    The set is deliberately narrower than ``on_unexpected_cancel``:
+    an attribution conflict has no safe ``re_place`` or ``ignore``
+    analogue (the former would buy back an operator's withdrawal, the
+    latter would trade on corrupt books).
+    """
+
+
+def load_broker_defaults(config_dir: Path) -> BrokerDefaults:
+    """Load :class:`BrokerDefaults` from ``<config_dir>/brokers.toml``.
+
+    Delegates to :func:`pynecore.core.config.ensure_config`, which
+    auto-creates the file with commented defaults on first run, preserves
+    user-edited values across regenerations, and caches the result on the
+    dataclass. Validation runs after loading — invalid values raise
+    :class:`ValueError` with the list of accepted policies so the
+    misconfiguration surfaces immediately at startup, not at the first
+    reconcile cycle.
+
+    :param config_dir: The ``workdir/config`` directory.
+    :return: A populated :class:`BrokerDefaults` instance.
+    :raises ValueError: If a loaded value falls outside its allowed set.
+    """
+    instance = ensure_config(BrokerDefaults, config_dir / 'brokers.toml')
+    assert isinstance(instance, BrokerDefaults)
+    if instance.on_unexpected_cancel not in VALID_UNEXPECTED_CANCEL_POLICIES:
+        raise ValueError(
+            f"brokers.toml: on_unexpected_cancel must be one of "
+            f"{sorted(VALID_UNEXPECTED_CANCEL_POLICIES)}, got "
+            f"{instance.on_unexpected_cancel!r}",
+        )
+    if instance.on_inventory_conflict not in VALID_INVENTORY_CONFLICT_POLICIES:
+        raise ValueError(
+            f"brokers.toml: on_inventory_conflict must be one of "
+            f"{sorted(VALID_INVENTORY_CONFLICT_POLICIES)}, got "
+            f"{instance.on_inventory_conflict!r}",
+        )
+    return instance