pine2pyne 0.2.4__py3-none-any.whl

pine2pyne/emit/__init__.py

@@ -0,0 +1,5 @@
+"""Code emitters, one per output profile (see :class:`pine2pyne.core.OutputProfile`)."""
+from .legacy import LegacyEmitter
+from .pynecomp import PyneCompEmitter, PyneCompModulePrinter
+
+__all__ = ['LegacyEmitter', 'PyneCompEmitter', 'PyneCompModulePrinter']

pine2pyne/emit/legacy.py

@@ -0,0 +1,14 @@
+"""pine2pyne's own output layout (the historical default)."""
+from __future__ import annotations
+
+from ..codegen import CodeGenerator
+from ..core.contracts import CompilationUnit, OutputProfile
+
+
+class LegacyEmitter:
+    """Prints the transformed tree with :class:`~pine2pyne.codegen.CodeGenerator` as is."""
+
+    profile = OutputProfile.LEGACY
+
+    def emit(self, unit: CompilationUnit) -> str:
+        return CodeGenerator().generate(unit.transformed)

pine2pyne/emit/pynecomp/__init__.py

@@ -0,0 +1,20 @@
+"""Output profile reproducing the layout of the closed PyneComp v6.0.79 compiler."""
+from .banner import PyneCompBanner
+from .blank_lines import AfterDefinitionPolicy, BlankLinePolicy, SourceLayoutPolicy
+from .emitter import PyneCompEmitter
+from .imports import ImportBlockFormatter
+from .printer import LayoutSource, PyneCompModulePrinter
+from .unparser import ExpressionPrinter, SourceQuotingUnparser, source_quoted_strings, string_literal
+
+__all__ = [
+    'AfterDefinitionPolicy',
+    'BlankLinePolicy',
+    'ExpressionPrinter',
+    'ImportBlockFormatter',
+    'LayoutSource',
+    'PyneCompBanner',
+    'PyneCompEmitter',
+    'PyneCompModulePrinter',
+    'SourceLayoutPolicy',
+    'SourceQuotingUnparser',
+]

pine2pyne/emit/pynecomp/banner.py

@@ -0,0 +1,30 @@
+"""The fixed text PyneComp puts around every module it compiles."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class PyneCompBanner:
+    """Module docstring and ``__main__`` footer of a PyneComp module."""
+
+    compiler: str = 'PyneComp v6.0.79'
+    magic: str = '@pyne edge'
+
+    def header(self) -> list[str]:
+        return [
+            '"""',
+            self.magic,
+            '',
+            f'This code was compiled by {self.compiler} — the Pine Script to Python compiler.',
+            'Run with open-source PyneCore: https://pynecore.org',
+            'Compile Pine Scripts online at PyneSys: https://pynesys.io',
+            '"""',
+        ]
+
+    def footer(self) -> list[str]:
+        return [
+            'if __name__ == "__main__":',
+            '    from pynecore.standalone import run',
+            '    run(__file__)',
+        ]

pine2pyne/emit/pynecomp/blank_lines.py

