opencode-pyneruntime 6.6.4__py3-none-any.whl

pynecore/types/na.py

@@ -0,0 +1,237 @@
+from math import isfinite
+from typing import Any, TypeVar, Generic, Type, Self
+
+__all__ = [
+    'NA', 'na_float', 'na_int', 'na_bool', 'na_str', 'isna_num',
+]
+
+T = TypeVar('T')
+
+# The one float na: Pine's float-typed na IS a native IEEE-754 nan.
+# Interned so identity-based fast paths (dict key lookup, ``is`` checks)
+# always see the same object when the na came from ``NA(float)``.
+_NAN = float('nan')
+
+
+def isna_num(x: Any) -> bool:
+    """
+    Representation-agnostic na test for numeric (float-typed) values.
+
+    Accepts both representations of a Pine numeric na: the ``NA`` object and a
+    native non-finite float. Uses Pine's ``na()`` predicate semantics
+    (``not isfinite``), so ``inf`` and ``-inf`` count as na too — matching
+    TradingView, where ``na(inf)`` is ``true``.
+
+    Cold paths only: never call this in a per-bar hot loop. Hot loops use the
+    inline idioms ``x != x`` (nan-only) or ``isinstance(x, NA) or x != x``.
+
+    :param x: value to test
+    :return: ``True`` if ``x`` is a numeric na, ``False`` otherwise
+    """
+    if isinstance(x, NA):
+        return True
+    try:
+        return not isfinite(x)
+    except TypeError:
+        return False
+
+
+class NA(Generic[T]):
+    """
+    Class representing NA (Not Available) values for non-float types.
+
+    ``NA(float)`` does NOT construct an instance: it returns the interned
+    native ``float('nan')`` — Pine's float na is a real IEEE-754 nan, so
+    arithmetic and comparisons on it run at native float speed. This shim in
+    ``__new__`` is a permanent compatibility contract: every already-compiled
+    script calling ``NA(float)`` (and the ``na(float)`` constructor face)
+    transparently produces the native nan.
+
+    All other types (int, str, drawing objects, UDTs, ...) get interned NA
+    instances: every operation returns self, every comparison is False.
+    """
+    __slots__ = ('type',)
+
+    _type_cache: dict[Type | None, 'NA'] = {}
+
+    # noinspection PyShadowingBuiltins
+    def __new__(cls, type: Type[T] | T | None = int) -> Self:
+        if type is float:
+            return _NAN  # type: ignore[return-value]
+        try:
+            return cls._type_cache[type]  # type: ignore[reportReturnType]
+        except KeyError:
+            na = super().__new__(cls)
+            cls._type_cache[type] = na
+            return na
+
+    # noinspection PyShadowingBuiltins
+    def __init__(self, type: Type[T] | T | None = int) -> None:
+        """
+        Initialize a new NA value with an optional type parameter.
+        The default type is int.
+        """
+        self.type = type
+
+    def __repr__(self) -> str:
+        if self.type is None:
+            return "NA"
+        return f"NA[{self.type.__name__}]"  # type: ignore
+
+    def __str__(self) -> str:
+        return ""
+
+    def __format__(self, format_spec: str) -> str:
+        return "NaN"
+
+    def __hash__(self) -> int:
+        return hash(self.type)
+
+    def __int__(self) -> 'NA[int]':
+        # We solve this with an AST Transformer
+        raise TypeError("NA cannot be converted to int")
+
+    def __float__(self) -> 'NA[float]':
+        # We solve this with an AST Transformer
+        raise TypeError("NA cannot be converted to float")
+
+    def __bool__(self) -> bool:
+        return False
+
+    def __round__(self, n=None) -> Self:
+        return self
+
+    #
+    # Arithmetic operations — every operation propagates self
+    #
+
+    def __neg__(self) -> Self:
+        return self
+
+    def __add__(self, _: Any) -> Self:
+        return self
+
+    def __radd__(self, _: Any) -> Self:
+        return self
+
+    def __sub__(self, _: Any) -> Self:
+        return self
+
+    def __rsub__(self, _: Any) -> Self:
+        return self
+
+    def __mul__(self, _: Any) -> Self:
+        return self
+
+    def __rmul__(self, _: Any) -> Self:
+        return self
+
+    def __truediv__(self, _: Any) -> Self:
+        return self
+
+    def __rtruediv__(self, _: Any) -> Self:
+        return self
+
+    def __mod__(self, _: Any) -> Self:
+        return self
+
+    def __rmod__(self, _: Any) -> Self:
+        return self
+
+    def __abs__(self) -> Self:
+        return self
+
+    #
+    # Bitwise operations
+    #
+
+    def __and__(self, _: Any) -> Self:
+        return self
+
+    def __rand__(self, _: Any) -> Self:
+        return self
+
+    def __or__(self, _: Any) -> Self:
+        return self
+
+    def __ror__(self, _: Any) -> Self:
+        return self
+
+    def __xor__(self, _: Any) -> Self:
+        return self
+
+    def __rxor__(self, _: Any) -> Self:
+        return self
+
+    def __lshift__(self, _: Any) -> Self:
+        return self
+
+    def __rlshift__(self, _: Any) -> Self:
+        return self
+
+    def __rshift__(self, _: Any) -> Self:
+        return self
+
+    def __rrshift__(self, _: Any) -> Self:
+        return self
+
+    def __invert__(self) -> Self:
+        return self
+
+    #
+    # Comparisons — all False (Pine semantics)
+    #
+
+    def __eq__(self, _: Any) -> bool:
+        return False
+
+    def __ne__(self, _: Any) -> bool:
+        return False
+
+    def __gt__(self, _: Any) -> bool:
+        return False
+
+    def __lt__(self, _: Any) -> bool:
+        return False
+
+    def __le__(self, _: Any) -> bool:
+        return False
+
+    def __ge__(self, _: Any) -> bool:
+        return False
+
+    #
+    # In contexts
+    #
+
+    def __getattr__(self, name: str) -> Self:
+        # Don't return self for special attributes
+        if name.startswith('__'):
+            raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
+        return self
+
+    def __getitem__(self, _: Any) -> Self:
+        return self
+
+    def __contains__(self, _: Any) -> bool:
+        # ``x in na`` must short-circuit to False: ``__getitem__`` returns self
+        # for every index and never raises IndexError, so the ``in`` operator's
+        # sequence-protocol fallback would iterate forever.
+        return False
+
+    def __iter__(self) -> Any:
+        # NA is not a sequence. Without an explicit __iter__, ``iter(na)``
+        # (e.g. ``str.join(na)``, ``list(na)``, tuple unpacking) falls back to
+        # the sequence protocol and — since ``__getitem__`` returns self for
+        # every index — spins forever while building an unbounded list.
+        # Failing loudly is the only safe behavior here.
+        raise TypeError("na is not iterable")
+
+    def __call__(self, *_, **__) -> Self:
+        return self
+
+
+na_float: float = _NAN
+na_int = NA(int)
+na_str = NA(str)
+na_bool = NA(bool)

