opencode-pyneruntime 6.6.4__py3-none-any.whl

pynecore/lib/_fixnan.py

@@ -0,0 +1,32 @@
+"""
+@pyne lib
+
+Stateful implementation of ``lib.fixnan``. It lives in its own small module
+because the ``@pyne`` marker is module-level and the host module
+(``lib/__init__.py``) must stay untransformed; the host re-exports the
+function, and the layout travels on the function object.
+"""
+# Absolute imports on purpose: the call-site classifier resolves absolute
+# imports at transform time, so NA() calls stay direct instead of anchored
+from typing import Any
+
+from pynecore.types import NA, Persistent
+
+__all__ = ['fixnan']
+
+
+def fixnan(source: Any) -> Any:
+    """
+    Fix NA values by replacing them with the last non-NA value
+
+    Hole detection is nan-only (``x != x``), deliberately NARROWER than the
+    ``na()`` predicate: TradingView's ``fixnan`` passes inf through as a
+    regular value (TV-verified) even though ``na(inf)`` is true. NA objects
+    (non-float na) are holes too.
+
+    :param source: The source value
+    :return: The source value if it is not a nan-hole, otherwise the last such value
+    """
+    last_not_nan: Persistent[Any] = NA(None)
+    last_not_nan = last_not_nan if (isinstance(source, NA) or source != source) else source
+    return last_not_nan

pynecore/lib/_math_stateful.py

