pine2pyne 0.2.4__py3-none-any.whl

pine2pyne/__init__.py

@@ -0,0 +1,84 @@
+"""
+pine2pyne: Pine Script v6 to PyneCore Python transpiler.
+
+A tool to convert TradingView Pine Script indicators and strategies
+to PyneCore Python code for local backtesting and analysis.
+"""
+
+__version__ = '0.2.4'
+__author__ = 'Pine2Pyne Transpiler'
+
+from .lexer import Lexer, tokenize
+from .parser import Parser, parse
+from .parse_repair import parse_source
+from .legacy_function_names import qualify_legacy_function_names
+from .pine_semantics import enforce as enforce_pine_semantics
+from .transformer import Transformer, PyneTransformedScript
+from .codegen import CodeGenerator, generate_code
+from .errors import (
+    Pine2PyneError,
+    LexerError,
+    ParserError,
+    TransformerError,
+    CodeGenError,
+    SemanticError,
+    SemanticWarning,
+    UnsupportedFeatureError,
+)
+
+
+from .core.contracts import OutputProfile, Transpiler
+from .pipeline.stages import CommentOnlySourceFilter
+
+
+def _is_comment_only(source: str) -> bool:
+    """Check if source contains only comments and whitespace."""
+    return CommentOnlySourceFilter().is_blank(source)
+
+
+def transpile(source: str, profile: 'OutputProfile | str | None' = None) -> str:
+    """
+    Transpile Pine Script source code to PyneCore Python.
+
+    The pipeline (parse -> normalize -> semantic guard -> transform -> emit) is
+    assembled by the dishka container in :mod:`pine2pyne.di`; ``profile`` picks
+    the output layout:
+
+    * ``'pynecomp'`` (default) - byte-compatible with the closed PyneComp v6.0.79 compiler;
+    * ``'legacy'`` - the historical pine2pyne layout, kept as a reference.
+
+    Args:
+        source: Pine Script v6 source code
+        profile: output profile (an :class:`OutputProfile` or its name)
+
+    Returns:
+        PyneCore-compatible Python source code (empty string if source is comment-only)
+
+    Raises:
+        Pine2PyneError: If any stage of transpilation fails
+    """
+    from .di import get_transpiler
+    return get_transpiler(profile).transpile(source)
+
+
+__all__ = [
+    'transpile',
+    'OutputProfile',
+    'Transpiler',
+    'Lexer',
+    'Parser',
+    'Transformer',
+    'CodeGenerator',
+    'tokenize',
+    'parse',
+    'generate_code',
+    'Pine2PyneError',
+    'LexerError',
+    'ParserError',
+    'TransformerError',
+    'CodeGenError',
+    'SemanticError',
+    'SemanticWarning',
+    'UnsupportedFeatureError',
+    'PyneTransformedScript',
+]

pine2pyne/__main__.py

@@ -0,0 +1,12 @@
+"""
+Entry point for running pine2pyne as a module.
+
+Usage:
+    python -m pine2pyne input.pine
+    python -m pine2pyne input.pine -o output.py
+"""
+import sys
+from .cli import main
+
+if __name__ == '__main__':
+    sys.exit(main())

pine2pyne/ast_nodes.py

