pine2pyne 0.2.4__py3-none-any.whl

pine2pyne/condition_typing.py

@@ -0,0 +1,260 @@
+"""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.
+
+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``,
+``bar_index``), arithmetic over numbers, ``time()``, ``nz()``, ``math.*``, the
+``ta.*`` calls that do not give a bool, a number input, a cast. An arm that is na
+does not count (``h = c ? close : na`` is a number), except in a typed declaration
+read outside an ``if``/``while`` header: there ``float x = c ? close : na`` is not,
+while the header reads the declared type (and ``float x = na`` is a number
+everywhere). A name holding a user function's result is a number except in an
+``if``/``while`` header. Such a name is cast in every condition but under ``not``
+(where only a pivot is).
+
+An *expression* written in the condition is cast only when it is ``ta.change(x)``
+of a number, ``time(...)``/``time_close(...)`` or a pivot, or, as the condition of
+a ternary that does not choose colours, arithmetic over numbers. ``nz()``,
+``math.*``, ``array.size()`` and user function calls written there are not.
+"""
+from __future__ import annotations
+
+from typing import Dict, Optional
+
+from .ast_nodes import (
+    Assignment, BinaryOp, FuncDecl, FunctionCall, Identifier, IfExpression, IndexAccess, InputDecl, Literal,
+    NaLiteral, Script, SwitchExpression, TernaryOp, UnaryOp, VarDecl, VaripDecl,
+)
+from .ast_walk import walk
+from .bool_builtins import BOOL_BUILTINS
+
+#: the built-in series that are numbers
+NUMERIC_SERIES = frozenset({
+    'open', 'high', 'low', 'close', 'volume', 'hl2', 'hlc3', 'ohlc4', 'hlcc4', 'bar_index', 'last_bar_index',
+    'time', 'time_close', 'timenow', 'time_tradingday', 'last_bar_time', 'dayofweek', 'dayofmonth', 'hour',
+    'minute', 'second', 'month', 'year', 'weekofyear', 'ta.tr', 'ta.vwap', 'ta.obv', 'ta.accdist', 'ta.iii',
+    'ta.nvi', 'ta.pvi', 'ta.pvt', 'ta.wad', 'ta.wvad'})
+#: calls whose result is a number
+NUMERIC_CALLS = frozenset({'time', 'time_close', 'timestamp', 'int', 'float', 'str.tonumber', 'input.int', 'abs', 'max', 'min',
+                           'round', 'pow',
+                           'input.float', 'input.source', 'input.price', 'input.time'})
+#: calls that give their first argument's type
+PASS_THROUGH_CALLS = frozenset({'nz', 'fixnan'})
+PIVOTS = frozenset({'ta.pivothigh', 'ta.pivotlow'})
+#: calls PyneComp casts where they are written as a condition
+DIRECT_CASTS = frozenset({'time', 'time_close'}) | PIVOTS
+ARITHMETIC = frozenset({'+', '-', '*', '/', '%'})
+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)
+_UNTYPED_PARAMETER = object()
+
+
+def _scope_key(function: FuncDecl) -> tuple:
+    """A function's scope, the same for the copies later lowerings make of its declaration."""
+    return function.name, function.line, function.column, len(function.params)
+
+
+def _is_arithmetic(expression) -> bool:
+    return (isinstance(expression, UnaryOp) and expression.op in ('-', '+')) or (
+        isinstance(expression, BinaryOp) and expression.op in ARITHMETIC)
+
+
+class ConditionTyping:
+    """The condition typing of one script (renamed, before the transformation)."""
+
+    def __init__(self, script: Script) -> None:
+        self._functions: Dict[str, FuncDecl] = {}
+        for node in walk(script):
+            if isinstance(node, FuncDecl):
+                self._functions.setdefault(node.name, node)
+        #: the declarations of the script's top level, and of each function (by id) on its own
+        self._global_values: Dict[str, object] = {}
+        self._function_values: Dict[tuple, Dict[str, object]] = {}
+        self._function_parameters: Dict[tuple, set] = {}
+        self._parameters: set = set()
+        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)
+            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
+                                                          else _UNTYPED)
+                                         for parameter in function.params}
+            for node in walk(function.body):
+                inside.add(id(node))
+                self._record(node, values)
+            self._function_values[_scope_key(function)] = values
+            self._function_parameters[_scope_key(function)] = {parameter.name for parameter in function.params}
+        for node in walk(script):
+            if id(node) not in inside and not isinstance(node, FuncDecl):
+                self._record(node, self._global_values)
+        self._values: Dict[str, object] = self._global_values
+        self._in_function = False
+
+    @staticmethod
+    def _record(node, values: Dict[str, object]) -> None:
+        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)
+                values.setdefault(name, _UNTYPED)
+        elif isinstance(node, (VarDecl, VaripDecl)):
+            values.setdefault(node.name, (node.type_hint, node.value))
+        elif isinstance(node, InputDecl):
+            values.setdefault(node.name, FunctionCall(func=node.func, args=node.args, kwargs=node.kwargs))
+
+    def enter(self, function: Optional[FuncDecl]) -> None:
+        """Type names as `function` sees them (its own declarations first); None: the top level."""
+        local = self._function_values.get(_scope_key(function)) if function is not None else None
+        self._values = {**self._global_values, **local} if local is not None else self._global_values
+        self._parameters = self._function_parameters.get(_scope_key(function), set()) if function is not None else set()
+        self._in_function = local is not None
+
+    # ------------------------------------------------------------ questions
+
+    def is_number(self, expression, header: bool = False, colour_ternary: bool = False,
+                  ternary: bool = False) -> bool:
+        """Whether PyneComp casts `expression`, written as a condition: `header` an if/while
+        condition, `ternary` the condition of a ternary (`colour_ternary`: one choosing colours)."""
+        written = expression
+        while isinstance(written, IndexAccess):
+            written = written.object
+        if isinstance(written, Identifier) and written.name in self._parameters:
+            return False  # a parameter as a condition is never cast, typed or not (jordanfray library)
+        if isinstance(written, (Identifier, Literal)):
+            return self._kind(expression, header, _DEPTH) == 'number'
+        if isinstance(written, FunctionCall) and isinstance(written.func, str):
+            if written.func in DIRECT_CASTS or (written.func == 'ta.change' and written.args):
+                return self._kind(expression, header, _DEPTH) == 'number'
+            return False
+        if isinstance(written, (BinaryOp, UnaryOp)) and ternary and not colour_ternary:
+            return self._kind(expression, header, _DEPTH) == 'number'
+        return False
+
+    def has_a_type(self, expression) -> bool:
+        """False for a parameter, beside which PyneComp casts no `and`/`or` operand (probes cb16, cb17)."""
+        return not (isinstance(expression, Identifier) and expression.name in self._parameters)
+
+    def is_bool(self, expression) -> bool:
+        """Whether `expression` is a bool where it is compared (`flag == 1`); a history read is not."""
+        if isinstance(expression, IndexAccess):
+            return False
+        return self._kind(expression, False, _DEPTH) == 'bool'
+
+    def is_pivot(self, expression) -> bool:
+        """`ta.pivothigh(...)`/`ta.pivotlow(...)`, or a name declared as one."""
+        for _ in range(_DEPTH):
+            if isinstance(expression, Identifier) and expression.name in self._values:
+                expression, _ = self._declared_value(expression.name, False)
+                continue
+            break
+        return isinstance(expression, FunctionCall) and expression.func in PIVOTS
+
+    # ------------------------------------------------------------ typing
+
+    def _declared_value(self, name: str, header: bool):
+        """The value `name` is typed from, and whether an arm that is na leaves it untyped."""
+        value = self._values.get(name)
+        if value is _UNTYPED or value is _UNTYPED_PARAMETER:
+            return None, False
+        if not isinstance(value, tuple):
+            return value, False
+        type_hint, value = value
+        if type_hint == 'bool':  # a number given to a bool declaration is cast there (`bool b = ta.change(t)`)
+            return Literal(value=True, literal_type='bool'), False
+        if type_hint in ('int', 'float') and (header or isinstance(value, NaLiteral) or value is None):
+            # an if/while header reads the declared type, as does every context for `float x = na`
+            return Literal(value=0 if type_hint != 'bool' else True, literal_type=type_hint), False
+        # elsewhere a typed declaration is typed from its value, where a na arm leaves it untyped
+        return value, type_hint is not None
+
+    def _kind(self, value, header: bool, depth: int, strict_na: bool = False) -> Optional[str]:
+        if depth <= 0 or value is None:
+            return None
+        depth -= 1
+        if isinstance(value, Literal):
+            if value.literal_type in ('int', 'float'):
+                return 'number'
+            return 'bool' if value.literal_type == 'bool' else None
+        if isinstance(value, NaLiteral):
+            return None
+        if isinstance(value, Identifier):
+            if value.name in ('true', 'false'):
+                return 'bool'
+            if value.name in NUMERIC_SERIES:
+                return 'number'
+            if value.name in self._values:
+                declared, strict = self._declared_value(value.name, header)
+                return self._kind(declared, header, depth, strict)
+            return None
+        if isinstance(value, IndexAccess):
+            return self._kind(value.object, header, depth)
+        if isinstance(value, UnaryOp):
+            if value.op == 'not':
+                return 'bool'
+            return self._kind(value.operand, header, depth)
+        if isinstance(value, BinaryOp):
+            if value.op in COMPARISONS:
+                return 'bool'
+            if value.op in ARITHMETIC:
+                kinds = {self._kind(value.left, header, depth), self._kind(value.right, header, depth)}
+                return 'number' if kinds == {'number'} else None
+            return None
+        if isinstance(value, TernaryOp):
+            arms = [value.true_expr, value.false_expr]
+            if strict_na and any(isinstance(arm, NaLiteral) for arm in arms):
+                return None  # `float x = c ? low : na` read outside an if/while header
+            kinds = {self._kind(arm, header, depth, strict_na) for arm in arms if not isinstance(arm, NaLiteral)}
+            return kinds.pop() if len(kinds) == 1 else None
+        if isinstance(value, (IfExpression, SwitchExpression)):
+            return None
+        if isinstance(value, FunctionCall):
+            return self._call_kind(value, header, depth)
+        return None
+
+    def _call_kind(self, call: FunctionCall, header: bool, depth: int) -> Optional[str]:
+        function = call.func if isinstance(call.func, str) else None
+        if function is None:
+            return None
+        if function in BOOL_BUILTINS or function in ('input.bool', 'bool'):
+            return 'bool'
+        if function in NUMERIC_CALLS or function.startswith('math.'):
+            return 'number'
+        if function in PASS_THROUGH_CALLS:
+            return self._kind(call.args[0], header, depth) if call.args else None
+        if function == 'ta.change' and call.args and self._kind(call.args[0], header, depth) == 'bool':
+            return 'bool'  # the change of a bool is a bool
+        if function.startswith('ta.'):
+            return 'number'
+        if function == 'input':
+            default = call.args[0] if call.args else call.kwargs.get('defval')
+            return self._kind(default, header, depth)
+        if function in self._functions:
+            if header:
+                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)
+                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`)
+            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
+                               if parameter.type_hint in ('int', 'float', 'bool')}}
+            try:
+                return self._kind(tail, header, depth)
+            finally:
+                self._values = outer
+        return None

pine2pyne/conditional_history_calls.py

@@ -0,0 +1,96 @@
+"""A `ta.*` call that runs on only some bars (card #96).
+
+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
+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
+reports the site, as TradingView does, so the author decides.
+
+A call is conditional when it sits in:
+- the body of an `if`, `else if` or `else`, or an `else if` condition (it is read only when the
+  earlier ones failed), as a statement or as a value;
+- 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.
+
+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.`
+variables are not calls and are hoisted by the transpiler already.
+"""
+from typing import List
+
+from .ast_nodes import (
+    BinaryOp, FuncDecl, FunctionCall, IfExpression, IfStatement, Script, SwitchExpression, SwitchStatement,
+    TernaryOp,
+)
+from .ast_walk import child_field_names, is_node
+from .strict_boolean import BOOLEAN_OPERATORS, evaluates_and_or_strictly
+
+HISTORY_CALL_PREFIX = 'ta.'
+
+
+def conditional_history_calls(script: Script) -> List[FunctionCall]:
+    """Every `ta.*` call of `script` that runs on only some bars, in source order."""
+    finder = _ConditionalCallFinder(evaluates_and_or_strictly(script))
+    finder.visit(script, False)
+    return sorted(finder.calls, key=lambda call: (call.line, call.column))
+
+
+class _ConditionalCallFinder:
+    def __init__(self, right_operand_always_runs: bool):
+        self.right_operand_always_runs = right_operand_always_runs
+        self.calls: List[FunctionCall] = []
+
+    def visit(self, value, conditional: bool) -> None:
+        if isinstance(value, (list, tuple)):
+            for item in value:
+                self.visit(item, conditional)
+        elif isinstance(value, dict):
+            for item in value.values():
+                self.visit(item, conditional)
+        elif is_node(value):
+            self.visit_node(value, conditional)
+
+    def visit_node(self, node, conditional: bool) -> None:
+        if isinstance(node, (IfStatement, IfExpression, TernaryOp)):
+            self.visit_branches(node, conditional)
+        elif isinstance(node, (SwitchStatement, SwitchExpression)):
+            self.visit_switch(node, conditional)
+        elif isinstance(node, BinaryOp) and node.op in BOOLEAN_OPERATORS:
+            self.visit(node.left, conditional)
+            self.visit(node.right, conditional or not self.right_operand_always_runs)
+        elif isinstance(node, FuncDecl):
+            self.visit(node.params, False)
+            self.visit(node.body, False)
+        else:
+            if conditional and isinstance(node, FunctionCall) and _is_history_call(node):
+                self.calls.append(node)
+            for name in child_field_names(type(node)):
+                self.visit(getattr(node, name), conditional)
+
+    def visit_branches(self, node, conditional: bool) -> None:
+        """The condition always runs; each branch and every `else if` condition only after it."""
+        self.visit(node.condition, conditional)
+        if isinstance(node, IfStatement):
+            self.visit(node.body, True)
+            for condition, body in node.elseifs:
+                self.visit(condition, True)
+                self.visit(body, True)
+            self.visit(node.else_body, True)
+        else:
+            self.visit(node.true_expr, True)
+            self.visit(node.false_expr, True)
+
+    def visit_switch(self, node, conditional: bool) -> None:
+        self.visit(node.expr, conditional)
+        for index, (case, body) in enumerate(node.cases):
+            self.visit(case, conditional if index == 0 else True)
+            self.visit(body, True)
+        self.visit(node.default, True)
+
+
+def _is_history_call(call: FunctionCall) -> bool:
+    return isinstance(call.func, str) and call.func.startswith(HISTORY_CALL_PREFIX)

pine2pyne/core/__init__.py

@@ -0,0 +1,26 @@
+"""Pipeline contracts: the abstractions every pine2pyne stage implements."""
+from .contracts import (
+    AstNormalizer,
+    CodeEmitter,
+    CompilationUnit,
+    OutputProfile,
+    ScriptTransformer,
+    SemanticGuard,
+    SourceFilter,
+    SourceParser,
+    Transpiler,
+    TranspilerSettings,
+)
+
+__all__ = [
+    'AstNormalizer',
+    'CodeEmitter',
+    'CompilationUnit',
+    'OutputProfile',
+    'ScriptTransformer',
+    'SemanticGuard',
+    'SourceFilter',
+    'SourceParser',
+    'Transpiler',
+    'TranspilerSettings',
+]

pine2pyne/core/contracts.py

@@ -0,0 +1,125 @@
+"""Abstractions of the transpilation pipeline (the D in SOLID).
+
+Every stage of pine2pyne is described here as a small Protocol. The
+application service (:class:`pine2pyne.pipeline.service.TranspileService`)
+depends only on these abstractions; concrete stages live in
+:mod:`pine2pyne.pipeline.stages` and :mod:`pine2pyne.emit`, and are wired
+together by the dishka container in :mod:`pine2pyne.di`.
+
+Stages are deliberately narrow (the I in SOLID): a parser only parses, a
+guard only refuses, an emitter only prints. A new output target is a new
+:class:`CodeEmitter` implementation plus a provider, with no edit of the
+service (the O in SOLID).
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import TYPE_CHECKING, Mapping, Protocol, runtime_checkable
+
+if TYPE_CHECKING:  # the engine modules are heavy; contracts only name them
+    from ..ast_nodes import Script
+    from ..transformer import PyneTransformedScript
+
+
+class OutputProfile(str, Enum):
+    """Which compiler's output the emitter reproduces."""
+
+    #: byte-for-byte layout of the closed PyneComp v6.0.79 compiler (the default)
+    PYNECOMP = 'pynecomp'
+    #: the historical pine2pyne layout, kept as a reference
+    LEGACY = 'legacy'
+
+    @classmethod
+    def parse(cls, value: 'OutputProfile | str | None') -> 'OutputProfile':
+        if value is None:
+            return cls.PYNECOMP
+        if isinstance(value, cls):
+            return value
+        try:
+            return cls(str(value).lower())
+        except ValueError:
+            names = ', '.join(profile.value for profile in cls)
+            raise ValueError(f'unknown output profile {value!r} (expected one of: {names})') from None
+
+
+@dataclass(frozen=True)
+class TranspilerSettings:
+    """Application-wide configuration, handed to the container as context."""
+
+    profile: OutputProfile = OutputProfile.PYNECOMP
+
+
+@dataclass
+class CompilationUnit:
+    """Everything an emitter may need about one script.
+
+    ``pine_source`` and ``pine_script`` let an emitter recover source layout
+    (blank lines, quote style, the Pine version); ``transformed`` is the
+    PyneCore-shaped tree the code generator prints.
+    """
+
+    pine_source: str
+    pine_script: 'Script'
+    transformed: 'PyneTransformedScript'
+    metadata: Mapping[str, object] = field(default_factory=dict)
+
+    @property
+    def pine_version(self) -> int | None:
+        version = getattr(self.pine_script, 'version', None)
+        text = getattr(version, 'version', None)
+        return int(text) if text and str(text).isdigit() else None
+
+
+@runtime_checkable
+class SourceFilter(Protocol):
+    """Decides whether a source has anything to transpile at all."""
+
+    def is_blank(self, source: str) -> bool: ...
+
+
+@runtime_checkable
+class SourceParser(Protocol):
+    """Pine source text -> Pine AST (lexing, parsing and known repairs)."""
+
+    def parse(self, source: str) -> 'Script': ...
+
+
+@runtime_checkable
+class AstNormalizer(Protocol):
+    """Pine AST -> Pine AST rewrite that keeps the program's meaning
+    (e.g. spelling Pine v1-v4 call names the way v5 spells them)."""
+
+    def normalize(self, script: 'Script') -> 'Script': ...
+
+
+@runtime_checkable
+class SemanticGuard(Protocol):
+    """Refuses what TradingView's compiler refuses; returns nothing."""
+
+    def check(self, script: 'Script') -> None: ...
+
+
+@runtime_checkable
+class ScriptTransformer(Protocol):
+    """Pine AST -> PyneCore-shaped tree."""
+
+    def transform(self, script: 'Script') -> 'PyneTransformedScript': ...
+
+
+@runtime_checkable
+class CodeEmitter(Protocol):
+    """PyneCore-shaped tree -> Python source text, in one output profile."""
+
+    profile: OutputProfile
+
+    def emit(self, unit: CompilationUnit) -> str: ...
+
+
+@runtime_checkable
+class Transpiler(Protocol):
+    """The use case: Pine source text -> Python source text."""
+
+    def transpile(self, source: str) -> str: ...
+
+    def validate(self, source: str) -> None: ...

