opencode-pyneruntime 6.6.4__py3-none-any.whl

pynecore/lib/color.py

@@ -0,0 +1,152 @@
+from ..types.color import Color
+from ..types.na import NA
+
+#
+# Constants
+#
+
+aqua = Color('#00BCD4')
+black = Color('#363A45')
+blue = Color('#2962ff')
+fuchsia = Color('#E040FB')
+gray = Color('#787B86')
+green = Color('#4CAF50')
+lime = Color('#00E676')
+maroon = Color('#880E4F')
+navy = Color('#311B92')
+olive = Color('#808000')
+orange = Color('#FF9800')
+purple = Color('#9C27B0')
+red = Color('#F23645')
+silver = Color('#B2B5BE')
+teal = Color('#089981')
+white = Color('#FFFFFF')
+yellow = Color('#FDD835')
+
+
+def r(color: Color) -> int:
+    """
+    Return the red component of a color
+
+    :param color: Color
+    :return: The red component of the color
+    """
+    return color.r
+
+
+def g(color: Color) -> int:
+    """
+    Return the green component of a color
+
+    :param color: Color
+    :return: The green component of the color
+    """
+    return color.g
+
+
+def b(color: Color) -> int:
+    """
+    Return the blue component of a color
+
+    :param color: Color
+    :return: The blue component of the color
+    """
+    return color.b
+
+
+def t(color: Color) -> float:
+    """
+    Return the transparency of a color
+
+    :param color: Color
+    :return: The transparency of the color, 0-100 (0: not transparent, 100: invisible)
+    """
+    return color.t
+
+
+# noinspection PyShadowingNames
+def new(color: Color | str | NA[Color], transp: float | NA[float] = 0) -> Color | NA[Color]:
+    """
+    Return a new color with the same RGB values and a different transparency
+
+    :param color: A color object or a string in "#RRGGBB" or "#RRGGBBAA" format
+    :param transp: Transparency percentage (0-100, 0: not transparent, 100: invisible)
+    """
+    # Pine propagates na: a na color or na transparency yields a na color
+    if isinstance(color, NA) or isinstance(transp, NA) or transp != transp:
+        return NA(Color)
+    if isinstance(color, str):
+        color = Color(color)
+    # Build a fresh color so the caller's color (e.g. a color.* constant) is not mutated
+    result = Color(f'#{color.value:08X}')
+    result.t = transp
+    return result
+
+
+# noinspection PyShadowingNames
+def rgb(r: int, g: int, b: int, transp: float = 0) -> Color:
+    """
+    Return a new color with the given RGB values and transparency
+
+    :param r: Red value
+    :param g: Green value
+    :param b: Blue value
+    :param transp: Transparency percentage (0-100, 0: not transparent, 100: invisible)
+    """
+    return Color.rgb(r, g, b, transp)
+
+
+def from_gradient(value: int | float | NA[float], bottom_value: int | float | NA[float],
+                  top_value: int | float | NA[float],
+                  bottom_color: Color | NA[Color], top_color: Color | NA[Color]) -> Color | NA[Color]:
+    """
+    Based on the relative position of value in the bottom_value to top_value range,
+    the function returns a color from the gradient defined by bottom_color to top_color.
+
+    :param value: Value to calculate the position-dependent color
+    :param bottom_value: Bottom position value corresponding to bottom_color
+    :param top_value: Top position value corresponding to top_color
+    :param bottom_color: Bottom position color
+    :param top_color: Top position color
+    :return: A color calculated from the linear gradient between bottom_color to top_color
+    """
+    # na value/bounds propagate: TradingView returns a na color for such a bar.
+    if (isinstance(value, NA) or value != value
+            or isinstance(bottom_value, NA) or bottom_value != bottom_value
+            or isinstance(top_value, NA) or top_value != top_value):
+        return NA(Color)
+
+    # Handle edge cases
+    if top_value == bottom_value:
+        return bottom_color
+
+    # Calculate the position as a ratio (0.0 to 1.0), clamped to [0, 1]
+    position = (value - bottom_value) / (top_value - bottom_value)
+    position = max(0.0, min(1.0, position))
+
+    # A na endpoint carries no hue (TV-verified: color.r/g/b(na)==0, color.t(na)==100).
+    # TradingView does NOT fade the visible RGB toward transparent-black; it keeps the
+    # solid endpoint's RGB and only fades transparency toward the na side (na transp=100),
+    # returning the literal na color exactly at the na endpoint's position.
+    bottom_na = isinstance(bottom_color, NA)
+    top_na = isinstance(top_color, NA)
+    if bottom_na and top_na:
+        return NA(Color)
+    if bottom_na:
+        if position <= 0.0:
+            return NA(Color)
+        transp = 100.0 + (top_color.t - 100.0) * position
+        return Color.rgb(top_color.r, top_color.g, top_color.b, transp)
+    if top_na:
+        if position >= 1.0:
+            return NA(Color)
+        transp = bottom_color.t + (100.0 - bottom_color.t) * position
+        return Color.rgb(bottom_color.r, bottom_color.g, bottom_color.b, transp)
+
+    # Both endpoints solid: interpolate RGB and transparency
+    red_comp = int(bottom_color.r + (top_color.r - bottom_color.r) * position)
+    green_comp = int(bottom_color.g + (top_color.g - bottom_color.g) * position)
+    blue_comp = int(bottom_color.b + (top_color.b - bottom_color.b) * position)
+    transp = bottom_color.t + (top_color.t - bottom_color.t) * position
+
+    return Color.rgb(red_comp, green_comp, blue_comp, transp)

