opencode-pyneruntime 6.6.4__py3-none-any.whl

pynecore/transformers/import_lifter.py

@@ -0,0 +1,61 @@
+from typing import List, cast
+import ast
+
+
+class ImportLifterTransformer(ast.NodeTransformer):
+    """
+    AST transformer that lifts all pynecore.lib related imports to module level.
+    Does not transform the imports, just moves them to global scope.
+    """
+
+    def __init__(self):
+        self.lifted_imports: List[ast.ImportFrom] = []
+
+    @staticmethod
+    def _is_lib_import(node: ast.ImportFrom) -> bool:
+        """Check if an import is lib-related"""
+        return bool(node.module and
+                    (node.module == 'pynecore.lib' or
+                     node.module.startswith('pynecore.lib.')))
+
+    def visit_Module(self, node: ast.Module) -> ast.Module:
+        """Process module and add lifted imports at the top"""
+        # Process the entire module first to collect all imports
+        node = cast(ast.Module, self.generic_visit(node))
+
+        # No imports were lifted, return original
+        if not self.lifted_imports:
+            return node
+
+        # Insert lifted imports after docstring if exists
+        insert_pos = 1 if (node.body and isinstance(node.body[0], ast.Expr) and
+                           isinstance(cast(ast.Expr, node.body[0]).value, ast.Constant)) else 0
+
+        node.body[insert_pos:insert_pos] = self.lifted_imports
+        return node
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.FunctionDef:
+        """Process function definitions and lift lib imports"""
+        # Process function body first
+        node = cast(ast.FunctionDef, self.generic_visit(node))
+
+        # Collect lib imports and remove them from function body
+        new_body = []
+        for stmt in node.body:
+            if isinstance(stmt, ast.ImportFrom) and self._is_lib_import(stmt):
+                # Add to lifted imports if not already there
+                if not any(self._imports_equal(stmt, lifted) for lifted in self.lifted_imports):
+                    self.lifted_imports.append(stmt)
+            else:
+                new_body.append(stmt)
+
+        node.body = new_body
+        return node
+
+    @staticmethod
+    def _imports_equal(import1: ast.ImportFrom, import2: ast.ImportFrom) -> bool:
+        """Compare two import statements for equality"""
+        return (import1.module == import2.module and
+                len(import1.names) == len(import2.names) and
+                all(n1.name == n2.name and n1.asname == n2.asname
+                    for n1, n2 in zip(import1.names, import2.names)))

pynecore/transformers/import_normalizer.py

