opencode-pine2pyne 0.1.0__py3-none-any.whl

pine2pyne/__init__.py

@@ -0,0 +1,86 @@
+"""
+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.1.0'
+__author__ = 'Pine2Pyne Transpiler'
+
+from .lexer import Lexer, tokenize
+from .parser import Parser, parse
+from .transformer import Transformer, PyneTransformedScript
+from .codegen import CodeGenerator, generate_code
+from .errors import (
+    Pine2PyneError,
+    LexerError,
+    ParserError,
+    TransformerError,
+    CodeGenError,
+    UnsupportedFeatureError,
+)
+
+
+def _is_comment_only(source: str) -> bool:
+    """Check if source contains only comments and whitespace."""
+    for line in source.splitlines():
+        stripped = line.strip()
+        if stripped and not stripped.startswith('//'):
+            return False
+    return True
+
+
+def transpile(source: str) -> str:
+    """
+    Transpile Pine Script source code to PyneCore Python.
+
+    Args:
+        source: Pine Script v6 source code
+
+    Returns:
+        PyneCore-compatible Python source code (empty string if source is comment-only)
+
+    Raises:
+        Pine2PyneError: If any stage of transpilation fails
+    """
+    # Skip empty or comment-only files
+    if not source or _is_comment_only(source):
+        return ""
+
+    # Tokenize
+    lexer = Lexer(source)
+    tokens = lexer.tokenize()
+
+    # Parse
+    parser = Parser(tokens)
+    ast = parser.parse()
+
+    # Transform
+    transformer = Transformer()
+    transformed = transformer.transform(ast)
+
+    # Generate code
+    codegen = CodeGenerator()
+    output = codegen.generate(transformed)
+
+    return output
+
+
+__all__ = [
+    'transpile',
+    'Lexer',
+    'Parser',
+    'Transformer',
+    'CodeGenerator',
+    'tokenize',
+    'parse',
+    'generate_code',
+    'Pine2PyneError',
+    'LexerError',
+    'ParserError',
+    'TransformerError',
+    'CodeGenError',
+    '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,352 @@
+"""
+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
+
+
+# ============================================================================
+# 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: str = ""
+    kwargs: dict = field(default_factory=dict)
+
+
+@dataclass
+class StrategyDecl(ASTNode):
+    """strategy("Title", ...) declaration."""
+    title: str = ""
+    kwargs: dict = field(default_factory=dict)
+
+
+@dataclass
+class LibraryDecl(ASTNode):
+    """library("Title", ...) declaration."""
+    title: str = ""
+    kwargs: dict = field(default_factory=dict)
+
+
+@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), ...]
+
+
+@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
+    indexed_params: set = field(default_factory=set)  # Params that use [n] history access
+
+
+@dataclass
+class Parameter(ASTNode):
+    """Function parameter: [type] name [= default]"""
+    name: str = ""
+    type_hint: Optional[str] = None
+    default: Optional['Expression'] = None
+
+
+@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
+
+
+@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 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
+
+
+@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
+
+
+# ============================================================================
+# 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
+
+
+@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)
+
+
+@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)
+
+
+@dataclass
+class WhileLoop(Statement):
+    """While loop: while condition\n    body"""
+    condition: Expression = None
+    body: List[Statement] = field(default_factory=list)
+
+
+@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 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/cli.py

