opencode-pyneruntime 6.6.4__py3-none-any.whl

pynecore/lib/barmerge.py

@@ -0,0 +1,60 @@
+"""
+``barmerge`` namespace — gap and lookahead modes for ``request.security()``.
+
+Gap modes
+---------
+
+- ``gaps_off``: forward-fill missing values (default)
+- ``gaps_on``: emit ``na`` between security periods
+
+Lookahead modes
+---------------
+
+PyneCore exposes three lookahead-mode constants. Pine v6's ``lookahead_off``
+and ``lookahead_on`` are kept for source-level compatibility with TradingView
+scripts; ``lookahead_last_closed`` is a PyneSys-native alternative.
+
+- ``lookahead_off`` (default): TV-faithful closed-bar behavior — the security
+  context advances only to the bar that has CLOSED at or before the chart
+  bar's time. In historical mode this matches TradingView exactly. In live
+  mode every HTF period close is shipped to the subprocess via the chart-side
+  ``HTFAggregator`` (the static ``.ohlcv`` file cannot grow at runtime); no
+  developing-bar exposure. Note: PyneCore's ``lookahead_off`` is intentionally
+  repaint-free even in live mode — it does not mirror TV's live developing
+  exposure for ``lookahead_off + close[0]``.
+
+- ``lookahead_last_closed`` (PyneSys-native): always returns the most recently
+  closed security bar. In historical mode it is functionally equivalent to
+  ``lookahead_off``; in live mode it uses the same closed-bar transport as
+  ``lookahead_off`` and stays repaint-free (no in-progress bar). Preferred
+  when you want explicit "last closed" semantics without depending on the TV
+  ``close[1]`` idiom.
+
+- ``lookahead_on``: TV-compatible. In live mode the security subprocess steps
+  into the containing HTF bar with ``barstate.isconfirmed=False`` and OHLCV
+  aggregated from chart-timeframe data — matching TradingView's developing-bar
+  semantics, so the TV idiom ``request.security(..., lookahead_on)[1]`` returns
+  the latest closed value as it does on TV. In historical mode it falls back
+  to closed-only semantics (equivalent to ``lookahead_off``), so historical
+  backtests never expose a developing close.
+
+Cross-symbol HTF ``lookahead_*`` in live mode is bounded by chart-symbol
+aggregation: only same-symbol HTF contexts get the live HTF transport. Cross-symbol
+HTF ``lookahead_off`` / ``lookahead_last_closed`` read closed bars from the
+security's own data feed. Cross-symbol HTF ``lookahead_on`` returns ``na`` for
+the current chart bar inside an open HTF period (the developing bar cannot be
+aggregated from the wrong instrument); ``close[1]`` at the period boundary
+still delivers the just-closed cross-symbol HTF close, preserving the TV
+``lookahead_on + close[1]`` idiom.
+"""
+from ..types.barmerge import BarMerge
+
+#
+# Constants
+#
+
+gaps_off = BarMerge()
+gaps_on = BarMerge()
+lookahead_off = BarMerge()
+lookahead_on = BarMerge()
+lookahead_last_closed = BarMerge()

pynecore/lib/barstate.py

@@ -0,0 +1,30 @@
+__all__ = [
+    'isfirst',
+    'islast',
+    'isconfirmed',
+    'ishistory',
+    'islastconfirmedhistory',
+    'isnew',
+    'isrealtime'
+]
+
+isfirst = True
+""" Returns true if current bar is first bar in barset, false otherwise."""
+
+islast = False
+""" Returns true if current bar is the last bar in barset, false otherwise. """
+
+isconfirmed = True
+""" Returns true if the script is calculating the last (closing) update of the current bar. """
+
+ishistory = True
+""" Returns true if script is calculating on historical bars, false otherwise. """
+
+islastconfirmedhistory = False
+""" Returns true on the last historical bar before real-time bars begin. """
+
+isnew = False
+""" Returns true if script is currently calculating on new bar, false otherwise. """
+
+isrealtime = False
+""" Returns true if script is calculating on real-time bars, false otherwise. """

pynecore/lib/box.py