@@ -0,0 +1,202 @@
+"""
+@pyne lib
+
+Stateful implementations of ``lib.math.random`` and ``lib.math.sum``. They
+live in their own small module because the ``@pyne`` marker is module-level
+and the host module (``lib/math.py``) must stay untransformed; the host
+re-exports the functions, and the layouts travel on the function objects.
+"""
+# Absolute imports on purpose: the call-site classifier resolves absolute
+# imports at transform time, so NA() calls stay direct instead of anchored
+from typing import TypeVar
+
+from pynecore.types import NA, Persistent, PyneFloat, PyneInt, Series, na_float
+from pynecore.core.random import PineRandom as _PineRandom
+# lib import (normalized to ``from pynecore import lib``) so the statement-position
+# ``max_bars_back`` call below is anchored and converted to a buffer resize.
+from pynecore.lib import max_bars_back
+
+TFI = TypeVar('TFI', float, int)
+
+__all__ = ['random', 'sum']
+
+
+# The lazy-init narrowing of ``prng`` is invisible to the IDE: ``Persistent`` is a
+# marker the AST transformer rewrites, so flow analysis keeps the ``| None`` arm.
+# noinspection PyShadowingBuiltins,PyShadowingNames,PyUnresolvedReferences
+def random(min: TFI | NA[TFI] = 0, max: TFI | NA[TFI] = 1, seed: PyneInt = NA(int)) -> PyneFloat:
+    """
+    Returns a random number between two numbers.
+
+    :param min: The minimum number.
+    :param max: The maximum number.
+    :param seed: The seed for the random number generator.
+    :return: A random number between the minimum and maximum numbers.
+    """
+    prng: Persistent[_PineRandom | None] = None
+    if prng is None:  # Lazy init: the PRNG must not be created before the seed is known
+        # An unseeded Pine `math.random(min, max)` arrives here with seed == na,
+        # not None; pass None so PineRandom time-seeds instead of building its
+        # state from an NA (which would XOR to NA and make every draw na).
+        prng = _PineRandom(None if isinstance(seed, NA) else seed)
+    res = prng.random(min, max)
+    return res
+
+
+# Three groups of IDE findings here are artifacts of the ``@pyne`` transform, not real
+# defects: ``Persistent`` assignments look dead because their value is read on the NEXT
+# bar, ``src`` looks possibly-unbound because it is a series whose storage outlives the
+# ``if`` that feeds it, and ``src[i]`` looks like subscripting a float because
+# ``Series[T]`` erases to ``T`` for the IDE.
+# noinspection PyShadowingBuiltins,PyUnusedLocal,PyUnboundLocalVariable,PyUnresolvedReferences
+def sum(source: TFI | NA[TFI], length: int) -> PyneFloat | TFI | NA[TFI]:
+    """
+    Returns the sum of a series over a specified length using Kahan summation.
+
+    :param source: Source series
+    :param length: Length of the sum
+    :return: The sliding sum of the series
+    """
+    summ: Persistent[float] = 0.0
+    count: Persistent[int] = 0
+    compensation: Persistent[float] = 0.0
+    prev_length: Persistent[int] = 0
+    removals: Persistent[int] = 0
+
+    # Representation-agnostic na test: an na source is either an NA object or a
+    # native nan (OHLCV gaps can already deliver a bare nan). Both must be
+    # excluded from the na-compacted buffer, or ``src[k]`` would poison ``summ``.
+    source_na = isinstance(source, NA) or source != source
+
+    if not source_na:
+        # Record every non-na bar's value into the sliding buffer BEFORE any
+        # early return (shortcut / warmup), so the positional recompute below
+        # sees a complete history with no holes. NA values are intentionally
+        # not stored: the buffer stays na-compacted, so ``src[k]`` is the k-th
+        # most recent non-na value — exactly the "last N non-na" window Pine's
+        # sum/sma use.
+        src: Series[float] = source
+        # The sliding window drops the value leaving it via ``src[length]`` (``length``
+        # non-na bars back). Grow the na-compacted buffer so that index stays addressable
+        # for lengths beyond the per-series default ``max_bars_back`` (500); otherwise the
+        # removal reads na and poisons ``summ`` permanently, collapsing any ``ta.sma`` /
+        # ``ta.sum`` with length > 500 to na right after warmup. Capacity persists across
+        # bars, so setting it on each non-na bar (from the first on) suffices — the window
+        # never removes before ``length`` non-na values have accumulated.
+        max_bars_back(src, int(length))
+
+    if length == 1:  # Shortcut
+        # The sliding accumulator is left untouched here; record length == 1 so a
+        # following bar with a different length recomputes instead of trusting the
+        # now-stale state.
+        prev_length = 1
+        return source
+    assert length > 0, "Invalid length, length must be greater than 0!"
+    length = int(length)
+
+    # The Kahan sliding window below is only valid while ``length`` stays
+    # constant. Pine allows a series ``length`` (e.g. ``ta.sma(src, barssince(...))``);
+    # when it changes bar-to-bar the accumulator no longer describes the requested
+    # trailing window, so recompute the sum directly from the source series over the
+    # current length (mirroring ``ta.highest``'s positional fallback) and re-seed the
+    # accumulator so a subsequently stable length resumes the O(1) fast path.
+    changed = prev_length != 0 and length != prev_length
+    prev_length = length
+    if changed:
+        removals = 0
+        if source_na:
+            # Length changed on an na bar: the old window is stale and cannot be
+            # rebuilt from a missing current value; restart the warmup cleanly.
+            summ = 0.0
+            count = 0
+            compensation = 0.0
+        else:
+            recomputed = 0.0
+            comp = 0.0
+            found = 0
+            for i in range(length):
+                v = src[i]
+                if isinstance(v, NA) or v != v:
+                    # The buffer is na-compacted, so the first na marks the end of
+                    # available history — every deeper index is na too. Stop here
+                    # instead of scanning the rest (keeps the recompute O(available),
+                    # never O(length) when length outruns the stored history).
+                    break
+                found += 1
+                corrected = float(v) - comp
+                new_recomputed = recomputed + corrected
+                comp = (new_recomputed - recomputed) - corrected
+                recomputed = new_recomputed
+            if found < length:  # Not enough non-na history for this window yet
+                summ = 0.0
+                count = 0
+                compensation = 0.0
+                return na_float
+            summ = recomputed
+            compensation = comp
+            count = length
+            return recomputed
+
+    if count < length - 1:
+        if not source_na:
+            count += 1
+            # Kahan summation for adding new value
+            corrected_value = float(source) - compensation
+            new_sum = summ + corrected_value
+            compensation = (new_sum - summ) - corrected_value
+            summ = new_sum
+        return na_float
+    elif count == length - 1:
+        if source_na:
+            return na_float
+        count += 1
+    else:
+        if source_na:
+            return summ
+        # Exact resync: the incremental remove+add path below carries residual
+        # rounding error from bars long outside the window (Kahan bounds it but
+        # never clears it). That residue breaks identities TV preserves — e.g.
+        # a window of equal values must sum to exactly n*v (a run of zeros must
+        # sum to 0.0, not -3e-15), or ``sma(sma(x))`` of a flat series flips
+        # strict comparisons like the Technical Ratings
+        # ``kStochRsi < dStochRsi`` on last-bit noise. Small windows (the
+        # precision-sensitive ``sma(x, 3)`` chains) recompute from the
+        # na-compacted buffer on EVERY bar — for those lengths the fresh Kahan
+        # pass costs the same as the remove+add pair it replaces, and the
+        # result depends on the window alone. Longer windows resync once per
+        # ``length`` removals, capping any drift's lifetime at one window
+        # turnover at an amortized O(1) cost per bar.
+        removals += 1
+        if removals >= length or length <= 8:
+            removals = 0
+            recomputed = 0.0
+            comp = 0.0
+            found = 0
+            for i in range(length):
+                v = src[i]
+                if isinstance(v, NA) or v != v:
+                    break
+                found += 1
+                corrected = float(v) - comp
+                new_recomputed = recomputed + corrected
+                comp = (new_recomputed - recomputed) - corrected
+                recomputed = new_recomputed
+            if found == length:
+                summ = recomputed
+                compensation = comp
+                return summ
+        # Kahan summation for removing old value (float() compiles to
+        # safe_convert.safe_float, returning NA instead of raising on NA)
+        old_value = float(src[length])
+        corrected_old = -old_value - compensation
+        new_sum = summ + corrected_old
+        compensation = (new_sum - summ) - corrected_old
+        summ = new_sum
+
+    # Kahan summation for adding new value
+    corrected_value = float(source) - compensation
+    new_sum = summ + corrected_value
+    compensation = (new_sum - summ) - corrected_value
+    summ = new_sum
+
+    return summ

