opencode-pyneruntime 6.6.4__py3-none-any.whl

pynecore/transformers/security_instantiation.py

@@ -0,0 +1,274 @@
+"""Per-call-site instantiation of security-bearing functions (Pine semantics).
+
+In Pine Script every call of a user function creates a separate INSTANCE: a
+``request.security()`` inside a function called from N sites is N distinct
+data requests, each bound to its own symbol/timeframe arguments. PyneCore's
+SecurityTransformer allocates one sec_id per *syntactic*
+``request.security()`` call, and the runtime binds a sec_id to ONE resolved
+(symbol, timeframe) on its first ``__sec_signal__`` — so multiple call sites
+of the same function would silently share the FIRST call's binding (a
+6-timeframe ``f_htf_trend(tf)`` helper would read the first timeframe's
+series six times).
+
+This pass restores Pine's instantiation semantics statically, BEFORE
+SecurityTransformer runs: any function whose subtree contains a
+``request.security[_lower_tf]`` call — or a direct call to another
+security-bearing function — is cloned per direct-Name call site. Each clone
+is a full deep copy inserted right after the original def, and exactly one
+call site is rewritten to each clone, so SecurityTransformer then allocates
+fresh sec_ids per call site and the whole downstream machinery (context
+registry, ``--security`` discovery, subprocesses) works unchanged.
+
+Bail-outs — the affected function keeps the legacy shared-context behavior:
+
+- recursive functions (any name-level call-graph cycle),
+- decorated functions (the runtime value is the decorator's return value),
+- functions whose name is referenced outside a direct-call position
+  (aliases, callbacks, stores),
+- duplicate top-of-scope definitions of the same name (shadowing),
+- attribute-style call sites (methods, cross-module library calls) are not
+  rewritten — a library function with security calls instantiated from
+  several script call sites remains a single shared context (documented
+  limitation).
+
+Must run after ImportNormalizerTransformer (security calls are in their
+``lib.request.security`` form) and before SecurityTransformer.
+"""
+import ast
+import copy
+
+from .security import SecurityTransformer
+
+__all__ = ['SecurityInstantiationTransformer']
+
+# Hard ceiling on clones per module — far above any real script (TradingView
+# itself caps unique request.* calls at 40) but low enough to stop a
+# pathological call-graph blow-up with a clear error instead of a hang.
+_MAX_CLONES = 64
+
+
+class _FuncInfo:
+    """One function definition eligible for instantiation analysis."""
+
+    __slots__ = ('node', 'owner_body', 'index', 'region')
+
+    def __init__(self, node: ast.FunctionDef | ast.AsyncFunctionDef,
+                 owner_body: list[ast.stmt], index: int, region: ast.AST):
+        self.node = node
+        self.owner_body = owner_body
+        self.index = index
+        # The subtree in which this def's name is in scope (the whole module
+        # for module-level defs, the enclosing function for nested defs).
+        self.region = region
+
+
+def _ordered_walk(node: ast.AST):
+    """DFS in source order (``ast.walk`` is BFS; clone/call-site numbering
+    must be stable and follow the source)."""
+    yield node
+    for child in ast.iter_child_nodes(node):
+        yield from _ordered_walk(child)
+
+
+class SecurityInstantiationTransformer:
+    """Not an ``ast.NodeTransformer`` — a whole-module fixpoint pass with the
+    same ``visit(tree) -> tree`` pipeline interface."""
+
+    def __init__(self):
+        self._clones_made = 0
+        self._module: ast.Module | None = None
+
+    # --- collection ---
+
+    @staticmethod
+    def _is_security_call(node: ast.AST) -> bool:
+        return isinstance(node, ast.Call) and (
+            SecurityTransformer._is_security_call(node)  # noqa
+            or SecurityTransformer._is_security_lower_tf_call(node)  # noqa
+        )
+
+    def _collect_functions(self, module: ast.Module) -> list[_FuncInfo]:
+        """Every FunctionDef with its owner body and scope region. Class
+        bodies are skipped entirely (methods are called by attribute, which
+        this pass never rewrites)."""
+        result: list[_FuncInfo] = []
+
+        def scan_body(body: list[ast.stmt], region: ast.AST) -> None:
+            for idx, stmt in enumerate(body):
+                if isinstance(stmt, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                    result.append(_FuncInfo(stmt, body, idx, region))
+                    scan_body(stmt.body, stmt)
+                elif isinstance(stmt, ast.ClassDef):
+                    continue
+                else:
+                    # Compound statements can nest defs (if/try/with/for).
+                    scan_sub(stmt, region)
+
+        def scan_sub(stmt: ast.stmt, region: ast.AST) -> None:
+            for field_body in ('body', 'orelse', 'finalbody'):
+                sub = getattr(stmt, field_body, None)
+                if isinstance(sub, list):
+                    scan_body(sub, region)
+            for handler in getattr(stmt, 'handlers', []) or []:
+                scan_body(handler.body, region)
+            for case in getattr(stmt, 'cases', []) or []:
+                scan_body(case.body, region)
+
+        scan_body(module.body, module)
+        return result
+
+    @staticmethod
+    def _call_sites(region: ast.AST, name: str) -> list[ast.Call]:
+        """Direct-Name call sites of ``name`` within ``region`` in source
+        order, excluding sites inside a nested def that redefines the name
+        (approximated: shadowing defs disqualify the whole function via
+        duplicate-name bail-out in ``_analyze``)."""
+        return [n for n in _ordered_walk(region)
+                if isinstance(n, ast.Call)
+                and isinstance(n.func, ast.Name) and n.func.id == name]
+
+    @staticmethod
+    def _non_call_refs(region: ast.AST, name: str,
+                       own_def: ast.AST) -> bool:
+        """Whether ``name`` is referenced outside its own def and outside a
+        direct-call func position (alias, callback argument, store, ...)."""
+        call_funcs = {
+            id(n.func) for n in _ordered_walk(region)
+            if isinstance(n, ast.Call) and isinstance(n.func, ast.Name)
+        }
+        for n in _ordered_walk(region):
+            if n is own_def:
+                continue
+            if isinstance(n, ast.Name) and n.id == name and id(n) not in call_funcs:
+                return True
+            if isinstance(n, (ast.Global, ast.Nonlocal)) and name in n.names:
+                return True
+        return False
+
+    # --- analysis ---
+
+    def _analyze(self, module: ast.Module) -> tuple[list[_FuncInfo], set[str]]:
+        """Return (eligible security-bearing functions with >1 call site,
+        bearing name set). Eligibility applies every bail-out."""
+        infos = self._collect_functions(module)
+
+        by_name: dict[str, list[_FuncInfo]] = {}
+        for info in infos:
+            by_name.setdefault(info.node.name, []).append(info)
+
+        # Direct bearers: subtree contains a security call.
+        bearing: set[str] = set()
+        for info in infos:
+            if any(self._is_security_call(n) for n in _ordered_walk(info.node)):
+                bearing.add(info.node.name)
+
+        # Name-level call edges among module functions (for transitivity and
+        # cycle detection).
+        edges: dict[str, set[str]] = {}
+        for info in infos:
+            callees = {
+                n.func.id for n in _ordered_walk(info.node)
+                if isinstance(n, ast.Call) and isinstance(n.func, ast.Name)
+                and n.func.id in by_name
+            }
+            edges.setdefault(info.node.name, set()).update(callees)
+
+        # Transitive closure: calling a bearer makes the caller a bearer.
+        changed = True
+        while changed:
+            changed = False
+            for name, callees in edges.items():
+                if name not in bearing and callees & bearing:
+                    bearing.add(name)
+                    changed = True
+
+        # Cycle detection over the bearing subgraph — any bearer on a cycle
+        # (recursion, mutual recursion) is excluded, or cloning would never
+        # converge.
+        on_cycle: set[str] = set()
+
+        def reaches(start: str, target: str, seen: set[str]) -> bool:
+            for callee in edges.get(start, ()):
+                if callee == target:
+                    return True
+                if callee not in seen:
+                    seen.add(callee)
+                    if reaches(callee, target, seen):
+                        return True
+            return False
+
+        for name in bearing:
+            if reaches(name, name, set()):
+                on_cycle.add(name)
+
+        eligible: list[_FuncInfo] = []
+        for info in infos:
+            name = info.node.name
+            if name not in bearing or name in on_cycle:
+                continue
+            if len(by_name[name]) > 1:  # shadowing / duplicate defs
+                continue
+            if info.node.decorator_list:
+                continue
+            if self._non_call_refs(info.region, name, info.node):
+                continue
+            if len(self._call_sites(info.region, name)) > 1:
+                eligible.append(info)
+        return eligible, bearing
+
+    # --- cloning ---
+
+    def _unique_name(self, base: str) -> str:
+        """Collision-free clone name (module-wide check; the global clone
+        counter keeps names unique even across nested re-instantiation)."""
+        assert self._module is not None
+        existing = {
+            n.name for n in _ordered_walk(self._module)
+            if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))
+        }
+        candidate = f"{base}__pyne_inst{self._clones_made}"
+        while candidate in existing:
+            candidate += "_"
+        return candidate
+
+    def _clone_one(self, module: ast.Module) -> bool:
+        """Clone the first eligible multi-site bearer; True if work was done."""
+        eligible, _ = self._analyze(module)
+        if not eligible:
+            return False
+        info = eligible[0]
+        name = info.node.name
+        sites = self._call_sites(info.region, name)
+        # Re-locate the def index (earlier clones may have shifted the body).
+        index = info.owner_body.index(info.node)
+        # Call site 1 keeps the original function; each further site gets a
+        # fresh clone inserted after the original (source order preserved).
+        for k, site in enumerate(sites[1:], start=2):
+            self._clones_made += 1
+            if self._clones_made > _MAX_CLONES:
+                raise SyntaxError(
+                    f"security instantiation exceeded {_MAX_CLONES} function "
+                    f"clones — the script's request.security call graph is "
+                    f"too large to instantiate per call site"
+                )
+            clone = copy.deepcopy(info.node)
+            clone.name = self._unique_name(name)
+            info.owner_body.insert(index + k - 1, clone)
+            site_func = site.func
+            assert isinstance(site_func, ast.Name)
+            site_func.id = clone.name
+        return True
+
+    # --- pipeline API ---
+
+    def visit(self, module: ast.Module) -> ast.Module:
+        if not any(self._is_security_call(n) for n in ast.walk(module)):
+            return module
+        self._module = module
+        # Fixpoint: cloning a caller duplicates its callees' call sites, so
+        # re-analyze until no eligible multi-site bearer remains. Bounded by
+        # the clone cap (each iteration makes at least one clone).
+        for _ in range(_MAX_CLONES + 1):
+            if not self._clone_one(module):
+                break
+        return module