@@ -0,0 +1,415 @@
+from copy import copy as _copy
+from typing import Any, overload
+
+from ..core.module_property import module_property
+
+from ..types.base import next_vid
+from ..types.box import Box
+from ..types.na import NA, na_int, na_float
+from ..types.pine_types import PyneFloat, PyneInt
+from ..types.chart import ChartPoint
+from ..lib import (color as _color, extend as _extend, xloc as _xloc, size as _size, line as _line,
+                   text as _text, font as _font)
+from .. import lib
+
+_registry: dict[Box, None] = {}
+
+
+@overload
+def new(top_left: ChartPoint, bottom_right: ChartPoint, border_color: _color.Color = _color.blue,
+        border_width: int = 1, border_style: _line.LineEnum = _line.style_solid,
+        extend: _extend.Extend = _extend.none, xloc: _xloc.XLoc = _xloc.bar_index,
+        bgcolor: _color.Color = _color.blue, text: str = "", text_size: _size.Size = _size.auto,
+        text_color: _color.Color = _color.black, text_halign: _text.AlignEnum = _text.align_center,
+        text_valign: _text.AlignEnum = _text.align_center, text_wrap: _text.WrapEnum = _text.wrap_none,
+        text_font_family: _font.FontFamilyEnum = _font.family_default, force_overlay: bool = False,
+        text_formatting: _text.FormatEnum = _text.format_none) -> Box: ...
+
+
+@overload
+def new(left: int | float, top: float, right: int | float, bottom: float,
+        border_color: _color.Color = _color.blue, border_width: int = 1,
+        border_style: _line.LineEnum = _line.style_solid, extend: _extend.Extend = _extend.none,
+        xloc: _xloc.XLoc = _xloc.bar_index, bgcolor: _color.Color = _color.blue, text: str = "",
+        text_size: _size.Size = _size.auto, text_color: _color.Color = _color.black,
+        text_halign: _text.AlignEnum = _text.align_center, text_valign: _text.AlignEnum = _text.align_center,
+        text_wrap: _text.WrapEnum = _text.wrap_none, text_font_family: _font.FontFamilyEnum = _font.family_default,
+        force_overlay: bool = False, text_formatting: _text.FormatEnum = _text.format_none) -> Box: ...
+
+
+# Positional parameter orders of the two Pine call shapes; ``new()`` maps ``*args``
+# onto one of these depending on whether the first positional is a ``chart.point``.
+_COMMON_PARAMS = ('border_color', 'border_width', 'border_style', 'extend', 'xloc', 'bgcolor',
+                  'text', 'text_size', 'text_color', 'text_halign', 'text_valign', 'text_wrap',
+                  'text_font_family', 'force_overlay', 'text_formatting')
+_POINT_PARAMS = ('top_left', 'bottom_right') + _COMMON_PARAMS
+_COORD_PARAMS = ('left', 'top', 'right', 'bottom') + _COMMON_PARAMS
+
+
+# noinspection PyProtectedMember
+def new(*args: Any, **kwargs: Any) -> Box:
+    """
+    Creates a new box object.
+
+    Two call shapes are accepted (Pine-compatible):
+    - ``box.new(top_left, bottom_right, ...)`` where both arguments are ``chart.point`` objects
+      (the top-left and bottom-right corners).
+    - ``box.new(left, top, right, bottom, ...)`` where ``left`` / ``right`` are bar index
+      (``xloc.bar_index``) or bar UNIX time in milliseconds (``xloc.bar_time``),
+      and ``top`` / ``bottom`` are prices. Float ``left`` / ``right`` are truncated
+      to int to mirror Pine's implicit float-to-int conversion on ``series int`` parameters.
+
+    :param left: Bar index / bar time of the left border (coordinate form)
+    :param top: Price of the top border (coordinate form)
+    :param right: Bar index / bar time of the right border (coordinate form only)
+    :param bottom: Price of the bottom border (coordinate form only)
+    :param border_color: Color of the four borders
+    :param border_width: Width of the four borders, in pixels
+    :param border_style: Style of the four borders
+    :param extend: When ``extend.none`` is used, the horizontal borders start at the left border and end at the right border
+    :param xloc: Determines whether ``left`` / ``right`` are a bar index or a bar time value
+    :param bgcolor: Background color of the box
+    :param text: The text to be displayed inside the box
+    :param text_size: Size of the box's text
+    :param text_color: The color of the text
+    :param text_halign: The horizontal alignment of the box's text
+    :param text_valign: The vertical alignment of the box's text
+    :param text_wrap: Whether to wrap text. Wrapped text starts a new line
+    :param text_font_family: The font family of the text
+    :param force_overlay: If true, the drawing will display on the main chart pane
+    :param text_formatting: The formatting of the displayed text
+    :param top_left: Top-left corner ``chart.point`` (point form, keyword equivalent of the first positional)
+    :param bottom_right: Bottom-right corner ``chart.point`` (point form, keyword equivalent of the second positional)
+    :return: A box object
+    """
+    if args:
+        names = _POINT_PARAMS if isinstance(args[0], ChartPoint) else _COORD_PARAMS
+        if len(args) > len(names):
+            raise TypeError(f"box.new() takes at most {len(names)} positional arguments")
+        for name, value in zip(names, args):
+            if name in kwargs:
+                raise TypeError(f"box.new() got multiple values for argument '{name}'")
+            kwargs[name] = value
+    top_left = kwargs.get('top_left')
+    bottom_right = kwargs.get('bottom_right')
+    border_color = kwargs.get('border_color', _color.blue)
+    border_width = kwargs.get('border_width', 1)
+    border_style = kwargs.get('border_style', _line.style_solid)
+    extend = kwargs.get('extend', _extend.none)
+    xloc = kwargs.get('xloc', _xloc.bar_index)
+    bgcolor = kwargs.get('bgcolor', _color.blue)
+    text = kwargs.get('text', "")
+    text_size = kwargs.get('text_size', _size.auto)
+    text_color = kwargs.get('text_color', _color.black)
+    text_halign = kwargs.get('text_halign', _text.align_center)
+    text_valign = kwargs.get('text_valign', _text.align_center)
+    text_wrap = kwargs.get('text_wrap', _text.wrap_none)
+    text_font_family = kwargs.get('text_font_family', _font.family_default)
+    force_overlay = kwargs.get('force_overlay', False)
+    text_formatting = kwargs.get('text_formatting', _text.format_none)
+    if isinstance(top_left, ChartPoint):
+        bottom_right_point = bottom_right if isinstance(bottom_right, ChartPoint) else top_left
+        if xloc == _xloc.bar_time:
+            left_val, top_val = top_left.time, top_left.price
+            right_val, bottom_val = bottom_right_point.time, bottom_right_point.price
+        else:
+            left_val, top_val = top_left.index, top_left.price
+            right_val, bottom_val = bottom_right_point.index, bottom_right_point.price
+    else:
+        left = kwargs.get('left')
+        top = kwargs.get('top')
+        right = kwargs.get('right')
+        bottom = kwargs.get('bottom')
+        left_val = int(left) if isinstance(left, (int, float)) and left == left else na_int
+        top_val = top if isinstance(top, (int, float)) else na_float
+        right_val = int(right) if isinstance(right, (int, float)) and right == right else na_int
+        bottom_val = bottom if isinstance(bottom, (int, float)) else na_float
+
+    box = Box(
+        left=left_val,
+        top=top_val,
+        right=right_val,
+        bottom=bottom_val,
+        border_color=border_color,
+        border_width=border_width,
+        border_style=border_style,
+        extend=extend,
+        xloc=xloc,
+        bgcolor=bgcolor,
+        text=text,
+        text_size=text_size,
+        text_color=text_color,
+        text_halign=text_halign,
+        text_valign=text_valign,
+        text_wrap=text_wrap,
+        text_font_family=text_font_family,
+        text_formatting=text_formatting,
+        force_overlay=force_overlay,
+    )
+    box.vid = next_vid()
+    _registry[box] = None
+    # Enforce Pine's max_boxes_count cap: drop the oldest box (FIFO) past the limit.
+    # A security child never sets ``lib._script``; fall back to TV's hard maximum
+    # (500) there, otherwise the registry grows without bound (the child re-runs
+    # main() for every bar of its own series, accumulating every drawing ever made).
+    if len(_registry) > (lib._script.max_boxes_count if lib._script is not None else 500):
+        del _registry[next(iter(_registry))]
+    return box
+
+
+# noinspection PyShadowingBuiltins
+@module_property
+def all() -> list[Box]:
+    """Returns all box objects"""
+    return list(_registry)
+
+
+# noinspection PyShadowingBuiltins
+def delete(id):
+    if isinstance(id, NA):
+        return
+    _registry.pop(id, None)
+
+
+# noinspection PyShadowingBuiltins,PyProtectedMember
+def copy(id):
+    if isinstance(id, NA):
+        return NA(Box)
+    clone = _copy(id)
+    clone.vid = next_vid()
+    _registry[clone] = None
+    if len(_registry) > (lib._script.max_boxes_count if lib._script is not None else 500):
+        del _registry[next(iter(_registry))]
+    return clone
+
+
+# Setter methods
+
+# noinspection PyShadowingBuiltins
+def set_bgcolor(id: Box, color: _color.Color) -> None:
+    """Sets the background color of the box."""
+    if isinstance(id, NA):
+        return
+    id.bgcolor = color
+
+
+# noinspection PyShadowingBuiltins
+def set_border_color(id: Box, color: _color.Color) -> None:
+    """Sets the border color of the box."""
+    if isinstance(id, NA):
+        return
+    id.border_color = color
+
+
+# noinspection PyShadowingBuiltins
+def set_border_style(id: Box, style: _line.LineEnum) -> None:
+    """Sets the border style of the box."""
+    if isinstance(id, NA):
+        return
+    id.border_style = style
+
+
+# noinspection PyShadowingBuiltins
+def set_border_width(id: Box, width: int) -> None:
+    """Sets the border width of the box."""
+    if isinstance(id, NA):
+        return
+    id.border_width = width
+
+
+# noinspection PyShadowingBuiltins
+def set_bottom(id: Box, bottom: float) -> None:
+    """Sets the bottom coordinate of the box."""
+    if isinstance(id, NA):
+        return
+    id.bottom = bottom
+
+
+# noinspection PyShadowingBuiltins
+def set_bottom_right_point(id: Box, point: ChartPoint) -> None:
+    """Sets the bottom-right corner location of the box to point."""
+    if isinstance(id, NA):
+        return
+    if id.xloc == _xloc.bar_time:
+        id.right = point.time
+    else:
+        id.right = point.index
+    id.bottom = point.price
+
+
+# noinspection PyShadowingBuiltins
+def set_extend(id: Box, extend: _extend.Extend) -> None:
+    """Sets extending type of the border of this box object."""
+    if isinstance(id, NA):
+        return
+    id.extend = extend
+
+
+# noinspection PyShadowingBuiltins
+def set_left(id: Box, left: int) -> None:
+    """Sets the left coordinate of the box."""
+    if isinstance(id, NA):
+        return
+    id.left = left
+
+
+# noinspection PyShadowingBuiltins
+def set_lefttop(id: Box, left: int, top: float) -> None:
+    """Sets the left and top coordinates of the box."""
+    if isinstance(id, NA):
+        return
+    id.left = left
+    id.top = top
+
+
+# noinspection PyShadowingBuiltins
+def set_right(id: Box, right: int) -> None:
+    """Sets the right coordinate of the box."""
+    if isinstance(id, NA):
+        return
+    id.right = right
+
+
+# noinspection PyShadowingBuiltins
+def set_rightbottom(id: Box, right: int, bottom: float) -> None:
+    """Sets the right and bottom coordinates of the box."""
+    if isinstance(id, NA):
+        return
+    id.right = right
+    id.bottom = bottom
+
+
+# noinspection PyShadowingBuiltins
+
+
+def set_text(id: Box, text: str) -> None:
+    """Sets the text in the box."""
+    if isinstance(id, NA):
+        return
+    id.text = text
+
+
+# noinspection PyShadowingBuiltins
+def set_text_color(id: Box, text_color: _color.Color) -> None:
+    """Sets the color of the text inside the box."""
+    if isinstance(id, NA):
+        return
+    id.text_color = text_color
+
+
+# noinspection PyShadowingBuiltins
+def set_text_font_family(id: Box, text_font_family: _font.FontFamilyEnum) -> None:
+    """Sets the font family of the text inside the box."""
+    if isinstance(id, NA):
+        return
+    id.text_font_family = text_font_family
+
+
+# noinspection PyShadowingBuiltins
+def set_text_formatting(id: Box, text_formatting: _text.FormatEnum) -> None:
+    """Sets the formatting attributes the drawing applies to displayed text."""
+    if isinstance(id, NA):
+        return
+    id.text_formatting = text_formatting
+
+
+# noinspection PyShadowingBuiltins
+def set_text_halign(id: Box, text_halign: _text.AlignEnum) -> None:
+    """Sets the horizontal alignment of the box's text."""
+    if isinstance(id, NA):
+        return
+    id.text_halign = text_halign
+
+
+# noinspection PyShadowingBuiltins
+def set_text_size(id: Box, text_size: _size.Size) -> None:
+    """Sets the size of the box's text."""
+    if isinstance(id, NA):
+        return
+    id.text_size = text_size
+
+
+# noinspection PyShadowingBuiltins
+def set_text_valign(id: Box, text_valign: _text.AlignEnum) -> None:
+    """Sets the vertical alignment of the box's text."""
+    if isinstance(id, NA):
+        return
+    id.text_valign = text_valign
+
+
+# noinspection PyShadowingBuiltins
+def set_text_wrap(id: Box, text_wrap: _text.WrapEnum) -> None:
+    """Sets the mode of wrapping of the text inside the box."""
+    if isinstance(id, NA):
+        return
+    id.text_wrap = text_wrap
+
+
+# noinspection PyShadowingBuiltins
+def set_top(id: Box, top: float) -> None:
+    """Sets the top coordinate of the box."""
+    if isinstance(id, NA):
+        return
+    id.top = top
+
+
+# noinspection PyShadowingBuiltins
+def set_top_left_point(id: Box, point: ChartPoint) -> None:
+    """Sets the top-left corner location of the box to point."""
+    if isinstance(id, NA):
+        return
+    if id.xloc == _xloc.bar_time:
+        id.left = point.time
+    else:
+        id.left = point.index
+    id.top = point.price
+
+
+# noinspection PyShadowingBuiltins
+def set_xloc(id: Box, left: int, right: int, xloc: _xloc.XLoc) -> None:
+    """Sets the left and right borders of a box and updates its xloc property."""
+    if isinstance(id, NA):
+        return
+    id.left = left
+    id.right = right
+    id.xloc = xloc
+
+
+# Getter methods
+
+# noinspection PyShadowingBuiltins
+def get_bottom(id: Box) -> PyneFloat:
+    """Returns the price value of the bottom border of the box."""
+    if isinstance(id, NA):
+        return na_float
+    return id.bottom
+
+
+# noinspection PyShadowingBuiltins
+def get_left(id: Box) -> PyneInt:
+    """
+    Returns the bar index or the UNIX time (depending on the last value used for 'xloc') of the
+    left border of the box.
+    """
+    if isinstance(id, NA):
+        return NA(int)
+    return id.left
+
+
+# noinspection PyShadowingBuiltins
+def get_right(id: Box) -> PyneInt:
+    """
+    Returns the bar index or the UNIX time (depending on the last value used for 'xloc') of the
+    right border of the box.
+    """
+    if isinstance(id, NA):
+        return NA(int)
+    return id.right
+
+
+# noinspection PyShadowingBuiltins
+def get_top(id: Box) -> PyneFloat:
+    """Returns the price value of the top border of the box."""
+    if isinstance(id, NA):
+        return na_float
+    return id.top