pynecore/lib/_timeframe_change.py

@@ -0,0 +1,101 @@
+"""
+@pyne lib
+
+Stateful implementation of ``lib.timeframe.change``. It lives in its own
+small module because the ``@pyne`` marker is module-level and the host
+module (``lib/timeframe.py``) must stay untransformed; the host re-exports
+the function, and the layout travels on the function object.
+
+The stateless helpers (session math) stay in the host module so they run
+untransformed at full speed.
+
+For daily/weekly/monthly timeframes ``change`` is equivalent to
+``ta.change(time(timeframe))`` on the year-reset scheduled grid (see the
+``core.resampler`` module docs): it returns ``true`` on the first chart bar
+of each new period. Intraday timeframes replay virtual candles against the
+session template to find period starts within the session.
+"""
+from datetime import datetime, timedelta
+
+from pynecore import lib
+from pynecore.lib import syminfo as _syminfo
+from pynecore.lib import timeframe as _timeframe
+from pynecore.types import Persistent
+
+__all__ = ['change']
+
+
+# The engine-private ``lib._*`` members are the intended interface here, and the
+# ``Persistent`` markers are rewritten by the AST transformer, so the IDE sees neither
+# the next-bar reads of the state variables nor their lazy-init narrowing.
+# noinspection PyProtectedMember,PyUnusedLocal,PyUnresolvedReferences,PyTypeChecker
+def change(timeframe: str) -> bool:
+    """
+    Detects changes in the specified timeframe.
+
+    :param timeframe: The timeframe to check
+    :return: Returns true on the first bar of a `timeframe`, false otherwise.
+    """
+    last_dt: Persistent[datetime | None] = None
+    last_signal: Persistent[datetime | None] = None
+    last_period: Persistent[object] = None
+
+    tf_sec = _timeframe.in_seconds(timeframe)
+    xchg_tf_sec = _timeframe.in_seconds(_syminfo.period)
+
+    # The timeframe to check must be greater (or equal) than the current timeframe
+    if tf_sec < xchg_tf_sec:
+        return False
+
+    _modifier, _multiplier = _timeframe._process_tf(timeframe)
+    assert _modifier != 'T', "Ticks are not (yet) supported!"
+
+    if _modifier == '' or _modifier == 'S':
+        # Intraday: replay virtual candles (even those missing from the
+        # dataset) and anchor period starts to the session start
+        dt: datetime = lib._datetime
+
+        if last_dt is None:
+            last_dt = dt - timedelta(seconds=xchg_tf_sec)
+            last_signal = last_dt
+
+        while last_dt < dt:
+            prev_dt = last_dt
+            last_dt = last_dt + timedelta(seconds=xchg_tf_sec)
+
+            # The anchor point is the session start
+            if _timeframe._is_new_session(last_dt, prev_dt, xchg_tf_sec):
+                # We need to round the session start to the nearest hour
+                last_signal = last_dt.replace(minute=0, second=0, microsecond=0)
+            seconds_since_last_session = (last_dt - last_signal).total_seconds()
+
+            if seconds_since_last_session % tf_sec == 0:
+                last_dt = dt
+                return lib.bar_index > 0
+
+        return False
+
+    # Daily/Weekly/Monthly: true on the first chart bar of a new period of
+    # the scheduled grid — the period identity changing is exactly
+    # ``ta.change(time(timeframe))`` on the verified grid
+    if _multiplier > 1:
+        if (_modifier, _multiplier) == _timeframe._process_tf(str(_syminfo.period)):
+            # The chart's own bars are the requested grid: every bar starts one
+            key = lib._time
+        else:
+            key = lib._dwm_change_key(timeframe, _modifier, _multiplier)
+    elif _modifier == 'D':
+        key = lib._dg_trading_day()
+    elif _modifier == 'W':
+        td = lib._dg_trading_day()
+        key = td - timedelta(days=td.weekday())
+    else:  # 'M'
+        td = lib._dg_trading_day()
+        key = (td.year, td.month)
+
+    if key != last_period:
+        is_first = last_period is None
+        last_period = key
+        if not is_first:
+            return lib.bar_index > 0
+    return False