pynecore/types/na.pyi

@@ -0,0 +1,83 @@
+from typing import Any, TypeVar, Generic, Type, Iterator
+
+T = TypeVar('T')
+
+
+def isna_num(x: Any) -> bool: ...
+
+
+class NA(Generic[T]):
+    type: Type[T] | T | None
+
+    # The "plain T" lie at its root: a constructed NA value types as T, so
+    # lib functions can return NA(X) under a plain -> X annotation and na
+    # sentinels flow anywhere an X is expected (in Pine any value can be na).
+    # No __init__ here: if the stub declares one, PyCharm ignores __new__'s
+    # return type and NA(float) degrades to NA[float] again.
+    def __new__(cls, type: Type[T] | T | None = int) -> T: ...  # type: ignore[misc]
+
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    def __format__(self, format_spec: str) -> str: ...
+    def __hash__(self) -> int: ...
+    def __bool__(self) -> bool: ...
+    def __round__(self, n: int = ...) -> Any: ...
+
+    # Protocol compliance: SupportsFloat, SupportsIndex
+    def __int__(self) -> int: ...
+    def __float__(self) -> float: ...
+    def __index__(self) -> int: ...
+
+    # Protocol compliance: Sized, Iterable
+    def __len__(self) -> int: ...
+    def __iter__(self) -> Iterator[Any]: ...
+    def __reversed__(self) -> Iterator[Any]: ...
+
+    # Arithmetic — return Any so NA propagates without type conflicts
+    def __neg__(self) -> Any: ...
+    def __add__(self, _: Any) -> Any: ...
+    def __radd__(self, _: Any) -> Any: ...
+    def __sub__(self, _: Any) -> Any: ...
+    def __rsub__(self, _: Any) -> Any: ...
+    def __mul__(self, _: Any) -> Any: ...
+    def __rmul__(self, _: Any) -> Any: ...
+    def __truediv__(self, _: Any) -> Any: ...
+    def __rtruediv__(self, _: Any) -> Any: ...
+    def __mod__(self, _: Any) -> Any: ...
+    def __rmod__(self, _: Any) -> Any: ...
+    def __abs__(self) -> Any: ...
+
+    # Bitwise
+    def __and__(self, _: Any) -> Any: ...
+    def __rand__(self, _: Any) -> Any: ...
+    def __or__(self, _: Any) -> Any: ...
+    def __ror__(self, _: Any) -> Any: ...
+    def __xor__(self, _: Any) -> Any: ...
+    def __rxor__(self, _: Any) -> Any: ...
+    def __lshift__(self, _: Any) -> Any: ...
+    def __rlshift__(self, _: Any) -> Any: ...
+    def __rshift__(self, _: Any) -> Any: ...
+    def __rrshift__(self, _: Any) -> Any: ...
+    def __invert__(self) -> Any: ...
+
+    # Comparison
+    def __eq__(self, _: Any) -> bool: ...
+    def __gt__(self, _: Any) -> bool: ...
+    def __lt__(self, _: Any) -> bool: ...
+    def __le__(self, _: Any) -> bool: ...
+    def __ge__(self, _: Any) -> bool: ...
+
+    # Catch-all for attribute access and indexing
+    def __getattr__(self, name: str) -> Any: ...
+    def __getitem__(self, _: Any) -> Any: ...
+    def __call__(self, *_: Any, **__: Any) -> Any: ...
+
+
+# The singleton constants wear the same "plain T" face as __new__ above:
+# na_float must be assignable wherever a float is, or every hot-path use of the
+# interned constants (instead of an NA(float) call) would false-positive.
+# (na_float genuinely IS a float now — the interned native nan.)
+na_float: float
+na_int: int
+na_str: str
+na_bool: bool