@@ -0,0 +1,405 @@
+"""
+AST (Abstract Syntax Tree) node definitions for Pine Script v6.
+
+All node types used by the parser to represent Pine Script syntax.
+"""
+from dataclasses import dataclass, field
+from typing import Any, List, Optional, Union
+
+
+# Base class for all AST nodes
+@dataclass
+class ASTNode:
+    """Base class for all AST nodes."""
+    line: int = 0
+    column: int = 0
+    # the Pine line a statement built by a lowering is laid out at, where `line` stays unset
+    source_line: int = field(default=0, compare=False, repr=False)
+
+
+# ============================================================================
+# Top-level nodes
+# ============================================================================
+
+@dataclass
+class Script(ASTNode):
+    """Root node representing the entire Pine Script."""
+    version: Optional['VersionAnnotation'] = None
+    script_decl: Optional[Union['IndicatorDecl', 'StrategyDecl', 'LibraryDecl']] = None
+    imports: List['ImportDecl'] = field(default_factory=list)
+    declarations: List[Union['VarDecl', 'VaripDecl', 'TypeDecl', 'EnumDecl', 'FuncDecl', 'InputDecl']] = field(default_factory=list)
+    body: List['Statement'] = field(default_factory=list)
+
+
+@dataclass
+class VersionAnnotation(ASTNode):
+    """//@version=6 annotation."""
+    version: str = ""  # "6" or "5"
+
+
+@dataclass
+class IndicatorDecl(ASTNode):
+    """indicator("Title", ...) declaration."""
+    title: Optional[str] = ""  # None: the title is an expression, kept in kwargs['title']
+    kwargs: dict = field(default_factory=dict)
+    # How the source wrote the call: how many arguments were positional, and the
+    # title's quotes. Codegen ignores it; a layout printer may reproduce it
+    positional_count: int = 0
+    title_double_quoted: bool = False
+    keyword_order: tuple = ()  # the keyword arguments' names as the source orders them
+
+
+@dataclass
+class StrategyDecl(ASTNode):
+    """strategy("Title", ...) declaration."""
+    title: Optional[str] = ""  # None: the title is an expression, kept in kwargs['title']
+    kwargs: dict = field(default_factory=dict)
+    # How the source wrote the call: how many arguments were positional, and the
+    # title's quotes. Codegen ignores it; a layout printer may reproduce it
+    positional_count: int = 0
+    title_double_quoted: bool = False
+    keyword_order: tuple = ()  # the keyword arguments' names as the source orders them
+
+
+@dataclass
+class LibraryDecl(ASTNode):
+    """library("Title", ...) declaration."""
+    title: Optional[str] = ""  # None: the title is an expression, kept in kwargs['title']
+    kwargs: dict = field(default_factory=dict)
+    # How the source wrote the call: how many arguments were positional, and the
+    # title's quotes. Codegen ignores it; a layout printer may reproduce it
+    positional_count: int = 0
+    title_double_quoted: bool = False
+    keyword_order: tuple = ()  # the keyword arguments' names as the source orders them
+
+
+@dataclass
+class ImportDecl(ASTNode):
+    """import user/library/version as alias"""
+    user: str = ""
+    library: str = ""
+    version: Optional[str] = None
+    alias: Optional[str] = None
+
+
+# ============================================================================
+# Declarations
+# ============================================================================
+
+@dataclass
+class VarDecl(ASTNode):
+    """var [type] name = value"""
+    name: str = ""
+    value: 'Expression' = None
+    type_hint: Optional[str] = None
+    is_var: bool = True  # True for 'var', False for 'varip'
+
+
+@dataclass
+class VaripDecl(ASTNode):
+    """varip [type] name = value"""
+    name: str = ""
+    value: 'Expression' = None
+    type_hint: Optional[str] = None
+
+
+@dataclass
+class TypeDecl(ASTNode):
+    """type MyType ... (User-defined type)"""
+    name: str = ""
+    fields: List[tuple] = field(default_factory=list)  # [(field_name, type_hint, default_value), ...] or [(field_name, type_hint), ...]
+    field_lines: List[int] = field(default_factory=list)  # each field's Pine line
+
+
+@dataclass
+class EnumDecl(ASTNode):
+    """enum MyEnum ... (Enum definition)"""
+    name: str = ""
+    members: List = field(default_factory=list)  # List[str] or List[tuple[str, Expression]]
+
+
+@dataclass
+class FuncDecl(ASTNode):
+    """Function declaration: name(params) => body"""
+    name: str = ""
+    params: List['Parameter'] = field(default_factory=list)
+    body: Union['Expression', List['Statement']] = None
+    return_type: Optional[str] = None
+    is_method: bool = False
+    is_export: bool = False
+    is_overload: bool = False  # One of several same-name declarations (card #39)
+    indexed_params: set = field(default_factory=set)  # Params that use [n] history access
+    value_is_bool: bool = False  # Pine v6: its value is of type bool (card #56)
+
+
+@dataclass
+class Parameter(ASTNode):
+    """Function parameter: [type] name [= default]"""
+    name: str = ""
+    type_hint: Optional[str] = None
+    default: Optional['Expression'] = None
+    is_series: bool = False  # declared `series T`: PyneComp annotates it Series[T]
+
+
+@dataclass
+class InputDecl(ASTNode):
+    """Input declaration: name = input.*(...)"""
+    name: str = ""
+    func: str = ""  # e.g., "input.int"
+    args: List['Expression'] = field(default_factory=list)
+    kwargs: dict = field(default_factory=dict)
+
+
+# ============================================================================
+# Expressions
+# ============================================================================
+
+@dataclass
+class Expression(ASTNode):
+    """Base class for all expressions."""
+    pass
+
+
+@dataclass
+class BinaryOp(Expression):
+    """Binary operation: left op right"""
+    left: Expression = None
+    op: str = ""
+    right: Expression = None
+    compound: bool = False  # written `x op= y`: printed that way, `x := x op y` is not
+
+
+@dataclass
+class UnaryOp(Expression):
+    """Unary operation: op operand"""
+    op: str = ""
+    operand: Expression = None
+
+
+@dataclass
+class TernaryOp(Expression):
+    """Ternary operation: condition ? true_expr : false_expr"""
+    condition: Expression = None
+    true_expr: Expression = None
+    false_expr: Expression = None
+
+
+@dataclass
+class FunctionCall(Expression):
+    """Function call: func(args, kwargs)"""
+    func: Union[str, 'MemberAccess'] = ""  # Can be "ta.sma" or MemberAccess node
+    args: List[Expression] = field(default_factory=list)
+    kwargs: dict = field(default_factory=dict)
+
+
+@dataclass
+class MethodCall(Expression):
+    """Method call: object.method(args)"""
+    object: Expression = None
+    method: str = ""
+    args: List[Expression] = field(default_factory=list)
+    kwargs: dict = field(default_factory=dict)
+
+
+@dataclass
+class MemberAccess(Expression):
+    """Member access: object.member"""
+    object: Union[str, Expression] = ""  # Can be identifier string or expression
+    member: str = ""
+
+
+@dataclass
+class IndexAccess(Expression):
+    """Index access: object[index]"""
+    object: Expression = None
+    index: Expression = None
+
+
+@dataclass
+class ArrayLiteral(Expression):
+    """Array literal: [elem1, elem2, ...]"""
+    elements: List[Expression] = field(default_factory=list)
+
+
+@dataclass
+class TupleDestructure(Expression):
+    """Tuple destructuring: [a, b, c] = expr"""
+    names: List[str] = field(default_factory=list)
+    value: Expression = None
+
+
+@dataclass
+class Identifier(Expression):
+    """Identifier (variable name)"""
+    name: str = ""
+
+
+@dataclass
+class NamedExpression(Expression):
+    """Transformer output only: binds `name` to `value` and is that value
+    (Python `(name := value)`). A switch subject is bound this way in the
+    first case test, so it is evaluated once, where Pine evaluates it (card #43)."""
+    name: str = ""
+    value: Expression = None
+
+
+@dataclass
+class Literal(Expression):
+    """Literal value (int, float, string, bool, color)"""
+    value: Any = None
+    literal_type: str = ""  # 'int', 'float', 'string', 'bool', 'color'
+    is_double_quoted: bool = False  # Track if original source used double quotes
+
+
+@dataclass
+class NaLiteral(Expression):
+    """The 'na' literal value"""
+    pass
+
+
+@dataclass
+class IfExpression(Expression):
+    """If expression (returns a value): if cond\n    val1\nelse\n    val2"""
+    condition: Expression = None
+    true_expr: Union[Expression, List['Statement']] = None
+    false_expr: Optional[Union[Expression, List['Statement']]] = None
+    value_is_bool: bool = False  # Pine v6: its value is of type bool (card #56)
+    chained: bool = False  # written `else if` after the if before it (not an `if` inside an `else` block)
+
+
+@dataclass
+class SwitchExpression(Expression):
+    """Switch expression (returns a value)"""
+    expr: Optional[Expression] = None
+    cases: List[tuple[Expression, Union[Expression, List['Statement']]]] = field(default_factory=list)
+    default: Optional[Union[Expression, List['Statement']]] = None
+    value_is_bool: bool = False  # Pine v6: its value is of type bool (card #56)
+
+
+# ============================================================================
+# Statements
+# ============================================================================
+
+@dataclass
+class Statement(ASTNode):
+    """Base class for all statements."""
+    pass
+
+
+@dataclass
+class Assignment(Statement):
+    """Assignment statement: target = value"""
+    target: Union[str, 'TupleDestructure'] = ""
+    value: Expression = None
+    type_hint: Optional[str] = None
+    is_const: bool = False  # declared `const T name = ...`: PyneComp moves a top-level one to the module
+
+
+@dataclass
+class Reassignment(Statement):
+    """Reassignment statement: target := value"""
+    target: str = ""
+    value: Expression = None
+
+
+@dataclass
+class IfStatement(Statement):
+    """If statement: if cond\n    body\nelse if ...\nelse ..."""
+    condition: Expression = None
+    body: List[Statement] = field(default_factory=list)
+    elseifs: List[tuple[Expression, List[Statement]]] = field(default_factory=list)
+    else_body: Optional[List[Statement]] = None
+
+
+@dataclass
+class ForLoop(Statement):
+    """For loop: for var = from to to_val [by step]"""
+    var: str = ""
+    from_val: Expression = None
+    to_val: Expression = None
+    step: Optional[Expression] = None
+    body: List[Statement] = field(default_factory=list)
+    value_is_bool: bool = False  # Pine v6: its value is of type bool (card #56)
+    # Pine v6, an end bound that can change between passes: the name of the runtime
+    # counter (`pine_loop`) that re-reads it; empty for a fixed `pine_range` (card #82)
+    counter_name: str = ""
+    counter_helper: str = ""  # the name `pine_loop` is imported under (an alias when the script uses the name)
+    range_helper: str = ""  # the name `pine_range` is imported under for a fixed loop; empty is `pine_range` (card #94)
+    # the value of an assignment (`x = for ...`): PyneComp writes no default step for it, even in Pine v4/v5
+    is_assigned_value: bool = False
+
+
+@dataclass
+class ForInLoop(Statement):
+    """For-in loop: for [vars] in iterable"""
+    vars: List[str] = field(default_factory=list)
+    iterable: Expression = None
+    body: List[Statement] = field(default_factory=list)
+    value_is_bool: bool = False  # Pine v6: its value is of type bool (card #56)
+
+
+@dataclass
+class WhileLoop(Statement):
+    """While loop: while condition\n    body"""
+    condition: Expression = None
+    body: List[Statement] = field(default_factory=list)
+    value_is_bool: bool = False  # Pine v6: its value is of type bool (card #56)
+
+
+@dataclass
+class SwitchStatement(Statement):
+    """Switch statement (imperative form)"""
+    expr: Optional[Expression] = None
+    cases: List[tuple[Expression, List[Statement]]] = field(default_factory=list)
+    default: Optional[List[Statement]] = None
+
+
+@dataclass
+class OnceStatement(Statement):
+    """Pine v6 once structure: once [cond]\n    body. The parser lowers it to
+    a `var` flag and an `if` (once_lowering.py, card #59); no later stage sees it."""
+    condition: Optional[Expression] = None
+    body: List[Statement] = field(default_factory=list)
+
+
+@dataclass
+class BreakStatement(Statement):
+    """Break statement"""
+    pass
+
+
+@dataclass
+class ContinueStatement(Statement):
+    """Continue statement"""
+    pass
+
+
+@dataclass
+class ExpressionStatement(Statement):
+    """Expression as statement (e.g., function call on its own line)"""
+    expr: Expression = None
+
+
+@dataclass
+class ReturnStatement(Statement):
+    """Explicit return statement (for codegen)"""
+    expr: Optional[Expression] = None
+
+
+@dataclass
+class RawCode(Statement):
+    """Raw Python code to be emitted as-is by codegen."""
+    code: str = ""
+
+
+# ============================================================================
+# Type annotations
+# ============================================================================
+
+# Forward references for type checking
+Statement = Union[
+    Assignment, Reassignment, IfStatement, ForLoop, ForInLoop,
+    WhileLoop, SwitchStatement, BreakStatement, ContinueStatement,
+    ExpressionStatement, ReturnStatement, VarDecl, VaripDecl,
+    FuncDecl, InputDecl
+]

