opencode-pyneruntime 6.6.4__py3-none-any.whl

pynecore/core/overload.py

@@ -0,0 +1,371 @@
+"""
+Function overloading with per-implementation instance state (slot scheme).
+
+The ``@overload`` decorator registers every implementation under the
+function's qualified name and binds the name to a single dispatcher. The
+dispatcher selects the implementation by argument types (Pine Script
+compatible matching) and calls it through a per-anchor bound cache:
+
+- Call sites reach the dispatcher on the UNIFORM route — the caller anchors
+  it in its own state vector with ``__bind_any__``, whose ``_bind_target``
+  finds the dispatcher's ``__pyne_bind__`` factory and stores a fresh
+  anchored dispatcher in the anchor slot.
+- One anchor holds one bound callable PER IMPLEMENTATION: a call site where
+  different argument types win on different bars keeps a separate persistent
+  instance for every implementation, while one implementation's state
+  persists across the bars it wins on.
+- State-carrying implementations are bound through
+  ``instance_state._bind_target`` (their ``__pyne_layout__`` comes from the
+  ``@__attach_layout__`` decorator the slot transform inserts below
+  ``@overload``); stateless implementations are called raw.
+- Calling the dispatcher directly (no anchor — module level, non-transformed
+  code, function values passed to builtins) falls back to the dispatcher's
+  own module-lifetime bound cache: one shared instance per implementation,
+  the same semantics the legacy module-global scope gave such calls.
+
+Implementation matching skips the hidden state parameter the slot transform
+injects (``__state__`` or the scope-qualified ``__state·{scope}__`` form):
+signatures and parameter types are computed from the VISIBLE parameters
+only, and the state argument is prepended by the bound partial, never by
+the caller.
+"""
+from typing import (TypeVar, Callable, get_type_hints, overload as typing_overload,
+                    Any, Type, Union, get_args, get_origin, cast)
+from functools import wraps, partial
+from inspect import signature
+from collections import defaultdict
+from types import FunctionType, UnionType
+
+from .instance_state import _bind_target, _make_state, register_shared_cache
+from ..types.base import StrLiteral
+from ..types.na import NA
+
+__all__ = ['overload']
+
+T = TypeVar('T')
+
+
+def _is_state_param(name: str) -> bool:
+    """Whether a parameter is the hidden state parameter injected by the
+    slot-layout transform.
+
+    :param name: Parameter name.
+    :return: True for ``__state__`` and the scope-qualified form.
+    """
+    return name == '__state__' or (name.startswith('__state·') and name.endswith('__'))
+
+
+class Implementation:
+    __slots__ = ('func', 'sig', 'type_hints', 'param_types')
+    func: FunctionType
+    sig: Any  # Signature object of the VISIBLE parameters
+    type_hints: dict
+    param_types: tuple  # Cached visible parameter types for quick checking
+
+    def __init__(self, func: FunctionType):
+        self.update(func)
+
+    def update(self, func: FunctionType) -> None:
+        """(Re)bind to the implementation function and cache its matching
+        metadata. Re-running a module re-decorates the same source lines —
+        the dispatcher and the Implementation objects survive, only the
+        function objects are swapped.
+
+        :param func: The (possibly re-created) implementation function.
+        """
+        if getattr(self, 'func', None) is not None and func.__code__ is self.func.__code__:
+            # The same source line re-executed (library mains and nested
+            # scopes re-run every bar): only the closure cells and default
+            # values are new, the matching metadata is unchanged — skip the
+            # expensive signature()/get_type_hints() recompute
+            self.func = func
+            return
+        sig = signature(func)
+        params = list(sig.parameters.values())
+        if params and _is_state_param(params[0].name):
+            # Hide the injected state parameter from matching: arity and
+            # types are checked against what the call site passes, the
+            # state argument comes from the bound partial
+            params = params[1:]
+        hints = get_type_hints(func)
+        self.func = func
+        self.sig = sig.replace(parameters=params)
+        self.type_hints = hints
+        self.param_types = tuple((p.name, hints.get(p.name, Any)) for p in params)
+
+
+_registry: dict[str, list[Implementation]] = defaultdict(list)
+_implementations: dict[str, Implementation] = {}  # Store implementations separately
+_dispatchers: dict[str, Callable] = {}  # Store dispatchers separately
+
+
+def _check_type(value: Any, expected_type: Type) -> bool:
+    """Cached type checking for better performance with Pine Script compatibility"""
+    # ``Any`` matches every value. Parameters without a type hint default to ``Any``
+    # (see ``param_types`` below), and the compiler threads a closure variable in as a
+    # leading, unannotated parameter -- both surface here as ``Any`` and must accept any
+    # argument, like an unconstrained Pine parameter. isinstance() rejects ``Any``.
+    if expected_type is Any:
+        return True
+
+    # Parameterized containers (list[T], dict[K, V], ...): isinstance() rejects
+    # parameterized generics. Match on the container type, then discriminate on a
+    # sample element -- overloads can differ only in their element types
+    # (map<string, string> vs map<string, float>)
+    _origin = get_origin(expected_type)
+    if isinstance(_origin, type) and _origin is not UnionType:
+        if isinstance(value, _origin):
+            _args = get_args(expected_type)
+            if _args and isinstance(value, dict):
+                if value:
+                    _key, _val = next(iter(value.items()))
+                    return _check_type(_key, _args[0]) and _check_type(_val, _args[1])
+            elif _args and isinstance(value, (list, tuple)) and value:
+                return _check_type(value[0], _args[0])
+            return True
+        expected_type = cast(Type, _origin)
+
+    # Direct type match
+    if isinstance(value, expected_type):
+        return True
+
+    # Pine Script-like int to float conversion
+    if expected_type is float and isinstance(value, int):
+        return True
+
+    # Pine Script allows plain str where StrLiteral subtypes are expected (e.g. size, xloc)
+    if isinstance(value, str) and isinstance(expected_type, type) and issubclass(expected_type, StrLiteral):
+        return True
+
+    # Handle NA values - Pine Script allows NA for any basic type
+    if isinstance(value, NA):
+        # Check if expected_type is a Pine Script basic type
+        if expected_type in (int, float, str, bool):
+            return True
+
+        # For Union types containing basic types, NA is also acceptable
+        origin = get_origin(expected_type)
+        if origin in (Union, type(None) | type):
+            args = get_args(expected_type)
+            # If any of the Union members is a basic type, accept NA
+            if any(arg in (int, float, str, bool) for arg in args):
+                return True
+
+        # For non-basic types, check if NA's type matches
+        na_type = value.type
+        # A typeless `na` is assignable to anything, like in Pine
+        if na_type is None:
+            return True
+        # Handle the case when na_type is an actual instance and not a type
+        if not isinstance(na_type, type):
+            na_type = type(na_type)
+        return na_type is expected_type
+
+    # Handle Union types
+    origin = get_origin(expected_type)
+    if origin in (Union, type(None) | type):
+        return any(_check_type(value, t) for t in get_args(expected_type))
+
+    if hasattr(expected_type, '__instancecheck__'):
+        return expected_type.__instancecheck__(value)
+
+    return False
+
+
+def _select(impls: list[Implementation], args: tuple, kwargs: dict) -> Implementation | None:
+    """Select the implementation matching a call's arguments.
+
+    :param impls: Registered implementations (registration order).
+    :param args: Positional arguments of the call.
+    :param kwargs: Keyword arguments of the call.
+    :return: The first matching implementation, or None.
+    """
+    # Quick path: try direct positional args match first
+    if not kwargs:
+        for impl in impls:
+            if len(args) == len(impl.param_types):
+                if all(_check_type(arg, type_)
+                       for arg, (_, type_) in zip(args, impl.param_types)):
+                    return impl
+
+    # Slower path: handle mixed args/kwargs and defaults
+    for impl in impls:
+        try:
+            bound = impl.sig.bind(*args, **kwargs)
+            bound.apply_defaults()
+
+            if all(_check_type(value, impl.type_hints[name])
+                   for name, value in bound.arguments.items()
+                   if name in impl.type_hints):
+                return impl
+        except TypeError:
+            continue
+    return None
+
+
+def _type_token(value: Any) -> Any:
+    """Hashable token capturing exactly the properties ``_check_type``
+    discriminates on, so that two arguments with equal tokens are
+    interchangeable for implementation selection.
+
+    Scalars map to their type; NA carries its ``type`` marker; parameterized
+    containers sample one element, mirroring ``_check_type``'s element probe.
+    The token is conservative: distinct tokens never merge arguments that
+    ``_check_type`` could treat differently.
+
+    :param value: A call argument.
+    :return: A hashable selection token.
+    """
+    t = type(value)
+    if t is int or t is float or t is str or t is bool:
+        return t
+    if isinstance(value, NA):
+        return NA, value.type
+    if t is dict:
+        if value:
+            _k, _v = next(iter(value.items()))
+            return dict, type(_k), type(_v)
+        return (dict,)
+    if t is list or t is tuple:
+        if value:
+            return t, type(value[0])
+        return (t,)
+    return t
+
+
+def _canonical_kwarg_renames(impls: list[Implementation],
+                             names: tuple[str, ...]) -> tuple[tuple[str, str], ...]:
+    """Compute the keyword renames onto canonically renamed parameters.
+
+    An untyped call site emits a keyword argument under its original Pine
+    spelling while the library ``def`` declares ``name + '__ren__'``
+    (PyneComp's canonical rename; the same contract as
+    ``pine_method._adapt_exported_kwargs``, which cannot see through the
+    dispatcher). A keyword is renamed only when NO implementation declares
+    the raw name and at least one declares the suffixed image — a correct
+    call is never altered. Overloads of one export come from one compilation
+    unit, so a name's rename decision is identical across implementations.
+
+    :param impls: Registered implementations of the overload group.
+    :param names: Keyword argument names as emitted at the call site.
+    :return: ``(raw, canonical)`` pairs to apply; empty when nothing renames.
+    """
+    declared = {name for impl in impls for name, _ in impl.param_types}
+    return tuple((k, k + '__ren__') for k in names
+                 if k not in declared and k + '__ren__' in declared)
+
+
+def _anchored(impls: list[Implementation], qualname: str,
+              cache: dict[Implementation, tuple[Callable, list | None, Callable]] | None = None
+              ) -> Callable:
+    """Create an anchored dispatch entry with its own per-implementation
+    bound cache. ``__pyne_bind__`` hands these out, one per anchor; the
+    dispatcher itself is one too (the shared, anchorless fallback, whose
+    cache is registered for clearing on ``instance_state.reset()`` — anchor
+    caches die with their anchor, the dispatcher's would outlive the run).
+
+    :param impls: The registry list of the overload group (shared, live).
+    :param qualname: Qualified name for error messages.
+    :param cache: Externally held cache dict (the dispatcher's registered
+        one); per-anchor entries create their own.
+    :return: The dispatch callable.
+    """
+    _cache: dict[Implementation, tuple[Callable, list | None, Callable]] = \
+        {} if cache is None else cache
+    # Per-anchor selection memo: a call site invokes the dispatcher with the
+    # same argument shape every bar, so the matching implementation is cached
+    # by call shape and the full _select (with inspect binding) runs once.
+    # Implementation objects are module-lifetime stable (re-runs swap only
+    # impl.func, handled below), so this never goes stale across resets.
+    _select_cache: dict[tuple, Implementation] = {}
+    # Keyword-name adaptation memo (see _canonical_kwarg_renames): keyed by
+    # the call's keyword-name tuple, stable for the same reason _select_cache
+    # is — implementation signatures only change with a recompile.
+    _kw_rename_cache: dict[tuple[str, ...], tuple[tuple[str, str], ...]] = {}
+
+    def dispatch(*args: Any, **kwargs: Any) -> Any:
+        if kwargs:
+            names = tuple(kwargs)
+            renames = _kw_rename_cache.get(names)
+            if renames is None:
+                renames = _kw_rename_cache[names] = _canonical_kwarg_renames(impls, names)
+            for raw, canonical in renames:
+                kwargs[canonical] = kwargs.pop(raw)
+        # Selection key, inlined (this is per-bar hot code): a uniform hashable
+        # ``(positional_tokens, keyword_tokens)`` pair so the no-kwargs and
+        # with-kwargs forms can never collide. map() over _type_token beats a
+        # generator expression here. Equal keys guarantee the same impl.
+        pos = tuple(map(_type_token, args))
+        key = (pos, ()) if not kwargs else \
+            (pos, tuple((k, _type_token(v)) for k, v in kwargs.items()))
+        impl = _select_cache.get(key)
+        if impl is None:
+            impl = _select(impls, args, kwargs)
+            if impl is None:
+                raise TypeError(f"No matching implementation found for {qualname}: {args}, {kwargs}")
+            _select_cache[key] = impl
+        entry = _cache.get(impl)
+        if entry is None or entry[0] is not impl.func:
+            # First win at this anchor, or the implementation function was
+            # re-created by a re-execution of its defining scope (library
+            # mains re-run every bar). Keep the existing instance state and
+            # take the closure from the new function object — the same
+            # split pine_method._bound_method does
+            func = impl.func
+            layout: dict[str, Any] | None = getattr(func, '__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)
+                entry = _cache[impl] = (func, state, partial(func, state))
+            else:
+                entry = _cache[impl] = (func, None, _bind_target(func))
+        return entry[2](*args, **kwargs)
+
+    return dispatch
+
+
+def overload(func: Callable[..., T]) -> Callable[..., T]:
+    """
+    Function overloading decorator with:
+    - Type checking cache
+    - Pre-calculated signatures and type hints (hidden state parameter excluded)
+    - Quick parameter matching
+    - Per-anchor instance state through ``__pyne_bind__``
+    - IDE type checking support via typing.overload
+    """
+    _func = cast(FunctionType, func)
+    qualname = _func.__module__ + '.' + _func.__qualname__
+    qualname_with_line = f"{qualname}:{_func.__code__.co_firstlineno}"
+
+    # Re-executed module: same dispatcher, rebind the implementation
+    _dispatcher = _dispatchers.get(qualname)
+    if _dispatcher is not None:
+        impl = _implementations.get(qualname_with_line)
+        if impl is not None:
+            impl.update(_func)
+            return _dispatcher
+
+    # Register with typing.overload for IDE support
+    typing_overload(func)
+
+    impl = Implementation(_func)
+    _implementations[qualname_with_line] = impl
+    _registry[qualname].append(impl)
+
+    if _dispatcher is None:
+        # The dispatcher must carry the implementation's metadata (__name__ in
+        # particular): for exported library functions the @export decorator sits
+        # above @overload and looks up the module-level Exported proxy by the
+        # wrapped callable's __name__.
+        _dispatcher = wraps(func)(_anchored(_registry[qualname], qualname,
+                                            register_shared_cache({})))
+        # @wraps copies the implementation's __dict__ too — including the
+        # __pyne_layout__ the slot transform attached. The dispatcher must
+        # not look state-carrying to the call-site classifier or to
+        # _bind_target.
+        _dispatcher.__dict__.pop('__pyne_layout__', None)
+        setattr(_dispatcher, '__pyne_bind__',
+                lambda: _anchored(_registry[qualname], qualname))
+        _dispatchers[qualname] = _dispatcher
+
+    return _dispatcher

pynecore/core/pine_cast.py

@@ -0,0 +1,113 @@
+from ..types.na import NA, na_float
+
+from ..types.color import Color
+from ..types.label import Label
+from ..types.table import Table
+from ..types.box import Box
+from ..types.line import Line
+from ..types.linefill import LineFill
+
+
+def cast_color(x: Color | NA) -> Color:
+    """
+    Casts `na` to Color
+    :param x: The value to convert
+    :return: The casted value
+    """
+    return NA(Color) if isinstance(x, NA) else x
+
+
+def cast_label(x: Label | NA) -> Label:
+    """
+    Casts `na` to Label
+
+    :param x: The value to convert
+    :return: The casted value
+    """
+    return NA(Label) if isinstance(x, NA) else x
+
+
+def cast_table(x: Table | NA) -> Table:
+    """
+    Casts `na` to Table
+
+    :param x: The value to convert
+    :return: The casted value
+    """
+    return NA(Table) if isinstance(x, NA) else x
+
+
+def cast_bool(x: bool | int | float | NA) -> bool:
+    """
+    Converts the x value to a bool value
+
+    :param x: The value to convert
+    :return: The casted value
+    """
+    if isinstance(x, NA) or x != x:  # NA object or native nan
+        return False
+    return not not x
+
+
+def cast_box(x: Box | NA) -> Box:
+    """
+    Casts `na` to Box
+
+    :param x: The value to convert
+    :return: The casted value
+    """
+    return NA(Box) if isinstance(x, NA) else x
+
+
+def cast_int(x: int | float | NA) -> int:
+    """
+    Casts na or truncates float value to int
+
+    :param x: The value to convert
+    :return: The casted value
+    """
+    if isinstance(x, NA) or x != x:  # NA object or native nan
+        return NA(int)
+    return int(x)
+
+
+def cast_line(x: Line | NA) -> Line:
+    """
+    Casts `na` to Line
+
+    :param x: The value to convert
+    :return: The casted value
+    """
+    return NA(Line) if isinstance(x, NA) else x
+
+
+def cast_float(x: float | int | NA) -> float:
+    """
+    Casts `na` to float
+
+    :param x: The value to convert
+    :return: The casted value
+    """
+    if isinstance(x, NA) or x != x:  # NA object or native nan
+        return na_float
+    return float(x)
+
+
+def cast_string(x: str | NA) -> str:
+    """
+    Casts `na` to string
+
+    :param x: The value to convert
+    :return: The casted value
+    """
+    return NA(str) if isinstance(x, NA) else x
+
+
+def cast_linefill(x: LineFill | NA) -> LineFill:
+    """
+    Casts `na` to LineFill
+
+    :param x: The value to convert
+    :return: The casted value
+    """
+    return NA(LineFill) if isinstance(x, NA) else x

pynecore/core/pine_export.py

@@ -0,0 +1,95 @@
+from typing import Callable, TypeVar, Generic, Optional, Any, Union, overload
+import sys
+
+__all__ = ['Exported', 'export']
+
+F = TypeVar('F', bound=Callable[..., Any])  # Function type
+
+
+class Exported(Generic[F]):
+    """
+    Function closure proxy with flexible type annotation support
+
+    Supports:
+    - Protocol with named parameters: Exported[MyProtocol]
+    - Callable types: Exported[Callable[[int, str], bool]]
+    - No annotation: Exported (falls back to Any)
+    """
+    __fn__: Optional[F] = None
+    __name__: str
+
+    def set(self, client: F):
+        """Set the client function"""
+        self.__fn__ = client
+        # Expose the client's name so callers that inspect the callable
+        # (e.g. method_call's builtin-method name check) see the real one
+        name = getattr(client, '__name__', None)
+        if name is not None:
+            self.__name__ = name
+
+    def __call__(self, *args, **kwargs) -> Any:
+        if self.__fn__ is None:
+            raise ValueError("Function has not been set yet")
+        return self.__fn__(*args, **kwargs)
+
+
+@overload
+def export(func: Callable) -> Callable:
+    ...
+
+
+@overload
+def export(*, func_globals: dict[str, Any]) -> Callable:
+    ...
+
+
+def export(
+        func: Optional[Callable] = None,
+        *,
+        func_globals: Optional[dict[str, Any]] = None
+) -> Union[Callable, Callable[[Callable], Callable]]:
+    """
+    Export decorator that can work with or without parameters.
+    It is exporting the function closure to the global scope of the module.
+
+    Usage:
+    @export
+    def my_func(): pass
+
+    @export(func_globals=some_globals)
+    def my_func(): pass
+    """
+    # Get caller's globals once at decorator definition time
+    if func_globals is None:
+        func_globals = sys._getframe(1).f_globals
+
+    def decorator(f: Callable) -> Callable:
+        func_name = f.__name__
+        assert func_globals is not None
+
+        # Check if there's already something with the same name in globals
+        if func_name in func_globals:
+            existing = func_globals[func_name]
+            if isinstance(existing, Exported):
+                # Set the function in the existing proxy
+                existing.set(f)
+                return existing
+            elif callable(existing):
+                # Function already exists in global scope, just return it unchanged (decorator as decoration)
+                return f
+
+        # No proxy found, throw error explaining what's needed
+        raise ValueError(
+            f"No Exported proxy found for function '{func_name}' in global scope. "
+            f"You must create an Exported proxy first:\n"
+            f"  {func_name} = Exported()\n"
+            f"  @export\n"
+            f"  def {func_name}(): ..."
+        )
+
+    if func is not None:
+        # Called without parentheses: @export
+        return decorator(func)
+    else:
+        # Called with parentheses: @export() or @export(func_globals=...)
+        return decorator