opencode-pyneruntime 6.6.4__py3-none-any.whl

pynecore/lib/pivotpointtype.py

@@ -0,0 +1,8 @@
+from ..types.pivotpointtype import PivotPointType
+
+traditional = PivotPointType("Traditional")
+fibonacci = PivotPointType("Fibonacci")
+woodie = PivotPointType("Woodie")
+classic = PivotPointType("Classic")
+dm = PivotPointType("DM")
+camarilla = PivotPointType("Camarilla")

pynecore/lib/plot.py

@@ -0,0 +1,95 @@
+from typing import Any
+import sys
+
+from ..types.plot import PlotEnum, Plot
+from ..types.plot_meta import PlotMeta
+
+
+#
+# Constants
+#
+
+style_area = PlotEnum()
+style_areabr = PlotEnum()
+style_circles = PlotEnum()
+style_columns = PlotEnum()
+style_cross = PlotEnum()
+style_histogram = PlotEnum()
+style_line = PlotEnum()
+style_linebr = PlotEnum()
+style_stepline = PlotEnum()
+style_steplinebr = PlotEnum()
+style_stepline_diamond = PlotEnum()
+
+linestyle_solid = PlotEnum()
+linestyle_dashed = PlotEnum()
+linestyle_dotted = PlotEnum()
+
+
+#
+# Module function
+#
+
+# noinspection PyProtectedMember,PyShadowingBuiltins
+def plot(series: Any, title: str | None = None, color: Any = 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, *_, **__):
+    """
+    Plot a series on the chart.
+
+    :param series: The value to plot on every bar
+    :param title: The title of the plot; if several plots share a title a number is appended
+    :param color: Plot color; when it varies per bar it is recorded as a dynamic channel
+    :param linewidth: Width of the plotted line in pixels
+    :param style: Plot style (``plot.style_*``); ``None`` means Pine's ``style_line``
+    :param trackprice: If true, a horizontal price line is shown at the last value
+    :param histbase: Reference value for ``style_histogram``, ``style_columns`` and ``style_area``
+    :param offset: Horizontal shift of the plot, in bars
+    :param join: If true, ``style_circles`` / ``style_cross`` points are joined with lines
+    :param editable: If true, the plot style is editable in the Format dialog
+    :param show_last: If set, only the last ``show_last`` bars are plotted
+    :param display: Controls where the plot is displayed
+    :param format: Formatting of the plotted values (``format.price``, ``format.volume`` etc.)
+    :param precision: Number of decimal places for the plotted values
+    :param force_overlay: If true, the plot displays on the main chart pane
+    :return: A Plot object, used to reference the plot in other functions
+    """
+    from .. import lib
+    if lib._lib_semaphore:
+        return Plot('')
+
+    if lib.bar_index == 0:  # Only check if it is the first bar for performance reasons
+        # Check if it is called from the main function
+        if sys._getframe(1).f_code.co_name != 'main':  # noqa
+            raise RuntimeError("The plot function can only be called from the main function!")
+
+    # Ensure unique title
+    title: str = 'Plot' if title is None else title
+    # Handle duplicate titles
+    c = 0
+    t: str = title
+    while t in lib._plot_data:
+        t = title + ' ' + str(c)
+        c += 1
+
+    lib._plot_data[t] = series
+    meta = lib._plot_meta.get(t)
+    if meta is None:
+        meta = PlotMeta(id=t, kind='plot', title=t, color=color, linewidth=linewidth, style=style,
+                        trackprice=trackprice, histbase=histbase, offset=offset, join=join,
+                        editable=editable, show_last=show_last, display=display, format=format,
+                        precision=precision, force_overlay=force_overlay)
+        lib._plot_meta[t] = meta
+        lib._plot_meta_new.append(meta)
+    if meta.dynamic:
+        # Once dynamic, record every bar so a return to the static color is emitted
+        lib._viz_dyn[t] = color
+    elif color is not None and color is not meta.color:
+        lib._viz_dyn[t] = color
+        meta.dynamic = True
+        # The static meta record is already out — re-queue an updated one.
+        lib._plot_meta_new.append(meta)
+
+    return Plot(t)

pynecore/lib/plot.pyi

