opencode-pyneruntime 6.6.4__py3-none-any.whl

pynecore/types/__init__.py

@@ -0,0 +1,21 @@
+from .persistent import Persistent
+from .ib_persistent import IBPersistent, IBPersistentSeries
+from .series import Series, PersistentSeries
+from .na import NA, na_float
+from .pine_types import PyneFloat, PyneInt, PyneStr, PyneBool
+
+from .box import Box
+from .chart import ChartPoint
+from .color import Color
+from .footprint import Footprint
+from .currency import Currency
+from .datetime import DayOfWeek
+from .hline import HLine
+from .label import Label
+from .line import Line
+from .linefill import LineFill
+from .polyline import Polyline
+from .table import Table
+from .volume_row import VolumeRow
+from .extend import Extend
+from .matrix import Matrix

pynecore/types/alert.py

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

pynecore/types/barmerge.py

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

pynecore/types/base.py

@@ -0,0 +1,39 @@
+class IntEnum(int):
+    """
+    IntEnum class that auto-increments values.
+    """
+
+    def __init_subclass__(cls, start: int = 0, **kwargs):
+        super().__init_subclass__(**kwargs)
+        cls._counter = start  # Each subclass gets its own counter
+
+    def __new__(cls):
+        # Create new object with the current counter value
+        value = cls._counter
+        cls._counter += 1
+        # noinspection PyTypeChecker
+        return super().__new__(cls, value)
+
+
+class StrLiteral(str):
+    """
+    StrLiteral class to store string literals.
+    """
+
+
+# Monotonic id counter for drawing objects (line/label/box/table/polyline/linefill).
+# Single-threaded runner, so a plain module-level integer needs no locking.
+_vid_counter = 0
+
+
+def next_vid() -> int:
+    """Return the next monotonically increasing drawing-object id."""
+    global _vid_counter
+    _vid_counter += 1
+    return _vid_counter
+
+
+def reset_vid_counter() -> None:
+    """Reset the drawing-object id counter (new run / new script)."""
+    global _vid_counter
+    _vid_counter = 0

pynecore/types/box.py

@@ -0,0 +1,37 @@
+from typing import Optional
+from dataclasses import dataclass
+
+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 .na import NA
+from .pine_types import PyneFloat, PyneInt
+
+
+@dataclass(slots=True, eq=False)
+class Box:
+    # Required parameters - coordinates (``na`` when set from a chart.point that lacks the
+    # corresponding coordinate for the active xloc)
+    left: PyneInt  # Bar index or UNIX time
+    top: PyneFloat  # Price of the top border
+    right: PyneInt  # Bar index or UNIX time
+    bottom: PyneFloat  # Price of the bottom border
+
+    # Optional parameters with defaults
+    border_color: Optional[_color.Color] = None
+    border_width: int = 1
+    border_style: Optional[_line.LineEnum] = None
+    extend: Optional[_extend.Extend] = None
+    xloc: Optional[_xloc.XLoc] = None
+    bgcolor: Optional[_color.Color] = None
+    text: str = ""
+    text_size: Optional[_size.Size] = None
+    text_color: Optional[_color.Color] = None
+    text_halign: Optional[_text.AlignEnum] = None
+    text_valign: Optional[_text.AlignEnum] = None
+    text_wrap: Optional[_text.WrapEnum] = None
+    text_font_family: Optional[_font.FontFamilyEnum] = None
+    text_formatting: Optional[_text.FormatEnum] = None
+
+    force_overlay: bool = False
+
+    vid: int = -1

pynecore/types/chart.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass
+
+from .pine_types import PyneFloat, PyneInt
+
+
+@dataclass(slots=True)
+class ChartPoint:
+    # The x-coordinate of the point, expressed as a bar index value (``na`` when the point
+    # was created from a time only, e.g. ``chart.point.from_time``)
+    index: PyneInt
+
+    # The x-coordinate of the point, expressed as a UNIX time value, in milliseconds (``na``
+    # when the point was created from an index only, e.g. ``chart.point.from_index``)
+    time: PyneInt
+
+    # The y-coordinate of the point
+    price: PyneFloat

pynecore/types/color.py