pine2pyne/di.py

@@ -0,0 +1,173 @@
+"""Composition root: the dishka container that wires the pipeline.
+
+Every concrete class is named here and nowhere else in the application
+layer. A provider groups one responsibility; an output profile is one
+provider, so a new target compiler is a new provider (open/closed)::
+
+    from pine2pyne.di import make_transpiler_container
+    from pine2pyne.core import OutputProfile, Transpiler
+
+    container = make_transpiler_container(OutputProfile.PYNECOMP)
+    print(container.get(Transpiler).transpile(pine_source))
+    container.close()
+
+All stages are stateless (the single-use Transformer and CodeGenerator are
+created per call inside their stages), so everything lives in ``Scope.APP``
+and one container serves any number of scripts.
+"""
+from __future__ import annotations
+
+from typing import Sequence
+
+from dishka import Container, Provider, Scope, from_context, make_container, provide
+
+from .core.contracts import (
+    AstNormalizer,
+    CodeEmitter,
+    OutputProfile,
+    ScriptTransformer,
+    SemanticGuard,
+    SourceFilter,
+    SourceParser,
+    Transpiler,
+    TranspilerSettings,
+)
+from .emit.legacy import LegacyEmitter
+from .emit.pynecomp import ImportBlockFormatter, PyneCompBanner, PyneCompEmitter, PyneCompModulePrinter
+from .emit.pynecomp.passes import ModulePass, default_passes
+from .pipeline.service import TranspileService
+from .pipeline.stages import (
+    CommentOnlySourceFilter,
+    FreshTransformer,
+    InputHoistingNormalizer,
+    LegacyFunctionNameNormalizer,
+    LegacySessionNormalizer,
+    PineSemanticGuard,
+    RepairingSourceParser,
+)
+
+
+class SettingsProvider(Provider):
+    """Configuration handed in by the caller as container context."""
+
+    settings = from_context(provides=TranspilerSettings, scope=Scope.APP)
+
+
+class FrontEndProvider(Provider):
+    """Pine text -> checked Pine AST."""
+
+    scope = Scope.APP
+
+    source_filter = provide(CommentOnlySourceFilter, provides=SourceFilter)
+    parser = provide(RepairingSourceParser, provides=SourceParser)
+    guard = provide(PineSemanticGuard, provides=SemanticGuard)
+
+    @provide
+    def normalizers(self) -> Sequence[AstNormalizer]:
+        return (LegacyFunctionNameNormalizer(), LegacySessionNormalizer(), InputHoistingNormalizer())
+
+
+class MiddleEndProvider(Provider):
+    """Pine AST -> PyneCore-shaped tree."""
+
+    scope = Scope.APP
+
+    transformer = provide(FreshTransformer, provides=ScriptTransformer)
+
+
+class LegacyOutputProvider(Provider):
+    """pine2pyne's own layout."""
+
+    scope = Scope.APP
+
+    emitter = provide(LegacyEmitter, provides=CodeEmitter)
+
+
+class PyneCompOutputProvider(Provider):
+    """The layout of the closed PyneComp v6.0.79 compiler."""
+
+    scope = Scope.APP
+
+    @provide
+    def banner(self) -> PyneCompBanner:
+        return PyneCompBanner()
+
+    @provide
+    def imports(self) -> ImportBlockFormatter:
+        return ImportBlockFormatter()
+
+    @provide
+    def printer(self, banner: PyneCompBanner, imports: ImportBlockFormatter) -> PyneCompModulePrinter:
+        return PyneCompModulePrinter(banner=banner, imports=imports)
+
+    @provide
+    def passes(self) -> Sequence[ModulePass]:
+        return default_passes()
+
+    @provide
+    def emitter(self, printer: PyneCompModulePrinter, passes: Sequence[ModulePass]) -> CodeEmitter:
+        return PyneCompEmitter(printer, passes)
+
+
+class ApplicationProvider(Provider):
+    """The use case, assembled from whatever the other providers bound."""
+
+    scope = Scope.APP
+
+    @provide
+    def transpiler(
+        self,
+        source_filter: SourceFilter,
+        parser: SourceParser,
+        normalizers: Sequence[AstNormalizer],
+        guard: SemanticGuard,
+        transformer: ScriptTransformer,
+        emitter: CodeEmitter,
+    ) -> Transpiler:
+        return TranspileService(source_filter, parser, normalizers, guard, transformer, emitter)
+
+
+#: The output provider of each profile. Register a new profile here.
+OUTPUT_PROVIDERS: dict[OutputProfile, type[Provider]] = {
+    OutputProfile.LEGACY: LegacyOutputProvider,
+    OutputProfile.PYNECOMP: PyneCompOutputProvider,
+}
+
+
+def build_providers(profile: OutputProfile) -> list[Provider]:
+    return [
+        SettingsProvider(),
+        FrontEndProvider(),
+        MiddleEndProvider(),
+        OUTPUT_PROVIDERS[profile](),
+        ApplicationProvider(),
+    ]
+
+
+def make_transpiler_container(
+    profile: OutputProfile | str | None = None,
+    *extra_providers: Provider,
+) -> Container:
+    """A container for one output profile. ``extra_providers`` come last, so
+    they may override any binding (tests swap a stage this way)."""
+    resolved = OutputProfile.parse(profile)
+    return make_container(
+        *build_providers(resolved), *extra_providers,
+        context={TranspilerSettings: TranspilerSettings(profile=resolved)},
+    )
+
+
+_containers: dict[OutputProfile, Container] = {}
+
+
+def default_container(profile: OutputProfile | str | None = None) -> Container:
+    """The process-wide container of a profile, built on first use."""
+    resolved = OutputProfile.parse(profile)
+    container = _containers.get(resolved)
+    if container is None:
+        container = _containers.setdefault(resolved, make_transpiler_container(resolved))
+    return container
+
+
+def get_transpiler(profile: OutputProfile | str | None = None) -> Transpiler:
+    return default_container(profile).get(Transpiler)