pine2pyne 0.2.5__tar.gz → 0.2.6__tar.gz

{pine2pyne-0.2.5/pine2pyne.egg-info → pine2pyne-0.2.6}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: pine2pyne
-Version: 0.2.5
-Summary: Pine Script v6 to PyneCore Python transpiler
-Author: rubycell
+Version: 0.2.6
+Summary: Pine Script v4, v5 and v6 to PyneCore Python transpiler
+Author: tripolskypetr
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://github.com/pine2pyne/pine2pyne
 Project-URL: Repository, https://github.com/pine2pyne/pine2pyne

{pine2pyne-0.2.5 → pine2pyne-0.2.6}/pine2pyne/__init__.py

@@ -1,11 +1,11 @@
 """
-pine2pyne: Pine Script v6 to PyneCore Python transpiler.
+pine2pyne: Pine Script v4, v5 and 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.5'
+__version__ = '0.2.6'
 __author__ = 'Pine2Pyne Transpiler'
 
 from .lexer import Lexer, tokenize
@@ -48,7 +48,7 @@ def transpile(source: str, profile: 'OutputProfile | str | None' = None) -> str:
     * ``'legacy'`` - the historical pine2pyne layout, kept as a reference.
 
     Args:
-        source: Pine Script v6 source code
+        source: Pine Script v4, v5 or v6 source code
         profile: output profile (an :class:`OutputProfile` or its name)
 
     Returns:

{pine2pyne-0.2.5 → pine2pyne-0.2.6}/pine2pyne/ast_nodes.py

@@ -1,5 +1,5 @@
 """
-AST (Abstract Syntax Tree) node definitions for Pine Script v6.
+AST (Abstract Syntax Tree) node definitions for Pine Script v4, v5 and v6.
 
 All node types used by the parser to represent Pine Script syntax.
 """
@@ -127,9 +127,9 @@ class FuncDecl(ASTNode):
     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)
+    is_overload: bool = False  # One of several same-name declarations
     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)
+    value_is_bool: bool = False  # Pine v6: its value is of type bool
 
 
 @dataclass
@@ -238,7 +238,7 @@ class Identifier(Expression):
 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)."""
+    first case test, so it is evaluated once, where Pine evaluates it."""
     name: str = ""
     value: Expression = None
 
@@ -263,7 +263,7 @@ class IfExpression(Expression):
     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)
+    value_is_bool: bool = False  # Pine v6: its value is of type bool
     chained: bool = False  # written `else if` after the if before it (not an `if` inside an `else` block)
 
 
@@ -273,7 +273,7 @@ class SwitchExpression(Expression):
     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)
+    value_is_bool: bool = False  # Pine v6: its value is of type bool
 
 
 # ============================================================================
@@ -319,12 +319,12 @@ class ForLoop(Statement):
     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)
+    value_is_bool: bool = False  # Pine v6: its value is of type bool
     # 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 (`pine_loop`) that re-reads it; empty for a fixed `pine_range`
     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)
+    range_helper: str = ""  # the name `pine_range` is imported under for a fixed loop; empty is `pine_range`
     # the value of an assignment (`x = for ...`): PyneComp writes no default step for it, even in Pine v4/v5
     is_assigned_value: bool = False
 
@@ -335,7 +335,7 @@ class ForInLoop(Statement):
     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)
+    value_is_bool: bool = False  # Pine v6: its value is of type bool
 
 
 @dataclass
@@ -343,7 +343,7 @@ 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)
+    value_is_bool: bool = False  # Pine v6: its value is of type bool
 
 
 @dataclass
@@ -357,7 +357,7 @@ class SwitchStatement(Statement):
 @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."""
