pine2pyne 0.2.4__py3-none-any.whl

pine2pyne/strategy_when_lowering.py

@@ -0,0 +1,101 @@
+"""`when=` of a strategy call, lowered to an `if` (card #117).
+
+    strategy.entry("l", strategy.long, when=c)      if c
+                                              ->        strategy.entry("l", strategy.long)
+
+Pine v1-v5 gave the order functions of `strategy.*` a `when` argument: the call acts only on the bars where it is
+true. Pine v6 removed it, and the runtime's `strategy.entry` / `strategy.close` / ... take none, so a `when=` that
+reached the generated code raised `TypeError: entry() got an unexpected keyword argument 'when'` at run. The
+lowering runs at the end of parsing, so no later stage sees one.
+
+Only the keyword form, only a call that stands as a statement (the functions return nothing), and only in a script
+declaring //@version 1-5. A v6 script is left as written: TradingView refuses a `when` there, so no spelling is
+invented for it. A positional `when` (the 9th slot of `strategy.entry`, the 2nd of v4 `strategy.close`) is not
+lowered here (card #117 follow-up).
+"""
+import dataclasses
+import itertools
+
+from .ast_nodes import (Assignment, ExpressionStatement, FuncDecl, FunctionCall, Identifier, IfStatement, IndexAccess,
+                        MethodCall, Script)
+from .ast_walk import child_field_names, contains, is_node
+
+STRATEGY_FUNCTIONS_WITH_WHEN = frozenset({
+    'strategy.entry', 'strategy.order', 'strategy.exit', 'strategy.close', 'strategy.close_all',
+    'strategy.cancel', 'strategy.cancel_all',
+})
+
+
+def lower_strategy_when_arguments(script: Script, pine_version: int) -> Script:
+    """A copy of `script` with each `strategy.*(..., when=c)` statement turned into `if c` around the call
+    without `when`. A script without one, or of another version, is returned unchanged."""
+    if not 1 <= pine_version <= 5 or not contains(script, _is_call_with_when):
+        return script
+    return _WhenLowering().lowered(script)
+
+
+def _is_call_with_when(node) -> bool:
+    # a callee that is not a name (`na(x)`: a NaLiteral node) is unhashable and is never a strategy function
+    return (isinstance(node, FunctionCall) and isinstance(node.func, str) and node.func in STRATEGY_FUNCTIONS_WITH_WHEN
+            and 'when' in node.kwargs)
+
+
+def _is_stateful_or_history(node) -> bool:
+    return isinstance(node, (FunctionCall, MethodCall, IndexAccess))
+
+
+class _Statements(list):
+    """The statements one statement is replaced by (a list item that expands to several)."""
+
+
+class _WhenLowering:
+    """Pine evaluates every argument of a `strategy.*(..., when=c)` call on every bar, whatever `c` is. An argument
+    holding a call (`ta.lowest(low, 10)`, a user function) or a history index (`close[1]`) has state per bar, and
+    inside an `if` it would update only on the bars where `c` holds. So such an argument is assigned to a temporary
+    before the `if`, and the temporary is what the call inside the `if` receives."""
+
+    def __init__(self):
+        self.temporary_numbers = itertools.count(1)
+
+    def lowered(self, node):
+        children = {name: self._map(getattr(node, name)) for name in child_field_names(type(node))}
+        rebuilt = dataclasses.replace(node, **children)
+        if isinstance(rebuilt, ExpressionStatement) and _is_call_with_when(rebuilt.expr):
+            return _Statements(self._if_around(rebuilt))
+        if isinstance(rebuilt, FuncDecl) and _is_call_with_when(rebuilt.body):
+            # `f(c) => strategy.close("l", when=c)`: the one-line body is the call, made a statement
+            call = rebuilt.body
+            statement = ExpressionStatement(expr=call, line=call.line, column=call.column)
+            return dataclasses.replace(rebuilt, body=self._if_around(statement))
+        return rebuilt
+
+    def _map(self, value):
+        if isinstance(value, list):
+            items = []
+            for item in value:
+                mapped = self._map(item)
+                items.extend(mapped) if isinstance(mapped, _Statements) else items.append(mapped)
+            return items
+        if isinstance(value, tuple):
+            return tuple(self._map(item) for item in value)
+        if isinstance(value, dict):
+            return {key: self._map(item) for key, item in value.items()}
+        return self.lowered(value) if is_node(value) else value
+
+    def _if_around(self, statement: ExpressionStatement) -> list:
+        call = statement.expr
+        temporaries = []
+        args = [self._every_bar(argument, 'argument', statement, temporaries) for argument in call.args]
+        kwargs = {key: self._every_bar(value, key, statement, temporaries)
+                  for key, value in call.kwargs.items() if key != 'when'}
+        without_when = dataclasses.replace(call, args=args, kwargs=kwargs)
+        guarded = IfStatement(condition=call.kwargs['when'], body=[dataclasses.replace(statement, expr=without_when)],
+                              line=statement.line, column=statement.column)
+        return [*temporaries, guarded]
+
+    def _every_bar(self, argument, label, statement, temporaries):
+        if not contains(argument, _is_stateful_or_history):
+            return argument
+        name = f'_when_{label}_{next(self.temporary_numbers)}'
+        temporaries.append(Assignment(target=name, value=argument, line=statement.line, column=statement.column))
+        return Identifier(name=name, line=statement.line, column=statement.column)