pynecore/types/ohlcv.py

@@ -0,0 +1,12 @@
+from typing import NamedTuple, Any
+
+
+class OHLCV(NamedTuple):
+    timestamp: int  # Unix timestamp in seconds
+    open: float
+    high: float
+    low: float
+    close: float
+    volume: float
+    extra_fields: dict[str, Any] | None = None
+    is_closed: bool = True

pynecore/types/order.py

@@ -0,0 +1,5 @@
+from ..types.base import StrLiteral
+
+
+class Order(StrLiteral):
+    ...

pynecore/types/persistent.py

@@ -0,0 +1,8 @@
+from typing import TypeVar, TypeAlias
+from .na import NA
+from .series import Series
+
+T = TypeVar('T')
+
+# Public type alias that allows both T and NA[T] or Series[T]
+Persistent: TypeAlias = T | NA[T] | Series[T]

pynecore/types/persistent.pyi

@@ -0,0 +1,13 @@
+"""
+Persistent is a transparent alias for type checkers: ``Persistent[T]`` IS ``T``.
+
+NA is deliberately dropped from the static view (the "plain T" policy): in Pine
+semantics any value can be na, so a ``T | NA[T]`` union only produces noise on
+every arithmetic use. Runtime (persistent.py) is unchanged — this stub exists
+because a bare TypeVar is not subscriptable at runtime.
+"""
+from typing import TypeVar, TypeAlias
+
+T = TypeVar('T')
+
+Persistent: TypeAlias = T

pynecore/types/pine_types.py

@@ -0,0 +1,11 @@
+from typing import TypeAlias, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pynecore.types.type_checker import *
+from pynecore.types.na import NA
+from pynecore.types.series import Series
+
+PyneFloat: TypeAlias = float | NA[float] | Series[float]
+PyneInt: TypeAlias = int | NA[int] | Series[int]
+PyneStr: TypeAlias = str | NA[str] | Series[str]
+PyneBool: TypeAlias = bool | NA[bool] | Series[bool]

pynecore/types/pine_types.pyi

@@ -0,0 +1,15 @@
+"""
+NA-free static view of the Pyne scalar aliases (the "plain T" policy — see
+persistent.pyi). The ``type_checker`` wildcard import swaps ``float``/``int``/
+``bool`` for their ``[n]``-indexable subclasses under PyCharm
+(``TYPECHECKER=pycharm``); under pyright they stay the builtins.
+Runtime (pine_types.py) is unchanged.
+"""
+from typing import TypeAlias
+
+from pynecore.types.type_checker import *
+
+PyneFloat: TypeAlias = float
+PyneInt: TypeAlias = int
+PyneStr: TypeAlias = str
+PyneBool: TypeAlias = bool