pine2pyne/ast_walk.py

@@ -0,0 +1,93 @@
+"""
+AST walk: the child traversal shared by the Pine-AST pre-passes and scans.
+
+A Pine AST node is a dataclass; its children sit in its fields, directly or
+inside lists, tuples (the arms of an else-if, the cases of a switch) and dicts
+(the keyword arguments of a call). A walk that forgets one of these containers
+silently misses what is inside it: a history index in a keyword argument or in
+an else-if arm was not seen (cards #32, #44). Every generic walk goes through
+`walk` (to find nodes) or `map_children` (to rebuild them), so the containers
+are decided in one place.
+
+Every transpile walks every file, so `walk` is iterative (a deep expression
+does not use up the recursion limit) and caches the child fields per node type.
+"""
+import dataclasses
+from typing import Callable, Dict, Iterator, Tuple, Union
+
+# The source position is not a child
+POSITION_FIELDS = frozenset({'line', 'column'})
+# Field values that are never a node nor hold one
+LEAF_TYPES = frozenset({str, int, float, bool, type(None)})
+CONTAINER_TYPES = frozenset({list, tuple})
+
+# node type -> its child field names, last first; False for a type that is not a node
+_CHILD_FIELDS_LAST_FIRST: Dict[type, Union[Tuple[str, ...], bool]] = {}
+# node type -> its child field names in declaration order
+_CHILD_FIELDS_IN_ORDER: Dict[type, Tuple[str, ...]] = {}
+
+
+def child_field_names(node_type: type) -> Tuple[str, ...]:
+    """The fields of a node type that can hold children, in declaration order."""
+    fields = _CHILD_FIELDS_IN_ORDER.get(node_type)
+    if fields is None:
+        fields = _CHILD_FIELDS_IN_ORDER[node_type] = tuple(reversed(_child_fields_last_first(node_type) or ()))
+    return fields
+
+
+def _child_fields_last_first(value_type: type):
+    fields = _CHILD_FIELDS_LAST_FIRST.get(value_type)
+    if fields is None:
+        is_node_type = hasattr(value_type, '__dataclass_fields__')
+        fields = tuple(reversed([field.name for field in dataclasses.fields(value_type)
+                                 if field.name not in POSITION_FIELDS])) if is_node_type else False
+        _CHILD_FIELDS_LAST_FIRST[value_type] = fields
+    return fields
+
+
+def is_node(value) -> bool:
+    """True for an AST node instance (a dataclass instance, not a class)."""
+    return _child_fields_last_first(type(value)) is not False and not isinstance(value, type)
+
+
+def walk(tree) -> Iterator:
+    """Every node in `tree` (a node, or lists, tuples and dicts of them),
+    each parent before its children, in source order."""
+    pending = [tree]
+    while pending:
+        value = pending.pop()
+        value_type = type(value)
+        if value_type in CONTAINER_TYPES:
+            pending.extend(item for item in reversed(value) if type(item) not in LEAF_TYPES)
+        elif value_type is dict:
+            pending.extend(item for item in reversed(list(value.values())) if type(item) not in LEAF_TYPES)
+        elif value_type not in LEAF_TYPES:
+            fields = _child_fields_last_first(value_type)
+            if fields is False:
+                continue
+            yield value
+            for name in fields:
+                child = getattr(value, name)
+                if type(child) not in LEAF_TYPES:
+                    pending.append(child)
+
+
+def contains(tree, predicate: Callable) -> bool:
+    """True when a node in `tree` satisfies `predicate`."""
+    for node in walk(tree):
+        if predicate(node):
+            return True
+    return False
+
+
+def map_children(value, rebuild: Callable):
+    """`value` with `rebuild` applied to each node it holds directly: a list,
+    tuple or dict is copied around the rebuilt items, anything else that is
+    not a node (a name, a number) is kept."""
+    if isinstance(value, list):
+        return [map_children(item, rebuild) for item in value]
+    if isinstance(value, tuple):
+        return tuple(map_children(item, rebuild) for item in value)
+    if isinstance(value, dict):
+        return {key: map_children(item, rebuild) for key, item in value.items()}
+    return rebuild(value) if is_node(value) else value