@@ -0,0 +1,107 @@
+class Color:
+    """
+    Color class that stores RGBA values in a single 32-bit integer.
+    The fmt is 0xRRGGBBAA where each component is 8 bits.
+    """
+
+    __slots__ = ('value',)
+
+    def __init__(self, hexstr: str) -> None:
+        # Remove leading '#' if present
+        hexstr = hexstr.lstrip('#').upper()
+
+        # Add default alpha if not provided
+        if len(hexstr) == 6:
+            hexstr += 'FF'
+
+        # Convert hex string to int
+        self.value = int(hexstr, 16)
+
+    def __repr__(self) -> str:
+        return f'Color("#{self.value:08X}")'
+
+    def __lt__(self, other: 'Color') -> bool:
+        return self.value < other.value
+
+    def __eq__(self, other: 'Color') -> bool:
+        return self.value == other.value
+
+    def __hash__(self) -> int:
+        # Value-based, consistent with __eq__. Defining __eq__ otherwise sets
+        # __hash__ to None (unhashable), which makes a Color an illegal
+        # dataclass field default (``@udt`` uses dataclass) and forbids use as a
+        # dict key / set member -- both of which Pine colors legitimately need.
+        return hash(self.value)
+
+    @property
+    def r(self) -> int:
+        """Red component (0-255)"""
+        return (self.value >> 24) & 0xFF
+
+    @property
+    def g(self) -> int:
+        """Green component (0-255)"""
+        return (self.value >> 16) & 0xFF
+
+    @property
+    def b(self) -> int:
+        """Blue component (0-255)"""
+        return (self.value >> 8) & 0xFF
+
+    @property
+    def a(self) -> int:
+        """Alpha component (0-255)"""
+        return self.value & 0xFF
+
+    @a.setter
+    def a(self, alpha: int) -> None:
+        """
+        Set alpha component (0-255)
+        0: fully transparent
+        255: fully opaque
+
+        :param alpha: Alpha value (0-255)
+        """
+        if not (0 <= alpha <= 255):
+            raise ValueError("Alpha must be between 0 and 255")
+        self.value = (self.value & 0xFFFFFF00) | alpha
+
+    @property
+    def t(self) -> float:
+        """
+        Transparency component (0-100)
+        0: not transparent (fully opaque)
+        100: invisible
+        """
+        return 100 - (self.value & 0xFF) / 255.0 * 100
+
+    @t.setter
+    def t(self, transp: float) -> None:
+        """
+        Set transparency component (0-100)
+        0: not transparent (fully opaque)
+        100: invisible
+
+        :param transp: Transparency percentage (0-100)
+        """
+        if not (0 <= transp <= 100):
+            raise ValueError("Transparency must be between 0 and 100")
+        self.value = (self.value & 0xFFFFFF00) | int((1 - transp / 100.0) * 255)
+
+    @classmethod
+    def rgb(cls, r: int, g: int, b: int, transp: float = 0) -> 'Color':
+        """
+        Create a Color object from RGB values and transparency.
+
+        :param r: Red component (0-255)
+        :param g: Green component (0-255)
+        :param b: Blue component (0-255)
+        :param transp: Transparency percentage (0-100, 0: not transparent, 100: invisible)
+        :return: Color object
+        """
+        # Pine accepts float channels (e.g. from math.random) and rounds them to
+        # the nearest integer, so normalise before the range check / hex format.
+        r, g, b = int(round(r)), int(round(g)), int(round(b))
+        if not (0 <= r <= 255 and 0 <= g <= 255 and 0 <= b <= 255):
+            raise ValueError("RGB values must be between 0 and 255")
+        return cls(f'#{r:02X}{g:02X}{b:02X}{int((1 - transp / 100.0) * 255):02X}')

pynecore/types/currency.py

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

pynecore/types/datetime.py

@@ -0,0 +1,6 @@
+from .base import IntEnum
+
+
+class DayOfWeek(IntEnum, start=1):
+    """Pine Script weekday constants: Sun=1, Mon=2, ..., Sat=7."""
+    ...

pynecore/types/display.py

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

pynecore/types/dividends.py

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

pynecore/types/earnings.py

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

pynecore/types/extend.py

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

pynecore/types/font.py

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

pynecore/types/footprint.py

@@ -0,0 +1,41 @@
+from dataclasses import dataclass
+
+from .volume_row import VolumeRow
+
+
+@dataclass(slots=True)
+class Footprint:
+    """
+    Stores volume footprint data for a bar, including total buy/sell volume,
+    delta, and key price level rows (VAH, VAL, POC).
+
+    Obtained via ``request.footprint()``.
+    """
+
+    def buy_volume(self) -> float:
+        """Total buy volume for the bar."""
+        raise NotImplementedError("Footprint.buy_volume() is not yet implemented in PyneCore")
+
+    def sell_volume(self) -> float:
+        """Total sell volume for the bar."""
+        raise NotImplementedError("Footprint.sell_volume() is not yet implemented in PyneCore")
+
+    def delta(self) -> float:
+        """Volume delta (buy - sell) for the bar."""
+        raise NotImplementedError("Footprint.delta() is not yet implemented in PyneCore")
+
+    def total_volume(self) -> float:
+        """Total volume (buy + sell) for the bar."""
+        raise NotImplementedError("Footprint.total_volume() is not yet implemented in PyneCore")
+
+    def vah(self) -> VolumeRow:
+        """Value Area High row."""
+        raise NotImplementedError("Footprint.vah() is not yet implemented in PyneCore")
+
+    def val(self) -> VolumeRow:
+        """Value Area Low row."""
+        raise NotImplementedError("Footprint.val() is not yet implemented in PyneCore")
+
+    def poc(self) -> VolumeRow:
+        """Point of Control row."""
+        raise NotImplementedError("Footprint.poc() is not yet implemented in PyneCore")