pine2pyne/strict_boolean.py

@@ -0,0 +1,101 @@
+"""
+Strict `and` / `or`: Pine v5 and earlier evaluate both operands (card #65).
+
+The Pine v6 migration guide: "Pine v5 evaluates all bool expressions except for the `?:`
+ternary operator strictly, meaning the second part of a conditional expression is always
+evaluated, regardless of the value of the first argument"; v6 evaluates them lazily. Python's
+`and` / `or` are lazy, so a stateful right operand (a `ta.*` call, a function with `var` or
+history state) of a v5 script advanced its history only on the bars where it ran. Only v5 is
+documented; v1-v4 are taken as strict like v5, and a script without a version annotation as
+v6, the transpiler's target (as bool_is_never_na does).
+
+The code generator emits `all((a, b, c))` / `any((a, b, c))` for a chain of one operator whose
+operands after the first may have an effect: a tuple evaluates every element, left to right,
+before `all` / `any` sees any. A chain whose later operands are pure (literals, names, history
+reads, arithmetic, comparisons, `not`, `?:`, and calls of the builtins that keep no state:
+`na`, `nz`, `math.*`, `str.*`, the strategy trade getters, collection getters) keeps the
+Python `and` / `or`: skipping them changes nothing, and a getter run on an empty collection
+(`strategy.opentrades.entry_price(0)` after a size check) must not start to run. A call of a
+function the script declares itself is stateful: it may hold `var` state or call `ta.*`.
+Every other call (`ta.*`, `request.*`, `fixnan`, a v4 `sma(...)`) is treated as stateful. This
+module decides which.
+"""
+from typing import FrozenSet, List, Optional
+
+from .ast_nodes import (BinaryOp, Expression, FunctionCall, Identifier, IndexAccess, Literal, MemberAccess,
+                        MethodCall, NaLiteral, Script, TernaryOp, UnaryOp)
+from .ast_walk import walk
+from .pine_builtins import TA_VARIABLE_FUNCTIONS
+
+BOOLEAN_OPERATORS = frozenset({'and', 'or'})
+# Nodes that cannot advance a history or change a variable. A call, a bound name (`:=`) or any
+# node not listed is taken to have an effect
+PURE_NODE_TYPES = (Literal, NaLiteral, Identifier, MemberAccess, IndexAccess, BinaryOp, UnaryOp, TernaryOp)
+# Builtin calls that read their arguments and keep no state, by exact name and by namespace
+PURE_FUNCTIONS = frozenset({'na', 'nz', 'int', 'float', 'bool', 'array.size', 'array.get', 'array.includes',
+                            'array.first', 'array.last', 'array.indexof', 'map.size', 'map.get', 'map.contains'})
+PURE_NAMESPACES = ('math.', 'str.', 'string.', 'strategy.opentrades.', 'strategy.closedtrades.')
+# `math.random` keeps its generator, `math.sum` its rolling window: both advance only on the bars that run them
+STATEFUL_IN_PURE_NAMESPACES = frozenset({'math.random', 'math.sum'})
+# The same getters called as methods: `values.size()`, `lookup.get(key)`
+PURE_METHODS = frozenset({'size', 'get', 'includes', 'contains', 'first', 'last', 'indexof'})
+
+
+def evaluates_and_or_strictly(script: Script) -> bool:
+    """True for Pine v5 and earlier; a script without a version annotation is v6."""
+    version = script.version.version if script.version else ''
+    return version.isdigit() and int(version) < 6
+
+
+def _dotted_name(node) -> str:
+    if isinstance(node, str):
+        return node
+    if isinstance(node, Identifier):
+        return node.name
+    if isinstance(node, MemberAccess):
+        return f'{_dotted_name(node.object)}.{node.member}'
+    return ''
+
+
+def _is_pure_call(node, user_function_names: FrozenSet[str]) -> bool:
+    if isinstance(node, MethodCall):
+        return node.method in PURE_METHODS and node.method not in user_function_names
+    name = 'na' if isinstance(node.func, NaLiteral) else _dotted_name(node.func)
+    if name in user_function_names:
+        return False
+    if name in PURE_FUNCTIONS:
+        return True
+    return name.startswith(PURE_NAMESPACES) and name not in STATEFUL_IN_PURE_NAMESPACES
+
+
+def _is_pure(node, user_function_names: FrozenSet[str]) -> bool:
+    if isinstance(node, (FunctionCall, MethodCall)):
+        return _is_pure_call(node, user_function_names)
+    if not isinstance(node, PURE_NODE_TYPES):
+        return False
+    # `ta.tr`, `ta.vwap`, ... are written without () but are calls with state
+    return _dotted_name(node) not in TA_VARIABLE_FUNCTIONS
+
+
+def may_have_effect(expression: Expression, user_function_names: FrozenSet[str]) -> bool:
+    """Whether evaluating `expression` can advance a history or bind a name."""
+    return any(not _is_pure(node, user_function_names) for node in walk(expression))
+
+
+def _flatten(expression: Expression, operator: str, operands: List[Expression]) -> None:
+    """The operands of a chain of one operator, left to right; a nested group of the same
+    operator joins the chain, since strict evaluation is associative."""
+    if isinstance(expression, BinaryOp) and expression.op == operator:
+        _flatten(expression.left, operator, operands)
+        _flatten(expression.right, operator, operands)
+    else:
+        operands.append(expression)
+
+
+def strict_operands(expression: BinaryOp, user_function_names: FrozenSet[str]) -> Optional[List[Expression]]:
+    """The operands to evaluate together, or None when the plain operator is enough."""
+    if expression.op not in BOOLEAN_OPERATORS:
+        return None
+    operands: List[Expression] = []
+    _flatten(expression, expression.op, operands)
+    return operands if any(may_have_effect(operand, user_function_names) for operand in operands[1:]) else None