@@ -0,0 +1,328 @@
+import ast
+from typing import Dict, Set, List, Optional, cast
+
+NON_MODULE_ATTRS = {
+    'input',  # class
+    'script',  # class
+}
+
+
+class ImportNormalizerTransformer(ast.NodeTransformer):
+    """
+    AST transformer that normalizes pynecore.lib imports.
+    - Converts all lib-related imports to 'from pynecore import lib'
+    - Transforms all references to use fully qualified names (lib.xxx.yyy)
+    - Moves function-level imports to module level
+    - Supports wildcard imports by using module's __all__
+    """
+
+    def __init__(self):
+        # Track import mappings: imported_name -> full_path
+        self.import_map: Dict[str, List[str]] = {}
+        # Track which names to replace with lib.xxx
+        self.names_to_replace: Set[str] = set()
+        # Track if we need to add 'from pynecore import lib'
+        self.needs_lib_import = False
+        # Track function level imports to move up
+        self.function_imports: List[ast.ImportFrom] = []
+        # Current function being processed
+        self.current_function: Optional[str] = None
+        # Track direct module imports: alias -> module_path
+        self.module_imports: Dict[str, str] = {}
+        # Track wildcard imports: module_path -> set of exposed names
+        self.wildcard_imports: Dict[str, Set[str]] = {}
+        # Track required submodules
+        self.required_submodules: Set[str] = set()
+        # Track function parameters to avoid replacing them
+        self.function_parameters: Set[str] = set()
+
+    @staticmethod
+    def _is_lib_import(node: ast.ImportFrom) -> bool:
+        """Check if an import is lib-related"""
+        return bool(node.module and (node.module == 'pynecore.lib' or
+                                     node.module.startswith('pynecore.lib.')))
+
+    @staticmethod
+    def _is_lib_module_import(node: ast.Import) -> bool:
+        """Check if it's a direct pynecore.lib module import"""
+        for alias in node.names:
+            if alias.name == 'pynecore.lib' or alias.name.startswith('pynecore.lib.'):
+                return True
+        return False
+
+    @staticmethod
+    def _get_full_path(module: str, name: str) -> List[str]:
+        """Convert module path to list of components"""
+        if module == 'pynecore.lib':
+            return ['lib', name]
+        # Handle submodules: pynecore.lib.xxx -> ['lib', 'xxx', name]
+        parts = module.split('.')
+        return ['lib'] + parts[2:] + [name]
+
+    @staticmethod
+    def _get_module_all(module: str) -> Set[str]:
+        """Get the __all__ list from a module by importing it."""
+        try:
+            # Import the module
+            imported = __import__(module, fromlist=['__all__'])
+            # Get its __all__ list
+            if hasattr(imported, '__all__'):
+                return set(imported.__all__)
+        except (ImportError, AttributeError):
+            pass
+        # Return empty set if anything goes wrong
+        return set()
+
+    def _handle_wildcard_import(self, module: str) -> None:
+        """Process a wildcard import by recording all names from module's __all__."""
+        # Get the exposed names from the module
+        exposed = self._get_module_all(module)
+
+        if not exposed:
+            # No __all__ found, this is probably an error
+            raise SyntaxError(
+                f"Cannot use wildcard import: module {module} has no __all__ defined"
+            )
+
+        self.wildcard_imports[module] = exposed
+
+        # Add all exposed names to our import mapping
+        path_parts = ['lib'] + module.split('.')[2:]  # Skip 'pynecore.lib'
+        for name in exposed:
+            self.import_map[name] = path_parts + [name]
+            self.names_to_replace.add(name)
+
+    def _handle_import_from(self, node: ast.ImportFrom) -> None:
+        """Process a lib-related 'from x import y' statement"""
+        if not self._is_lib_import(node):
+            return
+
+        self.needs_lib_import = True
+        module = node.module or ''
+
+        # Extract submodule if it exists
+        if module.startswith('pynecore.lib.'):
+            submodule = module.split('.')[2]  # Get first part after pynecore.lib
+            self.required_submodules.add(submodule)
+
+        # Handle wildcard imports
+        for alias in node.names:
+            if alias.name == '*':
+                self._handle_wildcard_import(module)
+                return
+
+        # Handle regular imports
+        for alias in node.names:
+            name = alias.name
+            asname = alias.asname or name
+            path = self._get_full_path(module, name)
+
+            self.import_map[asname] = path
+            self.names_to_replace.add(asname)
+
+    def _handle_import(self, node: ast.Import) -> None:
+        """Process direct module imports"""
+        if not self._is_lib_module_import(node):
+            return
+
+        self.needs_lib_import = True
+
+        for alias in node.names:
+            if not (alias.name == 'pynecore.lib' or
+                    alias.name.startswith('pynecore.lib.')):
+                continue
+
+            parts = alias.name.split('.')
+            if len(parts) <= 2:  # pynecore.lib
+                asname = alias.asname or 'lib'
+                self.module_imports[asname] = 'lib'
+            else:  # pynecore.lib.xxx
+                submodule = parts[2]  # First part after pynecore.lib
+                self.required_submodules.add(submodule)
+                asname = alias.asname or parts[-1]
+                self.module_imports[asname] = 'lib.' + '.'.join(parts[2:])
+
+    def visit_Module(self, node: ast.Module) -> ast.Module:
+        """Handle module level transformations"""
+        # First collect all imports
+        has_lib_import = False
+        for stmt in node.body:
+            if isinstance(stmt, ast.ImportFrom):
+                if stmt.module == 'pynecore' and any(n.name == 'lib' for n in stmt.names):
+                    has_lib_import = True
+
+            if isinstance(stmt, (ast.ImportFrom, ast.Import)):
+                self._validate_import(stmt)
+                if isinstance(stmt, ast.ImportFrom):
+                    self._handle_import_from(stmt)
+                else:
+                    self._handle_import(stmt)
+
+        # Process the rest of the module to collect attribute usages
+        node = cast(ast.Module, self.generic_visit(node))
+
+        # Filter out old lib imports
+        new_body = []
+        for stmt in node.body:
+            if isinstance(stmt, ast.ImportFrom):
+                if not self._is_lib_import(stmt):
+                    new_body.append(stmt)
+                # Keep original lib import if exists
+                elif stmt.module == 'pynecore' and any(n.name == 'lib' for n in stmt.names):
+                    new_body.append(stmt)
+            elif isinstance(stmt, ast.Import):
+                if not self._is_lib_module_import(stmt):
+                    new_body.append(stmt)
+            else:
+                new_body.append(stmt)
+
+        # Add imports if needed
+        imports = []
+
+        # Add base lib import if needed and not present
+        if self.needs_lib_import and not has_lib_import:
+            imports.append(
+                ast.ImportFrom(
+                    module='pynecore',
+                    names=[ast.alias(name='lib', asname=None)],
+                    level=0
+                )
+            )
+
+        # Add required submodule imports
+        for submodule in sorted(self.required_submodules):
+            imports.append(
+                ast.Import(
+                    names=[ast.alias(name=f'pynecore.lib.{submodule}', asname=None)]
+                )
+            )
+
+        # Function level imports moved up
+        if self.function_imports:
+            imports.extend(self.function_imports)
+
+        # Insert imports after docstring if exists
+        insert_pos = 1 if (new_body and isinstance(new_body[0], ast.Expr) and
+                           isinstance(cast(ast.Expr, new_body[0]).value, ast.Constant)) else 0
+        new_body[insert_pos:insert_pos] = imports
+
+        node.body = new_body
+        return node
+
+    def visit_Attribute(self, node: ast.Attribute) -> ast.AST:
+        """Track lib.xxx usage to detect required submodules"""
+        # Process children first
+        node = cast(ast.Attribute, self.generic_visit(node))
+
+        # Extract the full chain
+        parts = []
+        current = node
+        while isinstance(current, ast.Attribute):
+            parts.append(current.attr)
+            current = current.value
+
+        # Only process if it starts with 'lib'
+        if isinstance(current, ast.Name) and current.id == 'lib' and parts:
+            self.needs_lib_import = True
+
+            if len(parts) >= 2:  # lib.x.y pattern
+                module_name = parts[-1]  # Get the first part after lib
+                if module_name not in NON_MODULE_ATTRS:
+                    self.required_submodules.add(module_name)
+
+        return node
+
+    @staticmethod
+    def _validate_import(node: ast.ImportFrom | ast.Import) -> None:
+        """Validate import statements for unsupported patterns."""
+        if isinstance(node, ast.ImportFrom):
+            if node.module == 'pynecore':
+                for alias in node.names:
+                    if alias.name == 'lib' and alias.asname:
+                        raise SyntaxError(
+                            "'lib' must be imported as itself, not as an alias")
+
+    def visit_Name(self, node: ast.Name) -> ast.AST:
+        """Transform variable references"""
+        if isinstance(node.ctx, ast.Load):
+            # Don't replace function parameters
+            if node.id in self.function_parameters:
+                return node
+
+            # Handle regular imports
+            if node.id in self.names_to_replace:
+                path = self.import_map[node.id]
+                result: ast.expr = cast(ast.expr, ast.Name(id=path[0], ctx=ast.Load()))
+                for part in path[1:]:
+                    result = cast(ast.expr, ast.Attribute(
+                        value=result,
+                        attr=part,
+                        ctx=ast.Load()
+                    ))
+                return result
+            # Handle module imports
+            elif node.id in self.module_imports:
+                path = self.module_imports[node.id].split('.')
+                result: ast.expr = cast(ast.expr, ast.Name(id=path[0], ctx=ast.Load()))
+                for part in path[1:]:
+                    result = cast(ast.expr, ast.Attribute(
+                        value=result,
+                        attr=part,
+                        ctx=ast.Load()
+                    ))
+                return result
+            # Handle names from wildcard imports
+            else:
+                # Check each wildcard imported module
+                for module, exposed in self.wildcard_imports.items():
+                    if node.id in exposed:
+                        path = ['lib'] + module.split('.')[2:] + [node.id]
+                        result: ast.expr = cast(ast.expr, ast.Name(id=path[0], ctx=ast.Load()))
+                        for part in path[1:]:
+                            result = cast(ast.expr, ast.Attribute(
+                                value=result,
+                                attr=part,
+                                ctx=ast.Load()
+                            ))
+                        return result
+        return node
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.FunctionDef:
+        """Process function definitions and handle imports"""
+        old_function = self.current_function
+        old_parameters = self.function_parameters.copy()
+
+        self.current_function = node.name
+
+        # Parameter default values are evaluated in the ENCLOSING scope at def-execution
+        # time, not inside the function body. Visit them before the parameter names enter
+        # `function_parameters`, otherwise a default that references a lib module shadowed
+        # by a same-named parameter (e.g. a param `position` defaulting to
+        # `position.top_center`) is left unrewritten and the lib import is dropped.
+        node.args.defaults = [cast(ast.expr, self.visit(d)) for d in node.args.defaults]
+        node.args.kw_defaults = [
+            cast(ast.expr, self.visit(d)) if d is not None else None
+            for d in node.args.kw_defaults
+        ]
+
+        # Collect function parameters
+        for arg in node.args.args:
+            self.function_parameters.add(arg.arg)
+
+        # Also handle keyword-only args, positional-only args, vararg, and kwarg
+        for arg in node.args.posonlyargs:
+            self.function_parameters.add(arg.arg)
+        for arg in node.args.kwonlyargs:
+            self.function_parameters.add(arg.arg)
+        if node.args.vararg:
+            self.function_parameters.add(node.args.vararg.arg)
+        if node.args.kwarg:
+            self.function_parameters.add(node.args.kwarg.arg)
+
+        # Process function
+        node = cast(ast.FunctionDef, self.generic_visit(node))
+
+        # Reset function context
+        self.current_function = old_function
+        self.function_parameters = old_parameters
+        return node