+    a `var` flag and an `if` (once_lowering.py); no later stage sees it."""
     condition: Optional[Expression] = None
     body: List[Statement] = field(default_factory=list)
 

{pine2pyne-0.2.5 → pine2pyne-0.2.6}/pine2pyne/ast_walk.py

@@ -5,7 +5,7 @@ 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
+an else-if arm was not seen. Every generic walk goes through
 `walk` (to find nodes) or `map_children` (to rebuild them), so the containers
 are decided in one place.
 

{pine2pyne-0.2.5 → pine2pyne-0.2.6}/pine2pyne/block_value_lowering.py

@@ -11,7 +11,7 @@ they run when the branch is taken, and its last expression is the value:
     else
         0.0
 
-A Python conditional expression cannot hold statements (card #41: the branch
+A Python conditional expression cannot hold statements (the branch
 was emitted as `None`). This pre-pass rewrites every such value into the idiom
 Pine authors write by hand, which the transformer already emits correctly:
 
@@ -25,7 +25,7 @@ Pine authors write by hand, which the transformer already emits correctly:
 A block-valued switch becomes an if / else-if chain over a temporary that holds
 the subject, so the subject is evaluated once. `var`/`varip` targets run the
 lowered statements once, behind a flag. A branch that is a single binding
-(`k := close`) is a block too: its binding runs, and its value is k (card #50).
+(`k := close`) is a block too: its binding runs, and its value is k.
 
 A loop used as a value (`s = for …`, `s = while …`, a branch or a function tail
 that ends in a loop) yields what its body's tail gave on the last iteration
@@ -40,7 +40,7 @@ written to a fresh local, so the body still reads the target's old value:
 
 An arm that does not run (an if without else) yields false for a bool value
 and na otherwise; a tuple-returning one yields a tuple of na as wide as its
-tuples (cards #50, #54). `s op= <block>` reads s, then runs the block into a
+tuples. `s op= <block>` reads s, then runs the block into a
 fresh local (premise P1: Pine's operand order is UNVERIFIED on TradingView).
 `[a, b] = <if/switch/loop>` fills a fresh local that starts as a tuple of na,
 destructured once. A block value anywhere else (an operand of an operator, a
@@ -80,7 +80,7 @@ Write = Callable[[Expression], object]  # the statement that takes a value
 def lower_block_values(script: Script) -> Script:
     """Return a copy of `script` with every block value lowered to statements.
     A script without one is returned unchanged. An untaken bool arm is false