@@ -0,0 +1,33 @@
+from typing import Any
+
+from ..types.plot import Plot
+from ..types.plot import PlotEnum
+
+
+# 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 PlotModule:
+    style_area: PlotEnum
+    style_areabr: PlotEnum
+    style_circles: PlotEnum
+    style_columns: PlotEnum
+    style_cross: PlotEnum
+    style_histogram: PlotEnum
+    style_line: PlotEnum
+    style_linebr: PlotEnum
+    style_stepline: PlotEnum
+    style_steplinebr: PlotEnum
+    style_stepline_diamond: PlotEnum
+    linestyle_solid: PlotEnum
+    linestyle_dashed: PlotEnum
+    linestyle_dotted: PlotEnum
+
+    def __call__(self, series: Any, title: str | None = None, color: Any = None,
+                 linewidth: int = 1, style: PlotEnum | None = 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,
+                 *args, **kwargs) -> Plot: ...
+
+
+plot: PlotModule

pynecore/lib/polyline.py

@@ -0,0 +1,91 @@
+from ..core.module_property import module_property
+from ..types.base import next_vid
+from ..types.chart import ChartPoint
+from ..types.polyline import Polyline
+from ..types.na import NA
+from ..lib import xloc as _xloc, color as _color
+from ..types.line import LineEnum
+from .. import lib
+
+_registry: dict[Polyline, None] = {}
+
+# Line style constants (same as in line.py)
+style_arrow_both = LineEnum()
+style_arrow_left = LineEnum()
+style_arrow_right = LineEnum()
+style_dashed = LineEnum()
+style_dotted = LineEnum()
+style_solid = LineEnum()
+
+
+# noinspection PyProtectedMember
+def new(points: list[ChartPoint], curved: bool = False, closed: bool = False,
+        xloc: _xloc.XLoc = _xloc.bar_index, line_color: _color.Color = _color.blue,
+        fill_color: _color.Color | None = None, line_style: LineEnum = style_solid,
+        line_width: int = 1, force_overlay: bool = False) -> Polyline | NA[Polyline]:
+    """
+    Creates a new polyline instance and displays it on the chart, sequentially connecting all of the
+    points in the points array with line segments.
+
+    :param points: An array of chart.point objects for the drawing to sequentially connect
+    :param curved: If true, the drawing will connect all points using curved line segments
+    :param closed: If true, the drawing will connect the first point to the last point, resulting in a closed polyline
+    :param xloc: Determines the field of the chart.point objects that the polyline will use for its x-coordinates
+    :param line_color: The color of the line segments
+    :param fill_color: The fill color of the polyline
+    :param line_style: The style of the polyline
+    :param line_width: The width of the line segments, expressed in pixels
+    :param force_overlay: If true, the drawing will display on the main chart pane
+    :return: The ID of a new polyline object
+    """
+    if not points or len(points) == 0:
+        return NA(Polyline)
+
+    # Check if any points are NA
+    for point in points:
+        if isinstance(point, NA):
+            return NA(Polyline)
+
+    polyline_obj = Polyline(
+        points=points,
+        curved=curved,
+        closed=closed,
+        xloc=xloc,
+        line_color=line_color,
+        fill_color=fill_color,
+        line_style=line_style,
+        line_width=line_width,
+        force_overlay=force_overlay
+    )
+    polyline_obj.vid = next_vid()
+    _registry[polyline_obj] = None
+    # Enforce Pine's max_polylines_count cap: drop the oldest polyline (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_polylines_count if lib._script is not None else 500):
+        del _registry[next(iter(_registry))]
+    return polyline_obj
+
+
+# noinspection PyShadowingBuiltins
+def delete(id: Polyline) -> None:
+    """
+    Deletes the specified polyline object. It has no effect if the id doesn't exist.
+
+    :param id: The polyline ID to delete
+    """
+    if isinstance(id, NA):
+        return
+    _registry.pop(id, None)
+
+
+# noinspection PyShadowingBuiltins
+@module_property
+def all() -> list[Polyline]:
+    """
+    Returns an array containing all current polyline instances drawn by the script.
+
+    :return: Array of all polyline objects
+    """
+    return list(_registry)

pynecore/lib/position.py