pynecore/transformers/inline_series_hoist.py

@@ -0,0 +1,178 @@
+"""
+Hoist ``inline_series`` calls out of lazily evaluated expression positions.
+
+Pine evaluates a history-referenced expression (``expr[n]``) on every bar its
+statement executes, even when the ``[n]`` sits in a ternary branch or in a
+short-circuited ``and``/``or`` operand the bar's values skip. Verified against
+TradingView v6 bar-by-bar: ternary branches and ``and``/``or`` operands always
+yield fresh history; only statements inside conditionally executed BLOCKS
+(``if`` bodies) keep the documented compressed "gap" history. PyneComp
+compiles such history references to ``inline_series(expr, n)``, whose
+per-anchor buffer advances only when the call site is actually reached — so
+inside a lazy context it returns STALE history after skipped bars.
+
+This pass hoists every ``inline_series(...)`` call found in a lazy expression
+position to a temp assignment placed immediately before the enclosing
+statement and replaces the call with the temp's name. The assignment stays in
+the same statement list, so block-level conditional execution keeps its gap
+semantics and loop bodies keep their per-iteration frequency.
+
+``while`` tests are deliberately left untouched (they re-evaluate per
+iteration — a hoist above the loop would freeze them), and lambdas /
+comprehensions are not descended into (deferred or repeated evaluation).
+"""
+import ast
+from typing import cast
+
+from pynecore.transformers.locations import fix_locations
+
+__all__ = ['InlineSeriesHoistTransformer']
+
+
+def _is_inline_series(node: ast.expr) -> bool:
+    """Whether a node is a direct ``inline_series(...)`` call.
+
+    :param node: Expression node to check.
+    :return: True for a plain-name ``inline_series`` call (PyneComp's emission).
+    """
+    return (isinstance(node, ast.Call) and isinstance(node.func, ast.Name)
+            and node.func.id == 'inline_series')
+
+
+class _ExprHoister(ast.NodeTransformer):
+    """Rewrite one statement's expression tree: every ``inline_series`` call
+    in a lazy position is appended to ``hoisted`` as a temp assignment and
+    replaced by the temp's name.
+
+    ``_lazy`` is True while the current subtree only evaluates when
+    short-circuiting (``and``/``or`` operands after the first) or ternary
+    branch selection reaches it. Inner calls are collected before outer ones,
+    so the emitted assignments are ordered definition-before-use.
+    """
+
+    def __init__(self, transformer: 'InlineSeriesHoistTransformer'):
+        self._transformer = transformer
+        self.hoisted: list[ast.stmt] = []
+        self._lazy = False
+
+    def visit_as(self, node: ast.expr, lazy: bool) -> ast.expr:
+        """Visit a subtree with an explicit laziness flag.
+
+        :param node: Subtree root.
+        :param lazy: Whether the subtree is in a lazily evaluated position.
+        :return: The (possibly rewritten) subtree.
+        """
+        prev, self._lazy = self._lazy, lazy
+        try:
+            return cast(ast.expr, self.visit(node))
+        finally:
+            self._lazy = prev
+
+    def visit_BoolOp(self, node: ast.BoolOp) -> ast.expr:
+        node.values = [self.visit_as(value, self._lazy if i == 0 else True)
+                       for i, value in enumerate(node.values)]
+        return node
+
+    def visit_IfExp(self, node: ast.IfExp) -> ast.expr:
+        node.test = self.visit_as(node.test, self._lazy)
+        node.body = self.visit_as(node.body, True)
+        node.orelse = self.visit_as(node.orelse, True)
+        return node
+
+    # Deferred / repeated evaluation contexts: hoisting from inside would
+    # change how often the call runs — leave them untouched.
+    def visit_Lambda(self, node: ast.Lambda) -> ast.expr:
+        return node
+
+    def visit_ListComp(self, node: ast.ListComp) -> ast.expr:
+        return node
+
+    def visit_SetComp(self, node: ast.SetComp) -> ast.expr:
+        return node
+
+    def visit_DictComp(self, node: ast.DictComp) -> ast.expr:
+        return node
+
+    def visit_GeneratorExp(self, node: ast.GeneratorExp) -> ast.expr:
+        return node
+
+    def visit_Call(self, node: ast.Call) -> ast.expr:
+        if not (self._lazy and _is_inline_series(node)):
+            return cast(ast.expr, self.generic_visit(node))
+        # The hoisted call runs at statement level: its arguments leave the
+        # lazy context, so nested positions are judged from an eager root
+        node.args = [self.visit_as(arg, False) for arg in node.args]
+        for keyword in node.keywords:
+            keyword.value = self.visit_as(keyword.value, False)
+        name = self._transformer.next_name()
+        self.hoisted.append(ast.Assign(
+            targets=[ast.Name(id=name, ctx=ast.Store())],
+            value=node,
+        ))
+        return ast.Name(id=name, ctx=ast.Load())
+
+
+class InlineSeriesHoistTransformer:
+    """Statement-list walker applying :class:`_ExprHoister` to every
+    statement's own expressions, prepending the hoisted temp assignments in
+    the same statement list."""
+
+    #: Fields holding nested statement lists (handlers are special-cased).
+    _STMT_LIST_FIELDS = ('body', 'orelse', 'finalbody')
+
+    #: Statements whose own expressions evaluate at definition time
+    #: (decorators, defaults, bases) — nothing to hoist per bar.
+    _SKIP_EXPR_STMTS = (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)
+
+    def __init__(self):
+        self._counter = 0
+
+    def next_name(self) -> str:
+        """Allocate a module-unique temp name for a hoisted call."""
+        name = f'__hist_{self._counter}__'
+        self._counter += 1
+        return name
+
+    def visit(self, tree: ast.Module) -> ast.Module:
+        """Process a module tree in place.
+
+        :param tree: Parsed module.
+        :return: The same tree with lazy ``inline_series`` calls hoisted.
+        """
+        tree.body = self._process_body(tree.body)
+        if self._counter:
+            fix_locations(tree)
+        return tree
+
+    def _process_body(self, body: list[ast.stmt]) -> list[ast.stmt]:
+        """Process one statement list; returns the list with hoists inserted."""
+        new_body: list[ast.stmt] = []
+        for stmt in body:
+            # Nested statement lists first — each is its own hoist target,
+            # which keeps block-level (gap) semantics intact
+            for field in self._STMT_LIST_FIELDS:
+                value = getattr(stmt, field, None)
+                if value and isinstance(value[0], ast.stmt):
+                    setattr(stmt, field, self._process_body(value))
+            for handler in getattr(stmt, 'handlers', ()):
+                handler.body = self._process_body(handler.body)
+            new_body.extend(self._hoist_from(stmt))
+            new_body.append(stmt)
+        return new_body
+
+    def _hoist_from(self, stmt: ast.stmt) -> list[ast.stmt]:
+        """Rewrite the statement's own expression fields; return the temp
+        assignments to place before it."""
+        if isinstance(stmt, self._SKIP_EXPR_STMTS):
+            return []
+        hoister = _ExprHoister(self)
+        for field, value in ast.iter_fields(stmt):
+            if isinstance(stmt, ast.While) and field == 'test':
+                continue  # re-evaluated per iteration — must stay in place
+            if isinstance(value, ast.expr):
+                setattr(stmt, field, hoister.visit_as(value, False))
+            elif (isinstance(value, list) and value
+                  and isinstance(value[0], ast.expr)):
+                setattr(stmt, field,
+                        [hoister.visit_as(item, False) for item in value])
+        return hoister.hoisted