opencode-pyneruntime 6.6.4__py3-none-any.whl

pynecore/transformers/security.py

@@ -0,0 +1,752 @@
+import ast
+import copy
+import hashlib
+
+
+# Strategy state accessors are meaningful only in the chart context — the
+# security child process has no strategy state of its own, so referencing
+# these in a request.security() / request.security_lower_tf() expression is
+# always a programmer error. We raise SyntaxError when the offending attribute
+# access is direct (i.e. not bound through a local alias). Transitive flow
+# analysis is intentionally skipped — at runtime the security child returns
+# inert defaults via the `lib._script is None` guard in the strategy module,
+# so escaped cases fail safe rather than crash.
+_FORBIDDEN_STRATEGY_STATE_ATTRS = frozenset({
+    "equity", "eventrades", "grossloss", "grossprofit", "initial_capital",
+    "losstrades", "max_drawdown", "max_runup", "netprofit", "openprofit",
+    "position_avg_price", "position_size", "wintrades",
+})
+
+# Raw price series the security child can serve WITHOUT running the script's
+# ``main()``: every one is set straight from the bar by ``_set_lib_properties``
+# (the derived sources hl2/hlc3/ohlc4/hlcc4 are pure functions of that bar's
+# OHLC, also set there), so reading ``lib.<field>`` after the per-bar property
+# set is byte-identical to what ``main()`` would have produced. A
+# ``request.security[_lower_tf]`` whose expression is only these can take the
+# fast path (see ``security_process.security_process_main``).
+_OHLCV_PASSTHROUGH_FIELDS = frozenset({
+    "open", "high", "low", "close", "volume",
+    "hl2", "hlc3", "ohlc4", "hlcc4",
+})
+
+
+class SecurityTransformer(ast.NodeTransformer):
+    """
+    Transform request.security() calls into multiprocessing signal/write/read pattern.
+
+    Transforms each lib.request.security(symbol, timeframe, expression, ...) call:
+
+    1. Function start (chart context only):
+       if __active_security__ is None:
+           __sec_signal__("sec_id", symbol_expr, timeframe_expr)
+
+    2. Original call position:
+       if __active_security__ == "sec_id":
+           __sec_write__("sec_id", expression)
+       var = __sec_read__("sec_id", lib.na)
+
+    3. Function end (chart context only):
+       if __active_security__ is None:
+           __sec_wait__("sec_id")
+
+    Also creates module-level __security_contexts__ dict with metadata for each context.
+    Non-constant symbol/timeframe/lookahead values (e.g., function parameters or
+    input-derived expressions) are stored as None in __security_contexts__ and
+    resolved at runtime via __sec_signal__ arguments.
+
+    Must be applied after ImportNormalizerTransformer, before PersistentSeriesTransformer.
+    """
+
+    def __init__(self):
+        self._counter = 0
+        self._all_contexts: dict[str, dict[str, ast.expr]] = {}
+        self._signal_args: dict[
+            str, tuple[ast.expr | None, ast.expr | None, ast.expr | None]
+        ] = {}
+        self._needs_barmerge = False
+        self._needs_ltf_unzip = False
+        self._ltf_sec_ids: set[str] = set()
+        self._module_file: str = '<script>'
+
+    def _gen_id(self) -> str:
+        # The module hash keeps sec ids unique across modules: the main script and
+        # any imported library may each have their own security calls, and their
+        # contexts are merged into one registry by the runner
+        module_hash = hashlib.sha1(self._module_file.encode()).hexdigest()[:8]
+        sec_id = f"sec\xb7{module_hash}\xb7{self._counter}"
+        self._counter += 1
+        return sec_id
+
+    @staticmethod
+    def _is_security_call(node: ast.Call) -> bool:
+        """Check if node is lib.request.security(...)."""
+        return (isinstance(node.func, ast.Attribute)
+                and node.func.attr == 'security'
+                and isinstance(node.func.value, ast.Attribute)
+                and node.func.value.attr == 'request'
+                and isinstance(node.func.value.value, ast.Name)
+                and node.func.value.value.id == 'lib')
+
+    @staticmethod
+    def _is_security_lower_tf_call(node: ast.Call) -> bool:
+        """Check if node is lib.request.security_lower_tf(...)."""
+        return (isinstance(node.func, ast.Attribute)
+                and node.func.attr == 'security_lower_tf'
+                and isinstance(node.func.value, ast.Attribute)
+                and node.func.value.attr == 'request'
+                and isinstance(node.func.value.value, ast.Name)
+                and node.func.value.value.id == 'lib')
+
+    @staticmethod
+    def _extract_ltf_args(call: ast.Call) -> tuple[
+        ast.expr | None, ast.expr | None, ast.expr | None, ast.expr | None
+    ]:
+        """Extract (symbol, timeframe, expression, ignore_invalid_symbol)
+        from request.security_lower_tf() call.
+
+        Note: no gaps parameter (LTF has no gaps/lookahead).
+        """
+        args = list(call.args)
+        kwargs = {kw.arg: kw.value for kw in call.keywords if kw.arg is not None}
+        return (
+            kwargs.get('symbol', args[0] if len(args) > 0 else None),
+            kwargs.get('timeframe', args[1] if len(args) > 1 else None),
+            kwargs.get('expression', args[2] if len(args) > 2 else None),
+            kwargs.get('ignore_invalid_symbol', args[3] if len(args) > 3 else None),
+        )
+
+    @staticmethod
+    def _extract_args(call: ast.Call) -> tuple[
+        ast.expr | None, ast.expr | None, ast.expr | None, ast.expr | None,
+        ast.expr | None, ast.expr | None, ast.expr | None
+    ]:
+        """Extract (symbol, timeframe, expression, gaps, lookahead,
+        ignore_invalid_symbol, currency) from request.security() call.
+
+        Positional order matches Pine v6:
+        ``security(symbol, timeframe, expression, gaps, lookahead,
+        ignore_invalid_symbol, currency, ...)``.
+        """
+        args = list(call.args)
+        kwargs = {kw.arg: kw.value for kw in call.keywords if kw.arg is not None}
+        return (
+            kwargs.get('symbol', args[0] if len(args) > 0 else None),
+            kwargs.get('timeframe', args[1] if len(args) > 1 else None),
+            kwargs.get('expression', args[2] if len(args) > 2 else None),
+            kwargs.get('gaps', args[3] if len(args) > 3 else None),
+            kwargs.get('lookahead', args[4] if len(args) > 4 else None),
+            kwargs.get('ignore_invalid_symbol', args[5] if len(args) > 5 else None),
+            kwargs.get('currency', args[6] if len(args) > 6 else None),
+        )
+
+    @staticmethod
+    def _walk_skip_funcs(node: ast.AST):
+        """Walk AST nodes, skipping nested function definitions."""
+        yield node
+        for child in ast.iter_child_nodes(node):
+            if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                continue
+            yield from SecurityTransformer._walk_skip_funcs(child)
+
+    @staticmethod
+    def _find_forbidden_strategy_state(expr: ast.expr) -> ast.Attribute | None:
+        """Return the first `lib.strategy.<state_attr>` Attribute node found in
+        ``expr``, or None if there is none.
+
+        Only direct attribute chains (`lib.strategy.position_size` form,
+        produced by ImportNormalizerTransformer for any of `strategy.x`,
+        `from pynecore.lib import strategy; strategy.x`, or
+        `from pynecore.lib.strategy import x`) are detected. Local aliases
+        (`ps = strategy.position_size; security(..., ps)`) are not —
+        catching those would need a def-use chain analyzer; instead the
+        runtime fallback in the strategy module returns inert defaults.
+        """
+        for sub in ast.walk(expr):
+            if not isinstance(sub, ast.Attribute):
+                continue
+            if sub.attr not in _FORBIDDEN_STRATEGY_STATE_ATTRS:
+                continue
+            parent = sub.value
+            if (isinstance(parent, ast.Attribute) and parent.attr == 'strategy'
+                    and isinstance(parent.value, ast.Name)
+                    and parent.value.id == 'lib'):
+                return sub
+        return None
+
+    @staticmethod
+    def _is_module_level_expr(node: ast.expr) -> bool:
+        """Check if an expression can be evaluated at module level.
+
+        Constants and lib.* attribute chains are safe. Function parameters
+        and other local variables are not.
+        """
+        if isinstance(node, ast.Constant):
+            return True
+        if isinstance(node, ast.Attribute):
+            return SecurityTransformer._is_module_level_expr(node.value)
+        if isinstance(node, ast.Name):
+            return node.id == 'lib'
+        if isinstance(node, ast.Call):
+            return SecurityTransformer._is_module_level_expr(node.func)
+        return False
+
+    @staticmethod
+    def _ohlcv_field(node: ast.expr) -> str | None:
+        """Return the raw-OHLCV field name if ``node`` is a bare reference to one
+        (``close`` or ``lib.close``), else None. Conservative: only a plain
+        Name/``lib.<attr>`` matches — any computation falls through to the full
+        ``main()`` path."""
+        if isinstance(node, ast.Name) and node.id in _OHLCV_PASSTHROUGH_FIELDS:
+            return node.id
+        if (isinstance(node, ast.Attribute) and node.attr in _OHLCV_PASSTHROUGH_FIELDS
+                and isinstance(node.value, ast.Name) and node.value.id == 'lib'):
+            return node.attr
+        return None
+
+    @classmethod
+    def _ohlcv_passthrough(cls, expression: ast.expr | None) -> tuple[list[str], bool] | None:
+        """Detect a plain-OHLCV ``request.security[_lower_tf]`` expression.
+
+        Returns ``(field_names, is_tuple)`` when every element is a raw price
+        series (so the security child can serve it without running ``main()``),
+        or ``None`` otherwise. ``is_tuple`` is True for a tuple/list expression
+        (column-major arrays) and False for a scalar.
+        """
+        if expression is None:
+            return None
+        if isinstance(expression, (ast.Tuple, ast.List)):
+            if not expression.elts:
+                return None
+            fields = [cls._ohlcv_field(e) for e in expression.elts]
+            if all(f is not None for f in fields):
+                return [f for f in fields if f is not None], True
+            return None
+        field = cls._ohlcv_field(expression)
+        if field is not None:
+            return [field], False
+        return None
+
+    # --- AST node builders ---
+
+    @staticmethod
+    def _lib_na() -> ast.Attribute:
+        """Build: lib.na"""
+        return ast.Attribute(
+            value=ast.Name(id='lib', ctx=ast.Load()),
+            attr='na', ctx=ast.Load()
+        )
+
+    @staticmethod
+    def _default_gaps() -> ast.Attribute:
+        """Build: lib.barmerge.gaps_off"""
+        return ast.Attribute(
+            value=ast.Attribute(
+                value=ast.Name(id='lib', ctx=ast.Load()),
+                attr='barmerge', ctx=ast.Load()
+            ),
+            attr='gaps_off', ctx=ast.Load()
+        )
+
+    @staticmethod
+    def _func_call(name: str, *args: ast.expr) -> ast.Call:
+        return ast.Call(
+            func=ast.Name(id=name, ctx=ast.Load()),
+            args=list(args), keywords=[]
+        )
+
+    @staticmethod
+    def _is_none_check() -> ast.Compare:
+        """Build: __active_security__ is None"""
+        return ast.Compare(
+            left=ast.Name(id='__active_security__', ctx=ast.Load()),
+            ops=[ast.Is()], comparators=[ast.Constant(value=None)]
+        )
+
+    @staticmethod
+    def _eq_check(sec_id: str) -> ast.Compare:
+        """Build: __active_security__ == sec_id"""
+        return ast.Compare(
+            left=ast.Name(id='__active_security__', ctx=ast.Load()),
+            ops=[ast.Eq()], comparators=[ast.Constant(value=sec_id)]
+        )
+
+    def _signal_block(self, sec_ids: list[str]) -> ast.If:
+        """Build chart-context signal block for function start.
+
+        Passes actual symbol and timeframe expressions to __sec_signal__
+        so that runtime values (e.g., function parameters) are available.
+
+        Only includes sec_ids whose symbol/timeframe are module-level
+        expressions (constants or lib.* refs). Runtime-dependent signals
+        are emitted inline before their write blocks by _transform_body.
+        """
+        body = []
+        for s in sec_ids:
+            args: list[ast.expr] = [ast.Constant(value=s)]
+            # Lookahead is omitted here: a runtime-dependent lookahead forces the
+            # sid onto the inline-signal path (see _process_func classification).
+            sym_expr, tf_expr, _ = self._signal_args[s]
+            args.append(copy.deepcopy(sym_expr) if sym_expr is not None
+                        else ast.Constant(value=None))
+            args.append(copy.deepcopy(tf_expr) if tf_expr is not None
+                        else ast.Constant(value=None))
+            body.append(ast.Expr(value=self._func_call('__sec_signal__', *args)))
+        return ast.If(
+            test=self._is_none_check(),
+            body=body,
+            orelse=[]
+        )
+
+    def _inline_signal(self, sec_id: str) -> ast.If:
+        """Build a single inline signal for runtime-dependent
+        symbol/timeframe/lookahead."""
+        args: list[ast.expr] = [ast.Constant(value=sec_id)]
+        sym_expr, tf_expr, la_expr = self._signal_args[sec_id]
+        args.append(copy.deepcopy(sym_expr) if sym_expr is not None
+                    else ast.Constant(value=None))
+        args.append(copy.deepcopy(tf_expr) if tf_expr is not None
+                    else ast.Constant(value=None))
+        if la_expr is not None:
+            args.append(copy.deepcopy(la_expr))
+        return ast.If(
+            test=self._is_none_check(),
+            body=[ast.Expr(value=self._func_call('__sec_signal__', *args))],
+            orelse=[]
+        )
+
+    def _wait_block(self, sec_ids: list[str]) -> ast.If:
+        """Build chart-context wait block for function end."""
+        return ast.If(
+            test=self._is_none_check(),
+            body=[
+                ast.Expr(value=self._func_call('__sec_wait__', ast.Constant(value=s)))
+                for s in sec_ids
+            ],
+            orelse=[]
+        )
+
+    @staticmethod
+    def _in_same_context(sec_id: str) -> ast.Compare:
+        """Build: sec_id in __same_context__"""
+        return ast.Compare(
+            left=ast.Constant(value=sec_id),
+            ops=[ast.In()],
+            comparators=[ast.Name(id='__same_context__', ctx=ast.Load())]
+        )
+
+    def _write_block(self, sec_id: str, expression: ast.expr) -> ast.If:
+        """Build security-context write block.
+
+        The condition fires in two cases:
+        1. This IS the security process for sec_id (__active_security__ == sec_id)
+        2. This is the chart process and sec_id is same-context (sec_id in __same_context__)
+        """
+        return ast.If(
+            test=ast.BoolOp(
+                op=ast.Or(),
+                values=[self._eq_check(sec_id), self._in_same_context(sec_id)]
+            ),
+            body=[
+                ast.Expr(value=self._func_call(
+                    '__sec_write__', ast.Constant(value=sec_id), expression
+                ))
+            ],
+            orelse=[]
+        )
+
+    def _sec_read_call(self, sec_id: str, tuple_len: int | None = None) -> ast.Call:
+        """Build: __sec_read__("sec_id", <default>)
+
+        Default is ``lib.na`` for scalar reads, or an N-tuple of ``lib.na``
+        when the LHS unpacks the result. Pine `request.security()` returns a
+        tuple of `na` (one per element) on no-data bars — emitting a single
+        scalar would crash tuple-unpack with ``TypeError: cannot unpack
+        non-iterable NA object`` in `gaps_on` between-period reads or after a
+        `write_na` (session gap).
+        """
+        if tuple_len is None:
+            default: ast.expr = self._lib_na()
+        else:
+            default = ast.Tuple(
+                elts=[self._lib_na() for _ in range(tuple_len)],
+                ctx=ast.Load()
+            )
+        return self._func_call(
+            '__sec_read__', ast.Constant(value=sec_id), default
+        )
+
+    def _sec_read_call_ltf(self, sec_id: str, arity: int | None = None) -> ast.Call:
+        """Build the LTF read expression.
+
+        Scalar expression: ``__sec_read__("sec_id", [])`` returns the array
+        directly. Tuple expression (``arity`` set): wrap in
+        ``__ltf_unzip__(__sec_read__("sec_id", []), arity)`` to transpose the
+        row-major intrabar buffer into ``arity`` column arrays.
+        """
+        read = self._func_call(
+            '__sec_read__', ast.Constant(value=sec_id), ast.List(elts=[], ctx=ast.Load())
+        )
+        if arity is None:
+            return read
+        return self._func_call('__ltf_unzip__', read, ast.Constant(value=arity))
+
+    @staticmethod
+    def _detect_tuple_arity(stmt: ast.stmt, call: ast.Call) -> int | None:
+        """If ``stmt`` is a tuple-unpack assignment whose RHS is exactly
+        ``call``, return the LHS arity. Otherwise None.
+
+        Pine statically enforces LHS-arity == RHS-arity for tuple-returning
+        ``request.security()`` (compile errors CE10239 / CE10172), so the
+        unpack target's arity is the authoritative source.
+
+        Skipped: star-unpack (``*rest``), multi-target (``a = b = sec(...)``),
+        annotated/augmented assigns, calls wrapped in a larger expression.
+        """
+        if not isinstance(stmt, ast.Assign):
+            return None
+        if len(stmt.targets) != 1:
+            return None
+        target = stmt.targets[0]
+        if not isinstance(target, (ast.Tuple, ast.List)):
+            return None
+        if any(isinstance(e, ast.Starred) for e in target.elts):
+            return None
+        if stmt.value is not call:
+            return None
+        return len(target.elts)
+
+    # --- Collection ---
+
+    def _collect_calls(
+            self, body: list[ast.stmt]
+    ) -> list[tuple[ast.Call, str, bool]]:
+        """
+        Find all request.security() and request.security_lower_tf() calls in
+        function body, skipping nested functions. Marks each call node with
+        _sec_id attribute.
+
+        :return: List of (call_node, sec_id, is_ltf) tuples
+        """
+        calls = []
+        for stmt in body:
+            if isinstance(stmt, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                continue
+            for node in self._walk_skip_funcs(stmt):
+                if isinstance(node, ast.Call):
+                    if self._is_security_call(node):
+                        sec_id = self._gen_id()
+                        node._sec_id = sec_id  # type: ignore[attr-defined]
+                        calls.append((node, sec_id, False))
+                    elif self._is_security_lower_tf_call(node):
+                        sec_id = self._gen_id()
+                        node._sec_id = sec_id  # type: ignore[attr-defined]
+                        self._ltf_sec_ids.add(sec_id)
+                        calls.append((node, sec_id, True))
+        return calls
+
+    # --- Body transformation ---
+
+    def _transform_body(
+            self, body: list[ast.stmt], call_exprs: dict[str, ast.expr],
+            runtime_sec_ids: set[str]
+    ) -> list[ast.stmt]:
+        """
+        Recursively transform a body list: insert write blocks before statements
+        containing security calls, and replace calls with __sec_read__.
+
+        For runtime-dependent sec_ids (those in ``runtime_sec_ids``), also
+        emits an inline signal just before the write block, so the signal
+        runs after the symbol/timeframe variables are defined.
+
+        Algorithm:
+        1. For each statement, first recurse into compound sub-bodies
+           (this replaces calls there and removes their _sec_id markers)
+        2. Then walk the full statement — only expression-level calls remain
+        3. Insert inline signals (if runtime) + write blocks, replace calls
+        """
+        new_body: list[ast.stmt] = []
+        replacer = _CallReplacer(self)
+
+        for stmt in body:
+            if isinstance(stmt, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                new_body.append(stmt)
+                continue
+
+            self._recurse_subbodies(stmt, call_exprs, runtime_sec_ids)
+
+            call_nodes_here = [
+                n for n in self._walk_skip_funcs(stmt)
+                if isinstance(n, ast.Call) and hasattr(n, '_sec_id')
+            ]
+
+            if call_nodes_here:
+                for call_node in call_nodes_here:
+                    arity = self._detect_tuple_arity(stmt, call_node)
+                    if arity is not None:
+                        call_node._tuple_len = arity  # type: ignore[attr-defined]
+                        # LTF call with an opaque tuple expression (a function
+                        # call, not a literal): the expression's own arity is
+                        # unknowable here, but Pine enforces LHS-arity ==
+                        # RHS-arity, so the unpack target is just as
+                        # authoritative — wire the __ltf_unzip__ wrap from it.
+                        if (getattr(call_node, '_sec_id') in self._ltf_sec_ids
+                                and not hasattr(call_node, '_ltf_arity')):
+                            call_node._ltf_arity = arity  # type: ignore[attr-defined]
+                            self._needs_ltf_unzip = True
+
+                for call_node in call_nodes_here:
+                    sid = getattr(call_node, '_sec_id')
+                    if sid in runtime_sec_ids:
+                        new_body.append(self._inline_signal(sid))
+                    expr = copy.deepcopy(call_exprs[sid])
+                    expr = replacer.visit(expr)
+                    new_body.append(self._write_block(sid, expr))
+                new_body.append(replacer.visit(stmt))
+            else:
+                new_body.append(stmt)
+
+        return new_body
+
+    def _recurse_subbodies(
+            self, stmt: ast.stmt, call_exprs: dict[str, ast.expr],
+            runtime_sec_ids: set[str]
+    ):
+        """Recurse into sub-bodies of compound statements."""
+        if isinstance(stmt, ast.If):
+            stmt.body = self._transform_body(stmt.body, call_exprs, runtime_sec_ids)
+            stmt.orelse = self._transform_body(stmt.orelse, call_exprs, runtime_sec_ids)
+        elif isinstance(stmt, (ast.For, ast.AsyncFor, ast.While)):
+            stmt.body = self._transform_body(stmt.body, call_exprs, runtime_sec_ids)
+            stmt.orelse = self._transform_body(stmt.orelse, call_exprs, runtime_sec_ids)
+        elif isinstance(stmt, (ast.With, ast.AsyncWith)):
+            stmt.body = self._transform_body(stmt.body, call_exprs, runtime_sec_ids)
+        elif isinstance(stmt, ast.Try):
+            stmt.body = self._transform_body(stmt.body, call_exprs, runtime_sec_ids)
+            for handler in stmt.handlers:
+                handler.body = self._transform_body(handler.body, call_exprs, runtime_sec_ids)
+            stmt.orelse = self._transform_body(stmt.orelse, call_exprs, runtime_sec_ids)
+            stmt.finalbody = self._transform_body(stmt.finalbody, call_exprs, runtime_sec_ids)
+        elif hasattr(ast, 'TryStar') and isinstance(stmt, ast.TryStar):
+            stmt.body = self._transform_body(stmt.body, call_exprs, runtime_sec_ids)
+            for handler in stmt.handlers:
+                handler.body = self._transform_body(handler.body, call_exprs, runtime_sec_ids)
+            stmt.orelse = self._transform_body(stmt.orelse, call_exprs, runtime_sec_ids)
+            stmt.finalbody = self._transform_body(stmt.finalbody, call_exprs, runtime_sec_ids)
+        elif hasattr(ast, 'Match') and isinstance(stmt, ast.Match):
+            for case in stmt.cases:
+                case.body = self._transform_body(case.body, call_exprs, runtime_sec_ids)
+
+    # --- Function & module visitors ---
+
+    def _process_func(self, node: ast.FunctionDef | ast.AsyncFunctionDef):
+        """Transform a function containing request.security() / security_lower_tf() calls."""
+        calls = self._collect_calls(node.body)
+
+        if not calls:
+            return self.generic_visit(node)
+
+        call_exprs: dict[str, ast.expr] = {}
+        sec_ids: list[str] = []
+
+        for call, sec_id, is_ltf in calls:
+            currency = None
+            lookahead = None
+            if is_ltf:
+                symbol, timeframe, expression, ignore_invalid = (
+                    self._extract_ltf_args(call)
+                )
+                gaps = None
+                # A tuple/list expression makes security_lower_tf() return one
+                # array per element (column-major). The arity is authoritative
+                # from the expression itself, independent of how the result is
+                # unpacked. Mark the call so the read is wrapped in __ltf_unzip__.
+                if isinstance(expression, (ast.Tuple, ast.List)):
+                    call._ltf_arity = len(expression.elts)  # type: ignore[attr-defined]
+                    self._needs_ltf_unzip = True
+            else:
+                symbol, timeframe, expression, gaps, lookahead, ignore_invalid, currency = (
+                    self._extract_args(call)
+                )
+
+            if expression is not None:
+                bad = self._find_forbidden_strategy_state(expression)
+                if bad is not None:
+                    fn_name = 'request.security_lower_tf' if is_ltf else 'request.security'
+                    raise SyntaxError(
+                        f"'strategy.{bad.attr}' cannot be used as the expression "
+                        f"argument of {fn_name}() — strategy state is only "
+                        f"available in the chart context, not in a security "
+                        f"context.",
+                        (self._module_file, getattr(bad, 'lineno', 0),
+                         getattr(bad, 'col_offset', 0) + 1, None)
+                    )
+
+            call_exprs[sec_id] = expression if expression is not None else self._lib_na()
+
+            # Input-derived (Pine "simple") lookahead — e.g. the standard TV
+            # non-repaint HTF pattern ``repaint ? lookahead_off : lookahead_on``
+            # — cannot be evaluated at module level, so it is resolved at
+            # runtime through __sec_signal__ like a deferred symbol/timeframe.
+            lookahead_rt: ast.expr | None = None
+            if lookahead is not None and not self._is_module_level_expr(lookahead):
+                lookahead_rt = copy.deepcopy(lookahead)
+
+            # Store actual expressions for __sec_signal__ args (always passed at runtime)
+            self._signal_args[sec_id] = (
+                copy.deepcopy(symbol) if symbol is not None else None,
+                copy.deepcopy(timeframe) if timeframe is not None else None,
+                lookahead_rt,
+            )
+
+            # For __security_contexts__ at module level: only use values that are
+            # evaluable at module scope. Function parameters etc. become None.
+            ctx: dict[str, ast.expr] = {}
+            if symbol is not None:
+                if self._is_module_level_expr(symbol):
+                    ctx['symbol'] = copy.deepcopy(symbol)
+                else:
+                    ctx['symbol'] = ast.Constant(value=None)
+            if timeframe is not None:
+                if self._is_module_level_expr(timeframe):
+                    ctx['timeframe'] = copy.deepcopy(timeframe)
+                else:
+                    ctx['timeframe'] = ast.Constant(value=None)
+
+            if is_ltf:
+                ctx['is_ltf'] = ast.Constant(value=True)
+            else:
+                gaps_expr = (
+                    copy.deepcopy(gaps) if gaps is not None else self._default_gaps()
+                )
+                ctx['gaps'] = gaps_expr
+                if lookahead is not None:
+                    # A module-level lookahead (``barmerge.lookahead_*``) is
+                    # consumed at module load to wire the HTF transport. An
+                    # input-derived expression would NameError at import time,
+                    # so store None as a placeholder — the runtime value passed
+                    # to ``__sec_signal__`` resolves the mode on the first bar.
+                    ctx['lookahead'] = (copy.deepcopy(lookahead) if lookahead_rt is None
+                                        else ast.Constant(value=None))
+
+            if ignore_invalid is not None:
+                ctx['ignore_invalid_symbol'] = copy.deepcopy(ignore_invalid)
+
+            if not is_ltf and currency is not None:
+                ctx['currency'] = copy.deepcopy(currency)
+
+            # Plain-OHLCV fast path: when the expression is only raw price
+            # series, the security child can serve it straight from each bar
+            # without running main() (see security_process.security_process_main).
+            passthrough = self._ohlcv_passthrough(expression)
+            if passthrough is not None:
+                fields, is_tuple = passthrough
+                ctx['ohlcv_fields'] = ast.List(
+                    elts=[ast.Constant(value=f) for f in fields], ctx=ast.Load()
+                )
+                ctx['ohlcv_tuple'] = ast.Constant(value=is_tuple)
+
+            # Track if barmerge is used (only for non-LTF)
+            if not is_ltf:
+                if gaps is None:
+                    self._needs_barmerge = True
+                elif isinstance(gaps, ast.Attribute) and hasattr(gaps, 'value'):
+                    v = gaps.value
+                    if isinstance(v, ast.Attribute) and v.attr == 'barmerge':
+                        self._needs_barmerge = True
+                if (lookahead is not None
+                        and isinstance(lookahead, ast.Attribute)
+                        and hasattr(lookahead, 'value')):
+                    v = lookahead.value
+                    if isinstance(v, ast.Attribute) and v.attr == 'barmerge':
+                        self._needs_barmerge = True
+
+            self._all_contexts[sec_id] = ctx
+            sec_ids.append(sec_id)
+
+        # Separate module-level (constant) signals from runtime-dependent ones.
+        # Module-level signals can be emitted at function start for maximum
+        # parallelism. Runtime signals must be emitted inline, after the
+        # variables they reference have been assigned. A runtime-dependent
+        # lookahead forces the inline path too — its expression references
+        # locals that do not exist yet at function start.
+        top_sec_ids = []
+        runtime_sec_ids: set[str] = set()
+        for sid in sec_ids:
+            sym_expr, tf_expr, la_expr = self._signal_args[sid]
+            sym_ok = sym_expr is None or self._is_module_level_expr(sym_expr)
+            tf_ok = tf_expr is None or self._is_module_level_expr(tf_expr)
+            if sym_ok and tf_ok and la_expr is None:
+                top_sec_ids.append(sid)
+            else:
+                runtime_sec_ids.add(sid)
+
+        original_body = node.body
+        top_block = [self._signal_block(top_sec_ids)] if top_sec_ids else []
+        node.body = (
+                top_block
+                + self._transform_body(original_body, call_exprs, runtime_sec_ids)
+                + [self._wait_block(sec_ids)]
+        )
+
+        return self.generic_visit(node)
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.FunctionDef:
+        return self._process_func(node)  # type: ignore[return-value]
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> ast.AsyncFunctionDef:
+        return self._process_func(node)  # type: ignore[return-value]
+
+    def visit_Module(self, node: ast.Module) -> ast.Module:
+        self._module_file = getattr(node, '_module_file_path', '<script>')
+        node = self.generic_visit(node)  # type: ignore[assignment]
+
+        if self._all_contexts:
+            # Add barmerge import if needed (SecurityTransformer runs AFTER ImportNormalizer,
+            # so we must add it ourselves)
+            if self._needs_barmerge:
+                node.body.insert(0, ast.Import(
+                    names=[ast.alias(name='pynecore.lib.barmerge', asname=None)]
+                ))
+
+            # __ltf_unzip__ transposes tuple-valued security_lower_tf() results.
+            if self._needs_ltf_unzip:
+                node.body.insert(0, ast.ImportFrom(
+                    module='pynecore.core.security',
+                    names=[ast.alias(name='__ltf_unzip__', asname=None)],
+                    level=0,
+                ))
+
+            node.body.append(ast.Assign(
+                targets=[ast.Name(id='__security_contexts__', ctx=ast.Store())],
+                value=ast.Dict(
+                    keys=[ast.Constant(value=sid) for sid in self._all_contexts],
+                    values=[
+                        ast.Dict(
+                            keys=[ast.Constant(value=k) for k in ctx],
+                            values=list(ctx.values())
+                        )
+                        for ctx in self._all_contexts.values()
+                    ]
+                )
+            ))
+
+        return node
+
+
+class _CallReplacer(ast.NodeTransformer):
+    """Replace marked request.security() call nodes with __sec_read__() calls."""
+
+    def __init__(self, parent: SecurityTransformer):
+        self._parent = parent
+
+    # noinspection PyProtectedMember
+    def visit_Call(self, node: ast.Call) -> ast.AST:
+        node = self.generic_visit(node)  # type: ignore[assignment]
+        if hasattr(node, '_sec_id'):
+            sec_id = getattr(node, '_sec_id')
+            if sec_id in self._parent._ltf_sec_ids:
+                ltf_arity = getattr(node, '_ltf_arity', None)
+                return self._parent._sec_read_call_ltf(sec_id, ltf_arity)
+            tuple_len = getattr(node, '_tuple_len', None)
+            return self._parent._sec_read_call(sec_id, tuple_len)
+        return node