opencode-pyneruntime 6.6.4__py3-none-any.whl

pynecore/transformers/input_transformer.py

@@ -0,0 +1,175 @@
+from typing import cast
+import ast
+
+
+class InputTransformer(ast.NodeTransformer):
+    """
+    Transform input function calls:
+    1. Add _id parameter to input calls
+    2. Add getattr for source inputs at the start of functions
+    3. Add required imports (lib, na) if not present
+    Must be applied after SeriesTransformer.
+    """
+
+    def __init__(self):
+        self.function_source_vars = {}  # function_name -> {var_name -> source_str}
+        self.current_function = None
+        self.has_source_inputs = False
+        self.imported_names: set[str] = set()  # Track what's already imported
+
+    @staticmethod
+    def _is_input_call(node: ast.Call) -> bool:
+        """Check if node is lib.input(), lib.input.xxx(), or imported input() call"""
+        # Handle lib.input(...) pattern
+        if isinstance(node.func, ast.Attribute) and node.func.attr == 'input':
+            return isinstance(node.func.value, ast.Name) and node.func.value.id == 'lib'
+
+        # Handle lib.input.xxx(...) pattern
+        if isinstance(node.func, ast.Attribute) and isinstance(node.func.value, ast.Attribute):
+            return (isinstance(node.func.value.value, ast.Name) and
+                    node.func.value.value.id == 'lib' and
+                    node.func.value.attr == 'input')
+
+        # Handle imported input(...) call
+        if isinstance(node.func, ast.Name) and node.func.id == 'input':
+            return True
+
+        # Handle imported input.xxx(...) call
+        if isinstance(node.func, ast.Attribute) and isinstance(node.func.value, ast.Name):
+            return node.func.value.id == 'input'
+
+        return False
+
+    def visit_arguments(self, node: ast.arguments) -> ast.arguments:
+        """Add _id to input calls in function arguments and collect source vars"""
+        if self.current_function is None:
+            return node
+
+        # Loop through arguments and defaults together
+        for arg, default in zip(node.args[-len(node.defaults):], node.defaults):
+            if default and isinstance(default, ast.Call):
+                if self._is_input_call(default):
+                    # Add id keyword argument with argument name
+                    default.keywords.append(
+                        ast.keyword(
+                            arg='_id',
+                            value=ast.Constant(value=arg.arg)
+                        )
+                    )
+
+                    # Check if it's a source input
+                    is_source_call = False
+                    is_input_call = False
+
+                    if isinstance(default.func, ast.Attribute) and default.func.attr == 'source':
+                        # This is lib.input.source or input.source call
+                        is_source_call = True
+                    elif isinstance(default.func, ast.Attribute) and default.func.attr == 'input':
+                        # This is lib.input call
+                        is_input_call = True
+                    elif isinstance(default.func, ast.Name) and default.func.id == 'input':
+                        # This is imported input() call - check if defval is a source
+                        is_input_call = True
+
+                    # Find the defval parameter value (either positional or keyword)
+                    defval_node = None
+                    if default.args:
+                        defval_node = default.args[0]
+                    else:
+                        # Look for defval keyword argument
+                        for kw in default.keywords:
+                            if kw.arg == 'defval':
+                                defval_node = kw.value
+                                break
+
+                    # Only proceed if it's a source call or input call with a defval
+                    if (is_source_call or is_input_call) and defval_node:
+                        source_name = None
+
+                        if isinstance(defval_node, ast.Constant) and is_source_call:
+                            # Handle string constant in lib.input.source
+                            source_name = defval_node.value
+                        elif isinstance(defval_node, ast.Attribute):
+                            # Handle attribute reference (e.g., lib.close or close)
+                            attr = defval_node
+                            if isinstance(attr.value, ast.Name) and attr.value.id == 'lib':
+                                # For lib.xxx pattern, store the attribute name
+                                source_name = attr.attr
+                        elif isinstance(defval_node, ast.Name):
+                            # Handle direct name reference (e.g., close)
+                            source_name = defval_node.id
+
+                        if source_name:
+                            if self.current_function not in self.function_source_vars:
+                                self.function_source_vars[self.current_function] = {}
+                            self.function_source_vars[self.current_function][arg.arg] = source_name
+                            self.has_source_inputs = True
+
+        return node
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.FunctionDef:
+        """Insert getattr calls at the start of functions for source inputs"""
+        # Save previous function name
+        previous_function = self.current_function
+        self.current_function = node.name
+
+        # Process function arguments and body
+        node = cast(ast.FunctionDef, self.generic_visit(node))
+
+        # Add getattr for each source input in this function
+        source_vars = self.function_source_vars.get(self.current_function, {})
+        for var_name, source_str in source_vars.items():
+            # Create: var_name = __pyne_getattr__(lib, var_name, lib.na)
+            # A reserved module-level alias of the builtin is used instead of a
+            # bare ``getattr``: a script variable named ``getattr`` would shadow
+            # the builtin in the function scope and break this resolution (same
+            # class of bug as a ``len`` input shadowing the loop-guard length).
+            assign = ast.Assign(
+                targets=[ast.Name(id=var_name, ctx=ast.Store())],
+                value=ast.Call(
+                    func=ast.Name(id='__pyne_getattr__', ctx=ast.Load()),
+                    args=[
+                        ast.Name(id='lib', ctx=ast.Load()),
+                        ast.Name(id=var_name, ctx=ast.Load()),
+                        ast.Attribute(
+                            value=ast.Name(id='lib', ctx=ast.Load()),
+                            attr='na',
+                            ctx=ast.Load()
+                        )
+                    ],
+                    keywords=[]
+                )
+            )
+            node.body.insert(0, assign)
+
+        # Restore previous function name
+        self.current_function = previous_function
+        return node
+
+    def visit_Module(self, node: ast.Module) -> ast.Module:
+        """Add required imports if not present"""
+        # Process the module first to collect existing imports
+        node = cast(ast.Module, self.generic_visit(node))
+
+        if not self.has_source_inputs:
+            return node
+
+        # Source-input resolution emits ``__pyne_getattr__(lib, name, lib.na)``;
+        # bind that reserved alias to the builtin at module scope so a
+        # function-local ``getattr`` variable cannot shadow it.
+        alias_import = ast.ImportFrom(
+            module='builtins',
+            names=[ast.alias(name='getattr', asname='__pyne_getattr__')],
+            level=0)
+        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  # keep the module docstring first
+        while (insert_pos < len(node.body)
+               and isinstance(node.body[insert_pos], ast.ImportFrom)
+               and getattr(node.body[insert_pos], 'module', None) == '__future__'):
+            insert_pos += 1  # stay after any ``from __future__`` imports
+        node.body.insert(insert_pos, alias_import)
+
+        return node