pynecore/types/pivotpointtype.py

@@ -0,0 +1,5 @@
+from .base import StrLiteral
+
+
+class PivotPointType(StrLiteral):
+    __slots__ = ()

pynecore/types/plot.py

@@ -0,0 +1,12 @@
+from .base import IntEnum
+
+
+class PlotEnum(IntEnum):
+    ...
+
+
+class Plot:
+    __slots__ = ('id',)
+
+    def __init__(self, id: str = ''):  # noqa (shadowing built-in name (id) intentionally)
+        self.id = id

pynecore/types/plot_meta.py

@@ -0,0 +1,60 @@
+from dataclasses import dataclass
+from typing import Any
+
+from .color import Color
+
+
+@dataclass(slots=True)
+class PlotMeta:
+    """
+    Static (registered-once) metadata for a plot-family output.
+
+    Covers every plot family (``plot``, ``plotshape``, ``plotchar``, ``plotarrow``,
+    ``plotcandle``, ``plotbar``, ``bgcolor``, ``barcolor``, ``hline``, ``fill``); the
+    serializer drops ``None`` fields and applies kind-specific defaults. Per-bar values
+    (the series data and dynamic color channels) live elsewhere; this object only holds
+    what is fixed for the whole run.
+    """
+    id: str
+    kind: str  # 'plot'|'shape'|'char'|'arrow'|'candle'|'bar'|'bgcolor'|'barcolor'|'hline'|'fill'
+
+    title: str | None = None
+    color: Color | None = None
+    linewidth: int = 1
+    style: Any = None
+    trackprice: bool = False
+    histbase: float = 0.0
+    offset: int = 0
+    join: bool = False
+    editable: bool = True
+    show_last: int | None = None
+    display: Any = None
+    format: str | None = None
+    precision: int | None = None
+    force_overlay: bool = False
+
+    char: str | None = None
+    location: Any = None
+    size: Any = None
+    text: str | None = None
+    textcolor: Color | None = None
+
+    colorup: Color | None = None
+    colordown: Color | None = None
+    minheight: int | None = None
+    maxheight: int | None = None
+
+    wickcolor: Color | None = None
+    bordercolor: Color | None = None
+
+    price: float | None = None
+    linestyle: Any = None
+
+    plot1: str | None = None
+    plot2: str | None = None
+    hline1: str | None = None
+    hline2: str | None = None
+
+    fillgaps: bool = False
+
+    dynamic: bool = False

pynecore/types/polyline.py

@@ -0,0 +1,40 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Optional
+
+from ..lib import color as _color, xloc as _xloc
+from ..types.line import LineEnum
+
+if TYPE_CHECKING:
+    from .chart import ChartPoint
+
+
+@dataclass(slots=True, eq=False)
+class Polyline:
+    # Array of chart.point objects for the drawing to sequentially connect
+    points: list["ChartPoint"]
+    
+    # If true, the drawing will connect all points using curved line segments
+    curved: bool = False
+    
+    # If true, the drawing will connect the first point to the last point, resulting in a closed polyline
+    closed: bool = False
+    
+    # Determines the field of the chart.point objects that the polyline will use for its x-coordinates
+    xloc: Optional[_xloc.XLoc] = None
+    
+    # The color of the line segments
+    line_color: Optional[_color.Color] = None
+    
+    # The fill color of the polyline
+    fill_color: Optional[_color.Color] = None
+    
+    # The style of the polyline
+    line_style: Optional[LineEnum] = None
+    
+    # The width of the line segments, expressed in pixels
+    line_width: int = 1
+    
+    # If true, the drawing will display on the main chart pane
+    force_overlay: bool = False
+
+    vid: int = -1

pynecore/types/position.py

@@ -0,0 +1,5 @@
+from .base import StrLiteral
+
+
+class Position(StrLiteral):
+    ...

pynecore/types/scale.py

@@ -0,0 +1,5 @@
+from ..types.base import IntEnum
+
+
+class Scale(IntEnum):
+    ...

pynecore/types/script_type.py