-    only where `stamp_bool_values` stamped its value first (card #56)."""
+    only where `stamp_bool_values` stamped its value first."""
     if not _needs_lowering_somewhere(script):
         return script
     return _BlockValueLowering(collect_names(script), _UserFunctions.of(script),
@@ -107,7 +107,7 @@ def _needs_lowering_somewhere(script: Script) -> bool:
     accepts a function in a block. Other such functions are left to the
     transformer, so they do not cost this pass a copy of the script. This runs
     on every node of every script, hence the dispatch on the node's type
-    (card #50, transpile-time gate)."""
+    (transpile-time gate)."""
     untaken_tails = []
     for node in walk(script):
         if type(node) in CHILDLESS_NODE_TYPES:
@@ -130,7 +130,7 @@ def _needs_lowering_somewhere(script: Script) -> bool:
 def _has_loop_operand(node) -> bool:
     """True when a loop is a direct child of `node`: a bound value, an operand.
     Runs on every expression of every script, so it reads the fields once and
-    builds no lists (card #50, transpile-time gate)."""
+    builds no lists (transpile-time gate)."""
     for name in child_field_names(type(node)):
         child = getattr(node, name)
         if isinstance(child, LOOPS) or (type(child) is list and any(isinstance(item, LOOPS) for item in child)):
@@ -154,7 +154,7 @@ def has_block_branch(expression) -> bool:
     tail, is a block: several statements, a sole binding, or a tail statement
     with no value. A default-only switch with a subject counts too: its
     subject runs as a statement before the default, so its side effect is
-    kept (card #43)."""
+    kept."""
     if not isinstance(expression, VALUE_EXPRESSIONS):
         return False
     if isinstance(expression, SwitchExpression) and not expression.cases and expression.expr is not None:
@@ -164,7 +164,7 @@ def has_block_branch(expression) -> bool:
             return True  # an inline switch case `0 => for …` keeps its loop bare
         if isinstance(branch, list) and branch and (len(branch) > 1
                                                     or isinstance(branch[-1], VALUELESS_TAILS + BINDINGS)):
-            # a sole binding `k := close` is a block: the binding must run (card #50)
+            # a sole binding `k := close` is a block: the binding must run
             return True
         tail = _tail_expression(branch)
         if has_block_branch(tail):
@@ -262,8 +262,8 @@ def _is_bool_value(value) -> bool:
 def yields_bool(value) -> bool:
     """True when an arm of `value` yields a bool by its syntax. Only the slot of
     a loop that runs no iteration reads it: Pine's guide gives false to an
-    untaken if/switch arm, which the bool typing decides (card #56), and says
-    nothing of a loop, so that slot stays as #50 left it (UNVERIFIED)."""
+    untaken if/switch arm, which the bool typing decides, and says
+    nothing of a loop, so that slot stays as it is (UNVERIFIED)."""
     return any(_is_bool_value(tail) for tail in _value_tails(value))
 
 
@@ -280,8 +280,8 @@ THREE_STATE_BOOL_VERSIONS = ('4', '5')
 
 def keeps_three_state_bool(script: Script) -> bool:
     """True for a Pine v4 or v5 script: its bool may be na (`bool b = na`, a bool history before
-    warm-up), so its decorator sets the runtime's `na_bool` switch (card #99, item 5; MEASURED on
-    TradingView 2026-10-06, probe6). A script with no version annotation is v6, as in `bool_is_never_na`."""
+    warm-up), so its decorator sets the runtime's `na_bool` switch (MEASURED on
+    TradingView 2026-10-06). A script with no version annotation is v6, as in `bool_is_never_na`."""
     return bool(script.version) and script.version.version in THREE_STATE_BOOL_VERSIONS
 
 
@@ -391,7 +391,7 @@ class _BlockValueLowering:
 
     def untaken_of(self, value, value_is_bool: bool) -> _Untaken:
         """`value_is_bool` is the stamp of the if/switch/loop, or of the
-        function, whose value `value` is (bool_value_typing, card #56)."""
+        function, whose value `value` is (bool_value_typing)."""
         return _Untaken(tuple_width=_tuple_width(value, self.functions), is_bool=value_is_bool,
                         never_run_is_bool=self.bool_is_never_na and yields_bool(value))
 
@@ -575,7 +575,7 @@ class _BlockValueLowering:
     def compound_statement(self, node: Reassignment) -> list:
         """`s op= <block>`: s is read first, then the block runs into a fresh
         local, then `s := <s as read> op <block value>`. Reading s first is
-        premise P1, UNVERIFIED on TradingView (card #51)."""
+        premise P1, UNVERIFIED on TradingView."""
         operation = node.value
         left_operand = fresh_name('left_operand', self.used_names)
         block_value = fresh_name('block_value', self.used_names)
@@ -590,7 +590,7 @@ class _BlockValueLowering:
     def tuple_statement(self, node: Assignment) -> list:
         """`[a, b] = <if/switch/loop>`: the value goes to a fresh local that
         starts as a tuple of na as wide as the target, as does an arm that
-        does not run; the target destructures it once (card #50)."""
+        does not run; the target destructures it once."""
         names = list(node.target.names)
         untaken = _Untaken(tuple_width=len(names))
         slot = fresh_name('tuple_value', self.used_names)
@@ -630,7 +630,7 @@ class _BlockValueLowering:
                                                                   line=self.line)])
         if node.body and self.tail_is_lowered(node):
             # every arm of the tail ends in the expression it yields, which the
-            # transformer's tail walk returns (cards #53, #54)
+            # transformer's tail walk returns
             *leading, tail = node.body
             lowered_leading = self.statements(leading)
             enclosing_line, self.line = self.line, tail.line or self.line
@@ -645,7 +645,7 @@ class _BlockValueLowering:
     def tail_is_lowered(self, node: FuncDecl) -> bool:
         """A tail the transformer cannot return by itself: one that reaches a
         loop, or a tuple-returning if/switch with an arm that may not run,
-        which yields a tuple of na (card #54). A function the script
+        which yields a tuple of na. A function the script
         destructures, whose tuple width is unknown, is refused."""
         if _tail_reaches_loop(node.body):
             return True

{pine2pyne-0.2.5 → pine2pyne-0.2.6}/pine2pyne/bool_builtins.py

@@ -4,7 +4,7 @@ each builtin series, as the runtime annotates them.
 
 GENERATED by tools/collect_bool_builtins.py from opencode-pyneruntime 6.9.4; do not
 edit by hand. In Pine v6 an untaken if/switch whose value is of type bool is
-false, not na; bool_value_typing reads these to type a builtin (card #56).
+false, not na; bool_value_typing reads these to type a builtin.
 """
 from typing import Dict, FrozenSet
 

{pine2pyne-0.2.5 → pine2pyne-0.2.6}/pine2pyne/bool_value_typing.py

@@ -1,5 +1,5 @@
 """
-Pine v6 bool typing of the values an untaken arm can default (card #56).
+Pine v6 bool typing of the values an untaken arm can default.
 
 In Pine v6 an if/switch whose value is of TYPE bool gives false for an arm
 that does not run, not na (migration guide to v6). The type comes from the
@@ -67,12 +67,12 @@ def reads_na_of_bool(script: Script) -> bool:
     """Whether a named bool value is read where it may be na: with history (`b[1]`) or
     through `na(b)`. Pine v5 marks only such a script `na_bool=True`; the history of an
     expression (`(a > b)[1]`) or of an untyped parameter does not count. Measured with
-    probe scripts compiled by PyneComp v6.0.80; 82 of the 327 v5 scripts of the reference."""
+    scripts compiled by PyneComp v6.0.80; 82 of the 327 v5 scripts of the reference."""
     typing = _BoolTyping(script)
     for name, scope in typing.na_calls:
         binding = scope.lookup(name)
         if binding is not None and _is_bool_collection(binding.declared_type):
-            return True  # `na(a)` of an `array<bool>`, not its history: any Pine version (probes nb6_02, nb7_*)
+            return True  # `na(a)` of an `array<bool>`, not its history: any Pine version
     if _reads_na_of_a_bool_collection_argument(script):
         return True
     if _declared_version(script) != 5:
@@ -98,7 +98,7 @@ def _is_bool_collection(declared_type) -> bool:
 
 def _reads_na_of_a_bool_collection_argument(script: Script) -> bool:
     """`is_empty(arr) => na(arr) or ...` called with an `array<bool>`: the untyped parameter is a bool
-    collection where it is called with one (probe bis_isEmpty, PyneComp v6.0.80)."""
+    collection where it is called with one (PyneComp v6.0.80)."""
     from .ast_walk import walk
     from .ast_nodes import MethodCall, Parameter
     nodes = list(walk(script))
@@ -133,7 +133,7 @@ def _declared_version(script: Script) -> int:
 
 def has_untaken_bool_switch(script: Script) -> bool:
     """Whether a `switch` without a default arm gives a bool: an untaken switch is na, so a Pine v5
-    script that has one is `na_bool=True` (probes nb3_02..04, PyneComp v6.0.80). A switch used as
+    script that has one is `na_bool=True` (PyneComp v6.0.80). A switch used as
     a value or as a statement whose arms end with a bool (`x := true`) counts; an `if` does not."""
     switches = [node for node in walk_nodes(script)
                 if isinstance(node, (SwitchStatement, SwitchExpression)) and node.default is None and node.cases]
@@ -254,7 +254,7 @@ class _BoolTyping:
     # ------------------------------------------------------------ the walk
     def _walk(self, script: Script) -> None:
         """Visit every node once, giving each the scope it is in. Every file is
-        walked, so the loop makes no call per plain node (card #56 cost gate)."""
+        walked, so the loop makes no call per plain node."""
         pending = [(script, BlockScope(), None)]
         fields_by_type: Dict[type, tuple] = {}
         while pending:

{pine2pyne-0.2.5 → pine2pyne-0.2.6}/pine2pyne/cli.py

@@ -15,7 +15,7 @@ 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',
+        description='Transpile Pine Script v4, v5 and v6 to PyneCore Python',
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog='''
 Examples:
@@ -76,7 +76,7 @@ Examples:
 
 def reporting_semantic_warnings(input_path: Path, action: Callable[[], object]):
     """Run `action`, printing each SemanticWarning it raises as
-    `⚠ <file>:<line>:<column>: <message> [<code>]` (card #28). The warning
+    `⚠ <file>:<line>:<column>: <message> [<code>]`. The warning
     filters stay the user's: a fresh catch_warnings resets Python's
     once-per-location record, so every file reports its own warnings, and
     `-W ignore::pine2pyne.errors.SemanticWarning` silences them. A filter that
@@ -112,8 +112,8 @@ def transpile_file(input_path: Path, output_path: Optional[Path], validate_only:
         source = input_path.read_text(encoding='utf-8')
 
         if validate_only:
-            # Only lex and parse to validate syntax, with transpile()'s repairs (card #55),
-            # and refuse what transpile() refuses (card #28)
+            # Only lex and parse to validate syntax, with transpile()'s repairs,
+            # and refuse what transpile() refuses
             from .di import get_transpiler
 
             if verbose:
@@ -161,7 +161,7 @@ def transpile_file(input_path: Path, output_path: Optional[Path], validate_only:
 
     except Pine2PyneError as e:
         print(f'✗ {input_path}: {e}', file=sys.stderr)
-        # A repaired source that still fails: the first error above, then where it stopped (card #55)
+        # A repaired source that still fails: the first error above, then where it stopped
         cause = e.__cause__
         while isinstance(cause, Pine2PyneError):
             print(f'  after repairing it as valid Pine, the source stops at: {cause}', file=sys.stderr)

{pine2pyne-0.2.5 → pine2pyne-0.2.6}/pine2pyne/codegen.py

@@ -37,11 +37,11 @@ class CodeGenerator:
         self.output: List[str] = []
         # The Pine line of the top-level statement being emitted. The parser
         # stamps only top-level statements, so a refusal of a nested node
-        # reports this line (card #40)
+        # reports this line
         self.top_level_line = 0
-        # Pine v5 and earlier evaluate both operands of and/or (card #65)
+        # Pine v5 and earlier evaluate both operands of and/or
         self.strict_boolean_operators = False
-        # Pine v6 gives a UDT bool field without a default false; before v6 it is na (card #76)
+        # Pine v6 gives a UDT bool field without a default false; before v6 it is na
         self.bool_is_never_na = True
         self.user_function_names: frozenset = frozenset()
         # Output line index -> the Pine line its statement came from. A layout
@@ -119,7 +119,7 @@ class CodeGenerator:
         if script.imports or uses_any:
             self.emit('')
 
-        # 3-5. Module prelude in three phases (card #78): enum classes, then the module
+        # 3-5. Module prelude in three phases: enum classes, then the module
         # constants (they may read an enum member), then the UDT classes (a field default may
         # read an enum member, and cannot read a constant)
         # Enum declarations
@@ -145,7 +145,7 @@ class CodeGenerator:
             self.generate_type_declaration(type_decl)
             self.emit('')
 
-        # A library's export surface: one Exported proxy per exported name, published in __all__ (card #111).
+        # A library's export surface: one Exported proxy per exported name, published in __all__.
         # pynecore's `@export` resolves the proxy by name in this module's globals
         exported_names = list(dict.fromkeys(
             statement.name for statement in script.main_body if isinstance(statement, FuncDecl) and statement.is_export))
@@ -237,7 +237,7 @@ class CodeGenerator:
             prev_source_line = source_line
 
         # A script with no executable statement (a type-only or comment-only
-        # Pine script) still needs a statement under `def main():` (card #15)
+        # Pine script) still needs a statement under `def main():`
         if len(self.output) == main_body_start:
             self.emit('pass')
 
@@ -271,7 +271,7 @@ class CodeGenerator:
     def generate_decorator(self, decl: Union[IndicatorDecl, StrategyDecl, LibraryDecl]) -> str:
         """Generate @script.indicator, @script.strategy or @script.library decorator."""
         name = {IndicatorDecl: 'indicator', LibraryDecl: 'library'}.get(type(decl), 'strategy')
-        # A None title is an expression, emitted as the 'title' keyword (card #55)
+        # A None title is an expression, emitted as the 'title' keyword
         arguments = [] if decl.title is None else [f"'{self._escape_string(decl.title, chr(39))}'"]
         arguments += [f'{key}={self.generate_decorator_value(value)}' for key, value in decl.kwargs.items()]
         return f"@script.{name}({', '.join(arguments)})"
@@ -333,7 +333,7 @@ class CodeGenerator:
         self.indent_level += 1
 
         # Generate fields: a series built-in default is read per instance, a
-        # field without a default is na (card #17, udt_field_defaults)
+        # field without a default is na (udt_field_defaults)
         lines = list(getattr(type_decl, 'field_lines', ()) or ())
         for index, (field_name, field_type, default_value) in enumerate(type_decl.fields):
             if getattr(self, '_keeps_field_gaps', False) and 0 < index < len(lines) and lines[index] - lines[index - 1] > 1:
@@ -388,10 +388,10 @@ class CodeGenerator:
         # Emit @method decorator if this is a method
         if hasattr(func, 'is_method') and func.is_method:
             self.emit('@method')
-        # A library's exported function (card #111); pynecore's @export goes above @overload
+        # A library's exported function; pynecore's @export goes above @overload
         if func.is_export:
             self.emit('@export')
-        # Same-name declarations share one pynecore @overload dispatcher (card #39)
+        # Same-name declarations share one pynecore @overload dispatcher
         if func.is_overload:
             self.emit('@overload')
 
@@ -480,7 +480,7 @@ class CodeGenerator:
                 self.emit(line)
         else:
             # Refuse rather than drop the statement: a comment in its place
-            # changes what the program computes, or leaves a block empty (card #40)
+            # changes what the program computes, or leaves a block empty
             raise CodeGenError(f'Unsupported statement type: {type(stmt).__name__}',
                                line=self.refusal_line(stmt))
 
@@ -559,7 +559,7 @@ class CodeGenerator:
 
     def generate_for_loop(self, stmt: ForLoop) -> None:
         """Generate for loop with pine_range(), or with pine_loop() when the end
-        bound is re-read on every pass (Pine v6, card #82)."""
+        bound is re-read on every pass (Pine v6)."""
         # Convert Pine 'for i = from to to_val [by step]' to Python pine_range()
         from_val = self.generate_expression(stmt.from_val)
         to_val = self.generate_expression(stmt.to_val)
@@ -596,7 +596,7 @@ class CodeGenerator:
         iterable = self.generate_expression(stmt.iterable)
 
         # `for [k, v] in x` reaches here with its pairs already chosen by the
-        # transformer: enumerate(), a map's keys, or a run-time choice (card #17)
+        # transformer: enumerate(), a map's keys, or a run-time choice
         self.emit(f'for {vars_str} in {iterable}:')
 
         self.indent_level += 1
@@ -652,7 +652,7 @@ class CodeGenerator:
         elif isinstance(expr, NaLiteral):
             return 'na'
         else:
-            # A comment in expression position is not Python; refuse (card #40)
+            # A comment in expression position is not Python; refuse
             raise CodeGenError(f'Unsupported expression type: {type(expr).__name__}',
                                line=self.refusal_line(expr))
 
@@ -694,7 +694,7 @@ class CodeGenerator:
         return f'{left} {expr.op} {right}'
 
     def _generate_strict_boolean(self, operator: str, operands: List[Expression]) -> str:
-        """`all((a, b))` / `any((a, b))`: the tuple evaluates every operand, in order (card #65)."""
+        """`all((a, b))` / `any((a, b))`: the tuple evaluates every operand, in order."""
         function = 'all' if operator == 'and' else 'any'
         return f'{function}(({", ".join(self.generate_expression(operand) for operand in operands)}))'
 
@@ -705,7 +705,7 @@ class CodeGenerator:
         The parser keeps no parenthesis node, so grouping exists only in the
         tree shape and every operator-precedence parenthesis between binary
         and unary operators is re-derived here (index and member access on a
-        grouped object are not: card #32).
+        grouped object are not).
         """
         if isinstance(operand, UnaryOp):
             # Pine `not` binds tightest; Python `not` binds looser than any
@@ -793,7 +793,7 @@ class CodeGenerator:
 
     def generate_method_call(self, call: MethodCall) -> str:
         """Generate method call. The transformer routes every builtin method to its
-        namespace (card #8), so what reaches here is a Python method call."""
+        namespace, so what reaches here is a Python method call."""
         from .ast_nodes import BinaryOp, UnaryOp, TernaryOp, IfExpression
 
         obj = self.generate_expression(call.object)

{pine2pyne-0.2.5 → pine2pyne-0.2.6}/pine2pyne/condition_typing.py

@@ -1,8 +1,8 @@
 """Which values PyneComp reads as numbers where Pine wants a condition.
 
 A number in a condition is cast: ``if x`` is ``if cast_bool(x):``. PyneComp
-decides it from what it knows of the value's type; probe scripts compiled by
-PyneComp v6.0.80 (``tmp/probes/cb4..6.pine``) and the reference show what that is.
+decides it from what it knows of the value's type; scripts compiled by
+PyneComp v6.0.80 and its reference output show what that is.
 
 A *name* (or its history, or a literal) is typed from its declaration, at any
 distance: a number literal, a built-in price or time series (``close``,
@@ -51,7 +51,7 @@ COMPARISONS = frozenset({'==', '!=', '<', '>', '<=', '>=', 'and', 'or'})
 _DEPTH = 32
 #: a name declared without a type PyneComp reads: a parameter or a tuple element
 _UNTYPED = object()
-#: a parameter declared without a type: beside it, an `and`/`or` operand is not cast (probes cb16, cb17)
+#: a parameter declared without a type: beside it, an `and`/`or` operand is not cast
 _UNTYPED_PARAMETER = object()
 
 
@@ -81,7 +81,7 @@ class ConditionTyping:
         functions = [node for node in walk(script) if isinstance(node, FuncDecl)]
         inside = set()
         for function in functions:
-            # a typed parameter is its type (`b = vx * 2` with `float vx` is a number, probe cb13)
+            # a typed parameter is its type (`b = vx * 2` with `float vx` is a number)
             values: Dict[str, object] = {parameter.name: ((parameter.type_hint, NaLiteral())
                                                           if parameter.type_hint in ('int', 'float', 'bool')
                                                           else _UNTYPED_PARAMETER if not parameter.type_hint
@@ -103,7 +103,7 @@ class ConditionTyping:
         if isinstance(node, Assignment) and isinstance(node.target, str):
             values.setdefault(node.target, (node.type_hint, node.value))
         elif isinstance(node, Assignment) and hasattr(node.target, 'names'):
-            for name in node.target.names:  # `[a, b] = f()`: untyped (probe-checked on mZigzag)
+            for name in node.target.names:  # `[a, b] = f()`: untyped
                 values.setdefault(name, _UNTYPED)
         elif isinstance(node, (VarDecl, VaripDecl)):
             values.setdefault(node.name, (node.type_hint, node.value))
@@ -139,7 +139,7 @@ class ConditionTyping:
         return False
 
     def has_a_type(self, expression) -> bool:
-        """False for a parameter, beside which PyneComp casts no `and`/`or` operand (probes cb16, cb17)."""
+        """False for a parameter, beside which PyneComp casts no `and`/`or` operand."""
         return not (isinstance(expression, Identifier) and expression.name in self._parameters)
 
     def is_bool(self, expression) -> bool:
@@ -241,14 +241,14 @@ class ConditionTyping:
                 return None  # PyneComp does not type a user function's result in an if/while header
             if self._in_function:
                 # inside a function PyneComp reads no function's result type: a call is a number when
-                # an argument is arithmetic (`f(x, -1.0)`, `f(x, 0 - 1)`), else untyped (probes cb10..cb12)
+                # an argument is arithmetic (`f(x, -1.0)`, `f(x, 0 - 1)`), else untyped
                 arguments = list(call.args) + list(call.kwargs.values())
                 return 'number' if any(_is_arithmetic(argument) for argument in arguments) else None
             declaration = self._functions[function]
             body = declaration.body
             tail = body[-1] if isinstance(body, list) and body else body
             tail = getattr(tail, 'expr', tail)
-            # the tail reads the callee's names: its typed parameters are their type (probe cb8, `v * 2`)
+            # the tail reads the callee's names: its typed parameters are their type (`v * 2`)
             outer = self._values
             self._values = {**self._global_values, **self._function_values.get(_scope_key(declaration), {}),
                             **{parameter.name: (parameter.type_hint, NaLiteral()) for parameter in declaration.params

{pine2pyne-0.2.5 → pine2pyne-0.2.6}/pine2pyne/conditional_history_calls.py

@@ -1,8 +1,8 @@
-"""A `ta.*` call that runs on only some bars (card #96).
+"""A `ta.*` call that runs on only some bars.
 
 Pine keeps a call site's series history by running the call on every bar. A `ta.*` call
 reached only when a condition holds keeps a history that skips the other bars, so its value
-differs from the same call made on every bar (card #60 measured this: the transpiled output
+differs from the same call made on every bar (measured: the transpiled output
 matches Pine's call-site semantics in every construct, and a hoisted call gives another value).
 The Pine User Manual (Execution model) says to run such functions in the global scope for
 consistent results. The transpiler never hoists: it keeps the call where the script has it and
@@ -14,7 +14,7 @@ A call is conditional when it sits in:
 - a branch of `?:`;
 - a `switch` arm or its default, or a case after the first (the first case is always read);
 - the right operand of `and` / `or` in Pine v6, which evaluates them lazily. Pine v5 and earlier
-  evaluate both operands (card #65), so the right operand there is not conditional.
+  evaluate both operands, so the right operand there is not conditional.
 
 A function body starts unconditional again: whether the function is called conditionally is not
 decided here. A loop body is not conditional. `ta.vwap` and the other argument-free `ta.`

{pine2pyne-0.2.5 → pine2pyne-0.2.6}/pine2pyne/emit/pynecomp/blank_lines.py

@@ -1,6 +1,6 @@
 """Where PyneComp leaves blank lines inside a function body.
 
-Measured on ``assets/pyne``: for a Pine v4/v5 script every blank line in
+Measured on PyneComp's output: for a Pine v4/v5 script every blank line in
 ``main`` follows a nested ``def``/``class`` (619 of 622 modules); a Pine v6
 script keeps the blank lines of its source (291 of 293 modules have some).
 
@@ -9,7 +9,7 @@ a comment. The statements PyneComp moves out of ``main`` to the module (the
 constants the inputs read) keep their marks: between two statements of
 ``main``, ``n`` marks (the moved statements' and the second statement's own)
 print ``(2n + 1) // 3`` blank lines. Inputs, which become ``main``'s
-parameters, leave no mark. Measured with probe scripts compiled by PyneComp
+parameters, leave no mark. Measured with scripts compiled by PyneComp
 v6.0.80 (``n`` = 1..6) and checked on the 71 such gaps of the reference.
 """
 from __future__ import annotations

{pine2pyne-0.2.5 → pine2pyne-0.2.6}/pine2pyne/emit/pynecomp/imports.py

@@ -1,6 +1,6 @@
 """The import block, laid out the way PyneComp lays it out.
 
-Measured on the 1005 reference modules in ``assets/pyne``:
+Measured on 1005 modules compiled by PyneComp:
 
 * ``from`` imports come first, one per module, modules in alphabetical order;
   plain ``import`` statements (library imports) follow, sorted;

{pine2pyne-0.2.5 → pine2pyne-0.2.6}/pine2pyne/emit/pynecomp/passes/annotations.py

@@ -9,7 +9,7 @@
 * A series or persistent annotation keeps its element type (``Series[float]``)
   only then; otherwise it is bare (``Series``).
 
-Measured on ``assets/pyne``: 2626 ``str``, 1254 ``int``, 1048 ``float``, 1146
+Measured on PyneComp's output: 2626 ``str``, 1254 ``int``, 1048 ``float``, 1146
 ``bool``, 941 ``Color`` declarations; ``Series`` 2108 bare against 859 typed.
 """
 from __future__ import annotations
@@ -62,7 +62,7 @@ def inferable_type(value: ast.expr | None, classes: frozenset = frozenset(),
                    methods: frozenset = frozenset()) -> str | None:
     """The type PyneComp reads off a value without inference, or None. ``classes``:
     the module's UDT classes, whose constructor call names its type; ``methods``: the user
-    methods, whose call on a constructor (`T.new().m()`) PyneComp types as `T` (probe mc5)."""
+    methods, whose call on a constructor (`T.new().m()`) PyneComp types as `T`."""
     found = literal_type(value)
     if found:
         return found
@@ -129,7 +129,7 @@ class DeclaredTypes:
 
     @staticmethod
     def _generic_constructor_type(value) -> str | None:
-        """`map.new<string, bool>()` names its type, `map<string, bool>` (probe nb4_02); `T.copy(x)` names `T`
+        """`map.new<string, bool>()` names its type, `map<string, bool>`; `T.copy(x)` names `T`
         (Trendoscope/Zigzag `lPivot: Pivot = udt_copy(...)`)."""
         from ....ast_nodes import FunctionCall
         if isinstance(value, FunctionCall) and isinstance(value.func, str) and value.func.startswith('map.new<'):
@@ -232,7 +232,7 @@ class DeclarationAnnotationPass:
         self._classes = frozenset(node.name for node in tree.body if isinstance(node, ast.ClassDef))
         self._methods = frozenset(node.name for node in ast.walk(tree) if isinstance(node, ast.FunctionDef)
                                   and any(isinstance(d, ast.Name) and d.id == 'method' for d in node.decorator_list))
-        # each UDT's fields and their annotations: a field read is typed by its field (probe nodes1)
+        # each UDT's fields and their annotations: a field read is typed by its field
         self._fields = {node.name: {field.target.id: _unquoted(field.annotation) for field in node.body
                                     if isinstance(field, ast.AnnAssign) and isinstance(field.target, ast.Name)}
                         for node in tree.body if isinstance(node, ast.ClassDef)}