pynecore/transformers/lib_series.py

@@ -0,0 +1,201 @@
+import ast
+from typing import cast
+
+# Builtin price series that are always global (declared in main, not nested functions)
+BUILTIN_PRICE_SERIES = frozenset({
+    'open', 'high', 'low', 'close', 'volume',
+    'bid', 'ask',
+    'hl2', 'hlc3', 'ohlc4', 'hlcc4'
+})
+
+# Lib attributes that are NOT Series — subscript access on these should not be transformed
+NON_SERIES_LIB_ATTRS = frozenset({
+    'extra_fields',
+})
+
+
+class LibrarySeriesTransformer(ast.NodeTransformer):
+    """
+    AST transformer that prepares library Series variables for the SeriesTransformer.
+    When a library variable is used with indexing, it creates a local Series variable
+    declaration that SeriesTransformer can then process.
+    """
+
+    def __init__(self):
+        self.lib_series_vars: dict[
+            str, dict[str, tuple[str, ast.AST | None]]] = {}  # module -> {attr -> (local_name, type_annotation)}
+        self.used_series: set[tuple[str, str, str]] = set()  # (module, attr, function) tuples that are used as Series
+        self.declarations_to_insert: dict[str, list[ast.AnnAssign]] = {}  # function_name -> declarations
+        self.current_function: str | None = None
+        self.parent_functions: list[str] = []  # Stack of parent function names for nested function tracking
+        self.module_level_declarations: list[ast.AnnAssign] = []  # Declarations for module level (main function)
+
+    @staticmethod
+    def _make_series_name(attr: str) -> str:
+        """Generate unique name for the local Series variable"""
+        # Use unicode middle dot to avoid name collisions between module hierarchies
+        # Example: mylib.bar vs mylib_bar would both become __lib·mylib·bar vs __lib·mylib_bar
+        attr = attr.replace('.', '·')
+        return f'__lib·{attr}'
+
+    @staticmethod
+    def _create_attribute_chain(chain: list[str]) -> ast.expr:
+        """Create an attribute chain from a list of names"""
+        result: ast.expr = cast(ast.expr, ast.Name(id=chain[0], ctx=ast.Load()))
+        for name in chain[1:]:
+            result = cast(ast.expr, ast.Attribute(
+                value=result,
+                attr=name,
+                ctx=ast.Load()
+            ))
+        return result
+
+    def visit_Module(self, node: ast.Module) -> ast.Module:
+        """Process module and insert Series declarations"""
+        # Process the module first (collect all declarations)
+        node = cast(ast.Module, self.generic_visit(node))
+
+        # Insert function-level declarations into their target functions
+        self._insert_function_declarations(node)
+
+        # Insert module-level declarations at the beginning of the module
+        if self.module_level_declarations:
+            # Find the position after imports and before the main function
+            insert_pos = 0
+            for i, stmt in enumerate(node.body):
+                # Skip imports, from imports, and __all__ assignments
+                if isinstance(stmt, (ast.Import, ast.ImportFrom)):
+                    insert_pos = i + 1
+                elif (isinstance(stmt, ast.Assign) and
+                      len(stmt.targets) == 1 and
+                      isinstance(stmt.targets[0], ast.Name) and
+                      cast(ast.Name, stmt.targets[0]).id == '__all__'):
+                    insert_pos = i + 1
+                else:
+                    break
+
+            # Insert the declarations
+            node.body[insert_pos:insert_pos] = self.module_level_declarations
+
+        return node
+
+    def _insert_function_declarations(self, node: ast.Module) -> None:
+        """Insert collected declarations into their target functions."""
+        for stmt in ast.walk(node):
+            if isinstance(stmt, ast.FunctionDef) and stmt.name in self.declarations_to_insert:
+                decls = self.declarations_to_insert[stmt.name]
+                stmt.body = decls + stmt.body
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.FunctionDef:
+        """Track current function with parent tracking for nested functions"""
+        old_function = self.current_function
+
+        # Track parent functions for nested function detection
+        if self.current_function:
+            self.parent_functions.append(self.current_function)
+        self.current_function = node.name
+
+        # Process function body (declarations are inserted later in visit_Module)
+        new_node = cast(ast.FunctionDef, self.generic_visit(node))
+
+        self.current_function = old_function
+        if self.parent_functions:
+            self.parent_functions.pop()
+
+        return new_node
+
+    def process_series_usage(self, module: str, attr_chain: list[str], type_annotation: ast.AST | None = None) -> str:
+        """
+        Process a Series usage from a library, creating declaration if needed.
+        Returns the local variable name to use.
+
+        For builtin price series (close, open, high, low, volume, hl2, hlc3, ohlc4, hlcc4),
+        declarations are always placed in the main function, not nested functions.
+        This matches TradingView behavior where these series are global.
+        """
+        if module not in self.lib_series_vars:
+            self.lib_series_vars[module] = {}
+
+        # Determine if this is a builtin price series (single attribute like 'close', 'open', etc.)
+        is_builtin_price = len(attr_chain) == 1 and attr_chain[0] in BUILTIN_PRICE_SERIES
+
+        # For builtin price series in nested functions, use the top-level parent (main)
+        if is_builtin_price and self.parent_functions:
+            target_function = self.parent_functions[0]  # First parent is 'main'
+            function_key = target_function
+        else:
+            target_function = self.current_function
+            function_key = self.current_function or "__module__"
+
+        # Create unicode middle dot version for the variable name to avoid collisions
+        attr_key = '·'.join(attr_chain)
+        if attr_key not in self.lib_series_vars[module]:
+            local_name = self._make_series_name(attr_key)
+            self.lib_series_vars[module][attr_key] = (local_name, type_annotation)
+
+        local_name = self.lib_series_vars[module][attr_key][0]
+
+        # If this Series hasn't been used in target function or module level yet
+        if (module, attr_key, function_key) not in self.used_series:
+            self.used_series.add((module, attr_key, function_key))
+
+            # Create Series declaration with proper attribute chain. Builtin
+            # price series are float — a Series[float] annotation makes the
+            # SeriesTransformer carry the element type into the slot layout,
+            # so their buffers return the native nan for out-of-range reads.
+            if type_annotation is None:
+                if is_builtin_price:
+                    annotation: ast.expr = ast.Subscript(
+                        value=ast.Name(id='Series', ctx=ast.Load()),
+                        slice=ast.Name(id='float', ctx=ast.Load()),
+                        ctx=ast.Load())
+                else:
+                    annotation = ast.Name(id='Series', ctx=ast.Load())
+            else:
+                annotation = cast(ast.expr, type_annotation)
+            decl = ast.AnnAssign(
+                target=ast.Name(id=local_name, ctx=ast.Store()),
+                annotation=annotation,
+                value=self._create_attribute_chain([module] + attr_chain),
+                simple=1
+            )
+
+            # Store declaration to be inserted
+            if target_function:
+                # Inside a function
+                if target_function not in self.declarations_to_insert:
+                    self.declarations_to_insert[target_function] = []
+                self.declarations_to_insert[target_function].append(decl)
+            else:
+                # At module level (main function)
+                self.module_level_declarations.append(decl)
+
+        return local_name
+
+    def visit_Subscript(self, node: ast.Subscript) -> ast.AST:
+        """Convert library Series access when used with indexing"""
+
+        # Get the full attribute chain
+        def get_attribute_chain(_node):
+            if isinstance(_node, ast.Name):
+                return [_node.id]
+            elif isinstance(_node, ast.Attribute):
+                return get_attribute_chain(_node.value) + [_node.attr]
+            return []
+
+        if isinstance(node.value, ast.Attribute):
+            attr_chain = get_attribute_chain(node.value)
+            if attr_chain and attr_chain[0] == 'lib':
+                # Skip non-Series lib attributes (e.g., extra_fields is a dict, not a Series)
+                if len(attr_chain) >= 2 and attr_chain[1] in NON_SERIES_LIB_ATTRS:
+                    return self.generic_visit(node)
+
+                # Use the complete chain after 'lib'. The declaration of a
+                # builtin price series is anchored in the outermost function
+                # (see process_series_usage); a nested reference resolves to
+                # that scope's series slot through the SeriesTransformer's
+                # scope-chain lookup, so the local name is always enough here.
+                local_name = self.process_series_usage('lib', attr_chain[1:])
+                node.value = cast(ast.expr, ast.Name(id=local_name, ctx=ast.Load()))
+
+        return self.generic_visit(node)

