opencode-pyneruntime 6.6.4__py3-none-any.whl

pynecore/core/pine_method.py

@@ -0,0 +1,244 @@
+"""
+Pine method dispatch on the slot-based instance-state scheme.
+
+``method_call`` is on the transformer's NON_TRANSFORMABLE list, so its call
+sites stay raw and there is no caller anchor — the method is selected at
+runtime and bound through a module-lifetime per-method cache instead: ONE
+shared instance per method function, cleared between runs. This formalizes
+what the legacy runtime did implicitly (its ``__scope_id__`` here was forever
+``''``, so every isolation it requested landed on the same empty-scope cache
+key, shared by all call sites of a method and dropped on ``reset()``).
+"""
+import sys
+from types import ModuleType
+from typing import Any, Callable
+from functools import partial
+
+from ..lib import array, matrix, box, line, label, table, linefill, polyline
+from ..lib import map as map_lib
+from ..utils.sequence_view import SequenceView
+from ..types import matrix as matrix_types
+from ..types import line as line_types
+from ..types import box as box_types
+from ..types import label as label_types
+from ..types import table as table_types
+from ..types import linefill as linefill_types
+from ..types import polyline as polyline_types
+from ..types.na import NA
+
+from .instance_state import _make_state, register_shared_cache
+from .pine_export import Exported
+
+
+def method(func: Callable) -> Callable:
+    """
+    Decorator to mark a function as a Pine method.
+    This is used to indicate that the function should be treated as a method in Pine Script.
+    """
+    setattr(func, '__pine_method__', True)
+    return func
+
+
+def _get_builtin_method(method_name: str, var: Any) -> Callable | None:
+    """
+    Get the built-in method for a Pine Script object.
+    :param method_name: The name of the method
+    :param var: The object on which the method is being called
+    :return: The built-in method, or None if not found
+    """
+    try:
+        var_type = type(var)
+        if var_type is NA:
+            # An na value carries its DECLARED type. A builtin method invoked on
+            # an na builtin object (e.g. ``naLine.delete()`` on a line that was
+            # never drawn) must dispatch to that builtin namespace, which treats
+            # na as a no-op the way Pine does. An na of a UDT (or untyped) type
+            # matches nothing here and falls through to user-method dispatch.
+            declared = var.type
+            if declared is None:
+                return None
+            var_type = declared if isinstance(declared, type) else type(declared)
+        match var_type:
+            case _ if var_type is list:
+                return getattr(array, method_name)
+            case _ if var_type is SequenceView:
+                # array.slice() returns a view; method calls on it (e.g.
+                # slice(...).max()) dispatch to the array namespace too.
+                return getattr(array, method_name)
+            case _ if var_type is dict:
+                return getattr(map_lib, method_name)
+            case _ if var_type is matrix_types.Matrix:
+                return getattr(matrix, method_name)
+            case _ if var_type is line_types.Line:
+                return getattr(line, method_name)
+            case _ if var_type is box_types.Box:
+                return getattr(box, method_name)
+            case _ if var_type is label_types.Label:
+                return getattr(label, method_name)
+            case _ if var_type is table_types.Table:
+                return getattr(table, method_name)
+            case _ if var_type is linefill_types.LineFill:
+                return getattr(linefill, method_name)
+            case _ if var_type is polyline_types.Polyline:
+                return getattr(polyline, method_name)
+            case _:
+                return None
+    except AttributeError:
+        pass
+
+    return None
+
+
+# Method key -> (function identity, state vector or None, bound callable).
+# A per-function key is essential: a constant key would make every method
+# share one cache entry, running one method with another method's state.
+# Registered so instance_state.reset() clears it between runs.
+_method_anchors: dict[str, tuple[Any, list | None, Callable]] = register_shared_cache({})
+
+
+# noinspection PyShadowingNames
+def _bound_method(method: Any) -> Callable:
+    """Module-lifetime bound instance of a runtime-dispatched method.
+
+    The cache key is the method's qualified name and the entry survives
+    function-object re-creation: a method defined inside ``main()`` is a
+    fresh object every invocation, but its persistent state must live on —
+    on an identity miss the entry's state vector is rebound to the new
+    object (whose closure cells are the live ones). State from the cache,
+    closure from the passed object: the exact legacy split.
+
+    :param method: The method callable, or an ``Exported`` proxy of one.
+    :return: The callable to invoke with the visible arguments.
+    :raises ValueError: If an ``Exported`` proxy is not initialized yet.
+    """
+    target = method
+    if isinstance(target, Exported):
+        target = target.__fn__
+        if target is None:
+            raise ValueError("Exported proxy has not been initialized with a function yet")
+    key = f"{getattr(target, '__module__', '?')}.{getattr(target, '__qualname__', '?')}"
+    entry = _method_anchors.get(key)
+    if entry is not None and entry[0] is target:
+        return entry[2]
+    if isinstance(target, type) or (
+            hasattr(target, '__self__') and isinstance(target.__self__, type)):
+        return target  # types and classmethods are called as-is (legacy guard)
+    state: list | None = None
+    bind = getattr(target, '__pyne_bind__', None)
+    if bind is not None:
+        bound: Callable = bind()  # overload dispatcher: one shared anchored entry
+    else:
+        layout = getattr(target, '__pyne_layout__', None)
+        if layout is not None:
+            state = entry[1] if entry is not None and entry[1] is not None \
+                else _make_state(layout)
+            bound = partial(target, state)
+        else:
+            bound = target  # stateless — called raw
+    _method_anchors[key] = (target, state, bound)
+    return bound
+
+
+def _adapt_exported_kwargs(exported: Exported, kwargs: dict) -> dict:
+    """
+    Map keyword arguments onto a compiled library's canonically renamed
+    parameter names when needed.
+
+    A compiler cannot always know at emission time that a string-dispatched
+    method call targets a library export (the receiver may be untyped), so a
+    keyword argument can arrive under its original Pine spelling while the
+    library ``def`` declares ``name + '__ren__'``. The rename is applied only
+    when the raw name is absent from the target signature and the suffixed
+    one is present — a correct call is never altered.
+
+    :param exported: The resolved Exported proxy
+    :param kwargs: Keyword arguments as emitted at the call site
+    :return: Keyword arguments matching the target's parameter names
+    """
+    if not kwargs:
+        return kwargs
+    code: Any = getattr(exported.__fn__, '__code__', None)
+    if code is None:
+        return kwargs
+    params = code.co_varnames[:code.co_argcount + code.co_kwonlyargcount]
+    if all(k in params for k in kwargs):
+        return kwargs
+    return {(k + '__ren__' if k not in params and k + '__ren__' in params else k): v
+            for k, v in kwargs.items()}
+
+
+# noinspection PyShadowingNames
+def method_call(method: str | Callable, var: Any, *args, **kwargs) -> Any:
+    """
+    Dispatch a method call on a Pine Script variable to the appropriate handler.
+
+    This function serves as the central dispatcher for Pine Script method calls, handling both
+    built-in type methods (like array and matrix operations) and user-defined local methods.
+    It provides the Pine Script-like method calling syntax by routing calls to the correct
+    implementation based on the variable type and method name.
+
+    Closure-converted methods need no special handling: the closure transform
+    prepends the closure parameters to the method's signature and inserts the
+    matching arguments BEFORE the receiver at the call site, so the plain
+    positional order already lines up.
+
+    :param method: The method to call, either as a string name (for built-in methods) or a callable (for local methods)
+    :param var: The object/variable on which the method is being called (e.g., array, matrix, or custom object)
+    :param args: Positional arguments to pass to the method
+    :param kwargs: Keyword arguments to pass to the method
+    :return: The result of the method call, or None if the method cannot be dispatched
+    :raises AssertionError: If a string method name is provided but no matching method is found for the variable type
+    """
+    # If method is a string
+    if isinstance(method, str):
+        # Support for builtin methods
+        _method = _get_builtin_method(method, var)
+        if _method is not None:
+            return _method(var, *args, **kwargs)
+
+        # Modules
+        try:
+            return getattr(var, method)(*args, **kwargs)
+        except AttributeError:
+            pass
+
+        # Methods exported by a compiled library are module-level Exported proxies.
+        # Try the module that defines the receiver's UDT class first, then the
+        # caller's own module, then every library module the caller imports -- a
+        # library can export methods on another library's UDT, so the defining
+        # module is not always the UDT's own.
+        # If the raw name misses everywhere, retry once with PyneComp's canonical
+        # rename suffix: a compiled library emits a method whose Pine name cannot
+        # live verbatim in Python (``lambda``, ``method_call``, ...) under
+        # ``name + '__ren__'``. A stub with that shape can only be the image of
+        # this Pine name (a Pine ``x__ren__`` compiles to ``x__ren____ren__``),
+        # so the retry can never hit a wrong export.
+        caller_globals = sys._getframe(1).f_globals
+        mod = sys.modules.get(type(var).__module__)
+        for lookup_name in (method, method + '__ren__'):
+            _method = getattr(mod, lookup_name, None) if mod is not None else None
+            if not isinstance(_method, Exported):
+                _method = caller_globals.get(lookup_name)
+            if not isinstance(_method, Exported):
+                for _gval in caller_globals.values():
+                    if isinstance(_gval, ModuleType) and _gval.__name__.startswith('lib.'):
+                        _method = getattr(_gval, lookup_name, None)
+                        if isinstance(_method, Exported):
+                            break
+            if isinstance(_method, Exported):
+                return _bound_method(_method)(var, *args,
+                                              **_adapt_exported_kwargs(_method, kwargs))
+
+        assert False, f'No such method: {var}->{method}'
+
+    # It is a local method, it should be a local function
+    elif callable(method):
+        # It may not detected well the type and there may be a user with the same method name.
+        # So we 1st trt if it is a built-in object and has that method, because it has priority
+        _method = _get_builtin_method(method.__name__, var)
+        if _method:
+            return _method(var, *args, **kwargs)
+
+        return _bound_method(method)(var, *args, **kwargs)
+
+    return None