pynecore/transformers/series.py

@@ -0,0 +1,275 @@
+"""
+Transform Series type annotations and accesses into state-vector slots.
+
+A series variable's circular buffer (a
+:class:`~pynecore.core.series.SeriesImpl`) lives in a compile-time-assigned
+slot of its scope's state vector; ``_make_state`` creates a fresh buffer for
+every instance from the layout's ``series`` entries. The emitted code
+addresses the buffer with a literal index:
+
+- ``s: Series[float] = value`` -> ``s = __state__[N].add(value)`` (the local
+  name keeps tracking the current scalar value, plain reads stay untouched),
+- ``s = value``                -> ``s = __state__[N].set(value)``,
+- ``s += value``               -> ``s = __state__[N].set(s + value)``,
+- ``s[idx]``                   -> ``__state__[N][idx]``,
+- ``lib.max_bars_back(s, num)`` in statement position
+                               -> ``__state__[N].max_bars_back = num``
+  (other positions are left to the ``lib.max_bars_back`` runtime no-op),
+- a ``Series``-annotated parameter loses the Series wrapper from its
+  annotation and gets ``s = __state__[N].add(s)`` prepended to the body.
+
+Subscript READS resolve through the scope chain: a nested definition reaches
+a parent's series buffer through a closure reference on the parent's
+scope-qualified state parameter. The library-series declarations that
+:class:`~pynecore.transformers.lib_series.LibrarySeriesTransformer` anchors
+in ``main`` rely on this. Writes stay same-scope only, like the legacy
+transformer: a plain assignment in a nested scope declares a local that
+shadows the parent's series.
+"""
+from typing import cast
+import ast
+
+from .slot_layout import ModuleLayout, scope_for_function
+
+__all__ = ['SeriesTransformer']
+
+
+class SeriesTransformer(ast.NodeTransformer):
+    """Rewrite Series declarations and accesses to state-vector slots."""
+
+    def __init__(self, layout: ModuleLayout):
+        self.layout = layout
+        self.scope_stack: list[str] = []
+        self.current_scope: str = ''
+        # scope -> var name -> series slot
+        self.series_slots: dict[str, dict[str, int]] = {}
+        self.series_declarations: dict[str, set[str]] = {}
+        self.local_vars: dict[str, set[str]] = {}
+
+    # --- helpers ---------------------------------------------------------
+
+    def _lookup(self, var_name: str) -> tuple[str, int] | None:
+        """Resolve a name to its declaring scope and series slot.
+
+        A name locally assigned in the current scope (but not declared as a
+        Series there) shadows any parent series of the same name.
+
+        :param var_name: Source-level variable name.
+        :return: (declaring scope, slot index) or None.
+        """
+        if (var_name in self.local_vars.get(self.current_scope, ())
+                and var_name not in self.series_declarations.get(self.current_scope, ())):
+            return None
+        slots = self.series_slots.get(self.current_scope)
+        if slots is not None and var_name in slots:
+            return self.current_scope, slots[var_name]
+        for i in range(len(self.scope_stack) - 1, 0, -1):
+            scope = '·'.join(self.scope_stack[:i])
+            slots = self.series_slots.get(scope)
+            if slots is not None and var_name in slots:
+                return scope, slots[var_name]
+        return None
+
+    def _state_ref(self, scope: str, slot: int) -> ast.Subscript:
+        """Build a ``<state param>[slot]`` reference for a scope."""
+        return ast.Subscript(
+            value=ast.Name(id=self.layout.state_param(scope), ctx=ast.Load()),
+            slice=ast.Constant(value=slot), ctx=ast.Load())
+
+    def _buffer_call(self, scope: str, slot: int, method: str, args: list[ast.expr]) -> ast.Call:
+        """Build a ``<state param>[slot].<method>(...)`` call."""
+        return ast.Call(
+            func=ast.Attribute(value=self._state_ref(scope, slot),
+                               attr=method, ctx=ast.Load()),
+            args=args, keywords=[])
+
+    def _register(self, var_name: str, elem: str | None = None) -> int:
+        """Allocate a series slot for a declaration in the current scope.
+
+        :param var_name: Source-level variable name.
+        :param elem: Statically known element type name from the ``Series[T]``
+            annotation (``'float'`` selects the native-nan na value), or None.
+        :return: The allocated slot index.
+        """
+        slot = self.layout.scope(self.current_scope).add_series(
+            var_name, ast.Constant(value=None), elem)
+        self.series_slots.setdefault(self.current_scope, {})[var_name] = slot
+        self.series_declarations[self.current_scope].add(var_name)
+        self.local_vars[self.current_scope].add(var_name)
+        return slot
+
+    @staticmethod
+    def _is_series_type(annotation: ast.expr) -> bool:
+        """Check if a type annotation is Series."""
+        if isinstance(annotation, ast.Subscript):
+            return (isinstance(annotation.value, ast.Name)
+                    and annotation.value.id == 'Series')
+        return isinstance(annotation, ast.Name) and annotation.id == 'Series'
+
+    @staticmethod
+    def _series_elem(annotation: ast.expr) -> str | None:
+        """Element type name of a ``Series[T]`` annotation, if statically known.
+
+        Only ``'float'`` is meaningful downstream (it selects the native nan
+        as the series' na value); everything else — bare ``Series``, other
+        element types, complex annotations — yields None.
+
+        :param annotation: The (Series) type annotation.
+        :return: ``'float'`` for ``Series[float]``, otherwise None.
+        """
+        if (isinstance(annotation, ast.Subscript)
+                and isinstance(annotation.slice, ast.Name)
+                and annotation.slice.id == 'float'):
+            return 'float'
+        return None
+
+    # --- visitors --------------------------------------------------------
+
+    def visit_Module(self, node: ast.Module) -> ast.Module:
+        self.layout.assign_scope_ids(node)
+        return cast(ast.Module, self.generic_visit(node))
+
+    def visit_ImportFrom(self, node: ast.ImportFrom) -> ast.ImportFrom | None:
+        """Strip the Series name from pynecore imports."""
+        if node.module and node.module.startswith('pynecore'):
+            new_names = [name for name in node.names if name.name != 'Series']
+            if not new_names:
+                return None
+            node.names = new_names
+        return node
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.FunctionDef:
+        """Track scopes and convert Series-annotated parameters."""
+        self.scope_stack.append(self.layout.scope_segment(node))
+        self.current_scope = '·'.join(self.scope_stack)
+        scope_for_function(self.layout, self.current_scope, node)
+        self.local_vars.setdefault(self.current_scope, set())
+        self.series_declarations.setdefault(self.current_scope, set())
+
+        param_inits: list[ast.stmt] = []
+        for arg in node.args.args:
+            self.local_vars[self.current_scope].add(arg.arg)
+            if arg.annotation is not None and self._is_series_type(arg.annotation):
+                slot = self._register(arg.arg, self._series_elem(arg.annotation))
+                arg.annotation = (arg.annotation.slice
+                                  if isinstance(arg.annotation, ast.Subscript) else None)
+                param_inits.append(ast.Assign(
+                    targets=[ast.Name(id=arg.arg, ctx=ast.Store())],
+                    value=self._buffer_call(self.current_scope, slot, 'add',
+                                            [ast.Name(id=arg.arg, ctx=ast.Load())])))
+
+        node = cast(ast.FunctionDef, self.generic_visit(node))
+
+        if param_inits:
+            insert_pos = 0
+            first = node.body[0] if node.body else None
+            if (isinstance(first, ast.Expr) and isinstance(first.value, ast.Constant)
+                    and isinstance(first.value.value, str)):
+                insert_pos = 1
+            node.body[insert_pos:insert_pos] = param_inits
+
+        self.scope_stack.pop()
+        self.current_scope = '·'.join(self.scope_stack)
+        return node
+
+    def visit_AnnAssign(self, node: ast.AnnAssign) -> ast.AST | None:
+        """Convert Series declarations into slot allocations with ``add()``."""
+        if not (isinstance(node.target, ast.Name) and self._is_series_type(node.annotation)):
+            if isinstance(node.target, ast.Name) and self.current_scope:
+                # An annotated assignment declares a local — it shadows a
+                # same-named parent series, like a plain assignment does.
+                self.local_vars.setdefault(self.current_scope, set()).add(node.target.id)
+            if node.value:
+                node.value = cast(ast.expr, self.visit(node.value))
+            return node
+
+        if not self.current_scope:
+            raise SyntaxError("Series variables must be declared inside a function")
+
+        slot = self._register(node.target.id, self._series_elem(node.annotation))
+        if node.value is None:
+            return None
+        return ast.Assign(
+            targets=[ast.Name(id=node.target.id, ctx=ast.Store())],
+            value=self._buffer_call(self.current_scope, slot, 'add',
+                                    [cast(ast.expr, self.visit(node.value))]))
+
+    def visit_Assign(self, node: ast.Assign) -> ast.AST | list[ast.stmt]:
+        """Convert assignments to same-scope series variables into buffer writes."""
+        if len(node.targets) == 1 and isinstance(node.targets[0], ast.Name):
+            var_name = cast(ast.Name, node.targets[0]).id
+            slots = self.series_slots.get(self.current_scope)
+            if slots is not None and var_name in slots:
+                return ast.Assign(
+                    targets=[ast.Name(id=var_name, ctx=ast.Store())],
+                    value=self._buffer_call(self.current_scope, slots[var_name], 'set',
+                                            [cast(ast.expr, self.visit(node.value))]))
+            if self.current_scope:
+                self.local_vars.setdefault(self.current_scope, set()).add(var_name)
+
+        # Tuple/list unpacking (``a, b = f()``): a series element is declared bare
+        # (``a: Series`` with no initializer, so no per-bar ``add()``) and the
+        # unpack only binds the local name — its buffer never advances. Emit an
+        # ``add()`` per series element to record history so ``a[1]`` works.
+        target = node.targets[0] if len(node.targets) == 1 else None
+        if (isinstance(target, (ast.Tuple, ast.List))
+                and self.current_scope
+                and all(isinstance(e, ast.Name) for e in target.elts)):
+            slots = self.series_slots.get(self.current_scope, {})
+            node.value = cast(ast.expr, self.visit(node.value))
+            stmts: list[ast.stmt] = [node]
+            for elt in target.elts:
+                name = cast(ast.Name, elt).id
+                if name in slots:
+                    stmts.append(ast.Assign(
+                        targets=[ast.Name(id=name, ctx=ast.Store())],
+                        value=self._buffer_call(self.current_scope, slots[name], 'add',
+                                                [ast.Name(id=name, ctx=ast.Load())])))
+                else:
+                    self.local_vars.setdefault(self.current_scope, set()).add(name)
+            return stmts if len(stmts) > 1 else node
+
+        return cast(ast.AST, self.generic_visit(node))
+
+    def visit_AugAssign(self, node: ast.AugAssign) -> ast.AST:
+        """Convert augmented assignments to same-scope series into ``set()``."""
+        if isinstance(node.target, ast.Name):
+            slots = self.series_slots.get(self.current_scope)
+            if slots is not None and node.target.id in slots:
+                value = ast.BinOp(left=ast.Name(id=node.target.id, ctx=ast.Load()),
+                                  op=node.op,
+                                  right=cast(ast.expr, self.visit(node.value)))
+                return ast.Assign(
+                    targets=[ast.Name(id=node.target.id, ctx=ast.Store())],
+                    value=self._buffer_call(self.current_scope, slots[node.target.id],
+                                            'set', [value]))
+        return cast(ast.AST, self.generic_visit(node))
+
+    def visit_Subscript(self, node: ast.Subscript) -> ast.AST:
+        """Rewrite series indexing to address the buffer in its slot."""
+        if isinstance(node.value, ast.Name):
+            found = self._lookup(node.value.id)
+            if found:
+                scope, slot = found
+                node.value = self._state_ref(scope, slot)
+                node.slice = cast(ast.expr, self.visit(node.slice))
+                return node
+        return cast(ast.AST, self.generic_visit(node))
+
+    def visit_Expr(self, node: ast.Expr) -> ast.AST:
+        """Convert statement-position ``lib.max_bars_back(s, n)`` calls into
+        a ``max_bars_back`` attribute assignment on the buffer."""
+        call = node.value
+        if (isinstance(call, ast.Call) and isinstance(call.func, ast.Attribute)
+                and call.func.attr == 'max_bars_back'
+                and isinstance(call.func.value, ast.Name)
+                and call.func.value.id == 'lib'
+                and len(call.args) >= 2 and isinstance(call.args[0], ast.Name)):
+            found = self._lookup(call.args[0].id)
+            if found:
+                scope, slot = found
+                return ast.Assign(
+                    targets=[ast.Attribute(value=self._state_ref(scope, slot),
+                                           attr='max_bars_back', ctx=ast.Store())],
+                    value=cast(ast.expr, self.visit(call.args[1])))
+        return cast(ast.AST, self.generic_visit(node))