pynecore/transformers/locations.py

@@ -0,0 +1,70 @@
+"""Debugger-safe source-location filling for transformer-built AST nodes.
+
+``ast.fix_missing_locations`` copies the PARENT's full span onto every
+location-less node. For a transformer-inserted statement in a function body
+the nearest located parent is the ``FunctionDef`` itself, so the statement
+inherits the function's whole range (``def`` line .. last body line) — and
+CPython derives the bytecode position of attribute/subscript operations from
+a span's END, mapping parts of the emitted prologue onto the function's LAST
+source line. A breakpoint on that line then fires on every function entry,
+mid-prologue, with the body locals still unassigned.
+
+:func:`fix_locations` fills the same holes with single POINT anchors instead:
+
+- a located node is never touched (a missing end position is completed from
+  the node's own start, never from the parent's);
+- a location-less statement anchors to the earliest source location surviving
+  inside it (hoisted expressions keep their original lines), falling back to
+  the innermost located ancestor's start — function entry for the prologue;
+- every other synthetic node anchors to its enclosing statement's point.
+
+Points, not spans: a synthetic node stamped with a multi-line span would put
+its attribute-op line events on the span's end line, re-creating the bug.
+"""
+import ast
+
+__all__ = ('fix_locations',)
+
+
+def _located(node: ast.AST) -> bool:
+    return getattr(node, 'lineno', None) is not None
+
+
+def _stamp_point(node: ast.AST, line: int, col: int) -> None:
+    node.lineno = node.end_lineno = line  # type: ignore[attr-defined]
+    node.col_offset = node.end_col_offset = col  # type: ignore[attr-defined]
+
+
+def fix_locations(tree: ast.AST, line: int = 1, col: int = 0) -> ast.AST:
+    """Fill missing locations in ``tree`` without leaking parent spans.
+
+    Drop-in replacement for :func:`ast.fix_missing_locations` on transformed
+    Pyne modules (see module docstring for why the stock helper is unsafe).
+
+    :param tree: Tree to fix in place.
+    :param line: Anchor line for top-level location-less nodes.
+    :param col: Anchor column for top-level location-less nodes.
+    :return: The same tree.
+    """
+    _fix(tree, line, col)
+    return tree
+
+
+def _fix(node: ast.AST, line: int, col: int) -> None:
+    if 'lineno' in node._attributes:
+        if _located(node):
+            line, col = node.lineno, node.col_offset  # type: ignore[attr-defined]
+            if getattr(node, 'end_lineno', None) is None:
+                node.end_lineno = line  # type: ignore[attr-defined]
+            if getattr(node, 'end_col_offset', None) is None:
+                node.end_col_offset = col  # type: ignore[attr-defined]
+        else:
+            if isinstance(node, ast.stmt):
+                # Hoisted payloads keep their source lines — anchor the new
+                # statement next to them rather than at the function entry
+                inner = [getattr(n, 'lineno') for n in ast.walk(node) if _located(n)]
+                if inner:
+                    line, col = min(inner), 0
+            _stamp_point(node, line, col)
+    for child in ast.iter_child_nodes(node):
+        _fix(child, line, col)