pynecore/lib/color.pyi

@@ -0,0 +1,50 @@
+"""
+IDE-facing view of the color module. Returns are plain ``Color`` (the NA-free
+"plain T" policy — see types/persistent.pyi): in Pine semantics any color can
+be na, so ``Color | NA[Color]`` returns only poison every downstream callsite.
+Parameters stay permissive (accept NA), runtime (color.py) is unchanged.
+"""
+from ..types.color import Color as Color
+from ..types.na import NA
+
+aqua: Color
+black: Color
+blue: Color
+fuchsia: Color
+gray: Color
+green: Color
+lime: Color
+maroon: Color
+navy: Color
+olive: Color
+orange: Color
+purple: Color
+red: Color
+silver: Color
+teal: Color
+white: Color
+yellow: Color
+
+
+def r(color: Color | NA[Color]) -> int: ...
+
+
+def g(color: Color | NA[Color]) -> int: ...
+
+
+def b(color: Color | NA[Color]) -> int: ...
+
+
+def t(color: Color | NA[Color]) -> float: ...
+
+
+def new(color: Color | str | NA[Color], transp: float | NA[float] = 0) -> Color: ...
+
+
+# noinspection PyShadowingNames
+def rgb(r: int | float, g: int | float, b: int | float, transp: float = 0) -> Color: ...
+
+
+def from_gradient(value: int | float | NA[float], bottom_value: int | float | NA[float],
+                  top_value: int | float | NA[float],
+                  bottom_color: Color | NA[Color], top_color: Color | NA[Color]) -> Color: ...

pynecore/lib/currency.py

@@ -0,0 +1,62 @@
+from ..types.currency import Currency
+
+#
+# Constants
+#
+
+AED = Currency('AED')
+ARS = Currency('ARS')
+AUD = Currency('AUD')
+BDT = Currency('BDT')
+BHD = Currency('BHD')
+BRL = Currency('BRL')
+BTC = Currency('BTC')
+CAD = Currency('CAD')
+CHF = Currency('CHF')
+CLP = Currency('CLP')
+CNY = Currency('CNY')
+COP = Currency('COP')
+CZK = Currency('CZK')
+DKK = Currency('DKK')
+EGP = Currency('EGP')
+ETH = Currency('ETH')
+EUR = Currency('EUR')
+GBP = Currency('GBP')
+HKD = Currency('HKD')
+HUF = Currency('HUF')
+IDR = Currency('IDR')
+ILS = Currency('ILS')
+INR = Currency('INR')
+ISK = Currency('ISK')
+JPY = Currency('JPY')
+KES = Currency('KES')
+KRW = Currency('KRW')
+KWD = Currency('KWD')
+LKR = Currency('LKR')
+MAD = Currency('MAD')
+MXN = Currency('MXN')
+MYR = Currency('MYR')
+NGN = Currency('NGN')
+NOK = Currency('NOK')
+NONE = Currency('NONE')
+NZD = Currency('NZD')
+PEN = Currency('PEN')
+PHP = Currency('PHP')
+PKR = Currency('PKR')
+PLN = Currency('PLN')
+QAR = Currency('QAR')
+RON = Currency('RON')
+RSD = Currency('RSD')
+RUB = Currency('RUB')
+SAR = Currency('SAR')
+SEK = Currency('SEK')
+SGD = Currency('SGD')
+THB = Currency('THB')
+TND = Currency('TND')
+TRY = Currency('TRY')
+TWD = Currency('TWD')
+USD = Currency('USD')
+USDT = Currency('USDT')
+VES = Currency('VES')
+VND = Currency('VND')
+ZAR = Currency('ZAR')