pine2pyne/symbol_table.py

@@ -0,0 +1,166 @@
+"""
+Symbol table for tracking variable declarations and scopes.
+
+Used by the transformer to determine variable types and manage scope.
+"""
+from typing import Dict, List, Optional, Set
+from enum import Enum
+
+
+class VariableKind(Enum):
+    """Classification of variable kinds in Pine Script."""
+    VAR = "var"  # Persistent variable (var keyword)
+    VARIP = "varip"  # Persistent intrabar variable
+    INPUT = "input"  # Input parameter
+    SERIES = "series"  # Series variable (default for globals)
+    SIMPLE = "simple"  # Simple (non-series) variable
+    FUNCTION = "function"  # Function name
+    PARAMETER = "parameter"  # Function parameter
+    TYPE = "type"  # User-defined type (UDT) declaration
+
+
+class Symbol:
+    """Represents a symbol (variable, function) in the symbol table."""
+
+    def __init__(
+        self,
+        name: str,
+        kind: VariableKind,
+        type_hint: Optional[str] = None,
+        is_global: bool = False,
+        line: int = 0,
+        column: int = 0,
+    ):
+        self.name = name
+        self.kind = kind
+        self.type_hint = type_hint
+        self.is_global = is_global
+        self.line = line
+        self.column = column
+        self.is_series = False  # Will be set by type inference
+        self.is_indexed = False  # True if variable is indexed with [n]
+        self.is_from_ta_function = False  # True if assigned from ta.* function
+
+
+class Scope:
+    """Represents a lexical scope."""
+
+    def __init__(self, parent: Optional['Scope'] = None):
+        self.parent = parent
+        self.symbols: Dict[str, Symbol] = {}
+
+    def define(self, symbol: Symbol) -> None:
+        """Define a symbol in this scope."""
+        self.symbols[symbol.name] = symbol
+
+    def lookup(self, name: str) -> Optional[Symbol]:
+        """Look up a symbol in this scope or parent scopes."""
+        if name in self.symbols:
+            return self.symbols[name]
+        if self.parent:
+            return self.parent.lookup(name)
+        return None
+
+    def lookup_local(self, name: str) -> Optional[Symbol]:
+        """Look up a symbol only in this scope (not parent)."""
+        return self.symbols.get(name)
+
+
+class SymbolTable:
+    """Manages symbol definitions and scopes."""
+
+    def __init__(self):
+        self.global_scope = Scope()
+        self.current_scope = self.global_scope
+        self.builtin_symbols = self._init_builtins()
+        # UDT name -> field name -> declared (Python) type, from `type` declarations
+        self.udt_field_types: Dict[str, Dict[str, str]] = {}
+
+    def _init_builtins(self) -> Set[str]:
+        """Initialize built-in Pine Script variables."""
+        return {
+            # Price data
+            'open', 'high', 'low', 'close', 'volume',
+            'hl2', 'hlc3', 'ohlc4', 'hlcc4',
+            # Bar data
+            'bar_index', 'time', 'timenow',
+            # Bar state
+            'barstate.isfirst', 'barstate.islast', 'barstate.ishistory',
+            'barstate.isrealtime', 'barstate.isnew', 'barstate.isconfirmed',
+            # Constants
+            'na', 'true', 'false',
+            # Color constants
+            'color.red', 'color.green', 'color.blue', 'color.white', 'color.black',
+            'color.yellow', 'color.orange', 'color.purple', 'color.gray',
+            # Plot styles
+            'plot.style_line', 'plot.style_stepline', 'plot.style_histogram',
+            'plot.style_cross', 'plot.style_area', 'plot.style_columns',
+            'plot.style_circles', 'plot.style_linebr', 'plot.style_steplinebr',
+            # Strategy constants
+            'strategy.long', 'strategy.short',
+            'strategy.commission.percent', 'strategy.commission.cash_per_contract',
+            'strategy.commission.cash_per_order',
+            'strategy.percent', 'strategy.fixed', 'strategy.cash',
+            'strategy.percent_of_equity',
+        }
+
+    def enter_scope(self) -> None:
+        """Enter a new scope."""
+        self.current_scope = Scope(parent=self.current_scope)
+
+    def exit_scope(self) -> None:
+        """Exit the current scope."""
+        if self.current_scope.parent:
+            self.current_scope = self.current_scope.parent
+
+    def define(self, symbol: Symbol) -> None:
+        """Define a symbol in the current scope."""
+        self.current_scope.define(symbol)
+
+    def lookup(self, name: str) -> Optional[Symbol]:
+        """Look up a symbol in current or parent scopes, then among the builtins.
+
+        A user declaration that reuses a builtin name shadows it (Pine allows
+        `close = bar_index * 2`), so the nearest declared symbol wins and only an
+        undeclared builtin name resolves to a freshly synthesized SERIES symbol.
+        """
+        declared = self.current_scope.lookup(name)
+        if declared is not None:
+            return declared
+
+        if name in self.builtin_symbols:
+            return Symbol(name, VariableKind.SERIES, is_global=True)
+
+        return None
+
+    def lookup_global(self, name: str) -> Optional[Symbol]:
+        """Look up a symbol only in global scope."""
+        return self.global_scope.lookup_local(name)
+
+    def is_builtin(self, name: str) -> bool:
+        """Check if name is a built-in symbol."""
+        return name in self.builtin_symbols
+
+    def get_all_globals(self) -> List[Symbol]:
+        """Get all symbols defined in global scope."""
+        return list(self.global_scope.symbols.values())
+
+    def mark_as_indexed(self, name: str) -> None:
+        """Mark a variable as being indexed (e.g., close[1])."""
+        symbol = self.lookup(name)
+        if symbol:
+            symbol.is_indexed = True
+            symbol.is_series = True  # Indexed variables are always Series
+
+    def mark_as_series(self, name: str) -> None:
+        """Mark a variable as a Series type."""
+        symbol = self.lookup(name)
+        if symbol:
+            symbol.is_series = True
+
+    def mark_from_ta_function(self, name: str) -> None:
+        """Mark a variable as assigned from a ta.* function."""
+        symbol = self.lookup(name)
+        if symbol:
+            symbol.is_from_ta_function = True
+            symbol.is_series = True  # ta.* functions return Series