@@ -0,0 +1,69 @@
+"""Where PyneComp leaves blank lines inside a function body.
+
+Measured on ``assets/pyne``: 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).
+
+A Pine v6 statement *marks* a gap when the Pine line just above it is blank or
+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
+v6.0.80 (``n`` = 1..6) and checked on the 71 such gaps of the reference.
+"""
+from __future__ import annotations
+
+import ast
+from typing import Mapping, Protocol, Sequence
+
+_BLOCK_DEFINITIONS = (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)
+
+
+class BlankLinePolicy(Protocol):
+    def blank_lines_before(self, previous: ast.stmt, current: ast.stmt) -> int: ...
+
+
+class AfterDefinitionPolicy:
+    """Pine v4/v5: one blank line after a nested function or class, none elsewhere."""
+
+    def blank_lines_before(self, previous: ast.stmt, current: ast.stmt) -> int:
+        return 1 if isinstance(previous, _BLOCK_DEFINITIONS) else 0
+
+
+class SourceLayoutPolicy:
+    """Pine v6: a blank line where the Pine line just above the statement is
+    blank or a comment (a dropped comment leaves a blank line behind).
+
+    ``origins`` maps a Python line number to the Pine line the statement
+    printed there came from.
+    """
+
+    def __init__(self, origins: Mapping[int, int], pine_lines: Sequence[str],
+                 moved_lines: Sequence[int] = ()) -> None:
+        self._origins = origins
+        self._pine_lines = pine_lines
+        #: the Pine lines of the statements moved out of main() to the module
+        self._moved_lines = sorted(set(moved_lines))
+
+    def _pine_line(self, node: ast.stmt) -> int:
+        decorators = getattr(node, 'decorator_list', None)
+        first = min(decorator.lineno for decorator in decorators) if decorators else node.lineno
+        return self._origins.get(first, 0)
+
+    def _marks(self, line: int) -> bool:
+        above = self._pine_lines[line - 2].strip() if 0 <= line - 2 < len(self._pine_lines) else ''
+        return not above or above.startswith('//')
+
+    def blank_lines_before(self, previous: ast.stmt, current: ast.stmt) -> int:
+        line = self._pine_line(current)
+        previous_line = self._pine_line(previous)
+        after_definition = isinstance(previous, _BLOCK_DEFINITIONS)
+        # `a = 1, b = 2` on one Pine line; a value's last assignment after its lowered block (`x = switch`)
+        if not after_definition and (line <= 1 or line <= previous_line):
+            return 0
+        # a nested def or class marks the gap after it once, whatever its source has (467 of 467 gaps)
+        marks = (1 if after_definition else 0) + (1 if line > 1 and self._marks(line) else 0)
+        if 0 < previous_line < line:
+            marks += sum(1 for moved in self._moved_lines if previous_line < moved < line and self._marks(moved))
+        return max((2 * marks + 1) // 3, 1 if after_definition else 0)

pine2pyne/emit/pynecomp/emitter.py

@@ -0,0 +1,61 @@
+"""The PyneComp output profile: pine2pyne semantics, PyneComp layout."""
+from __future__ import annotations
+
+import ast
+import sys
+from typing import Sequence
+
+from ...codegen import CodeGenerator
+from ...core.contracts import CompilationUnit, OutputProfile
+from ...errors import CodeGenError
+from .passes import ModulePass, PassContext
+from .printer import LayoutSource, PyneCompModulePrinter
+
+
+class PyneCompEmitter:
+    """Generates code with :class:`~pine2pyne.codegen.CodeGenerator`, then
+    re-prints it with :class:`PyneCompModulePrinter`.
+
+    Three separate concerns: the generator decides *what* the program says,
+    the passes respell it the way PyneComp spells it, the printer lays it out.
+    """
+
+    profile = OutputProfile.PYNECOMP
+
+    def __init__(self, printer: PyneCompModulePrinter, passes: Sequence[ModulePass] = ()) -> None:
+        self._printer = printer
+        self._passes = tuple(passes)
+
+    #: the AST passes walk an expression recursively: a long concatenation (forex_factory_events_id_A) is deep
+    RECURSION_LIMIT = 20000
+
+    def emit(self, unit: CompilationUnit) -> str:
+        if sys.getrecursionlimit() < self.RECURSION_LIMIT:
+            sys.setrecursionlimit(self.RECURSION_LIMIT)
+        # Pine v4/v5 strict and/or is StrictBooleanHoistingPass's job, not all((...))
+        unit.transformed.strict_boolean_operators = False
+        generator = CodeGenerator(keep_keyword_string_quotes=True)
+        python_source = generator.generate(unit.transformed)
+        # an output element may span several lines (the import block does)
+        first_line_of: list[int] = []
+        line_number = 1
+        for element in generator.output:
+            first_line_of.append(line_number)
+            line_number += element.count('\n') + 1
+        origins = {first_line_of[index]: pine_line for index, pine_line in generator.line_origins.items()
+                   if index < len(first_line_of)}
+        source = LayoutSource(
+            python_source=python_source,
+            pine_source=unit.pine_source,
+            pine_version=unit.pine_version,
+            origins=origins,
+        )
+        try:
+            tree = ast.parse(python_source)
+        except SyntaxError as error:  # a construct the generator spelled as no valid Python
+            raise CodeGenError(f'the generated code is not valid Python: {error.msg}',
+                               line=origins.get(error.lineno or 0, 0)) from error
+        context = PassContext(unit=unit, origins=origins)
+        for module_pass in self._passes:
+            module_pass.apply(tree, context)
+        return self._printer.render(source, tree, context.spellings)

pine2pyne/emit/pynecomp/imports.py

@@ -0,0 +1,65 @@
+"""The import block, laid out the way PyneComp lays it out.
+
+Measured on the 1005 reference modules in ``assets/pyne``:
+
+* ``from`` imports come first, one per module, modules in alphabetical order;
+  plain ``import`` statements (library imports) follow, sorted;
+* names of a ``pynecore`` module are sorted (code-point order), ``typing``
+  keeps the order it was given;
+* a ``from`` line up to 100 characters stays on one line; a longer one is
+  parenthesised and its names filled greedily, 77 characters on the first
+  inner line and 99 on the following ones (856 of 857 wrapped imports).
+"""
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class ImportBlockFormatter:
+    single_line_limit: int = 100
+    first_line_width: int = 77
+    next_line_width: int = 99
+    indent: str = '    '
+    unsorted_modules: frozenset = frozenset({'typing'})
+
+    def format(self, statements: list[ast.stmt]) -> list[str]:
+        from_imports: dict[str, list[str]] = {}
+        plain_imports: list[str] = []
+        for statement in statements:
+            if isinstance(statement, ast.ImportFrom):
+                module = '.' * statement.level + (statement.module or '')
+                names = from_imports.setdefault(module, [])
+                for alias in statement.names:
+                    spelled = alias.name if alias.asname is None else f'{alias.name} as {alias.asname}'
+                    if spelled not in names:
+                        names.append(spelled)
+            elif isinstance(statement, ast.Import):
+                line = ast.unparse(statement)
+                if line not in plain_imports:
+                    plain_imports.append(line)
+        lines: list[str] = []
+        for module in sorted(from_imports):
+            names = from_imports[module]
+            if module not in self.unsorted_modules:
+                names = sorted(names)
+            lines.extend(self._from_import(module, names))
+        return lines + sorted(plain_imports)  # library imports sorted by path (23 of 23 in the reference)
+
+    def _from_import(self, module: str, names: list[str]) -> list[str]:
+        single = f'from {module} import {", ".join(names)}'
+        if len(single) <= self.single_line_limit:
+            return [single]
+        rows: list[list[str]] = [[]]
+        for name in names:
+            row = rows[-1]
+            width = self.first_line_width if len(rows) == 1 else self.next_line_width
+            candidate = self.indent + ', '.join(row + [name]) + ','
+            if row and len(candidate) > width:
+                rows.append([name])
+            else:
+                row.append(name)
+        body = [self.indent + ', '.join(row) + ',' for row in rows[:-1]]
+        body.append(self.indent + ', '.join(rows[-1]))
+        return [f'from {module} import ('] + body + [')']

pine2pyne/emit/pynecomp/passes/__init__.py

@@ -0,0 +1,84 @@
+"""Python-AST rewrites from pine2pyne's spelling to PyneComp's."""
+from .annotations import ClosureHistoryPass, ColorCastPass, DeclarationAnnotationPass, SeriesAnnotationPass
+from .base import ModulePass, PassContext
+from .builtins import (
+    CurrentValuePass,
+    InputOptionsPass,
+    LegacyHlineStylePass,
+    LegacyLineWidthPass,
+    LegacyStrategyDirectionPass,
+    ShadowedNamespacePass,
+    TaSeriesPass,
+)
+from .hoisting import LegacyIffPass, StrictBooleanHoistingPass
+from .imports import ImportReconciliationPass
+from .legacy_colors import LegacyTransparencyPass
+from .library import LibraryPreamblePass
+from .rewrites import (
+    ArithmeticReassociationPass,
+    DeclarationCallShapePass,
+    FlatBoolOpPass,
+    HexColorPass,
+    MathNamespacePass,
+    NaBoolFlagPass,
+    StrategyDefaultsPass,
+)
+
+
+def default_passes() -> tuple[ModulePass, ...]:
+    """The PyneComp rewrites in the order they apply; imports are reconciled last."""
+    return (
+        DeclarationCallShapePass(),
+        StrategyDefaultsPass(),
+        NaBoolFlagPass(),
+        SeriesAnnotationPass(),
+        LegacyTransparencyPass(),
+        HexColorPass(),
+        ColorCastPass(),
+        MathNamespacePass(),
+        TaSeriesPass(),
+        LegacyStrategyDirectionPass(),
+        LegacyLineWidthPass(),
+        CurrentValuePass(),
+        LegacyHlineStylePass(),
+        InputOptionsPass(),
+        FlatBoolOpPass(),
+        ArithmeticReassociationPass(),
+        StrictBooleanHoistingPass(),
+        LegacyIffPass(),
+        DeclarationAnnotationPass(),
+        ClosureHistoryPass(),
+        ShadowedNamespacePass(),
+        LibraryPreamblePass(),
+        ImportReconciliationPass(),
+    )
+
+
+__all__ = [
+    'LibraryPreamblePass',
+    'ArithmeticReassociationPass',
+    'ClosureHistoryPass',
+    'ColorCastPass',
+    'CurrentValuePass',
+    'InputOptionsPass',
+    'LegacyHlineStylePass',
+    'LegacyLineWidthPass',
+    'LegacyStrategyDirectionPass',
+    'TaSeriesPass',
+    'DeclarationCallShapePass',
+    'FlatBoolOpPass',
+    'HexColorPass',
+    'ImportReconciliationPass',
+    'LegacyIffPass',
+    'LegacyTransparencyPass',
+    'MathNamespacePass',
+    'DeclarationAnnotationPass',
+    'ModulePass',
+    'NaBoolFlagPass',
+    'PassContext',
+    'SeriesAnnotationPass',
+    'ShadowedNamespacePass',
+    'StrategyDefaultsPass',
+    'StrictBooleanHoistingPass',
+    'default_passes',
+]