pynecore/types/format.py

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

pynecore/types/hline.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass
+from typing import Optional, Union
+
+from .base import StrLiteral
+from ..lib import color as _color, display as _display
+
+
+class HLineEnum(StrLiteral):
+    ...
+
+
+@dataclass(slots=True)
+class HLine:
+    # Required parameter
+    price: Union[int, float]  # Price value at which the object will be rendered
+
+    # Optional parameters
+    title: Optional[str] = None  # Title of the object
+    color: Optional[_color.Color] = None  # Color of the rendered line
+    linestyle: Optional[HLineEnum] = None  # Style of the rendered line
+    linewidth: int = 1  # Width of the rendered line
+    editable: bool = True  # If true then hline style will be editable in Format dialog
+    display: Optional[_display.Display] = None  # Controls where the hline is displayed
+    id: Optional[str] = None  # Registration id assigned by ``hline()``

pynecore/types/ib_persistent.py

@@ -0,0 +1,8 @@
+from typing import TypeVar, TypeAlias
+from pynecore.types.na import NA
+from .series import Series
+
+T = TypeVar('T')
+
+IBPersistent: TypeAlias = T | NA[T] | Series[T]
+IBPersistentSeries: TypeAlias = T | NA[T] | Series[T]

pynecore/types/ib_persistent.pyi

@@ -0,0 +1,10 @@
+"""
+Transparent aliases for type checkers, same rationale as persistent.pyi:
+NA-free static view, runtime module unchanged.
+"""
+from typing import TypeVar, TypeAlias
+
+T = TypeVar('T')
+
+IBPersistent: TypeAlias = T
+IBPersistentSeries: TypeAlias = T

pynecore/types/label.py

@@ -0,0 +1,35 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from ..lib import color as _color, xloc as _xloc, yloc as _yloc, size as _size, text as _text, font as _font
+from .base import StrLiteral
+from .na import NA
+from .pine_types import PyneFloat, PyneInt
+
+
+class LabelStyleEnum(StrLiteral):
+    ...
+
+
+@dataclass(slots=True, eq=False)
+class Label:
+    # Required parameters (``na`` when set from a chart.point that lacks the corresponding
+    # coordinate for the active xloc)
+    x: PyneInt  # Bar index or UNIX time
+    y: PyneInt | PyneFloat  # Price of the label position
+    text: str = ""  # Label text
+    
+    # Optional parameters with defaults
+    xloc: Optional[_xloc.XLoc] = None
+    yloc: Optional[_yloc.YLoc] = None
+    color: Optional[_color.Color] = None
+    style: Optional[LabelStyleEnum] = None
+    textcolor: Optional[_color.Color] = None
+    size: Optional[_size.Size] = None
+    textalign: Optional[_text.AlignEnum] = None
+    tooltip: str = ""
+    text_font_family: Optional[_font.FontFamilyEnum] = None
+    force_overlay: bool = False
+    text_formatting: Optional[_text.FormatEnum] = None
+
+    vid: int = -1

pynecore/types/line.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from ..lib import color as _color, extend as _extend, xloc as _xloc
+from .base import StrLiteral
+from .na import NA
+from .pine_types import PyneFloat, PyneInt
+
+
+class LineEnum(StrLiteral):
+    ...
+
+
+@dataclass(slots=True, eq=False)
+class Line:
+    # Required parameters - coordinates (``na`` when set from a chart.point that lacks the
+    # corresponding coordinate for the active xloc)
+    x1: PyneInt  # Bar index or UNIX time
+    y1: PyneFloat  # Price of the first point
+    x2: PyneInt  # Bar index or UNIX time
+    y2: PyneFloat  # Price of the second point
+
+    # Optional parameters with defaults
+    xloc: Optional[_xloc.XLoc] = None
+    extend: Optional[_extend.Extend] = None
+    color: Optional[_color.Color] = None
+    style: Optional[LineEnum] = None
+    width: int = 1
+
+    force_overlay: bool = False
+
+    vid: int = -1

pynecore/types/linefill.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+
+from ..lib import color as _color
+from .line import Line
+
+
+@dataclass(slots=True, eq=False)
+class LineFill:
+    line1: Line  # First line object
+    line2: Line  # Second line object
+    color: _color.Color  # Fill color
+
+    vid: int = -1

pynecore/types/location.py

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