pine2pyne/tokens.py

@@ -0,0 +1,143 @@
+"""
+Token type definitions for Pine Script v6 lexer.
+"""
+from enum import Enum, auto
+from dataclasses import dataclass
+from typing import Any, Optional
+
+
+class TokenType(Enum):
+    """All token types supported by the Pine Script v6 lexer."""
+
+    # Literals
+    INT_LITERAL = auto()
+    FLOAT_LITERAL = auto()
+    STRING_LITERAL = auto()
+    BOOL_LITERAL = auto()
+    COLOR_LITERAL = auto()
+    NA_LITERAL = auto()
+
+    # Identifiers and types
+    IDENTIFIER = auto()
+    TYPE_IDENTIFIER = auto()
+
+    # Keywords
+    VAR = auto()
+    VARIP = auto()
+    IF = auto()
+    ELSE = auto()
+    FOR = auto()
+    TO = auto()
+    BY = auto()
+    IN = auto()
+    WHILE = auto()
+    SWITCH = auto()
+    BREAK = auto()
+    CONTINUE = auto()
+    IMPORT = auto()
+    EXPORT = auto()
+    METHOD = auto()
+    TYPE = auto()
+    ENUM = auto()
+    NOT = auto()
+    AND = auto()
+    OR = auto()
+    FUNCTION = auto()
+    TRUE = auto()
+    FALSE = auto()
+
+    # Operators
+    ASSIGN = auto()          # =
+    REASSIGN = auto()        # :=
+    PLUS_ASSIGN = auto()     # +=
+    MINUS_ASSIGN = auto()    # -=
+    MULT_ASSIGN = auto()     # *=
+    DIV_ASSIGN = auto()      # /=
+    MOD_ASSIGN = auto()      # %=
+    PLUS = auto()            # +
+    MINUS = auto()           # -
+    MULT = auto()            # *
+    DIV = auto()             # /
+    MOD = auto()             # %
+    GT = auto()              # >
+    LT = auto()              # <
+    GTE = auto()             # >=
+    LTE = auto()             # <=
+    EQ = auto()              # ==
+    NEQ = auto()             # !=
+    ARROW = auto()           # =>
+    TERNARY = auto()         # ?
+    COLON = auto()           # :
+    DOT = auto()             # .
+
+    # Delimiters
+    LPAREN = auto()          # (
+    RPAREN = auto()          # )
+    LBRACKET = auto()        # [
+    RBRACKET = auto()        # ]
+    COMMA = auto()           # ,
+    NEWLINE = auto()         # \n
+    INDENT = auto()          # Increase indentation
+    DEDENT = auto()          # Decrease indentation
+    EOF = auto()             # End of file
+
+    # Special
+    COMMENT = auto()         # // comment
+    VERSION_ANNOTATION = auto()     # //@version=6
+    COMPILER_ANNOTATION = auto()    # //@description, //@function, etc.
+
+
+# Keywords mapping
+KEYWORDS = {
+    'var': TokenType.VAR,
+    'varip': TokenType.VARIP,
+    'if': TokenType.IF,
+    'else': TokenType.ELSE,
+    'for': TokenType.FOR,
+    'to': TokenType.TO,
+    'by': TokenType.BY,
+    'in': TokenType.IN,
+    'while': TokenType.WHILE,
+    'switch': TokenType.SWITCH,
+    'break': TokenType.BREAK,
+    'continue': TokenType.CONTINUE,
+    'import': TokenType.IMPORT,
+    'export': TokenType.EXPORT,
+    'method': TokenType.METHOD,
+    'type': TokenType.TYPE,
+    'enum': TokenType.ENUM,
+    'not': TokenType.NOT,
+    'and': TokenType.AND,
+    'or': TokenType.OR,
+    'function': TokenType.FUNCTION,
+    'true': TokenType.TRUE,
+    'false': TokenType.FALSE,
+    'na': TokenType.NA_LITERAL,
+}
+
+# Type identifiers (Pine Script built-in types)
+TYPE_KEYWORDS = {
+    'int', 'float', 'bool', 'string', 'color',
+    'line', 'label', 'box', 'table', 'linefill', 'polyline',
+    'array', 'matrix', 'map',
+    'series', 'simple', 'input', 'const',
+}
+
+
+@dataclass
+class Token:
+    """Represents a single token from the Pine Script source."""
+    type: TokenType
+    value: Any
+    line: int
+    column: int
+    lexeme: Optional[str] = None
+    is_double_quoted: bool = False  # Track if string literal was double-quoted in source
+
+    def __repr__(self) -> str:
+        if self.lexeme:
+            return f"Token({self.type.name}, {self.value!r}, {self.line}:{self.column}, {self.lexeme!r})"
+        return f"Token({self.type.name}, {self.value!r}, {self.line}:{self.column})"
+
+    def __str__(self) -> str:
+        return self.__repr__()