pynecore/core/pine_range.py

@@ -0,0 +1,86 @@
+from typing import Generator, overload
+
+from pynecore.types.pine_types import PyneFloat, PyneInt
+
+
+@overload
+def pine_range(from_num: int, to_num: int, step_num: int | None = None) -> range: ...
+
+
+@overload
+def pine_range(from_num: PyneInt | PyneFloat, to_num: PyneInt | PyneFloat,
+               step_num: PyneInt | PyneFloat | None = None) -> Generator[float, None, None]: ...
+
+
+def pine_range(from_num: PyneInt | PyneFloat, to_num: PyneInt | PyneFloat, step_num: PyneInt | PyneFloat | None = None):
+    """
+    Emulates Pine Script's for loop range behavior.
+
+    :param from_num: Start value (inclusive)
+    :param to_num: End value (inclusive)
+    :param step_num: Step value (optional, defaults to +1/-1 based on direction)
+    :return: A native ``range`` for integer bounds, otherwise a generator that yields
+             values from from_num to to_num (inclusive)
+    :raises ValueError: If step_num is zero
+    """
+    # Fast path: pure-integer bounds map exactly onto a native range, which iterates at
+    # C speed instead of resuming a Python generator on every step. The vast majority of
+    # Pine for loops are integer index ranges, so this is the common case.
+    if isinstance(from_num, int) and isinstance(to_num, int) and (step_num is None or isinstance(step_num, int)):
+        if from_num <= to_num:
+            step = 1 if step_num is None else abs(step_num)
+            if step == 0:
+                raise ValueError("Step cannot be zero in pine_range")
+            # +1 makes the upper bound inclusive, matching Pine's `to`
+            return range(from_num, to_num + 1, step)
+        step = -1 if step_num is None else -abs(step_num)
+        if step == 0:
+            raise ValueError("Step cannot be zero in pine_range")
+        # -1 makes the lower bound inclusive for the descending direction
+        return range(from_num, to_num - 1, step)
+
+    return _pine_range_float(from_num, to_num, step_num)
+
+
+def _pine_range_float(from_num: PyneFloat, to_num: PyneFloat, step_num: PyneFloat | None = None):
+    """
+    Generator fallback for Pine for-loop ranges with non-integer bounds.
+
+    :param from_num: Start value (inclusive)
+    :param to_num: End value (inclusive)
+    :param step_num: Step value (optional, defaults to +1/-1 based on direction)
+    :return: A generator that yields values from from_num to to_num (inclusive)
+    :raises ValueError: If step_num is zero
+    """
+    # Determine direction based on from_num and to_num
+    direction = 1 if from_num <= to_num else -1
+
+    # Use default step if none provided
+    step_val = step_num if step_num is not None else direction
+
+    # Prevent infinite loops
+    if step_val == 0:
+        raise ValueError("Step cannot be zero in pine_range")
+
+    # Ensure step direction matches the from->to direction
+    if (direction > 0 > step_val) or (direction < 0 < step_val):
+        step_val = -step_val
+
+    # Generate values
+    current = from_num
+    if direction > 0:
+        # Ascending loop
+        while current <= to_num:
+            yield current
+            current += step_val
+            # Safety check to prevent infinite loops due to floating point precision
+            if step_val > 0 and current > to_num + abs(step_val):
+                break
+    else:
+        # Descending loop
+        while current >= to_num:
+            yield current
+            current += step_val
+            # Safety check to prevent infinite loops due to floating point precision
+            if step_val < 0 and current < to_num - abs(step_val):
+                break