pynecore/lib/adjustment.py

@@ -0,0 +1,6 @@
+#
+# Constants
+#
+none = 0
+dividends = 1
+splits = 2

pynecore/lib/alert.py

@@ -0,0 +1,39 @@
+"""
+Alert
+
+The module is both a function (``alert(...)``) and a namespace (``alert.freq_once_per_bar``);
+call sites are routed to :func:`alert` by the module property AST transformer.
+"""
+from ..types.alert import AlertEnum
+
+
+#
+# Constants
+#
+
+freq_all = AlertEnum('all')
+freq_once_per_bar = AlertEnum('once_per_bar')
+freq_once_per_bar_close = AlertEnum('once_per_bar_close')
+
+
+#
+# Module function
+#
+
+def alert(
+        message: str,
+        freq: AlertEnum = freq_once_per_bar
+) -> None:
+    """
+    Display alert message. Uses rich formatting if available, falls back to print.
+
+    :param message: Alert message to display
+    :param freq: Alert frequency (currently ignored)
+    """
+    try:
+        # Try to use typer for nice colored output
+        import typer
+        typer.secho(f"🚨 ALERT: {message}", fg=typer.colors.BRIGHT_YELLOW, bold=True)
+    except ImportError:
+        # Fallback to simple print
+        print(f"🚨 ALERT: {message}")

pynecore/lib/alert.pyi

@@ -0,0 +1,14 @@
+from ..types.alert import AlertEnum
+
+
+# IDE-facing view of the function-and-namespace module: user code reads the
+# constants and calls the bare name; the AST transformer resolves both at runtime.
+class AlertModule:
+    freq_all: AlertEnum
+    freq_once_per_bar: AlertEnum
+    freq_once_per_bar_close: AlertEnum
+
+    def __call__(self, message: str, freq: AlertEnum = ...) -> None: ...
+
+
+alert: AlertModule