pynecore/lib/dayofweek.py

@@ -0,0 +1,36 @@
+from ..types.datetime import DayOfWeek
+from ..core.module_property import module_function_property
+
+
+#
+# Constants
+#
+
+sunday = DayOfWeek()
+monday = DayOfWeek()
+tuesday = DayOfWeek()
+wednesday = DayOfWeek()
+thursday = DayOfWeek()
+friday = DayOfWeek()
+saturday = DayOfWeek()
+
+
+#
+# Module function
+#
+
+# noinspection PyShadowingNames,PyProtectedMember
+@module_function_property
+def dayofweek(time: int | None = None, timezone: str | None = None) -> int:
+    """
+    Day of the week
+
+    :param time: The time to get the day of the week from, if None the current time is used
+    :param timezone: The timezone of the time, if not specified the exchange timezone is used
+    :return: The day of the week, 1 is Sunday, 2 is Monday, ..., 7 is Saturday
+    """
+    from .. import lib
+    res = lib._get_dt(time, timezone).weekday() + 2
+    if res == 8:
+        res = 1
+    return res

pynecore/lib/dayofweek.pyi

@@ -0,0 +1,18 @@
+from ..types.datetime import DayOfWeek
+
+
+# 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 DayOfWeekModule:
+    sunday: DayOfWeek
+    monday: DayOfWeek
+    tuesday: DayOfWeek
+    wednesday: DayOfWeek
+    thursday: DayOfWeek
+    friday: DayOfWeek
+    saturday: DayOfWeek
+
+    def __call__(self, time: int | None = None, timezone: str | None = None) -> int: ...
+
+
+dayofweek: DayOfWeekModule

pynecore/lib/display.py

@@ -0,0 +1,8 @@
+from ..types.display import Display
+
+all: Display = Display()  # noqa F821
+data_window: Display = Display()
+none: Display = Display()
+pane: Display = Display()
+price_scale: Display = Display()
+status_line: Display = Display()

pynecore/lib/dividends.py

@@ -0,0 +1,9 @@
+from ..types.na import na_float
+from ..types.dividends import Dividends
+
+gross = Dividends("gross")
+net = Dividends("net")
+
+future_amount = na_float
+future_ex_date = na_float
+future_pay_date = na_float

pynecore/lib/earnings.py

@@ -0,0 +1,11 @@
+from ..types.na import NA, na_float
+from ..types.earnings import Earnings
+
+actual = Earnings("actual")
+estimate = Earnings("estimate")
+standardized = Earnings("standardized")
+
+future_eps = na_float
+future_time = NA(int)
+future_revenue = na_float
+future_period_end_time = NA(int)

pynecore/lib/extend.py

@@ -0,0 +1,6 @@
+from ..types.extend import Extend
+
+both: Extend = Extend('b')
+left: Extend = Extend('l')
+none: Extend = Extend('n')
+right: Extend = Extend('r')

pynecore/lib/font.py

@@ -0,0 +1,5 @@
+from ..types.font import FontFamilyEnum
+
+# Font family constants
+family_default = FontFamilyEnum('default')
+family_monospace = FontFamilyEnum('monospace')

pynecore/lib/footprint.py

