pine2pyne 0.2.4__py3-none-any.whl

pine2pyne/pipeline/service.py

@@ -0,0 +1,70 @@
+"""The transpile use case, composed from injected stages."""
+from __future__ import annotations
+
+from typing import Sequence
+
+from ..core.contracts import (
+    AstNormalizer,
+    CodeEmitter,
+    CompilationUnit,
+    ScriptTransformer,
+    SemanticGuard,
+    SourceFilter,
+    SourceParser,
+)
+
+
+class TranspileService:
+    """Pine source -> Python source.
+
+    The service only orders the stages; it knows nothing about how any of
+    them works (S and D in SOLID). Swap a stage by registering another
+    implementation of its contract in the container.
+    """
+
+    def __init__(
+        self,
+        source_filter: SourceFilter,
+        parser: SourceParser,
+        normalizers: Sequence[AstNormalizer],
+        guard: SemanticGuard,
+        transformer: ScriptTransformer,
+        emitter: CodeEmitter,
+    ) -> None:
+        self._source_filter = source_filter
+        self._parser = parser
+        self._normalizers = tuple(normalizers)
+        self._guard = guard
+        self._transformer = transformer
+        self._emitter = emitter
+
+    @property
+    def emitter(self) -> CodeEmitter:
+        return self._emitter
+
+    def _front_end(self, source: str):
+        script = self._parser.parse(source)
+        for normalizer in self._normalizers:
+            script = normalizer.normalize(script)
+        self._guard.check(script)
+        return script
+
+    def transpile(self, source: str) -> str:
+        """Python source for ``source``; an empty string for a comment-only source.
+
+        Raises:
+            Pine2PyneError: if any stage refuses the script.
+        """
+        if self._source_filter.is_blank(source):
+            return ''
+        script = self._front_end(source)
+        transformed = self._transformer.transform(script)
+        return self._emitter.emit(CompilationUnit(pine_source=source, pine_script=script, transformed=transformed))
+
+    def validate(self, source: str) -> None:
+        """Parse and run the semantic guard without generating code (``--validate``).
+
+        Unlike :meth:`transpile`, the legacy name pass is skipped, as the CLI's
+        ``--validate`` always did: it checks the script as written.
+        """
+        self._guard.check(self._parser.parse(source))

pine2pyne/pipeline/stages.py

@@ -0,0 +1,73 @@
+"""Concrete pipeline stages: thin adapters over the transpiler engine.
+
+Each class implements one contract from :mod:`pine2pyne.core.contracts` and
+delegates to the engine module that already does the work, so the engine
+keeps its own tests while the application layer sees only abstractions.
+"""
+from __future__ import annotations
+
+from ..ast_nodes import Script
+from ..input_hoisting import hoist_inputs
+from ..legacy_function_names import qualify_legacy_function_names
+from ..legacy_sessions import qualify_legacy_sessions
+from ..parse_repair import parse_source
+from ..pine_semantics import enforce
+from ..transformer import PyneTransformedScript, Transformer
+
+
+class CommentOnlySourceFilter:
+    """A source made of comments and whitespace has nothing to transpile."""
+
+    def is_blank(self, source: str) -> bool:
+        if not source:
+            return True
+        for line in source.splitlines():
+            stripped = line.strip()
+            if stripped and not stripped.startswith('//'):
+                return False
+        return True
+
+
+class RepairingSourceParser:
+    """Lex and parse; a rejected known spelling of valid Pine is repaired (card #55)."""
+
+    def parse(self, source: str) -> Script:
+        script, _repairs = parse_source(source)
+        return script
+
+
+class LegacyFunctionNameNormalizer:
+    """Pine v1-v4 call names are spelled the way Pine v5 spells them (card #116)."""
+
+    def normalize(self, script: Script) -> Script:
+        return qualify_legacy_function_names(script)
+
+
+class LegacySessionNormalizer:
+    """Pine v4 sessions of time()/time_close() get v4's default days (see :mod:`pine2pyne.legacy_sessions`)."""
+
+    def normalize(self, script: Script) -> Script:
+        return qualify_legacy_sessions(script)
+
+
+class InputHoistingNormalizer:
+    """Every top-level input call becomes a main() parameter (see :mod:`pine2pyne.input_hoisting`)."""
+
+    def normalize(self, script: Script) -> Script:
+        return hoist_inputs(script)
+
+
+class PineSemanticGuard:
+    """Refuse what TradingView's compiler refuses, at the Pine line (card #28)."""
+
+    def check(self, script: Script) -> None:
+        enforce(script)
+
+
+class FreshTransformer:
+    """:class:`~pine2pyne.transformer.Transformer` is single-use (card #83):
+    this stage builds a fresh one for every script, so the stage itself is
+    stateless and safe to share."""
+
+    def transform(self, script: Script) -> PyneTransformedScript:
+        return Transformer().transform(script)