pynecore/core/pine_udt.py

@@ -0,0 +1,69 @@
+import copy as _copy
+from dataclasses import dataclass, replace as _dataclass_replace, is_dataclass
+from typing import TypeVar, Type, Any, dataclass_transform
+
+__all__ = ['udt', 'udt_copy']
+
+T = TypeVar('T')
+
+
+def udt_copy(obj: T, **changes: Any) -> T:
+    """
+    Copy a UDT or object value (used by the transpiler for Pine `.copy()`).
+
+    A dataclass UDT is copied with ``dataclasses.replace`` (honouring optional
+    field overrides). Non-dataclass objects — the drawing types (Label, Box,
+    Line, …) are plain classes, not dataclasses — are deep-copied instead, so
+    `.copy()` on e.g. a `map<string, label>` value works rather than raising
+    "replace() should be called on dataclass instances".
+    """
+    if is_dataclass(obj):
+        return _dataclass_replace(obj, **changes)
+    return _copy.deepcopy(obj)
+
+
+@dataclass_transform()
+def udt(cls: Type[T]) -> Type[T]:
+    """
+    Custom dataclass decorator that adds a `copy` method to the class.
+
+    This decorator applies the standard dataclass decorator and then adds
+    a `copy` method that creates a copy of the instance using dataclass.replace().
+
+    :param cls: The class to decorate
+    :return: The decorated class with added copy method
+    """
+    # Apply the standard dataclass decorator with slots=True for better performance
+    decorated_cls = dataclass(cls, slots=True)  # type: ignore
+
+    def copy(self: T, **changes: Any) -> T:
+        """
+        Create a copy of this instance with optional field modifications.
+
+        :param self: The instance to copy
+        :param changes: Optional keyword arguments to override field values
+        :return: A new instance with the specified changes
+        """
+        return udt_copy(self, **changes)
+
+    # noinspection PyShadowingNames
+    @classmethod  # noqa
+    def new(cls, *args, **kwargs) -> T:
+        """
+        Pine Script-style constructor method.
+
+        Creates a new instance of the class using the same arguments as __init__.
+        This provides Pine Script compatibility where UDTs are created with .new().
+
+        :param cls: The class to construct
+        :param args: Positional arguments for the constructor
+        :param kwargs: Keyword arguments for the constructor
+        :return: A new instance of the class
+        """
+        return cls(*args, **kwargs)
+
+    # Add the methods to the class
+    decorated_cls.copy = copy  # type: ignore
+    decorated_cls.new = new
+
+    return decorated_cls