@@ -0,0 +1,15 @@
+from .base import IntEnum
+
+__all__ = [
+    'ScriptType',
+    'indicator', 'strategy', 'library',
+]
+
+
+class ScriptType(IntEnum):
+    ...
+
+
+indicator = ScriptType()
+strategy = ScriptType()
+library = ScriptType()

pynecore/types/series.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+from typing import TypeVar, Generic
+
+__all__ = (
+    'Series',
+    'PersistentSeries',
+)
+
+T = TypeVar('T')
+
+
+class Series(Generic[T]):
+    """
+    This is the runtime, do nothing implementation of the Series type. The actual Series behavior is
+    implented in AST Transformers and the SeriesImpl class.
+    """
+
+    def __new__(cls, val: T) -> T:
+        return val
+
+
+# This is only for the AST transformer to mark a variable as Pine Script like persistent series
+PersistentSeries = Series

pynecore/types/series.pyi

@@ -0,0 +1,19 @@
+"""
+Series is a transparent alias: ``Series[T]`` IS ``T`` for type checkers.
+
+The Pine dual behavior (scalar AND ``[n]``-history-indexable at once) cannot be
+expressed in a stub — Python typing has no intersection type, and a Union means
+"either", not "both at once". The alias makes the scalar side (arithmetic,
+calls, assignments) fully type-correct; the history-indexing side is covered by
+the ``type_checker`` compat layer (PyCharm) or by suppressing
+``reportIndexIssue`` in the generated pyrightconfig (pyright/Pylance).
+
+The old ``TypeAlias`` syntax (not PEP 695 ``type``) is kept deliberately:
+PyCharm resolves unbound-TypeVar aliases this way.
+"""
+from typing import TypeVar, TypeAlias
+
+T = TypeVar('T')
+
+Series: TypeAlias = T
+PersistentSeries: TypeAlias = T

pynecore/types/session.py

@@ -0,0 +1,35 @@
+from dataclasses import dataclass
+from datetime import time
+from typing import Set
+
+from ..types.base import StrLiteral
+
+
+@dataclass(frozen=True)
+class SessionInfo:
+    """
+    Session information containing time range, valid days, and timezone.
+    
+    This dataclass represents a trading session specification that can be used
+    to determine if a given timestamp falls within the session bounds.
+    """
+    start_time: time
+    end_time: time
+    days: Set[int]  # 1=Sunday, 2=Monday, ..., 7=Saturday (TradingView format)
+    timezone: str | None
+    is_overnight: bool = False
+
+    def __post_init__(self):
+        """Validate session parameters after initialization."""
+        # Check if this is an overnight session
+        if self.start_time > self.end_time:
+            object.__setattr__(self, 'is_overnight', True)
+
+        # Validate days
+        for day in self.days:
+            if not 1 <= day <= 7:
+                raise ValueError(f"Invalid day: {day}. Days must be between 1 (Sunday) and 7 (Saturday)")
+
+
+class Session(StrLiteral):
+    ...

pynecore/types/shape.py

@@ -0,0 +1,5 @@
+from ..types.base import StrLiteral
+
+
+class Shape(StrLiteral):
+    ...

pynecore/types/size.py

@@ -0,0 +1,5 @@
+from .base import StrLiteral
+
+
+class Size(StrLiteral):
+    ...

pynecore/types/source.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+from .series import Series
+
+
+class Source(Series[float]):
+    """
+    Represents a built-in source like "open", "high", "low", "close", "hl2", etc.
+
+    DESIGN NOTES:
+    =============
+
+    This class provides type-safe source placeholders for IDE support while enabling
+    dynamic runtime resolution through AST transformation:
+
+    1. INITIALIZATION: Source objects store the source name for type hints
+    2. INPUT DETECTION: InputTransformer detects Source objects in input() calls
+    3. AST INJECTION: Adds `var = getattr(lib, var, lib.na)` at function start
+    4. RUNTIME: ScriptRunner dynamically sets lib.close = actual_price per candle
+
+    This allows `input(defval=close)` to work with proper types while being fast
+    and compatible with both Source objects and string literals in input.source().
+    """
+
+    def __new__(cls, name: str) -> Source:
+        obj = object.__new__(cls)
+        setattr(obj, "name", name)
+        return obj
+
+    def __repr__(self) -> str:
+        return f"Source({getattr(self, 'name')})"
+
+    def __str__(self) -> str:
+        return getattr(self, 'name')

pynecore/types/splits.py

@@ -0,0 +1,5 @@
+from .base import StrLiteral
+
+
+class Splits(StrLiteral):
+    ...