@@ -0,0 +1,212 @@
+"""
+Command-line interface for pine2pyne transpiler.
+"""
+import argparse
+import sys
+from pathlib import Path
+from typing import List, Optional
+from . import transpile, __version__, _is_comment_only
+from .errors import Pine2PyneError
+
+
+def parse_args(args: Optional[List[str]] = None) -> argparse.Namespace:
+    """Parse command-line arguments."""
+    parser = argparse.ArgumentParser(
+        prog='pine2pyne',
+        description='Transpile Pine Script v6 to PyneCore Python',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog='''
+Examples:
+  # Output to stdout
+  python -m pine2pyne strategy.pine
+
+  # Output to file
+  python -m pine2pyne strategy.pine -o strategy.py
+
+  # Validate syntax only
+  python -m pine2pyne strategy.pine --validate
+
+  # Batch convert multiple files
+  python -m pine2pyne strategy/*.pine -o output/
+        '''
+    )
+
+    parser.add_argument(
+        'input',
+        nargs='+',
+        type=str,
+        help='Input Pine Script file(s) (.pine)'
+    )
+
+    parser.add_argument(
+        '-o', '--output',
+        type=str,
+        help='Output file or directory. If directory, outputs will have .py extension'
+    )
+
+    parser.add_argument(
+        '--validate',
+        action='store_true',
+        help='Validate syntax only (parse without generating code)'
+    )
+
+    parser.add_argument(
+        '-v', '--verbose',
+        action='store_true',
+        help='Enable verbose output'
+    )
+
+    parser.add_argument(
+        '--version',
+        action='version',
+        version=f'%(prog)s {__version__}'
+    )
+
+    return parser.parse_args(args)
+
+
+def transpile_file(input_path: Path, output_path: Optional[Path], validate_only: bool, verbose: bool) -> bool:
+    """
+    Transpile a single Pine Script file.
+
+    Returns:
+        True if successful, False otherwise
+    """
+    try:
+        # Read input file
+        if verbose:
+            print(f'Reading {input_path}...')
+
+        source = input_path.read_text(encoding='utf-8')
+
+        if validate_only:
+            # Only parse to validate syntax
+            from .lexer import Lexer
+            from .parser import Parser
+
+            if verbose:
+                print('Tokenizing...')
+            lexer = Lexer(source)
+            tokens = lexer.tokenize()
+
+            if verbose:
+                print('Parsing...')
+            parser = Parser(tokens)
+            ast = parser.parse()
+
+            print(f'✓ {input_path} - Valid syntax')
+            return True
+
+        # Full transpilation
+        if verbose:
+            print('Transpiling...')
+
+        output_code = transpile(source)
+
+        # Empty output is only legitimate for a comment-only / empty source.
+        # If the source carries real Pine code but the transpiler produced
+        # nothing, an unsupported construct was silently dropped — fail loudly
+        # instead of reporting a bogus success (exit 0 with no file written).
+        if not output_code:
+            if _is_comment_only(source):
+                if verbose:
+                    print(f'Skipping {input_path} (comment-only file)')
+                return True
+            print(f'✗ {input_path}: transpiler produced no output for non-comment '
+                  f'source (unsupported construct silently dropped)', file=sys.stderr)
+            return False
+
+        # Write output
+        if output_path:
+            if verbose:
+                print(f'Writing to {output_path}...')
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_text(output_code, encoding='utf-8')
+            print(f'✓ {input_path} → {output_path}')
+        else:
+            # Output to stdout
+            print(output_code)
+
+        return True
+
+    except Pine2PyneError as e:
+        print(f'✗ {input_path}: {e}', file=sys.stderr)
+        return False
+    except FileNotFoundError:
+        print(f'✗ {input_path}: File not found', file=sys.stderr)
+        return False
+    except Exception as e:
+        print(f'✗ {input_path}: Unexpected error: {e}', file=sys.stderr)
+        if verbose:
+            import traceback
+            traceback.print_exc()
+        return False
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    """Main entry point for CLI."""
+    args = parse_args(argv)
+
+    # Resolve input files
+    input_paths: List[Path] = []
+    for input_pattern in args.input:
+        path = Path(input_pattern)
+        if path.is_file():
+            input_paths.append(path)
+        elif '*' in input_pattern or '?' in input_pattern:
+            # Glob pattern
+            from glob import glob
+            for match in glob(input_pattern):
+                input_paths.append(Path(match))
+        else:
+            print(f'Error: {input_pattern} is not a file or valid pattern', file=sys.stderr)
+            return 1
+
+    if not input_paths:
+        print('Error: No input files found', file=sys.stderr)
+        return 1
+
+    # Determine output strategy
+    output_is_dir = False
+    output_base = None
+
+    if args.output:
+        output_path = Path(args.output)
+        if output_path.is_dir() or (not output_path.exists() and len(input_paths) > 1):
+            output_is_dir = True
+            output_base = output_path
+        elif len(input_paths) > 1:
+            print('Error: Multiple input files require output to be a directory', file=sys.stderr)
+            return 1
+        else:
+            output_base = output_path
+
+    # Process files
+    success_count = 0
+    fail_count = 0
+
+    for input_path in input_paths:
+        # Determine output path
+        if args.output is None:
+            output_path = None  # stdout
+        elif output_is_dir:
+            output_name = input_path.stem + '.py'
+            output_path = output_base / output_name
+        else:
+            output_path = output_base
+
+        # Transpile
+        if transpile_file(input_path, output_path, args.validate, args.verbose):
+            success_count += 1
+        else:
+            fail_count += 1
+
+    # Print summary for multiple files
+    if len(input_paths) > 1:
+        print(f'\nSummary: {success_count} succeeded, {fail_count} failed')
+
+    return 0 if fail_count == 0 else 1
+
+
+if __name__ == '__main__':
+    sys.exit(main())