@@ -0,0 +1,15 @@
+from ..types.position import Position
+
+#
+# Constants
+#
+
+bottom_center = Position('bottom_center')
+bottom_left = Position('bottom_left')
+bottom_right = Position('bottom_right')
+middle_center = Position('middle_center')
+middle_left = Position('middle_left')
+middle_right = Position('middle_right')
+top_center = Position('top_center')
+top_left = Position('top_left')
+top_right = Position('top_right')

pynecore/lib/request.py

@@ -0,0 +1,281 @@
+from __future__ import annotations
+
+from math import nan
+from typing import TYPE_CHECKING, Any, TypeVar, overload
+
+from ..types.footprint import Footprint
+from ..types.na import NA
+
+if TYPE_CHECKING:
+    from ..core.currency import CurrencyRateProvider
+
+_currency_provider: CurrencyRateProvider | None = None
+
+T = TypeVar('T')
+
+
+# noinspection PyUnusedLocal
+def security(symbol, timeframe, expression: T, *args, **kwargs) -> T:
+    """
+    Request data from another symbol/timeframe.
+
+    Pine v6 positional signature:
+    ``security(symbol, timeframe, expression, gaps, lookahead,
+    ignore_invalid_symbol, currency, ...)``.
+
+    Supported ``lookahead`` modes:
+
+    - ``barmerge.lookahead_off`` (default): closed-only — the security
+      context shows the most recently CLOSED security bar in both
+      historical and live mode. Repaint-free.
+    - ``barmerge.lookahead_last_closed``: PyneSys-native synonym for
+      "last closed" in any mode. Functionally identical to
+      ``lookahead_off`` in PyneCore; prefer it when "last closed" is the
+      explicit intent (no reliance on the TV ``close[1]`` idiom).
+    - ``barmerge.lookahead_on``: TV-compatible. Same-symbol HTF: the
+      security context steps into the containing HTF bar. In live mode the
+      developing bar runs with ``barstate.isconfirmed=False`` and OHLCV
+      aggregated from the chart timeframe; in historical/backtest mode the
+      containing bar is already complete in the data file, so a bare
+      ``close`` reads its final value (TV's classical future-leak) while an
+      inner ``close[1]`` reads the just-closed prior period — the daily-pivot
+      idiom ``security(sym, "D", close[1], lookahead_on)``. Cross-symbol HTF:
+      the developing bar cannot be aggregated (wrong instrument), so the
+      chart bar inside an open HTF period reads as ``na``; ``close[1]`` at
+      the period boundary still delivers the just-closed cross-symbol HTF
+      close, so the idiom continues to work.
+
+    This function exists for IDE support only. In compiled scripts, the
+    SecurityTransformer rewrites all calls into the signal/write/read
+    protocol at AST level — this function is never called at runtime.
+    """
+    raise RuntimeError(
+        "request.security() should not be called directly. "
+        "It is rewritten by SecurityTransformer during compilation."
+    )
+
+
+# noinspection PyUnusedLocal
+@overload
+def security_lower_tf(
+        symbol, timeframe, expression: tuple,
+        ignore_invalid_symbol=False, currency=None,
+        ignore_invalid_timeframe=False, calc_bars_count=None,
+) -> tuple[list, ...]: ...
+
+
+# noinspection PyUnusedLocal
+@overload
+def security_lower_tf(
+        symbol, timeframe, expression: T,
+        ignore_invalid_symbol=False, currency=None,
+        ignore_invalid_timeframe=False, calc_bars_count=None,
+) -> list[T]: ...
+
+
+# noinspection PyUnusedLocal
+def security_lower_tf(
+        symbol, timeframe, expression,
+        ignore_invalid_symbol=False, currency=None,
+        ignore_invalid_timeframe=False, calc_bars_count=None,
+) -> Any:
+    """
+    Request intrabar data from a lower timeframe.
+
+    Returns an array of values, one per intrabar within each chart bar; a tuple
+    expression yields a tuple of such arrays, one per tuple element.
+    This function exists for IDE support only. In compiled scripts, the
+    SecurityTransformer rewrites all calls into the LTF signal/write/read
+    protocol at AST level — this function is never called at runtime.
+
+    :param symbol: Symbol to request data from
+    :param timeframe: Lower timeframe string (must be <= chart timeframe)
+    :param expression: Expression to evaluate in the lower timeframe context
+    :param ignore_invalid_symbol: If True, return empty array for invalid symbols
+    :param currency: Currency for conversion (not yet supported)
+    :param ignore_invalid_timeframe: If True, ignore invalid timeframe
+    :param calc_bars_count: Number of bars to calculate (not yet supported)
+    :return: array of expression values per intrabar
+    """
+    raise RuntimeError(
+        "request.security_lower_tf() should not be called directly. "
+        "It is rewritten by SecurityTransformer during compilation."
+    )
+
+
+def currency_rate(from_currency: str, to_currency: str) -> float:
+    """
+    Get the currency conversion rate between two currencies.
+
+    Returns the exchange rate to convert from ``from_currency`` to ``to_currency``
+    at the current bar's timestamp. The rate is looked up from OHLCV data files
+    whose TOML metadata matches the requested currency pair.
+
+    :param from_currency: Source currency code (e.g. ``"EUR"``, ``currency.EUR``)
+    :param to_currency: Target currency code (e.g. ``"USD"``, ``currency.USD``)
+    :return: Exchange rate as float, or ``na`` if no data is available
+    """
+    if _currency_provider is None:
+        return nan
+    from .. import lib
+    # noinspection PyProtectedMember
+    timestamp = int(lib._datetime.timestamp())
+    return _currency_provider.get_rate(str(from_currency), str(to_currency), timestamp)
+
+
+# noinspection PyUnusedLocal
+def dividends(
+        ticker=None, field=None, gaps=None, lookahead=None,
+        ignore_invalid_symbol=False,
+) -> float:
+    """
+    Request dividend data for a symbol.
+
+    :param ticker: Symbol ticker
+    :param field: Dividend field (dividends.gross, dividends.net)
+    :param gaps: Gap handling mode (barmerge.gaps_on/off)
+    :param lookahead: Lookahead mode (barmerge.lookahead_on/off)
+    :param ignore_invalid_symbol: If True, return na instead of raising
+    :return: Dividend value or na
+    :raises NotImplementedError: When ignore_invalid_symbol is False
+    """
+    if ignore_invalid_symbol:
+        return nan
+    raise NotImplementedError("request.dividends() is not yet implemented in PyneCore")
+
+
+# noinspection PyUnusedLocal
+def splits(
+        ticker=None, field=None, gaps=None, lookahead=None,
+        ignore_invalid_symbol=False,
+) -> float:
+    """
+    Request stock split data for a symbol.
+
+    :param ticker: Symbol ticker
+    :param field: Split field (splits.numerator, splits.denominator)
+    :param gaps: Gap handling mode (barmerge.gaps_on/off)
+    :param lookahead: Lookahead mode (barmerge.lookahead_on/off)
+    :param ignore_invalid_symbol: If True, return na instead of raising
+    :return: Split value or na
+    :raises NotImplementedError: When ignore_invalid_symbol is False
+    """
+    if ignore_invalid_symbol:
+        return nan
+    raise NotImplementedError("request.splits() is not yet implemented in PyneCore")
+
+
+# noinspection PyUnusedLocal
+def earnings(
+        ticker=None, field=None, gaps=None, lookahead=None,
+        ignore_invalid_symbol=False,
+) -> float:
+    """
+    Request earnings data for a symbol.
+
+    :param ticker: Symbol ticker
+    :param field: Earnings field (earnings.actual, earnings.estimate, earnings.standardized)
+    :param gaps: Gap handling mode (barmerge.gaps_on/off)
+    :param lookahead: Lookahead mode (barmerge.lookahead_on/off)
+    :param ignore_invalid_symbol: If True, return na instead of raising
+    :return: Earnings value or na
+    :raises NotImplementedError: When ignore_invalid_symbol is False
+    """
+    if ignore_invalid_symbol:
+        return nan
+    raise NotImplementedError("request.earnings() is not yet implemented in PyneCore")
+
+
+# noinspection PyUnusedLocal
+def financial(
+        symbol=None, financial_id=None, period=None, gaps=None,
+        ignore_invalid_symbol=False, currency=None,
+) -> float:
+    """
+    Request financial data from FactSet.
+
+    :param symbol: Symbol ticker
+    :param financial_id: Financial metric id (e.g. "MARKET_CAP_BASIC")
+    :param period: Reporting period ("FQ", "FH", "FY", "TTM", "D")
+    :param gaps: Gap handling mode (barmerge.gaps_on/off)
+    :param ignore_invalid_symbol: If True, return na instead of raising
+    :param currency: Currency for conversion
+    :return: Financial value or na
+    :raises NotImplementedError: When ignore_invalid_symbol is False
+    """
+    if ignore_invalid_symbol:
+        return nan
+    raise NotImplementedError("request.financial() is not yet implemented in PyneCore")
+
+
+# noinspection PyUnusedLocal
+def economic(*args, **kwargs) -> float:
+    """
+    Request economic data.
+
+    :raises NotImplementedError: Not yet implemented in PyneCore
+    """
+    raise NotImplementedError("request.economic() is not yet implemented in PyneCore")
+
+
+# noinspection PyUnusedLocal
+def quandl(*args, **kwargs) -> float:
+    """
+    Request data from Quandl/Nasdaq.
+
+    :raises NotImplementedError: Not yet implemented in PyneCore
+    """
+    raise NotImplementedError("request.quandl() is not yet implemented in PyneCore")
+
+
+# noinspection PyUnusedLocal
+def seed(source=None, symbol=None, expression=None,
+         ignore_invalid_symbol=False, calc_bars_count=None):
+    """
+    Request data from user-maintained GitHub repositories.
+
+    Seed data lives in TradingView-hosted community repositories that PyneCore
+    has no access to — like :func:`footprint`, the data is fundamentally
+    unavailable, so the call returns ``na`` instead of aborting the script;
+    well-written scripts guard their seed series with ``na()`` checks.
+
+    :param source: Seed repository name (e.g. "seed_crypto_santiment")
+    :param symbol: Data series name within the repository
+    :param expression: Expression to evaluate in the seed context
+    :param ignore_invalid_symbol: If True, return na for invalid symbols
+    :param calc_bars_count: Number of bars to calculate (unused)
+    :return: na — seed data is not available in PyneCore. When ``expression`` is a
+        tuple of series (e.g. ``request.seed(id, sym, [close, ta.sma(close, 10)])``),
+        Pine returns a tuple, so return a tuple of ``na`` of the same arity to keep
+        the tuple destructuring valid; ``na()``-guarding scripts then see na as usual.
+    """
+    if isinstance(expression, (list, tuple)):
+        return tuple(NA(None) for _ in expression)
+    return NA(None)
+
+
+# noinspection PyUnusedLocal
+def footprint(ticks_per_row: int, va_percent: int = 70,
+              imbalance_percent: int = 300) -> Footprint | NA[Footprint]:
+    """
+    Request volume footprint data for the current bar.
+
+    Footprint order flow (per-tick buy/sell aggressor split, POC, VAH, VAL) is
+    sourced by TradingView from tick-level bid/ask data that PyneCore does not
+    have — only OHLCV bars are available. Rather than aborting the whole script,
+    the footprint is reported as ``na`` so that scripts guarding their footprint
+    reads with ``na()`` (the required Pine pattern, since TV itself returns na
+    when footprint data is unavailable) fall back to their price-action paths.
+
+    :param ticks_per_row: Number of ticks per footprint row
+    :param va_percent: Value Area percentage
+    :param imbalance_percent: Buy/sell imbalance threshold percentage
+    :return: ``na`` footprint (order-flow data unavailable in PyneCore)
+    """
+    return NA(Footprint)
+
+
+def _reset_request_state() -> None:
+    """Reset request module state between script runs."""
+    global _currency_provider
+    _currency_provider = None

pynecore/lib/runtime.py

@@ -0,0 +1,5 @@
+def error(message: str):
+    """
+    Stop running script with an error message
+    """
+    raise RuntimeError(message)

pynecore/lib/scale.py

@@ -0,0 +1,9 @@
+from ..types.scale import Scale
+
+#
+# Constants
+#
+
+left = Scale()
+none = Scale()
+right = Scale()