pynecore/lib/chart.py

@@ -0,0 +1,128 @@
+from copy import copy as _copy
+
+from ..types.color import Color
+from ..types.chart import ChartPoint
+from ..types.na import NA
+from ..core.module_property import module_property
+
+from .. import lib
+from .timeframe import in_seconds
+
+__all__ = [
+    'bg_color',
+    'fg_color',
+    'is_heikinashi',
+    'is_kagi',
+    'is_linebreak',
+    'is_pnf',
+    'is_range',
+    'is_renko',
+    'is_standard',
+    'left_visible_bar_time',
+    'right_visible_bar_time',
+    'point'
+]
+
+_visible_bars = 20
+
+bg_color = Color('#000000')
+fg_color = Color('#FFFFFF')
+
+is_heikinashi = False
+is_kagi = False
+is_linebreak = False
+is_pnf = False
+is_range = False
+is_renko = False
+is_standard = True
+
+
+# The visible range is anchored to the chart's LAST bar (a chart scrolled to
+# its right edge — TradingView's default viewport). ``lib.last_bar_time`` is
+# fixed to the final bar on historical runs and tracks the realtime bar live,
+# so ``time == chart.right_visible_bar_time`` is true once per historical run
+# (on the final bar) and on every realtime bar — matching TV.
+@module_property
+def left_visible_bar_time() -> int:
+    return lib.last_bar_time - int(in_seconds(lib.syminfo.period) * 1000) * _visible_bars
+
+
+@module_property
+def right_visible_bar_time() -> int:
+    return lib.last_bar_time
+
+
+# noinspection PyShadowingBuiltins
+class _ChartPoint:
+    """
+    The ``chart.point`` constructor namespace.
+
+    A chart point holds the coordinates a drawing object uses to position itself: a bar
+    ``index``, a UNIX ``time`` (in milliseconds), and a ``price``. The ``xloc`` of the
+    consuming drawing decides which x-coordinate field is read (``index`` for
+    ``xloc.bar_index``, ``time`` for ``xloc.bar_time``).
+    """
+
+    @staticmethod
+    def new(time: int, index: int, price: float) -> ChartPoint:
+        """
+        Creates a new ``chart.point`` from explicit time, index, and price values.
+
+        :param time: The x-coordinate as a UNIX time value, in milliseconds
+        :param index: The x-coordinate as a bar index value
+        :param price: The y-coordinate
+        :return: A new chart.point object
+        """
+        return ChartPoint(index=index, time=time, price=price)
+
+    # noinspection PyProtectedMember
+    @staticmethod
+    def now(price: float) -> ChartPoint:
+        """
+        Creates a new ``chart.point`` at the current bar, using its index and time.
+
+        :param price: The y-coordinate
+        :return: A new chart.point object with the current bar's index and time
+        """
+        return ChartPoint(
+            index=int(lib.bar_index),
+            time=int(lib._datetime.timestamp() * 1000),
+            price=price
+        )
+
+    @staticmethod
+    def from_index(index: int, price: float) -> ChartPoint:
+        """
+        Creates a new ``chart.point`` from a bar index and price. The ``time`` field is ``na``.
+
+        :param index: The x-coordinate as a bar index value
+        :param price: The y-coordinate
+        :return: A new chart.point object whose ``time`` field is ``na``
+        """
+        return ChartPoint(index=index, time=NA(int), price=price)
+
+    @staticmethod
+    def from_time(time: int, price: float) -> ChartPoint:
+        """
+        Creates a new ``chart.point`` from a UNIX time and price. The ``index`` field is ``na``.
+
+        :param time: The x-coordinate as a UNIX time value, in milliseconds
+        :param price: The y-coordinate
+        :return: A new chart.point object whose ``index`` field is ``na``
+        """
+        return ChartPoint(index=NA(int), time=time, price=price)
+
+    @staticmethod
+    def copy(id: ChartPoint) -> ChartPoint:
+        """
+        Returns a copy of the ``chart.point`` object.
+
+        :param id: The chart.point object to copy
+        :return: A new chart.point object with the same field values
+        """
+        if isinstance(id, NA):
+            return NA(ChartPoint)
+        return _copy(id)
+
+
+point = _ChartPoint()