@@ -0,0 +1,79 @@
+from ..types.footprint import Footprint
+from ..types.volume_row import VolumeRow
+
+
+# noinspection PyShadowingBuiltins
+def buy_volume(id: Footprint) -> float:
+    """
+    Total buy volume for the bar.
+
+    :param id: Footprint object
+    :return: Buy volume
+    """
+    return id.buy_volume()
+
+
+# noinspection PyShadowingBuiltins
+def sell_volume(id: Footprint) -> float:
+    """
+    Total sell volume for the bar.
+
+    :param id: Footprint object
+    :return: Sell volume
+    """
+    return id.sell_volume()
+
+
+# noinspection PyShadowingBuiltins
+def delta(id: Footprint) -> float:
+    """
+    Volume delta (buy - sell) for the bar.
+
+    :param id: Footprint object
+    :return: Volume delta
+    """
+    return id.delta()
+
+
+# noinspection PyShadowingBuiltins
+def total_volume(id: Footprint) -> float:
+    """
+    Total volume (buy + sell) for the bar.
+
+    :param id: Footprint object
+    :return: Total volume
+    """
+    return id.total_volume()
+
+
+# noinspection PyShadowingBuiltins
+def vah(id: Footprint) -> VolumeRow:
+    """
+    Value Area High row.
+
+    :param id: Footprint object
+    :return: VolumeRow for VAH
+    """
+    return id.vah()
+
+
+# noinspection PyShadowingBuiltins
+def val(id: Footprint) -> VolumeRow:
+    """
+    Value Area Low row.
+
+    :param id: Footprint object
+    :return: VolumeRow for VAL
+    """
+    return id.val()
+
+
+# noinspection PyShadowingBuiltins
+def poc(id: Footprint) -> VolumeRow:
+    """
+    Point of Control row.
+
+    :param id: Footprint object
+    :return: VolumeRow for POC
+    """
+    return id.poc()

pynecore/lib/format.py

@@ -0,0 +1,11 @@
+from ..types.format import Format
+
+#
+# Constants
+#
+
+inherit = Format("inherit")
+mintick = Format("mintick")
+percent = Format("percent")
+price = Format("price")
+volume = Format("volume")

pynecore/lib/hline.py

@@ -0,0 +1,67 @@
+"""
+Horizontal line
+
+The module is both a function (``hline(...)``) and a namespace (``hline.style_solid``);
+call sites are routed to :func:`hline` by the module property AST transformer.
+"""
+from ..types.hline import HLineEnum, HLine
+from ..types.plot_meta import PlotMeta
+
+from . import color as _color, display as _display
+from .. import lib
+
+
+#
+# Constants
+#
+
+style_solid = HLineEnum('style_solid')
+style_dotted = HLineEnum('style_dotted')
+style_dashed = HLineEnum('style_dashed')
+
+
+#
+# Module function
+#
+
+def hline(
+        price: float,
+        title: str = "",
+        color: _color.Color = _color.blue,
+        linestyle: HLineEnum = style_solid,
+        linewidth: int = 1,
+        editable: bool = True,
+        display: _display.Display = _display.all
+) -> HLine:
+    """
+    Renders a horizontal line at a given fixed price level.
+
+    :param price: Price value at which the object will be rendered. Required argument.
+    :param title: Title of the object
+    :param color: Color of the rendered line. Must be a constant value (not an expression)
+    :param linestyle: Style of the rendered line. Possible values are: hline.style_solid, hline.style_dotted, hline.style_dashed
+    :param linewidth: Width of the rendered line. Default value is 1
+    :param editable: If true then hline style will be editable in Format dialog. Default is true
+    :param display: Controls where the hline is displayed. Possible values are: display.none, display.all. Default is display.all
+    :return: An hline object, that can be used in fill
+    """
+    n = lib._viz_seq.get('hline', 0)
+    lib._viz_seq['hline'] = n + 1
+    hid = f'hline#{n}'
+    t = title or None
+    if hid not in lib._plot_meta:
+        meta = PlotMeta(id=hid, kind='hline', title=t, price=price, color=color,
+                        linestyle=linestyle, linewidth=linewidth, editable=editable,
+                        display=display)
+        lib._plot_meta[hid] = meta
+        lib._plot_meta_new.append(meta)
+    return HLine(
+        price=price,
+        title=t,
+        color=color,
+        linestyle=linestyle,
+        linewidth=linewidth,
+        editable=editable,
+        display=display,
+        id=hid
+    )

pynecore/lib/hline.pyi

@@ -0,0 +1,24 @@
+from ..types.hline import HLineEnum, HLine
+from . import color as _color, display as _display
+
+
+# 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 HLineModule:
+    style_solid: HLineEnum
+    style_dotted: HLineEnum
+    style_dashed: HLineEnum
+
+    def __call__(
+            self,
+            price: float,
+            title: str = ...,
+            color: _color.Color = ...,
+            linestyle: HLineEnum = ...,
+            linewidth: int = ...,
+            editable: bool = ...,
+            display: _display.Display = ...
+    ) -> HLine: ...
+
+
+hline: HLineModule